第一版提交

schangxiang@126.com

2025-05-10 8372214fbc4db844645b846b286c441c1822af3d

 PipeLineLems/server/src/CMS.Plugin.PipeLineLems.Application/Implements/WorkPlanAppService.cs

@@ -1,127 +1,135 @@
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.WorkPlan; 
using CMS.Plugin.PipeLineLems.Application.Contracts.Services; 
using CMS.Plugin.PipeLineLems.Domain.Shared; 
using CmsQueryExtensions; 
using CMS.Plugin.PipeLineLems.Domain.WorkPlan; 
using CmsQueryExtensions.Extension; 
using System.Linq.Expressions; 
using Volo.Abp; 
using Volo.Abp.Application.Dtos; 
using Volo.Abp.Data; 
using Volo.Abp.ObjectExtending; 
using Volo.Abp.ObjectMapping; 
 
namespace CMS.Plugin.PipeLineLems.Application.Implements; 
 
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.WorkPlan;
using CMS.Plugin.PipeLineLems.Application.Contracts.Services;
using CMS.Plugin.PipeLineLems.Domain.Shared;
using CmsQueryExtensions;
using CMS.Plugin.PipeLineLems.Domain.WorkPlan;
using CmsQueryExtensions.Extension;
using System.Linq.Expressions;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Data;
using Volo.Abp.ObjectExtending;
using Volo.Abp.ObjectMapping;
using CMS.Plugin.FormulaManagement.Abstractions;
using CMS.Plugin.OrderManagement.Abstractions.Enums;
using CMS.Plugin.OrderManagement.Abstractions.Models;
using CMS.Plugin.OrderManagement.Abstractions;
using CMS.Plugin.ProductManagement.Abstractions;
using Microsoft.Extensions.DependencyInjection;

namespace CMS.Plugin.PipeLineLems.Application.Implements;

/// <summary> 
/// 作业计划表应用服务 
/// </summary> 
public class WorkPlanAppService : CMSPluginAppService, IWorkPlanAppService 
{ 
    private readonly IWorkPlanRepository workPlanRepository; 
 
public class WorkPlanAppService : CMSPluginAppService, IWorkPlanAppService
{
    private readonly IWorkPlanRepository workPlanRepository;
    private readonly IServiceProvider _serviceProvider;

    /// <summary> 
    /// Initializes a new instance of the <see cref="WorkPlanAppService"/> class. 
    /// </summary> 
    /// <param name="WorkPlanRepository">The task job repository.</param> 
    public WorkPlanAppService(IWorkPlanRepository _WorkPlanRepository) 
    { 
        workPlanRepository = _WorkPlanRepository; 
    } 
 
    public WorkPlanAppService(IWorkPlanRepository _WorkPlanRepository, IServiceProvider serviceProvider)
    {
        workPlanRepository = _WorkPlanRepository;
        _serviceProvider = serviceProvider;
    }

    /// <summary> 
    /// 获取指定作业计划表 
    /// </summary> 
    /// <param name="id"></param> 
    /// <returns></returns> 
    public virtual async Task<WorkPlanDto> GetAsync(Guid id) 
    { 
        return ObjectMapper.Map<WorkPlan, WorkPlanDto>(await workPlanRepository.GetAsync(id)); 
    } 
 
    public virtual async Task<WorkPlanDto> GetAsync(Guid id)
    {
        return ObjectMapper.Map<WorkPlan, WorkPlanDto>(await workPlanRepository.GetAsync(id));
    }

    /// <summary> 
    /// 分页获取作业计划表 
    /// </summary> 
    /// <param name="input"></param> 
    /// <returns></returns> 
    public virtual async Task<PagedResultDto<WorkPlanDto>> GetListAsync(GetWorkPlanInput input) 
    { 
        Check.NotNull(input, nameof(input)); 
 
        if (input.Sorting.IsNullOrWhiteSpace()) 
        { 
            input.Sorting = nameof(WorkPlan.Sort); 
        } 
 
    public virtual async Task<PagedResultDto<WorkPlanDto>> GetListAsync(GetWorkPlanInput input)
    {
        Check.NotNull(input, nameof(input));

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            input.Sorting = nameof(WorkPlan.Sort);
        }

        #region 动态构造查询条件  
 

        //动态构造查询条件  
        var whereConditions = DynamicGetQueryParams(input); 
 
        #endregion 
 
        var count = await workPlanRepository.GetCountAsync(whereConditions); 
        var list = await workPlanRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount); 
 
        return new PagedResultDto<WorkPlanDto>(count, ObjectMapper.Map<List<WorkPlan>, List<WorkPlanDto>>(list)); 
    } 
 
        var whereConditions = DynamicGetQueryParams(input);

        #endregion

        var count = await workPlanRepository.GetCountAsync(whereConditions);
        var list = await workPlanRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount);

        return new PagedResultDto<WorkPlanDto>(count, ObjectMapper.Map<List<WorkPlan>, List<WorkPlanDto>>(list));
    }

    /// <summary>  
    /// 动态构造查询条件  
    /// </summary>  
    /// <param name="input">输入参数</param>  
    /// <returns></returns>  
    private FunReturnResultModel<Expression<Func<WorkPlan, bool>>> DynamicGetQueryParams(GetWorkPlanInput input) 
    { 
    private FunReturnResultModel<Expression<Func<WorkPlan, bool>>> DynamicGetQueryParams(GetWorkPlanInput input)
    {
        //动态构造查询条件  
        var whereConditions = WhereConditionsExtensions.GetWhereConditions<WorkPlan, GetWorkPlanInput>(input); 
        if (!whereConditions.IsSuccess) 
        { 
            throw new Exception("动态构造查询条件失败:" + whereConditions.ErrMsg); 
        } 
 
        var whereConditions = WhereConditionsExtensions.GetWhereConditions<WorkPlan, GetWorkPlanInput>(input);
        if (!whereConditions.IsSuccess)
        {
            throw new Exception("动态构造查询条件失败:" + whereConditions.ErrMsg);
        }

        //也可再次自定义构建查询条件  
        Expression<Func<WorkPlan, bool>> extendExpression = a => a.IsDeleted == false; 
        Expression<Func<WorkPlan, bool>> extendExpression = a => a.IsDeleted == false;
        // 使用 System.Linq.PredicateBuilder 的 And 
        var pres = (System.Linq.Expressions.Expression<Func<WorkPlan, bool>>)(whereConditions.data); 
        whereConditions.data = System.Linq.PredicateBuilder.And(pres, extendExpression); 
 
        return whereConditions; 
    } 
 
        var pres = (System.Linq.Expressions.Expression<Func<WorkPlan, bool>>)(whereConditions.data);
        whereConditions.data = System.Linq.PredicateBuilder.And(pres, extendExpression);

        return whereConditions;
    }

    /// <summary> 
    /// 新建作业计划表 
    /// </summary> 
    /// <param name="input"></param> 
    /// <returns></returns> 
    /// <exception cref="UserFriendlyException"></exception> 
    public virtual async Task<WorkPlanDto> CreateAsync(WorkPlanCreateDto input) 
    { 
        await CheckCreateOrUpdateDtoAsync(input); 
 
        var exist = await workPlanRepository.NameExistAsync(input.TaskCode); 
        if (exist) 
        { 
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.TaskCode]); 
        } 
 
        var maxSort = await workPlanRepository.GetMaxSortAsync(); 
        var sort = input.Sort ?? maxSort; 
 
        var insertObj = ObjectMapper.Map<WorkPlanCreateDto, WorkPlan>(input); 
        insertObj.Sort = sort; 
        input.MapExtraPropertiesTo(insertObj, MappingPropertyDefinitionChecks.None); 
 
        await workPlanRepository.InsertAsync(insertObj); 
 
    public virtual async Task<WorkPlanDto> CreateAsync(WorkPlanCreateDto input)
    {
        await CheckCreateOrUpdateDtoAsync(input);

        var exist = await workPlanRepository.NameExistAsync(input.TaskCode);
        if (exist)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.TaskCode]);
        }

        var maxSort = await workPlanRepository.GetMaxSortAsync();
        var sort = input.Sort ?? maxSort;

        var insertObj = ObjectMapper.Map<WorkPlanCreateDto, WorkPlan>(input);
        insertObj.Sort = sort;
        input.MapExtraPropertiesTo(insertObj, MappingPropertyDefinitionChecks.None);

        await workPlanRepository.InsertAsync(insertObj);

        //if (input.Sort.HasValue && insertObj.Sort != maxSort) 
        //{ 
        //    await AdjustSortAsync(insertObj.Id, insertObj.Sort); 
        //} 
 
        return ObjectMapper.Map<WorkPlan, WorkPlanDto>(insertObj); 
    } 
 

        return ObjectMapper.Map<WorkPlan, WorkPlanDto>(insertObj);
    }

    /// <summary> 
    /// 更新作业计划表 
    /// </summary> 
@@ -129,21 +137,21 @@
    /// <param name="input"></param> 
    /// <returns></returns> 
    /// <exception cref="UserFriendlyException"></exception> 
    public virtual async Task<WorkPlanDto> UpdateAsync(Guid id, WorkPlanUpdateDto input) 
    { 
        await CheckCreateOrUpdateDtoAsync(input); 
 
        var updateObj = await workPlanRepository.GetAsync(id); 
        var exist = await workPlanRepository.NameExistAsync(input.TaskCode, updateObj.Id); 
        if (exist) 
        { 
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.TaskCode]); 
        } 
 
        updateObj.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp); 
        input.MapExtraPropertiesTo(updateObj, MappingPropertyDefinitionChecks.None); 
 
                updateObj.TaskCode = input.TaskCode;
    public virtual async Task<WorkPlanDto> UpdateAsync(Guid id, WorkPlanUpdateDto input)
    {
        await CheckCreateOrUpdateDtoAsync(input);

        var updateObj = await workPlanRepository.GetAsync(id);
        var exist = await workPlanRepository.NameExistAsync(input.TaskCode, updateObj.Id);
        if (exist)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.TaskCode]);
        }

        updateObj.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
        input.MapExtraPropertiesTo(updateObj, MappingPropertyDefinitionChecks.None);

        updateObj.TaskCode = input.TaskCode;
        updateObj.DataIdentifier = input.DataIdentifier;
        updateObj.MaterialMode = input.MaterialMode;
        updateObj.Length = input.Length;
@@ -177,20 +185,20 @@
        updateObj.TeamInfo = input.TeamInfo;
        updateObj.Timestamp = input.Timestamp;
        updateObj.Remark = input.Remark;
 
 
        await workPlanRepository.UpdateAsync(updateObj); 
 
        return ObjectMapper.Map<WorkPlan, WorkPlanDto>(updateObj); 
    } 
 


        await workPlanRepository.UpdateAsync(updateObj);

        return ObjectMapper.Map<WorkPlan, WorkPlanDto>(updateObj);
    }

    /// <summary> 
    /// 克隆作业计划表 
    /// </summary> 
    /// <param name="ids"></param> 
    /// <returns></returns> 
    public async Task<List<WorkPlanDto>> CloneAsync(IEnumerable<Guid> ids) 
    { 
    public async Task<List<WorkPlanDto>> CloneAsync(IEnumerable<Guid> ids)
    {
        //var workPlans = new List<WorkPlan>(); 
        //if (ids != null) 
        //{ 
@@ -210,285 +218,435 @@
        //                    name += WorkPlanConsts.CloneTag; 
        //                    continue; 
        //                } 
 

        //                notExist = true; 
        //            } 
 

        //            //WorkPlan = await workPlanRepository.InsertAsync(WorkPlan.Clone(GuidGenerator.Create(), name, sort++)); 
        //            workPlans.Add(WorkPlan); 
        //        } 
        //    } 
        //} 
 

        //return ObjectMapper.Map<List<WorkPlan>, List<WorkPlanDto>>(workPlans); 
        return new List<WorkPlanDto>(); 
    } 
 
        return new List<WorkPlanDto>();
    }

    /// <summary> 
    /// 删除单个作业计划表 
    /// </summary> 
    /// <param name="id"></param> 
    /// <returns></returns> 
    public virtual Task DeleteAsync(Guid id) 
    { 
        return workPlanRepository.DeleteAsync(id); 
    } 
 
    public virtual Task DeleteAsync(Guid id)
    {
        return workPlanRepository.DeleteAsync(id);
    }

    /// <summary> 
    /// 删除多个作业计划表 
    /// </summary> 
    /// <param name="ids"></param> 
    /// <returns></returns> 
    public async Task DeleteManyAsync(IEnumerable<Guid> ids) 
    { 
        foreach (var id in ids) 
        { 
            await DeleteAsync(id); 
        } 
    } 
 
    public async Task DeleteManyAsync(IEnumerable<Guid> ids)
    {
        foreach (var id in ids)
        {
            await DeleteAsync(id);
        }
    }

    /// <summary> 
    /// 调整排序作业计划表 
    /// </summary> 
    /// <param name="id"></param> 
    /// <param name="sort"></param> 
    /// <returns></returns> 
    public virtual async Task AdjustSortAsync(Guid id, int sort) 
    { 
        var list = await workPlanRepository.GetListAsync(null, nameof(WorkPlan.Sort)); 
        if (list != null && list.Any()) 
        { 
            var initSort = 1; 
            list.ForEach(x => x.AdjustSort(initSort++)); 
            var entity = list.FirstOrDefault(x => x.Id == id); 
            if (entity != null) 
            { 
                if (sort == 1) 
                { 
                    list.Where(x => x.Id != id).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1)); 
                } 
                else if (entity.Sort > sort) 
                { 
                    list.Where(x => x.Id != id && x.Sort >= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1)); 
                    list.Where(x => x.Id != id && x.Sort < sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1)); 
                } 
                else if (entity.Sort < sort) 
                { 
                    list.Where(x => x.Id != id && x.Sort > sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1)); 
                    list.Where(x => x.Id != id && x.Sort <= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1)); 
                } 
 
                entity.AdjustSort(sort); 
            } 
        } 
 
        await workPlanRepository.UpdateManyAsync(list); 
    } 
 
    public virtual async Task AdjustSortAsync(Guid id, int sort)
    {
        var list = await workPlanRepository.GetListAsync(null, nameof(WorkPlan.Sort));
        if (list != null && list.Any())
        {
            var initSort = 1;
            list.ForEach(x => x.AdjustSort(initSort++));
            var entity = list.FirstOrDefault(x => x.Id == id);
            if (entity != null)
            {
                if (sort == 1)
                {
                    list.Where(x => x.Id != id).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                }
                else if (entity.Sort > sort)
                {
                    list.Where(x => x.Id != id && x.Sort >= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                    list.Where(x => x.Id != id && x.Sort < sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1));
                }
                else if (entity.Sort < sort)
                {
                    list.Where(x => x.Id != id && x.Sort > sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                    list.Where(x => x.Id != id && x.Sort <= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1));
                }

                entity.AdjustSort(sort);
            }
        }

        await workPlanRepository.UpdateManyAsync(list);
    }

    /// <summary> 
    /// 导入作业计划表 
    /// </summary> 
    /// <param name="input"></param> 
    /// <returns></returns> 
    /// <exception cref="UserFriendlyException"></exception> 
    public async Task ImportAsync(WorkPlansImportModel input) 
    { 
        Check.NotNull(input, nameof(input)); 
 
        var workPlanCreateDtos = new List<(int RowIndex, WorkPlanCreateDto Item)>(); 
        var workPlanUpdateDtos = new List<(int RowIndex, Guid Id, WorkPlanUpdateDto Item)>(); 
        var importItems = input.WorkPlans; 
 
        if (importItems != null && importItems.Any()) 
        { 
            #region 导入校验 
 
            // 判断名称是否重复，并输出第几行重复 
            var duplicateWorkPlans = importItems.GroupBy(x => x.TaskCode).Where(x => x.Count() > 1).ToList(); 
            if (duplicateWorkPlans?.Any() == true) 
            { 
                var duplicateWorkPlanMsgs = duplicateWorkPlans.Select(x => $"第 {string.Join(",", x.Select(x => x.RowIndex))} 行：{x.Key}  名称重复"); 
                var errorMsg = $"导入失败！配置， {string.Join(",", duplicateWorkPlanMsgs)}，终止导入"; 
                throw new UserFriendlyException(errorMsg); 
            } 
 
            #endregion 
 
            foreach (var impItem in importItems) 
            { 
                if (impItem.TaskCode.IsNullOrWhiteSpace()) 
                { 
                    continue; 
                } 
 
                if (impItem.TaskCode.IsNullOrWhiteSpace()) 
                { 
                    var errorMsg = $"导入失败！配置，第{impItem.RowIndex}行：WorkPlan名称不能为空"; 
                    throw new UserFriendlyException(errorMsg); 
                } 
 
                var oldWorkPlan = await workPlanRepository.FindByNameAsync(impItem.TaskCode); 
                if (oldWorkPlan != null) 
                { 
                    var workPlanUpdateDto = new WorkPlanUpdateDto 
                    { 
                        TaskCode = impItem.TaskCode,
DataIdentifier = impItem.DataIdentifier,
MaterialMode = impItem.MaterialMode,
Length = impItem.Length,
MarkingContent = impItem.MarkingContent,
MarkingPosition = impItem.MarkingPosition,
CuttingPosition = impItem.CuttingPosition,
Quantity = impItem.Quantity,
FlangeThickness = impItem.FlangeThickness,
FlangeInnerDiameter = impItem.FlangeInnerDiameter,
WeldingHeatInput = impItem.WeldingHeatInput,
PipeAllowableStress = impItem.PipeAllowableStress,
PipeDiameter = impItem.PipeDiameter,
PipeWallThickness = impItem.PipeWallThickness,
FactoryCode = impItem.FactoryCode,
ProductCode = impItem.ProductCode,
WorkstationCode = impItem.WorkstationCode,
EquipmentCode = impItem.EquipmentCode,
WorkpieceName = impItem.WorkpieceName,
ProcessName = impItem.ProcessName,
PipeFittingCode = impItem.PipeFittingCode,
PreSerialNumber = impItem.PreSerialNumber,
PipeSpecCode = impItem.PipeSpecCode,
PipeSectionName = impItem.PipeSectionName,
OuterDiameter = impItem.OuterDiameter,
Thickness = impItem.Thickness,
Material = impItem.Material,
HasMainSignature = impItem.HasMainSignature,
ProcessRouteNumber = impItem.ProcessRouteNumber,
PlannedStartTime = impItem.PlannedStartTime,
PlannedEndTime = impItem.PlannedEndTime,
TeamInfo = impItem.TeamInfo,
Timestamp = impItem.Timestamp,
Remark = impItem.Remark,
 
                    }; 
 
                    workPlanUpdateDtos.Add((impItem.RowIndex, oldWorkPlan.Id, workPlanUpdateDto)); 
                } 
                else 
                { 
                    var workPlanCreateDto = new WorkPlanCreateDto 
                    { 
                        TaskCode = impItem.TaskCode,
DataIdentifier = impItem.DataIdentifier,
MaterialMode = impItem.MaterialMode,
Length = impItem.Length,
MarkingContent = impItem.MarkingContent,
MarkingPosition = impItem.MarkingPosition,
CuttingPosition = impItem.CuttingPosition,
Quantity = impItem.Quantity,
FlangeThickness = impItem.FlangeThickness,
FlangeInnerDiameter = impItem.FlangeInnerDiameter,
WeldingHeatInput = impItem.WeldingHeatInput,
PipeAllowableStress = impItem.PipeAllowableStress,
PipeDiameter = impItem.PipeDiameter,
PipeWallThickness = impItem.PipeWallThickness,
FactoryCode = impItem.FactoryCode,
ProductCode = impItem.ProductCode,
WorkstationCode = impItem.WorkstationCode,
EquipmentCode = impItem.EquipmentCode,
WorkpieceName = impItem.WorkpieceName,
ProcessName = impItem.ProcessName,
PipeFittingCode = impItem.PipeFittingCode,
PreSerialNumber = impItem.PreSerialNumber,
PipeSpecCode = impItem.PipeSpecCode,
PipeSectionName = impItem.PipeSectionName,
OuterDiameter = impItem.OuterDiameter,
Thickness = impItem.Thickness,
Material = impItem.Material,
HasMainSignature = impItem.HasMainSignature,
ProcessRouteNumber = impItem.ProcessRouteNumber,
PlannedStartTime = impItem.PlannedStartTime,
PlannedEndTime = impItem.PlannedEndTime,
TeamInfo = impItem.TeamInfo,
Timestamp = impItem.Timestamp,
Remark = impItem.Remark,
 
                    }; 
 
                    workPlanCreateDtos.Add((impItem.RowIndex, workPlanCreateDto)); 
                } 
            } 
        } 
 
        // 新增 
        foreach (var workPlanDto in workPlanCreateDtos) 
        { 
            try 
            { 
                await CreateAsync(workPlanDto.Item); 
            } 
            catch (Exception e) 
            { 
                var errorMsg = $"导入失败！配置，第{workPlanDto.RowIndex}行：{e.Message}，终止导入"; 
                throw new UserFriendlyException(errorMsg); 
            } 
        } 
 
        // 更新 
        foreach (var workPlanDto in workPlanUpdateDtos) 
        { 
            try 
            { 
                await UpdateAsync(workPlanDto.Id, workPlanDto.Item); 
            } 
            catch (Exception e) 
            { 
                var errorMsg = $"导入失败！配置，第{workPlanDto.RowIndex}行：{e.Message}，终止导入"; 
                throw new UserFriendlyException(errorMsg); 
            } 
        } 
    } 
 
    public async Task ImportAsync(WorkPlansImportModel input)
    {

        //转换数据
        var result = ObjectMapper.Map<List<WorkPlansImportModel.WorkPlanImportModel>, List<WorkPlanInput>>(input.WorkPlans);

        await CreatebyApsAsync(result);
    }


    public async Task<MesOrderResponse> CreatebyApsAsync(List<WorkPlanInput> input)
    {
        if (input == null)
        {
            throw new UserFriendlyException("输入参数不能为空");
        }

        if (input.Count == 0)
        {
            throw new UserFriendlyException("输入参数Data不能为空");
        }

        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
        var productProvider = _serviceProvider.GetRequiredService<IProductProvider>();
        var formulaProvider = _serviceProvider.GetRequiredService<IFormulaProvider>();
        List<OrderModel> orderModels = new List<OrderModel>();
        //按照任务编号分组
        var groupTask = input.GroupBy(x => x.TaskCode);
        foreach (var gTask in groupTask)
        {
            var taskCode = gTask.Key;
            var order = await orderManager.GetByCodeAsync(taskCode);
            if (order != null)
            {
                throw new UserFriendlyException($"任务编号[{taskCode}]已存在");
            }


            //var product = await productProvider.FindByNameAsync(orderItem.PipeSectionName);
            //if (product == null)
            //{
            //    throw new UserFriendlyException($"产品名称[{orderItem.PipeSectionName}]不存在");
            //}

            //var formula = await formulaProvider.GetFormulaAsync(product.Id);
            //if (formula == null)
            //{
            //    throw new UserFriendlyException($"产品型号[{orderItem.MaterialCode}]无关联配方");
            //}
            //首先要创建 打码切割的工单 
            var productForCut = await productProvider.FindByNameAsync("切割原料管");
            if (productForCut == null)
            {
                throw new UserFriendlyException($"产品名称[切割原料管]不存在");
            }
            var formulaForCut = await formulaProvider.GetFormulaAsync(productForCut.Id);
            if (formulaForCut == null)
            {
                throw new UserFriendlyException($"产品名称[切割原料管]无关联配方");
            }
            //分组数据
            var group = gTask.ToList().GroupBy(x => x.DataIdentifier);
            foreach (var item in group)
            {
                OrderModel orderModelForCut = new OrderModel()
                {
                    Id = Guid.NewGuid(),
                    Code = "Cut_" + taskCode,
                    Source = "APS推送",
                    PlanStartTime = gTask.ToList().First().PlannedStartTime,
                    PlanFinishTime = gTask.ToList().First().PlannedEndTime,
                    PlanQty = (ulong)item.ToList().Count,
                    Status = OrderStatus.NotActive,
                    Product = new AssociationProductModel() { Id = productForCut.Id, Name = productForCut.Name, Model = productForCut.Model, ShortNumber = productForCut.ShortNumber },
                    Formula = new AssociationFormulaModel() { Id = formulaForCut.Id, Code = formulaForCut.Code, Name = formulaForCut.Name }
                };
                orderModelForCut.ExtraProperties["OuterDiameter"] = gTask.ToList().First().OuterDiameter;//外径
                orderModelForCut.ExtraProperties["Material"] = gTask.ToList().First().Material;//材质
                orderModelForCut.ExtraProperties["Length"] = gTask.ToList().First().Length;//长度

                var orderForCut = await orderManager.GetByCodeAsync(orderModelForCut.Code);
                if (orderForCut != null)
                {
                    //throw new UserFriendlyException($"工单[{orderModelForCut.Code}]已存在");
                    //不再抛异常，直接跳过
                    break;
                }

                var orderModelResultForCut = await orderManager.CreateAsync(orderModelForCut);
                if (orderModelResultForCut == null)
                {
                    throw new UserFriendlyException($"工单[{orderModelForCut.Code}]创建失败");
                }
                orderModels.Add(orderModelResultForCut);


                //OrderModel orderModel = new OrderModel();
                //orderModel.Id = Guid.NewGuid();
                //orderModel.Code = orderItem.TaskCode;
                //orderModel.Source = "APS推送";
                //orderModel.Product = new AssociationProductModel() { Id = product.Id, Name = product.Name, Model = product.Model, ShortNumber = product.ShortNumber };
                ////orderModel.Formula = new AssociationFormulaModel() { Id = formula.Id, Code = formula.Code, Name = formula.Name };
                //orderModel.PlanStartTime = orderItem.PlannedStartTime;
                //orderModel.PlanFinishTime = orderItem.PlannedEndTime;
                //orderModel.PlanQty = (ulong?)orderItem.OrderQty;
                //orderModel.Status = OrderStatus.NotActive;
                //orderModel.ExtraProperties["Source"] = "ddd";
                //var source = orderModel.ExtraProperties["Source"];
                //var orderModelResult = await orderManager.CreateAsync(orderModel);
                //if (orderModelResult == null)
                //{
                //    throw new UserFriendlyException($"工单[{orderItem.TaskCode}]创建失败");
                //}
                //orderModels.Add(orderModelResult);
            }

        }


        //保存到表中
        foreach (var item in input)
        {
            var insertObj = ObjectMapper.Map<WorkPlanInput, WorkPlanCreateDto>(item);
            //insertObj.OrgMaterialCode = "1111";
            insertObj.Sort = 1;
            await CreateAsync(insertObj);
        }


        // 发布事件
        //await _eventBus.PublishAsync(new EntityChangedEto("MESCREATE", input, null, EntityChangeType.Add, true));

        var response = new MesOrderResponse
        {
            Code = "000000",
            Data = orderModels,
            Fail = false,
            Mesg = "处理成功",
            Success = true,
            Time = DateTime.UtcNow
        };
        return response;
    }

    ///// <summary> 
    ///// 导入作业计划表 
    ///// </summary> 
    ///// <param name="input"></param> 
    ///// <returns></returns> 
    ///// <exception cref="UserFriendlyException"></exception> 
    //public async Task ImportAsync(WorkPlansImportModel input)
    //{
    //    Check.NotNull(input, nameof(input));

    //    var workPlanCreateDtos = new List<(int RowIndex, WorkPlanCreateDto Item)>();
    //    var workPlanUpdateDtos = new List<(int RowIndex, Guid Id, WorkPlanUpdateDto Item)>();
    //    var importItems = input.WorkPlans;

    //    if (importItems != null && importItems.Any())
    //    {
    //        #region 导入校验 

    //        // 判断名称是否重复，并输出第几行重复 
    //        var duplicateWorkPlans = importItems.GroupBy(x => x.TaskCode).Where(x => x.Count() > 1).ToList();
    //        if (duplicateWorkPlans?.Any() == true)
    //        {
    //            var duplicateWorkPlanMsgs = duplicateWorkPlans.Select(x => $"第 {string.Join(",", x.Select(x => x.RowIndex))} 行：{x.Key}  名称重复");
    //            var errorMsg = $"导入失败！配置， {string.Join(",", duplicateWorkPlanMsgs)}，终止导入";
    //            throw new UserFriendlyException(errorMsg);
    //        }

    //        #endregion

    //        foreach (var impItem in importItems)
    //        {
    //            if (impItem.TaskCode.IsNullOrWhiteSpace())
    //            {
    //                continue;
    //            }

    //            if (impItem.TaskCode.IsNullOrWhiteSpace())
    //            {
    //                var errorMsg = $"导入失败！配置，第{impItem.RowIndex}行：WorkPlan名称不能为空";
    //                throw new UserFriendlyException(errorMsg);
    //            }

    //            var oldWorkPlan = await workPlanRepository.FindByNameAsync(impItem.TaskCode);
    //            if (oldWorkPlan != null)
    //            {
    //                var workPlanUpdateDto = new WorkPlanUpdateDto
    //                {
    //                    TaskCode = impItem.TaskCode,
    //                    DataIdentifier = impItem.DataIdentifier,
    //                    MaterialMode = impItem.MaterialMode,
    //                    Length = impItem.Length,
    //                    MarkingContent = impItem.MarkingContent,
    //                    MarkingPosition = impItem.MarkingPosition,
    //                    CuttingPosition = impItem.CuttingPosition,
    //                    Quantity = impItem.Quantity,
    //                    FlangeThickness = impItem.FlangeThickness,
    //                    FlangeInnerDiameter = impItem.FlangeInnerDiameter,
    //                    WeldingHeatInput = impItem.WeldingHeatInput,
    //                    PipeAllowableStress = impItem.PipeAllowableStress,
    //                    PipeDiameter = impItem.PipeDiameter,
    //                    PipeWallThickness = impItem.PipeWallThickness,
    //                    FactoryCode = impItem.FactoryCode,
    //                    ProductCode = impItem.ProductCode,
    //                    WorkstationCode = impItem.WorkstationCode,
    //                    EquipmentCode = impItem.EquipmentCode,
    //                    WorkpieceName = impItem.WorkpieceName,
    //                    ProcessName = impItem.ProcessName,
    //                    PipeFittingCode = impItem.PipeFittingCode,
    //                    PreSerialNumber = impItem.PreSerialNumber,
    //                    PipeSpecCode = impItem.PipeSpecCode,
    //                    PipeSectionName = impItem.PipeSectionName,
    //                    OuterDiameter = impItem.OuterDiameter,
    //                    Thickness = impItem.Thickness,
    //                    Material = impItem.Material,
    //                    HasMainSignature = impItem.HasMainSignature,
    //                    ProcessRouteNumber = impItem.ProcessRouteNumber,
    //                    PlannedStartTime = impItem.PlannedStartTime,
    //                    PlannedEndTime = impItem.PlannedEndTime,
    //                    TeamInfo = impItem.TeamInfo,
    //                    Timestamp = impItem.Timestamp,
    //                    Remark = impItem.Remark,

    //                };

    //                workPlanUpdateDtos.Add((impItem.RowIndex, oldWorkPlan.Id, workPlanUpdateDto));
    //            }
    //            else
    //            {
    //                var workPlanCreateDto = new WorkPlanCreateDto
    //                {
    //                    TaskCode = impItem.TaskCode,
    //                    DataIdentifier = impItem.DataIdentifier,
    //                    MaterialMode = impItem.MaterialMode,
    //                    Length = impItem.Length,
    //                    MarkingContent = impItem.MarkingContent,
    //                    MarkingPosition = impItem.MarkingPosition,
    //                    CuttingPosition = impItem.CuttingPosition,
    //                    Quantity = impItem.Quantity,
    //                    FlangeThickness = impItem.FlangeThickness,
    //                    FlangeInnerDiameter = impItem.FlangeInnerDiameter,
    //                    WeldingHeatInput = impItem.WeldingHeatInput,
    //                    PipeAllowableStress = impItem.PipeAllowableStress,
    //                    PipeDiameter = impItem.PipeDiameter,
    //                    PipeWallThickness = impItem.PipeWallThickness,
    //                    FactoryCode = impItem.FactoryCode,
    //                    ProductCode = impItem.ProductCode,
    //                    WorkstationCode = impItem.WorkstationCode,
    //                    EquipmentCode = impItem.EquipmentCode,
    //                    WorkpieceName = impItem.WorkpieceName,
    //                    ProcessName = impItem.ProcessName,
    //                    PipeFittingCode = impItem.PipeFittingCode,
    //                    PreSerialNumber = impItem.PreSerialNumber,
    //                    PipeSpecCode = impItem.PipeSpecCode,
    //                    PipeSectionName = impItem.PipeSectionName,
    //                    OuterDiameter = impItem.OuterDiameter,
    //                    Thickness = impItem.Thickness,
    //                    Material = impItem.Material,
    //                    HasMainSignature = impItem.HasMainSignature,
    //                    ProcessRouteNumber = impItem.ProcessRouteNumber,
    //                    PlannedStartTime = impItem.PlannedStartTime,
    //                    PlannedEndTime = impItem.PlannedEndTime,
    //                    TeamInfo = impItem.TeamInfo,
    //                    Timestamp = impItem.Timestamp,
    //                    Remark = impItem.Remark,

    //                };

    //                workPlanCreateDtos.Add((impItem.RowIndex, workPlanCreateDto));
    //            }
    //        }
    //    }

    //    // 新增 
    //    foreach (var workPlanDto in workPlanCreateDtos)
    //    {
    //        try
    //        {
    //            await CreateAsync(workPlanDto.Item);
    //        }
    //        catch (Exception e)
    //        {
    //            var errorMsg = $"导入失败！配置，第{workPlanDto.RowIndex}行：{e.Message}，终止导入";
    //            throw new UserFriendlyException(errorMsg);
    //        }
    //    }

    //    // 更新 
    //    foreach (var workPlanDto in workPlanUpdateDtos)
    //    {
    //        try
    //        {
    //            await UpdateAsync(workPlanDto.Id, workPlanDto.Item);
    //        }
    //        catch (Exception e)
    //        {
    //            var errorMsg = $"导入失败！配置，第{workPlanDto.RowIndex}行：{e.Message}，终止导入";
    //            throw new UserFriendlyException(errorMsg);
    //        }
    //    }
    //}

    /// <summary> 
    /// 导出作业计划表 
    /// </summary> 
    /// <param name="input"></param> 
    /// <returns></returns> 
    public async Task<(Dictionary<string, object> Sheets, string FileName)> ExportAsync(GetWorkPlanInput input) 
    { 
        Check.NotNull(input, nameof(input)); 
 
        if (input.Sorting.IsNullOrWhiteSpace()) 
        { 
            input.Sorting = nameof(WorkPlan.Sort); 
        } 
 
    public async Task<(Dictionary<string, object> Sheets, string FileName)> ExportAsync(GetWorkPlanInput input)
    {
        Check.NotNull(input, nameof(input));

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            input.Sorting = nameof(WorkPlan.Sort);
        }

        #region 动态构造查询条件  
 

        //动态构造查询条件  
        var whereConditions = DynamicGetQueryParams(input); 
 
        #endregion 
 
 
        var list = await workPlanRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount, includeDetails: true); 
        var result = ObjectMapper.Map<List<WorkPlan>, List<WorkPlanDto>>(list); 
 
        var sheets = new Dictionary<string, object> 
        { 
            ["配置"] = ExportHelper.ConvertListToExportData(result), 
        }; 
 
        var fileName = "作业计划"; 
        return (sheets, fileName); 
    } 
 
        var whereConditions = DynamicGetQueryParams(input);

        #endregion


        var list = await workPlanRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount, includeDetails: true);
        var result = ObjectMapper.Map<List<WorkPlan>, List<WorkPlanDto>>(list);

        var sheets = new Dictionary<string, object>
        {
            ["配置"] = ExportHelper.ConvertListToExportData(result),
        };

        var fileName = "作业计划";
        return (sheets, fileName);
    }

    /// <summary> 
    /// 校验作业计划表，当新建或更新时 
    /// </summary> 
    /// <param name="input"></param> 
    /// <returns></returns> 
    protected Task CheckCreateOrUpdateDtoAsync(WorkPlanCreateOrUpdateDtoBase input) 
    { 
        Check.NotNull(input, nameof(input)); 
                Check.NotNullOrWhiteSpace(input.TaskCode, "任务编码", 256);
    protected Task CheckCreateOrUpdateDtoAsync(WorkPlanCreateOrUpdateDtoBase input)
    {
        Check.NotNull(input, nameof(input));
        Check.NotNullOrWhiteSpace(input.TaskCode, "任务编码", 256);
        Check.NotNull(input.Length, "长度(mm)");
        Check.NotNull(input.MarkingPosition, "打码位置");
        Check.NotNull(input.CuttingPosition, "切割位置");
@@ -500,7 +658,7 @@
        Check.NotNull(input.OuterDiameter, "外径(mm)");
        Check.NotNull(input.Thickness, "壁厚(mm)");
        Check.NotNull(input.HasMainSignature, "是否主支管");
 
        return Task.CompletedTask; 
    } 
} 

        return Task.CompletedTask;
    }
}