BookingHeChuan/Myshipping.Application/Service/TrackingSystem/ServiceWorkFlowBaseService.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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Myshipping.Application
{
    
    /// <summary>
    /// 服务流程
    /// </summary>
    [ApiDescriptionSettings("Application", Name = "ServiceWorkFlowBase", Order = 10)]
    public class ServiceWorkFlowBaseService : IServiceWorkFlowBaseService, IDynamicApiController, ITransient
    {
        private readonly SqlSugarRepository<ServiceWorkFlowBaseInfo> _serviceWorkFlowBaseRepository;
        private readonly SqlSugarRepository<ServiceWorkFlowActivitiesInfo> _serviceWorkFlowActivitiesInfoRepository;
        private readonly SqlSugarRepository<ServiceWorkFlowProjectRelation> _serviceWorkFlowProjectRelationRepository;
        private readonly SqlSugarRepository<ServiceWorkFlowActivitiesRelation> _serviceWorkFlowActivitiesRelationRepository;

        

        private readonly ILogger<ServiceWorkFlowBaseService> _logger;
        public ServiceWorkFlowBaseService(SqlSugarRepository<ServiceWorkFlowBaseInfo> serviceWorkFlowBaseRepository,
            ILogger<ServiceWorkFlowBaseService> logger,
            SqlSugarRepository<ServiceWorkFlowActivitiesInfo> serviceWorkFlowActivitiesInfoRepository,
            SqlSugarRepository<ServiceWorkFlowProjectRelation> serviceWorkFlowProjectRelationRepository,
            SqlSugarRepository<ServiceWorkFlowActivitiesRelation> serviceWorkFlowActivitiesRelationRepository)
        {
            _serviceWorkFlowBaseRepository = serviceWorkFlowBaseRepository;
            _serviceWorkFlowActivitiesInfoRepository = serviceWorkFlowActivitiesInfoRepository;
            _serviceWorkFlowProjectRelationRepository = serviceWorkFlowProjectRelationRepository;
            _serviceWorkFlowActivitiesRelationRepository = serviceWorkFlowActivitiesRelationRepository;

            _logger = logger;
        }

        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="info">服务流程详情</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/Save")]
        public async Task<TaskManageOrderResultDto> Save([FromBody] ServiceWorkFlowBaseDto 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;
        }

        #region 保存服务流程活动
        /// <summary>
        /// 保存服务流程活动
        /// </summary>
        /// <param name="info">保存服务流程活动详情</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/SaveWFActivities")]
        public async Task<TaskManageOrderResultDto> SaveWFActivities([FromBody] ServiceWorkFlowActivitiesDto info)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                /*
                 1、状态有记录。
                 2、同一状态不能有相同的显示名称
                 3、已经关联服务流程的，并且已经发布的不能修改内容。（只可以新增）
                 */
                var entity = info.Adapt<ServiceWorkFlowActivitiesInfo>();

                if (string.IsNullOrWhiteSpace(entity.STATUS_SKU_ID))
                {
                    throw Oops.Oh($"状态不能为空", typeof(InvalidOperationException));
                }

                if (string.IsNullOrWhiteSpace(entity.SHOW_NAME) || entity.SHOW_NAME.Length < 2)
                {
                    throw Oops.Oh($"状态显示名称不能为空，并且不能少于2个字符", typeof(InvalidOperationException));
                }

                //同一状态不能有相同的显示名称
                var checkList = _serviceWorkFlowActivitiesInfoRepository.AsQueryable()
                    .Where(a=>a.STATUS_SKU_ID == entity.STATUS_SKU_ID 
                    && a.SHOW_NAME == entity.SHOW_NAME && a.PK_ID != entity.PK_ID).ToList();

                if (checkList.Count > 0)
                    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();

                    _serviceWorkFlowActivitiesInfoRepository.Insert(entity);
                }
                else
                {
                    //已经关联服务流程的，并且已经发布的不能修改内容。（只可以新增）
                    var wfRelation = _serviceWorkFlowActivitiesRelationRepository.AsQueryable()
                        .Where(a=>a.SERVICE_ACTIVITIES_ID == entity.PK_ID)
                        .ToList();

                    if (wfRelation.Count > 0)
                    {
                        var currArg = wfRelation.Select(a=>a.SERVICE_WORKFLOW_ID).Distinct().ToList();

                        if (_serviceWorkFlowBaseRepository.AsQueryable().Any(a => currArg.Any(b => b == a.PK_ID)
                        && (!string.IsNullOrWhiteSpace(a.RELEASE_VERSION) || a.IS_LOCK == 1)))
                        {
                            throw Oops.Oh($"当前状态已关联发布流程，不能保存", typeof(InvalidOperationException));
                        }
                    }

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

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

                result.succ = true;
                result.msg = "保存成功";
                result.ext = entity.PK_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(ServiceWorkFlowBaseDto info, bool isSetEnable = false)
        {
            ServiceWorkFlowBaseInfo entity = info.Adapt<ServiceWorkFlowBaseInfo>();

            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();

                _serviceWorkFlowBaseRepository.Insert(entity);
            }
            else
            {
                var model = InnerGetInfo(entity.PK_ID);

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

                ValidateServiceWorkFlow(entity, true);

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

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

                //批量删除服务流程与服务项目关系（物理删除）
                _serviceWorkFlowProjectRelationRepository.EntityContext.Deleteable<ServiceWorkFlowProjectRelation>()
                    .Where(a => a.SERVICE_WORKFLOW_ID == entity.PK_ID);

                //批量删除服务流程与服务活动关系（物理删除）
                _serviceWorkFlowActivitiesRelationRepository.EntityContext.Deleteable<ServiceWorkFlowProjectRelation>()
                    .Where(a => a.SERVICE_WORKFLOW_ID == entity.PK_ID);
            }

            //服务流程与服务项目关系
            if (info.ServiceProject != null && !string.IsNullOrWhiteSpace(info.ServiceProject.PKId))
            {
                var wfRelationProject = new ServiceWorkFlowProjectRelation { 
                    PK_ID = IDGen.NextID().ToString(),
                    SERVICE_WORKFLOW_ID = entity.PK_ID,
                    SERVICE_PROJECT_ID = info.ServiceProject.PKId,
                };

                //插入关系
                await _serviceWorkFlowProjectRelationRepository.InsertAsync(wfRelationProject);
            }

            //服务流程与服务活动关系
            if (info.StatusSkuList != null && info.StatusSkuList.Count > 0)
            {
                info.StatusSkuList.ForEach(async sku =>
                {
                    var wfRelationActivities  = new ServiceWorkFlowActivitiesRelation {
                        PK_ID = IDGen.NextID().ToString(),
                        SERVICE_WORKFLOW_ID = entity.PK_ID,
                        SERVICE_ACTIVITIES_ID = sku.PKId,
                    };

                    await _serviceWorkFlowActivitiesRelationRepository.InsertAsync();
                });
            }

            return entity.PK_ID;
        }
        #endregion

        #region 校验
        /// <summary>
        /// 校验
        /// </summary>
        /// <param name="entity">服务项目详情</param>
        /// <param name="isCheckRelation">是否校验关系</param>
        /// <returns></returns>
        private void ValidateServiceWorkFlow(ServiceWorkFlowBaseInfo entity, bool isCheckRelation = false)
        {
            /*
             
             */
            //if (isCheckRelation && _serviceWorkFlowActivitiesInfoRepository.Any(a => a.STATUS_SKU_ID == entity.PK_ID))
            //{
            //    _logger.LogInformation($"当前状态已关联服务流程不能修改");

            //    throw Oops.Oh($"当前状态已关联服务流程不能修改", typeof(InvalidOperationException));
            //}
        }
        #endregion

        #region 单票查询
        /// <summary>
        /// 单票查询
        /// </summary>
        /// <param name="pkId">状态主键</param>
        private ServiceWorkFlowBaseInfo InnerGetInfo(string pkId)
        {
            if (string.IsNullOrWhiteSpace(pkId))
            {
                throw Oops.Oh($"状态主键不能为空", typeof(InvalidOperationException));
            }

            var model = _serviceWorkFlowBaseRepository.AsQueryable().First(a => a.PK_ID == pkId);

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

            return model;
        }
        #endregion

        /// <summary>
        /// 保存并启用
        /// </summary>
        /// <param name="info">服务流程详情</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> SaveAndEnable(ServiceWorkFlowBaseDto 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;
        }

        /// <summary>
        /// 启用
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> SetEnable(string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var model = InnerGetInfo(pkId);

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

                //ValidateServiceProject(model, true);

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

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

                }).ExecuteCommandAsync();

                result.succ = true;
                result.msg = "执行成功";

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

            return result;
        }

        /// <summary>
        /// 取消启用
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> SetUnEnable(string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var model = InnerGetInfo(pkId);

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

                //ValidateServiceProject(model, true);

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

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

                }).ExecuteCommandAsync();

                result.succ = true;
                result.msg = "执行成功";

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

            return result;
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> Delete(string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var model = InnerGetInfo(pkId);

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

                if (model.IS_ENABLE == 1)
                    //ValidateServiceProject(model, true);

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

                await _serviceWorkFlowBaseRepository.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;
        }

        /// <summary>
        /// 复制
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> Copy(string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var model = InnerGetInfo(pkId);

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

                //ValidateServiceProject(model, true);

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

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

                }).ExecuteCommandAsync();

                result.succ = true;
                result.msg = "执行成功";

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

            return result;
        }

        /// <summary>
        /// 获取服务流程详情
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> GetInfo(string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var model = InnerGetInfo(pkId);

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

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

            return result;
        }

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

            try
            {
                var list = await _serviceWorkFlowBaseRepository.AsQueryable().Where(a =>
                    a.IS_ENABLE == 1 && !a.IsDeleted && (a.SERVICE_WORKFLOW_CODE.Contains(queryItem) || a.SERVICE_WORKFLOW_NAME.Contains(queryItem)))
                    .Take(topNum).ToListAsync();

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

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

            return result;
        }

        /// <summary>
        /// 服务流程台账查询
        /// </summary>
        /// <param name="QuerySearch">服务流程台账查询请求</param>
        /// <returns>返回结果</returns>
        [HttpPost("/ServiceWorkFlowBase/GetPage")]
        public async Task<SqlSugarPagedList<ServiceWorkFlowBasePageDto>> GetPageAsync([FromBody]QueryServiceWorkFlowBaseDto 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<BookingTruckDto, BookingTruck>(QuerySearch.SortField);

            var entities = await _serviceWorkFlowBaseRepository.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.ServiceWorkflowName), t => t.SERVICE_WORKFLOW_NAME.Contains(QuerySearch.ServiceWorkflowName) ||
                                        t.SERVICE_WORKFLOW_CODE.Contains(QuerySearch.ServiceWorkflowName))
                                     .WhereIF(!string.IsNullOrWhiteSpace(QuerySearch.ServiceWorkflowNote), t => t.SERVICE_WORKFLOW_NOTE.Contains(QuerySearch.ServiceWorkflowNote))
                                     .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<ServiceWorkFlowBasePageDto>>();
        }


        /// <summary>
        /// 发布服务流程
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> PublishRelease(string pkId)
        {
            return new TaskManageOrderResultDto();
        }

        #region 获取展示服务流程时间轴列表
        /// <summary>
        /// 获取展示服务流程时间轴列表
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        /// <returns>返回回执</returns>
        public async Task<TaskManageOrderResultDto> GetShowTimeLine(string pkId)
        {
            return new TaskManageOrderResultDto();
        }
        #endregion
    }
}