BookingHeChuan/Myshipping.Application/Service/TrackingSystem/ServiceProjectService.cs

using Furion.DependencyInjection;
using Furion.DistributedIDGenerator;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Furion.JsonSerialization;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Myshipping.Application.Entity;
using Myshipping.Application.Helper;
using Myshipping.Core;
using MySqlX.XDevAPI.Common;
using StackExchange.Profiling.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Myshipping.Application
{
    /// <summary>
    /// 服务项目管理
    /// </summary>
    [ApiDescriptionSettings("Application", Name = "ServiceProject", Order = 20)]
    public class ServiceProjectService : IServiceProjectService, IDynamicApiController, ITransient
    {
        private readonly SqlSugarRepository<ServiceProjectBaseInfo> _serviceProjectBaseInfoRepository;
        private readonly SqlSugarRepository<ServiceWorkFlowProjectRelation> _serviceWorkFlowProjectRelationRepository;


        private readonly ILogger<ServiceProjectService> _logger;

        public ServiceProjectService(SqlSugarRepository<ServiceProjectBaseInfo> serviceProjectBaseInfoRepository,
            ILogger<ServiceProjectService> logger,
            SqlSugarRepository<ServiceWorkFlowProjectRelation> serviceWorkFlowProjectRelationRepository)
        {
            _serviceProjectBaseInfoRepository = serviceProjectBaseInfoRepository;
            _logger = logger;
            _serviceWorkFlowProjectRelationRepository = serviceWorkFlowProjectRelationRepository;
        }

        #region 保存
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="info">服务项目详情</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceProject/Save")]
        public async Task<TaskManageOrderResultDto> Save([FromBody] ServiceProjectBaseDto info)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var id = await InnerSave(info);

                result.succ = true;
                result.msg = "保存成功";
                result.ext = id;
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"保存服务项目异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 保存内部方法
        /// <summary>
        /// 保存内部方法
        /// </summary>
        /// <param name="info">服务项目详情</param>
        /// <param name="isSetEnable">是否启用</param>
        /// <returns>返回派车Id</returns>
        [SqlSugarUnitOfWork]
        private async Task<string> InnerSave(ServiceProjectBaseDto info,bool isSetEnable = false)
        {
            ServiceProjectBaseInfo entity = info.Adapt<ServiceProjectBaseInfo>();

            if(isSetEnable)
            {
                entity.IS_ENABLE = 1;
            }

            if (entity == null)
                throw Oops.Oh($"服务项目不能为空", typeof(InvalidOperationException));

            _logger.LogInformation($"服务项目保存 JSON={JSON.Serialize(entity)} user={UserManager.UserId}");

            if (string.IsNullOrWhiteSpace(entity.PK_ID))
            {
                entity.PK_ID = IDGen.NextID().ToString();

                _serviceProjectBaseInfoRepository.Insert(entity);
            }
            else
            {
                var model = _serviceProjectBaseInfoRepository.AsQueryable().First(a => a.PK_ID == entity.PK_ID);

                if (model == null)
                    throw Oops.Oh($"服务项目获取失败，服务项目信息不存在或已作废", typeof(InvalidOperationException));


                _logger.LogInformation($"更新服务项目前，获取原始记录 JSON={JSON.Serialize(model)}");

                ValidateServiceProject(entity, OperateTypeEnum.Save);

                entity.UpdatedTime = DateTime.Now;
                entity.UpdatedUserId = UserManager.UserId;
                entity.UpdatedUserName = UserManager.Name;

                await _serviceProjectBaseInfoRepository.AsUpdateable(entity).IgnoreColumns(it => new
                {
                    it.TenantId,
                    it.TenantName,
                    it.CreatedTime,
                    it.CreatedUserId,
                    it.CreatedUserName,
                    it.IsDeleted,
                }).ExecuteCommandAsync();

            }

            return entity.PK_ID;
        }
        #endregion

        #region 校验
        /// <summary>
        /// 校验
        /// </summary>
        /// <param name="entity">服务项目详情</param>
        /// <param name="opTypeEnum">操作类型枚举</param>
        /// <returns></returns>
        private void ValidateServiceProject(ServiceProjectBaseInfo entity, OperateTypeEnum opTypeEnum)
        {
            /*
             1、服务项目代码和名称不能低于2个字符。
             2、服务项目修改，需要判断当前服务项目是否关联服务流程。已关联的不能修改服务项目。
             3、取消启用时，需要判断当前服务项目是否关联服务流程。已关联的不能取消启用。
             */
            if (_serviceWorkFlowProjectRelationRepository.Any(a => a.SERVICE_PROJECT_ID == entity.PK_ID))
            {
                _logger.LogInformation($"当前服务项目已关联服务流程不能修改,{entity.SERVICE_PROJECT_CODE}");

                throw Oops.Oh($"当前服务项目已关联服务流程不能修改", typeof(InvalidOperationException));
            }

            if (opTypeEnum == OperateTypeEnum.Save)
            {
                if (_serviceWorkFlowProjectRelationRepository.AsQueryable().Any(a => a.SERVICE_PROJECT_ID == entity.PK_ID))
                {
                    throw Oops.Oh($"当前服务项目已关联服务流程，不能修改", typeof(InvalidOperationException));
                }

                if (entity.SERVICE_PROJECT_CODE.Length < 2 || entity.SERVICE_PROJECT_NAME.Length < 2)
                    throw Oops.Oh($"服务项目代码和状态名称不能小于2个字符，不能修改", typeof(InvalidOperationException));
            }

            if (opTypeEnum == OperateTypeEnum.SetUnEnable)
            {
                if (_serviceWorkFlowProjectRelationRepository.AsQueryable().Any(a => a.SERVICE_PROJECT_ID == entity.PK_ID))
                {
                    throw Oops.Oh($"当前服务项目已关联服务流程，不能取消启用", typeof(InvalidOperationException));
                }
            }
        }
        #endregion

        #region 保存并启用
        /// <summary>
        /// 保存并启用
        /// </summary>
        /// <param name="info">服务项目详情</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceProject/SaveAndEnable")]
        public async Task<TaskManageOrderResultDto> SaveAndEnable([FromBody]ServiceProjectBaseDto info)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var id = await InnerSave(info,true);

                result.succ = true;
                result.msg = "保存成功";
                result.ext = id;
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"保存并启用服务项目异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 启用
        /// <summary>
        /// 启用
        /// </summary>
        /// <param name="pkIds">服务项目主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceProject/SetEnable")]
        public async Task<TaskManageOrderResultDto> SetEnable([FromBody] string[] pkIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                if (pkIds.Length == 0)
                {
                    throw Oops.Oh($"服务项目主键数组不能为空", typeof(InvalidOperationException));
                }

                var list = _serviceProjectBaseInfoRepository.AsQueryable()
                    .Where(a => pkIds.Contains(a.PK_ID)).ToList();

                if (list.Count == 0)
                    throw Oops.Oh($"服务项目获取失败，请服务项目信息是否存在", typeof(InvalidOperationException));

                if (list.Count != pkIds.Length)
                    throw Oops.Oh($"部分服务项目获取失败，请服务项目信息是否存在", typeof(InvalidOperationException));

                List<TaskManageOrderResultDto> rltList = new List<TaskManageOrderResultDto>();

                list.ForEach(pr => {

                    rltList.Add(InnerExcuteServiceProject(pr, OperateTypeEnum.SetEnable).GetAwaiter().GetResult());
                });

                result.succ = true;
                result.msg = rltList.FirstOrDefault().msg;

                result.ext = rltList;

                var succ = rltList.Count(x => x.succ);
                var fail = rltList.Count(x => !x.succ);

                if (succ > 0)
                {
                    result.batchTotal = succ.ToString();
                }
                else
                {
                    result.batchTotal = "- ";
                }

                if (fail > 0)
                {
                    result.batchTotal += "/" + fail.ToString();
                }
                else
                {
                    result.batchTotal += " -";
                }
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"启用服务项目异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 取消启用
        /// <summary>
        /// 取消启用
        /// </summary>
        /// <param name="pkIds">服务项目主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceProject/SetUnEnable")]
        public async Task<TaskManageOrderResultDto> SetUnEnable([FromBody] string[] pkIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                if (pkIds.Length == 0)
                {
                    throw Oops.Oh($"服务项目主键数组不能为空", typeof(InvalidOperationException));
                }

                var list = _serviceProjectBaseInfoRepository.AsQueryable()
                    .Where(a => pkIds.Contains(a.PK_ID)).ToList();

                if (list.Count == 0)
                    throw Oops.Oh($"服务项目获取失败，请服务项目信息是否存在", typeof(InvalidOperationException));

                if (list.Count != pkIds.Length)
                    throw Oops.Oh($"部分服务项目获取失败，请服务项目信息是否存在", typeof(InvalidOperationException));

                List<TaskManageOrderResultDto> rltList = new List<TaskManageOrderResultDto>();

                list.ForEach(pr => {

                    rltList.Add(InnerExcuteServiceProject(pr, OperateTypeEnum.SetUnEnable).GetAwaiter().GetResult());
                });

                result.succ = true;
                result.msg = rltList.FirstOrDefault().msg;

                result.ext = rltList;

                var succ = rltList.Count(x => x.succ);
                var fail = rltList.Count(x => !x.succ);

                if (succ > 0)
                {
                    result.batchTotal = succ.ToString();
                }
                else
                {
                    result.batchTotal = "- ";
                }

                if (fail > 0)
                {
                    result.batchTotal += "/" + fail.ToString();
                }
                else
                {
                    result.batchTotal += " -";
                }
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"启用服务项目异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 删除
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="pkIds">服务项目主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceProject/Delete")]
        public async Task<TaskManageOrderResultDto> Delete([FromBody] string[] pkIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                if (pkIds.Length == 0)
                {
                    throw Oops.Oh($"服务项目主键数组不能为空", typeof(InvalidOperationException));
                }

                var list = _serviceProjectBaseInfoRepository.AsQueryable()
                    .Where(a=> pkIds.Contains(a.PK_ID)).ToList();

                if(list.Count == 0)
                    throw Oops.Oh($"服务项目获取失败，请服务项目信息是否存在", typeof(InvalidOperationException));

                if (list.Count != pkIds.Length)
                    throw Oops.Oh($"部分服务项目获取失败，请服务项目信息是否存在", typeof(InvalidOperationException));

                List<TaskManageOrderResultDto> rltList = new List<TaskManageOrderResultDto>();

                list.ForEach(pr => {

                    rltList.Add(InnerExcuteServiceProject(pr, OperateTypeEnum.Delete).GetAwaiter().GetResult());
                });

                result.succ = true;
                result.msg = rltList.FirstOrDefault().msg;

                result.ext = rltList;

                var succ = rltList.Count(x => x.succ);
                var fail = rltList.Count(x => !x.succ);

                if (succ > 0)
                {
                    result.batchTotal = succ.ToString();
                }
                else
                {
                    result.batchTotal = "- ";
                }

                if (fail > 0)
                {
                    result.batchTotal += "/" + fail.ToString();
                }
                else
                {
                    result.batchTotal += " -";
                }
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"删除服务项目异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 处理服务项目内部方法
        /// <summary>
        /// 处理服务项目内部方法
        /// </summary>
        /// <param name="model">服务项目详情</param>
        /// <param name="opTypeEnum">操作类型</param>
        /// <returns>返回回执</returns>
        private async Task<TaskManageOrderResultDto> InnerExcuteServiceProject(ServiceProjectBaseInfo model,OperateTypeEnum opTypeEnum)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            result.bno = model?.SERVICE_PROJECT_NAME;

            try
            {
                if (model == null)
                    throw Oops.Oh($"服务项目获取失败，服务项目信息不存在或已作废", typeof(InvalidOperationException));

                _logger.LogInformation($"更新服务项目前，获取原始记录 JSON={JSON.Serialize(model)}");

                model.UpdatedTime = DateTime.Now;
                model.UpdatedUserId = UserManager.UserId;
                model.UpdatedUserName = UserManager.Name;

                if(opTypeEnum == OperateTypeEnum.SetEnable)
                {
                    model.IS_ENABLE = 1;

                    await _serviceProjectBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                    {
                        it.IS_ENABLE,
                        it.UpdatedTime,
                        it.UpdatedUserId,
                        it.UpdatedUserName

                    }).ExecuteCommandAsync();
                }
                else if (opTypeEnum == OperateTypeEnum.SetUnEnable)
                {
                    ValidateServiceProject(model, opTypeEnum);

                    model.IS_ENABLE = 0;

                    await _serviceProjectBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                    {
                        it.IS_ENABLE,
                        it.UpdatedTime,
                        it.UpdatedUserId,
                        it.UpdatedUserName

                    }).ExecuteCommandAsync();
                }
                else if (opTypeEnum == OperateTypeEnum.Delete)
                {
                    ValidateServiceProject(model, opTypeEnum);

                    model.IsDeleted = true;

                    await _serviceProjectBaseInfoRepository.AsUpdateable(model).UpdateColumns(it => new
                    {
                        it.IsDeleted,
                        it.UpdatedTime,
                        it.UpdatedUserId,
                        it.UpdatedUserName

                    }).ExecuteCommandAsync();
                }

                result.succ = true;
                result.msg = "执行成功";
                
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"执行启用异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 获取服务项目详情
        /// <summary>
        /// 获取服务项目详情
        /// </summary>
        /// <param name="pkId">服务项目主键</param>
        /// <returns>返回回执</returns>
        [HttpGet("/ServiceProject/GetInfo")]
        public async Task<TaskManageOrderResultDto> GetInfo([FromQuery] string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                if (string.IsNullOrWhiteSpace(pkId))
                {
                    throw Oops.Oh($"服务项目主键不能为空", typeof(InvalidOperationException));
                }

                var model = await _serviceProjectBaseInfoRepository.AsQueryable().FirstAsync(a => a.PK_ID == pkId);

                if (model == null)
                    throw Oops.Oh($"服务项目获取失败，服务项目信息不存在或已作废", typeof(InvalidOperationException));

                var showModel = model.Adapt<ServiceProjectBaseShowDto>();

                result.succ = true;
                result.ext = showModel;
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"获取服务项目详情异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 检索服务项目列表
        /// <summary>
        /// 检索服务项目列表
        /// </summary>
        /// <param name="queryItem">检索值</param>
        /// <param name="topNum">最大返回行数（默认15）</param>
        /// <returns>返回回执</returns>
        [HttpGet("/ServiceProject/QueryList")]
        public async Task<TaskManageOrderResultDto> QueryList([FromQuery] string queryItem, [FromQuery] int topNum = 15)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var list = await _serviceProjectBaseInfoRepository.AsQueryable().Where(a =>
                    a.IS_ENABLE == 1 && !a.IsDeleted && (string.IsNullOrWhiteSpace(queryItem) || a.SERVICE_PROJECT_CODE.Contains(queryItem) || a.SERVICE_PROJECT_NAME.Contains(queryItem)))
                    .Take(topNum).ToListAsync();

                result.succ = true;
                result.ext = list.Adapt<List<ServiceProjectBaseDto>>();

            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"检索服务项目列表异常，原因：{ex.Message}";
            }

            return result;
        }
        #endregion

        #region 服务项目台账查询
        /// <summary>
        /// 服务项目台账查询
        /// </summary>
        /// <param name="QuerySearch">服务项目台账查询请求</param>
        /// <returns>返回结果</returns>
        [HttpPost("/ServiceProject/GetPage")]
        public async Task<SqlSugarPagedList<ServiceProjectBasePageDto>> GetPageAsync([FromBody]QueryServiceProjectBaseDto QuerySearch)
        {
            //制单日期
            DateTime createBegin = DateTime.MinValue;
            DateTime createEnd = DateTime.MinValue;
            //更新日期
            DateTime updateBegin = DateTime.MinValue;
            DateTime updateEnd = DateTime.MinValue;

            //制单日期
            if (!string.IsNullOrWhiteSpace(QuerySearch.CreateBegin))
            {
                if (!DateTime.TryParse(QuerySearch.CreateBegin, out createBegin))
                    throw Oops.Oh($"创建起始日期格式错误，{QuerySearch.CreateBegin}");
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.CreateEnd))
            {
                if (!DateTime.TryParse(QuerySearch.CreateEnd, out createEnd))
                    throw Oops.Oh($"创建结束日期格式错误，{QuerySearch.CreateEnd}");

                createEnd = createEnd.AddDays(1);
            }

            //更新日期
            if (!string.IsNullOrWhiteSpace(QuerySearch.UpdateBegin))
            {
                if (!DateTime.TryParse(QuerySearch.UpdateBegin, out updateBegin))
                    throw Oops.Oh($"更新起始日期格式错误，{QuerySearch.UpdateBegin}");
            }

            if (!string.IsNullOrWhiteSpace(QuerySearch.UpdateEnd))
            {
                if (!DateTime.TryParse(QuerySearch.UpdateEnd, out updateEnd))
                    throw Oops.Oh($"更新结束日期格式错误，{QuerySearch.UpdateEnd}");

                updateEnd = updateEnd.AddDays(1);
            }

            string entityOrderCol = "CreatedTime";

            //这里因为返回给前端的台账数据是DTO，所以这里排序时候需要转换成Entity对应的字段
            if (!string.IsNullOrWhiteSpace(QuerySearch.SortField))
                entityOrderCol = MapsterExtHelper.GetAdaptProperty<ServiceProjectBasePageDto, ServiceProjectBaseInfo>(QuerySearch.SortField);

            var entities = await _serviceProjectBaseInfoRepository.AsQueryable()
                                     .WhereIF(createBegin != DateTime.MinValue, t => t.CreatedTime >= createBegin)
                                     .WhereIF(createEnd != DateTime.MinValue, t => t.CreatedTime < createEnd)
                                     .WhereIF(updateBegin != DateTime.MinValue, t => t.UpdatedTime.HasValue && t.UpdatedTime.Value >= updateBegin)
                                     .WhereIF(updateEnd != DateTime.MinValue, t => t.UpdatedTime.HasValue && t.UpdatedTime.Value < updateEnd)
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.IsEnable) && QuerySearch.IsEnable == "1", t => t.IS_ENABLE == 1)
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.IsEnable) && QuerySearch.IsEnable == "2", t => t.IS_ENABLE == 0)
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.ServiceProjectName), t => t.SERVICE_PROJECT_NAME.Contains(QuerySearch.ServiceProjectName)|| 
                                        t.SERVICE_PROJECT_CODE.Contains(QuerySearch.ServiceProjectName))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.ServiceProjectNote), t => t.SERVICE_PROJECT_NOTE.Contains(QuerySearch.ServiceProjectNote))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.CreateUser), t => t.CreatedUserName.Contains(QuerySearch.CreateUser))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.UpdateUser), t => t.UpdatedUserName.Contains(QuerySearch.UpdateUser))
                                     .OrderBy(entityOrderCol + (QuerySearch.descSort ? " asc " : " desc "))
                                     .ToPagedListAsync(QuerySearch.PageNo, QuerySearch.PageSize);

            return entities.Adapt<SqlSugarPagedList<ServiceProjectBasePageDto>>();
        }
        #endregion
    }
}