using Furion.DependencyInjection;
using Furion.DistributedIDGenerator;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Furion.JsonSerialization;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.Extensions.Logging;
using Myshipping.Application.Entity;
using Myshipping.Application.Helper;
using Myshipping.Core;
using Myshipping.Core.Entity;
using MySqlX.XDevAPI.Common;
using NPOI.SS.Formula.PTG;
using NPOI.Util;
using SqlSugar;
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 = "ServiceWorkFlowBase", Order = 20)]
    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 SqlSugarRepository<ServiceWorkFlowActivitiesSubRelation> _serviceWorkFlowActivitiesSubRelationRepository;
        private readonly SqlSugarRepository<ServiceWorkFlowReleaseInfo> _serviceWorkFlowReleaseInfoRepository;

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

            _logger = logger;
            _serviceWorkFlowActivitiesSubRelationRepository = serviceWorkFlowActivitiesSubRelationRepository;
            _serviceWorkFlowReleaseInfoRepository = serviceWorkFlowReleaseInfoRepository;
        }

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

            if(entity.BELONG_TENANT_ID == 0)
            {
                entity.BELONG_TENANT_ID = UserManager.TENANT_ID;
                entity.BELONG_TENANT_NAME = UserManager.TENANT_NAME;
            }

            if (info.StatusSkuList != null && info.StatusSkuList.Count > 0)
            {
                if (info.StatusSkuList.Any(a => a.IsContainsSub == 1 && (a.SubList == null || a.SubList.Count == 0)))
                {
                    throw Oops.Oh($"状态已选择包含子状态，子状态列表不能为空", typeof(InvalidOperationException));
                }

                if (info.StatusSkuList.Any(a => a.SortNo == 0))
                    throw Oops.Oh($"状态必需指定大于零的顺序号", typeof(InvalidOperationException));

                if (info.StatusSkuList.GroupBy(a => a.SortNo).Any(a => a.ToList().Count > 1))
                    throw Oops.Oh($"状态顺序号不能重复", typeof(InvalidOperationException));

                info.StatusSkuList = info.StatusSkuList.OrderBy(a => a.SortNo).Select((a, idx) =>
                {
                    if (a.SubList == null || a.SubList.Count == 0)
                    {
                        a.SortNo = idx + 1;
                        return a;
                    }

                    a.SortNo = idx + 1;
                    a.SubList = a.SubList.OrderBy(b => b.SortNo).Select((b, sidx) =>
                    {
                        b.SortNo = sidx + 1;
                        return b;
                    }).ToList();

                    return a;
                }).ToList();
            }

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

            string currVersion = string.Empty;

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

                currVersion = entity.DEVELOP_VERSION;

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

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

                

                ValidateServiceWorkFlow(entity, OperateTypeEnum.Save);

                entity.UpdatedTime = DateTime.Now;
                entity.UpdatedUserId = UserManager.UserId;
                entity.UpdatedUserName = UserManager.Name;
                
                if (!isSetEnable)
                {
                    entity.IS_ENABLE = model.IS_ENABLE;
                }

                entity.IS_LOCK = model.IS_LOCK;

                if (string.IsNullOrWhiteSpace(model.DEVELOP_VERSION))
                {
                    if(!string.IsNullOrWhiteSpace(model.RELEASE_VERSION))
                    {
                        entity.DEVELOP_VERSION = "DEVELOP";
                    }
                }
                else
                {
                    entity.DEVELOP_VERSION = model.DEVELOP_VERSION;

                }

                currVersion = entity.DEVELOP_VERSION;

                if (info.StatusSkuList != null && info.StatusSkuList.Count > 0)
                {
                    entity.STATUS_NUM = info.StatusSkuList.Sum(a =>
                    {
                        if (a.SubList != null)
                            return a.SubList.Count + 1;
                        return 1;
                    });
                }
                
                await _serviceWorkFlowBaseRepository.AsUpdateable(entity).IgnoreColumns(it => new
                {
                    it.TenantId,
                    it.TenantName,
                    it.CreatedTime,
                    it.CreatedUserId,
                    it.CreatedUserName,
                    it.IsDeleted,
                    it.RELEASE_VERSION,
                    it.PUBLISH_DATE,
                    it.PUBLISH_ER,
                    it.PUBLISH_NAME,
                    it.IS_LOCK
                }).ExecuteCommandAsync();

                currVersion = entity.DEVELOP_VERSION;

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

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

                //批量删除服务流程活动与子活动的关系（物理删除）
                _serviceWorkFlowActivitiesSubRelationRepository.EntityContext.Deleteable<ServiceWorkFlowActivitiesSubRelation>()
                   .EnableQueryFilter().Where(a => a.SERVICE_WORKFLOW_ID == entity.PK_ID && a.WF_VERSION == currVersion).ExecuteCommand();
            }

            //服务流程与服务项目关系
            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,
                    WF_VERSION = currVersion
                };

                //插入关系
                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,
                        SORT_NO = sku.SortNo,
                        IS_CONTAINS_SUB = sku.IsContainsSub,
                        VAL_TYPE = !string.IsNullOrWhiteSpace(sku.ValType)? sku.ValType: StatusSKUValTypeEnum.DATETIME.ToString(),
                        WF_VERSION = currVersion
                    };

                    await _serviceWorkFlowActivitiesRelationRepository.InsertAsync(wfRelationActivities);

                    //处理子状态
                    if(sku.IsContainsSub == 1)
                    {
                        sku.SubList.ForEach(async sub => {
                            var wfRelationActivitiesSub = new ServiceWorkFlowActivitiesSubRelation
                            {
                                PK_ID = IDGen.NextID().ToString(),
                                SERVICE_WORKFLOW_ID = entity.PK_ID,
                                SERVICE_ACTIVITIES_ID = sku.PKId,
                                SUB_SERVICE_ACTIVITIES_ID = sub.PKId,
                                SORT_NO = sub.SortNo,
                                VAL_TYPE = !string.IsNullOrWhiteSpace(sku.ValType) ? sku.ValType : StatusSKUValTypeEnum.DATETIME.ToString(),
                                WF_VERSION = currVersion
                            };

                            await _serviceWorkFlowActivitiesSubRelationRepository.InsertAsync(wfRelationActivitiesSub);
                        });
                    }
                });
            }

            return entity.PK_ID;
        }
        #endregion

        #region 校验
        /// <summary>
        /// 校验
        /// </summary>
        /// <param name="entity">服务流程详情</param>
        /// <param name="opTypeEnum">操作类型枚举</param>
        /// <returns></returns>
        private void ValidateServiceWorkFlow(ServiceWorkFlowBaseInfo entity, OperateTypeEnum opTypeEnum)
        {
            /*
             1、服务流程代码和名称不能低于2个字符。
             */
            if (opTypeEnum == OperateTypeEnum.Save)
            {
                if (_serviceWorkFlowProjectRelationRepository.AsQueryable().Any(a => a.SERVICE_PROJECT_ID == entity.PK_ID))
                {
                    throw Oops.Oh($"当前服务项目已关联服务流程，不能修改", typeof(InvalidOperationException));
                }

                if (entity.SERVICE_WORKFLOW_CODE.Length < 2 || entity.SERVICE_WORKFLOW_NAME.Length < 2)
                    throw Oops.Oh($"服务流程代码和状态名称不能小于2个字符，不能修改", 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

        #region 单票查询显示详情
        /// <summary>
        /// 单票查询显示详情
        /// </summary>
        /// <param name="pkId">服务流程主键</param>
        private ServiceWorkFlowBaseShowDto InnerGetShowInfo(string pkId)
        {
            var model = InnerGetInfo(pkId);

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

            /*
             1、获取关联的服务项目（单条）
             2、获取关联的服务活动列表（多条）
             */
            string currVersion = string.Empty;

            if(!string.IsNullOrWhiteSpace(model.DEVELOP_VERSION))
            {
                currVersion = model.DEVELOP_VERSION;
            }
            else
            {
                currVersion = model.RELEASE_VERSION;
            }

            var projectInfo = _serviceWorkFlowProjectRelationRepository.AsQueryable()
                  .LeftJoin<ServiceProjectBaseInfo>((rela, prj) => rela.SERVICE_PROJECT_ID == prj.PK_ID)
                  .Where(rela => rela.SERVICE_WORKFLOW_ID == pkId && rela.WF_VERSION == currVersion)
                  .Select((rela, prj) => prj).First();

            if (projectInfo != null)
            {
                showModel.ServiceProject = projectInfo.Adapt<ServiceProjectBaseShowDto>();
            }

            var activitiesList = _serviceWorkFlowActivitiesRelationRepository.AsQueryable()
                 .LeftJoin<ServiceWorkFlowActivitiesInfo>((rela, act) =>
                     rela.SERVICE_ACTIVITIES_ID == act.PK_ID && rela.SERVICE_WORKFLOW_ID == pkId && rela.WF_VERSION == currVersion)
                 .LeftJoin<StatusSkuBaseInfo>((rela, act, sku) => act.STATUS_SKU_ID == sku.PK_ID)
                 .Select((rela, act, sku) =>
                 new { Act = act, Sku = sku, SortNo = rela.SORT_NO, IsSub = rela.IS_CONTAINS_SUB,ValType = rela.VAL_TYPE })
                 .ToList();

            if (activitiesList.Count > 0)
            {
                showModel.StatusSkuList = activitiesList.OrderBy(a => a.SortNo)
                    .Select(a =>
                    {
                        var actModel = a.Act.Adapt<ServiceWorkFlowActivitiesShowDto>();

                        actModel.SortNo = a.SortNo;
                        actModel.IsContainsSub = a.IsSub;
                        actModel.ValType = a.ValType;
                        actModel.statusSkuBase = a.Sku.Adapt<StatusSkuBaseDto>();

                        return actModel;
                    }).ToList();
            }

            var activitiesSubList = _serviceWorkFlowActivitiesSubRelationRepository.AsQueryable()
                 .LeftJoin<ServiceWorkFlowActivitiesInfo>((rela, act) =>
                     rela.SUB_SERVICE_ACTIVITIES_ID == act.PK_ID && rela.SERVICE_WORKFLOW_ID == pkId && rela.WF_VERSION == currVersion)
                 .LeftJoin<StatusSkuBaseInfo>((rela, act, sku) => act.STATUS_SKU_ID == sku.PK_ID)
                 .Select((rela, act, sku) => 
                 new { Act = act, Sku = sku, SortNo = rela.SORT_NO, ParentId = rela.SERVICE_ACTIVITIES_ID })
                 .ToList();

            if(activitiesSubList.Count > 0)
            {
                var subList = activitiesSubList
                    .GroupBy(a => a.ParentId)
                    .Select(a => {
                        var currArg = a.ToList();


                        return new { Key = a.Key, SubList = currArg.OrderBy(b=>b.SortNo)
                            .Select(b => {

                            var actModel = b.Act.Adapt<ServiceWorkFlowActivitiesSubShowDto>();

                            actModel.SortNo = b.SortNo;
                            actModel.statusSkuBase = b.Sku.Adapt<StatusSkuBaseDto>();

                            return actModel;
                        }).ToList() };
                    });

                showModel.StatusSkuList.GroupJoin(subList, l => l.PKId, r => r.Key, (l,
                    r) => {
                        var currArg = r.ToList();

                        if (currArg.Count == 0)
                            return l;

                        l.SubList = currArg.FirstOrDefault().SubList.ToList();

                        return l;

                    }).ToList();
            }

            return showModel;
        }
        #endregion

        /// <summary>
        /// 通过服务活动主键获取所有相关服务流程列表
        /// </summary>
        /// <param name="activitiesArgs">服务活动主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/GetServiceWorkFlowListByActivities")]
        public async Task<TaskManageOrderResultDto> GetServiceWorkFlowListByActivities([FromBody]string[] activitiesArgs)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                /*
                 1、通过服务活动ID获取所有关联的服务流程详情列表
                 2、轮询服务流程列表，组织详细的服务流程列表
                 */
                var activitiesList = _serviceWorkFlowActivitiesRelationRepository.AsQueryable().Filter(null, true)
                    .LeftJoin<ServiceWorkFlowBaseInfo>((rela, wf) => rela.SERVICE_WORKFLOW_ID == wf.PK_ID 
                        && rela.WF_VERSION == wf.RELEASE_VERSION)
                    .Where((rela,wf) => activitiesArgs.Contains(rela.SERVICE_ACTIVITIES_ID) 
                        && !wf.IsDeleted && wf.IS_ENABLE == 1)
                    .Select((rela, wf) => wf).Distinct().ToList();

                var subActList = _serviceWorkFlowActivitiesSubRelationRepository.AsQueryable().Filter(null, true)
                    .LeftJoin<ServiceWorkFlowBaseInfo>((rela, wf) => rela.SERVICE_WORKFLOW_ID == wf.PK_ID 
                        && rela.WF_VERSION == wf.RELEASE_VERSION)
                    .Where((rela, wf) => activitiesArgs.Contains(rela.SUB_SERVICE_ACTIVITIES_ID)
                        && !wf.IsDeleted && wf.IS_ENABLE == 1)
                    .Select((rela, wf) => wf).Distinct().ToList();

                if(subActList.Count > 0)
                {
                    activitiesList.AddRange(subActList);
                    //去重
                    activitiesList = activitiesList.Distinct().ToList();
                }
                
                if(activitiesList.Count == 0)
                {
                    _logger.LogInformation($"{JSON.Serialize(activitiesArgs)} 未检索到有效服务流程");

                    throw Oops.Oh("未检索到有效服务流程", typeof(InvalidOperationException));
                }

                var wfArg = activitiesList.Select(a => a.PK_ID).ToArray();

                var mergeList =
                    _serviceWorkFlowBaseRepository.AsQueryable().Filter(null, true)
                     .LeftJoin<ServiceWorkFlowActivitiesRelation>((wf, rela) => wf.PK_ID == rela.SERVICE_WORKFLOW_ID
                        && wf.RELEASE_VERSION == rela.WF_VERSION)                    
                     .LeftJoin<ServiceWorkFlowActivitiesInfo>((wf,rela, act) =>
                         rela.SERVICE_ACTIVITIES_ID == act.PK_ID && wf.RELEASE_VERSION == rela.WF_VERSION)
                     .LeftJoin<StatusSkuBaseInfo>((wf,rela, act, sku) =>
                        act.STATUS_SKU_ID == sku.PK_ID)
                     .Where((wf) => wfArg.Contains(wf.PK_ID))
                     .Select((wf,rela, act, sku) =>
                     new { WF = wf, Act = act, Sku = sku, SortNo = rela.SORT_NO, IsSub = rela.IS_CONTAINS_SUB, ValType = rela.VAL_TYPE })
                     .ToList();


                var mergeSubList =
                    _serviceWorkFlowBaseRepository.AsQueryable().Filter(null, true)
                     .LeftJoin<ServiceWorkFlowActivitiesSubRelation>((wf, rela) => wf.PK_ID == rela.SERVICE_WORKFLOW_ID
                        && wf.RELEASE_VERSION == rela.WF_VERSION)
                     .LeftJoin<ServiceWorkFlowActivitiesInfo>((wf, rela, act) =>
                         rela.SUB_SERVICE_ACTIVITIES_ID == act.PK_ID && wf.RELEASE_VERSION == rela.WF_VERSION)
                     .LeftJoin<StatusSkuBaseInfo>((wf, rela, act, sku) =>
                        act.STATUS_SKU_ID == sku.PK_ID)
                     .Where((wf) => wfArg.Contains(wf.PK_ID))
                     .Select((wf,rela, act, sku) =>
                     new { WF = wf, Act = act, Sku = sku, SortNo = rela.SORT_NO, ParentId = rela.SERVICE_ACTIVITIES_ID, ValType = rela.VAL_TYPE })
                     .ToList();


                var prjectList = 
                    _serviceWorkFlowBaseRepository.AsQueryable().Filter(null, true)
                    .LeftJoin<ServiceWorkFlowProjectRelation>((wf, rela) => wf.PK_ID == rela.SERVICE_WORKFLOW_ID
                        && wf.RELEASE_VERSION == rela.WF_VERSION)
                    .LeftJoin<ServiceProjectBaseInfo>((wf,rela, prj) => 
                        rela.SERVICE_PROJECT_ID == prj.PK_ID)
                    .Where((wf) => wfArg.Contains(wf.PK_ID))
                    .Select((wf,rela, prj) => new{ WF = wf, Rela = rela,Prj = prj }).ToList();


                var list = mergeList.GroupBy(a => a.WF.PK_ID)
                     .Select(a => {
                         var model = a.FirstOrDefault().WF;

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

                         showModel.StatusSkuList = a.ToList().OrderBy(a => a.SortNo)
                            .Select(a =>
                            {
                                var actModel = a.Act.Adapt<ServiceWorkFlowActivitiesShowDto>();

                                actModel.SortNo = a.SortNo;
                                actModel.IsContainsSub = a.IsSub;
                                actModel.ValType = a.ValType;
                                actModel.statusSkuBase = a.Sku.Adapt<StatusSkuBaseDto>();

                                if(a.IsSub == 1)
                                {
                                    actModel.SubList = mergeSubList.Where(
                                        b =>
                                            b.WF.PK_ID == a.WF.PK_ID && b.ParentId == a.Act.PK_ID)
                                    .OrderBy(b => b.SortNo)
                                    .Select(b =>
                                    {

                                        var actModel = b.Act.Adapt<ServiceWorkFlowActivitiesSubShowDto>();

                                        actModel.SortNo = b.SortNo;
                                        actModel.statusSkuBase = b.Sku.Adapt<StatusSkuBaseDto>();

                                        return actModel;
                                    }).ToList();
                                }

                                return actModel;
                            }).ToList();

                         return showModel;
                     }).ToList();

                list = list.GroupJoin(prjectList, l => l.PKId,
                    r => r.WF.PK_ID,
                    (l, r) =>
                    {
                        var currList = r.ToList();

                        l.ServiceProject = currList.FirstOrDefault().Prj.Adapt<ServiceProjectBaseShowDto>();

                        return l;
                    }).ToList();

                result.succ = true;
                result.ext = list;
            }
            catch (Exception ex)
            {
                result.succ = false;
                result.msg = $"保存服务流程活动异常，原因：{ex.Message}";
            }

            return result;
        }

        #region 保存并启用
        /// <summary>
        /// 保存并启用
        /// </summary>
        /// <param name="info">服务流程详情</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/SaveAndEnable")]
        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;
        }
        #endregion

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

            result.bno = model?.SERVICE_WORKFLOW_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 _serviceWorkFlowBaseRepository.AsUpdateable(model).UpdateColumns(it => new
                    {
                        it.IS_ENABLE,
                        it.UpdatedTime,
                        it.UpdatedUserId,
                        it.UpdatedUserName

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

                    model.IS_ENABLE = 0;

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

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

                    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;
        }
        #endregion


        /// <summary>
        /// 启用
        /// </summary>
        /// <param name="pkIds">服务流程主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/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 = _serviceWorkFlowBaseRepository.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(InnerExcuteServiceWF(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;
        }

        /// <summary>
        /// 取消启用
        /// </summary>
        /// <param name="pkIds">服务流程主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/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 = _serviceWorkFlowBaseRepository.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(InnerExcuteServiceWF(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;
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="pkIds">服务流程主键</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/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 = _serviceWorkFlowBaseRepository.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(InnerExcuteServiceWF(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;
        }

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

            try
            {
                /*
                 复制整票服务流程详情（服务项目和服务流程活动）
                 */
                var model = InnerGetInfo(pkId);

                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>
        [HttpGet("/ServiceWorkFlowBase/GetInfo")]
        public async Task<TaskManageOrderResultDto> GetInfo([FromQuery]string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                result.succ = true;
                result.ext = InnerGetShowInfo(pkId);
            }
            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>
        [HttpGet("/ServiceWorkFlowBase/QueryList")]
        public async Task<TaskManageOrderResultDto> QueryList([FromQuery]string queryItem, [FromQuery] 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="pkIds">服务流程主键数组</param>
        /// <returns>返回回执</returns>
        [HttpPost("/ServiceWorkFlowBase/PublishRelease")]
        public async Task<TaskManageOrderResultDto> PublishRelease([FromBody]string[] pkIds)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

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

                var list = _serviceWorkFlowBaseRepository.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(InnerPublishReleasServiceWF(pr).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;
        }

        #region 发布服务流程内部方法
        /// <summary>
        /// 发布服务流程内部方法
        /// </summary>
        /// <param name="model">服务流程详情</param>
        /// <returns>返回回执</returns>
        [SqlSugarUnitOfWork]
        private async Task<TaskManageOrderResultDto> InnerPublishReleasServiceWF(ServiceWorkFlowBaseInfo model)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            result.bno = model?.SERVICE_WORKFLOW_NAME;

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

                if(string.IsNullOrWhiteSpace(model.DEVELOP_VERSION))
                    throw Oops.Oh($"服务流程未修改，不需要重复发布", typeof(InvalidOperationException));

                var lastReleaseInfo = _serviceWorkFlowReleaseInfoRepository.AsQueryable()
                    .First(a => a.SERVICE_WF_ID == model.PK_ID && a.IS_DEL == 0);

                int currNum = lastReleaseInfo == null ? 1 : lastReleaseInfo.TOTAL_NUM;

                ServiceWorkFlowReleaseInfo releaseInfo = new ServiceWorkFlowReleaseInfo
                {
                    PK_ID = IDGen.NextID().ToString(),
                    SERVICE_WF_ID = model.PK_ID,
                    PUBLISH_DATE = DateTime.Now,
                    IS_DEL = 0,
                    PUBLISH_ER = UserManager.UserId,
                    PUBLISH_NAME = UserManager.Name,
                    TOTAL_NUM = currNum + 1,
                };

                if (lastReleaseInfo != null)
                {
                    releaseInfo.LAST_PK_ID = lastReleaseInfo.PK_ID;
                    lastReleaseInfo.IS_DEL = 1;

                    _serviceWorkFlowReleaseInfoRepository.AsUpdateable(lastReleaseInfo).UpdateColumns(it => new
                    {
                        it.IS_DEL
                    }).ExecuteCommand();
                }
 
                //写入发布表
                _serviceWorkFlowReleaseInfoRepository.Insert(releaseInfo);

                releaseInfo = _serviceWorkFlowReleaseInfoRepository.AsQueryable()
                .First(a => a.SERVICE_WF_ID == model.PK_ID && a.IS_DEL == 0);
                
                string releaseVersion = releaseInfo.RELEASE_VERSION;

                var wfBaseInfo = InnerGetShowInfo(model.PK_ID);
                string currVersion = wfBaseInfo.DevelopVersion;

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

                await _serviceWorkFlowBaseRepository.AsUpdateable(model).UpdateColumns(it => new
                {
                    it.RELEASE_VERSION,
                    it.UpdatedTime,
                    it.UpdatedUserId,
                    it.UpdatedUserName,
                }).ExecuteCommandAsync();

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

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

                //服务流程与服务活动关系
                if (wfBaseInfo.StatusSkuList != null && wfBaseInfo.StatusSkuList.Count > 0)
                {
                    wfBaseInfo.StatusSkuList.ForEach(async sku =>
                    {
                        var wfRelationActivities = new ServiceWorkFlowActivitiesRelation
                        {
                            PK_ID = IDGen.NextID().ToString(),
                            SERVICE_WORKFLOW_ID = wfBaseInfo.PKId,
                            SERVICE_ACTIVITIES_ID = sku.PKId,
                            SORT_NO = sku.SortNo,
                            IS_CONTAINS_SUB = sku.IsContainsSub,
                            VAL_TYPE = !string.IsNullOrWhiteSpace(sku.ValType) ? sku.ValType : StatusSKUValTypeEnum.DATETIME.ToString(),
                            WF_VERSION = releaseVersion
                        };

                        await _serviceWorkFlowActivitiesRelationRepository.InsertAsync(wfRelationActivities);

                        //处理子状态
                        if (sku.IsContainsSub == 1)
                        {
                            sku.SubList.ForEach(async sub =>
                            {
                                var wfRelationActivitiesSub = new ServiceWorkFlowActivitiesSubRelation
                                {
                                    PK_ID = IDGen.NextID().ToString(),
                                    SERVICE_WORKFLOW_ID = wfBaseInfo.PKId,
                                    SERVICE_ACTIVITIES_ID = sku.PKId,
                                    SUB_SERVICE_ACTIVITIES_ID = sub.PKId,
                                    SORT_NO = sub.SortNo,
                                    VAL_TYPE = !string.IsNullOrWhiteSpace(sku.ValType) ? sku.ValType : StatusSKUValTypeEnum.DATETIME.ToString(),
                                    WF_VERSION = releaseVersion
                                };

                                await _serviceWorkFlowActivitiesSubRelationRepository.InsertAsync(wfRelationActivitiesSub);
                            });
                        }
                    });
                }

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

                //批量删除服务流程与服务活动关系（物理删除）
                _serviceWorkFlowActivitiesRelationRepository.EntityContext.Deleteable<ServiceWorkFlowActivitiesRelation>()
                    .EnableQueryFilter().Where(a => a.SERVICE_WORKFLOW_ID == model.PK_ID && a.WF_VERSION == currVersion).ExecuteCommand();

                //批量删除服务流程活动与子活动的关系（物理删除）
                _serviceWorkFlowActivitiesSubRelationRepository.EntityContext.Deleteable<ServiceWorkFlowActivitiesSubRelation>()
                   .EnableQueryFilter().Where(a => a.SERVICE_WORKFLOW_ID == model.PK_ID && a.WF_VERSION == currVersion).ExecuteCommand();

                var updateModel = _serviceWorkFlowBaseRepository.FirstOrDefault(a => a.PK_ID == model.PK_ID);

                updateModel.DEVELOP_VERSION = null;

                await _serviceWorkFlowBaseRepository.AsUpdateable(updateModel).UpdateColumns(it => new
                {
                    it.DEVELOP_VERSION,
                }).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("/ServiceWorkFlowBase/GetShowTimeLine")]
        public async Task<TaskManageOrderResultDto> GetShowTimeLine([FromQuery] string pkId)
        {
            TaskManageOrderResultDto result = new TaskManageOrderResultDto();

            try
            {
                var showModel = new ServiceWorkFlowRunDto();

                /*
                 根据已保存的服务流程生成测试数据
                 */
                var model = InnerGetShowInfo(pkId);

                if(model != null)
                {
                    showModel.PKId = pkId;

                    if(model.ServiceProject != null)
                    {
                        showModel.ServiceProjectName = model.ServiceProject.ServiceProjectName;
                        showModel.ServiceProjectCode = model.ServiceProject.ServiceProjectCode;
                    }

                    if (model.StatusSkuList != null && model.StatusSkuList.Count > 0)
                    {
                        int endSortNo = model.StatusSkuList.Max(a => a.SortNo);

                        DateTime startDate = DateTime.Now.AddDays(-(endSortNo + 1));

                        showModel.ActivitiesList = model.StatusSkuList.Select(a => {

                            var runModel = new ServiceWorkFlowActivitiesRunDto
                            {
                                PKId = Guid.NewGuid().ToString(),
                                ActDate = startDate.AddDays(a.SortNo),
                                ActId = a.PKId,
                                ExecSortNo = a.SortNo,
                                ActVal = string.Empty,
                                IsStart = (a.SortNo == 1) ? 1 : 0,
                                IsEnd = (a.SortNo == endSortNo) ? 1 : 0,
                                IsYield = 1,
                                RunId = Guid.NewGuid().ToString(),
                                ShowName = a.ShowName,
                                SourceType = "AUTO",
                                StatusSKUCode = a.statusSkuBase.StatusSKUCode,
                                StatusSKUId = a.StatusSKUId
                            };
                           
                            if(a.IsContainsSub == 1)
                            {
                                int endSubSortNo = a.SubList.Max(a => a.SortNo);

                                DateTime startSubDate = DateTime.Now.AddDays(-(endSubSortNo + 1));

                                runModel.SubList = a.SubList.Select(b => {
                                    var subModel = new ServiceWorkFlowActivitiesRunSubDto {
                                        PKId = Guid.NewGuid().ToString(),
                                        ActDate = startSubDate.AddDays(b.SortNo),
                                        ActId = b.PKId,
                                        ExecSortNo = b.SortNo,
                                        ActVal = string.Empty,
                                        IsStart = (b.SortNo == 1) ? 1 : 0,
                                        IsEnd = (b.SortNo == endSortNo) ? 1 : 0,
                                        IsYield = 1,
                                        RunId = Guid.NewGuid().ToString(),
                                        ShowName = b.ShowName,
                                        SourceType = "AUTO",
                                        StatusSKUCode = b.statusSkuBase.StatusSKUCode,
                                        StatusSKUId = b.StatusSKUId
                                    };

                                    return subModel;
                                }).ToList();
                            }

                            return runModel;

                        }).ToList();
                    }
                }


                result.succ = true;
                result.ext = showModel;

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

            return result;
        }
        #endregion
    }
}