优化代码

schangxiang@126.com

2025-05-12 91030ca8300557a1e03e17fb34167c16577aad45

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

@@ -7,17 +7,38 @@
using Microsoft.Extensions.DependencyInjection;
using Volo.Abp;
using Microsoft.Extensions.DependencyInjection;
using NPOI.Util;
using CMS.Plugin.PipeLineLems.Domain.CallMaterialOrder;
using CMS.Plugin.PipeLineLems.Application.Contracts.Services;
using CMS.Plugin.PipeLineLems.Application.Contracts.Dtos.CallMaterialOrder;
using Volo.Abp.Uow;
using System.Text;
using CMS.Plugin.PipeLineLems.Domain.WorkPlan;
using CMS.Plugin.PipeLineLems.Domain.CallMaterialOrderRecord;
using Volo.Abp.Users;

namespace CMS.Plugin.PipeLineLems.Application.Implements;

/// <summary> 
/// 作业计划表应用服务 
/// </summary> 
public class SharedService: CMSPluginAppService
public class SharedService : CMSPluginAppService
{
   
    public async Task<MesOrderResponse> CommonCreatebyApsAsync(List<WorkPlanInput> input, IServiceProvider _serviceProvider, WorkPlanAppService workPlanAppService)
    /// <summary>
    /// 创建作业计划
    /// </summary>
    /// <param name="input"></param>
    /// <param name="_serviceProvider"></param>
    /// <param name="workPlanAppService"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>

    public async Task<MesOrderResponse> CommonCreatebyApsAsync(List<WorkPlanInput> input, IServiceProvider _serviceProvider,
        WorkPlanAppService workPlanAppService,
        string userId, string userAccount
        )
    {
      
        if (input == null)
        {
            throw new UserFriendlyException("输入参数不能为空");
@@ -28,111 +49,178 @@
            throw new UserFriendlyException("输入参数Data不能为空");
        }

        //校验数据
        //1、原料标识相同的不能存在于两个 管段编号中
        //var validationResult = ValidateUniqueDataIdentifierPerPipeSection(input);
        //if (!validationResult.isValid)
        //{
        //    处理验证失败的情况
        //    throw new UserFriendlyException($"验证失败: {validationResult.errorMessage}");
        //    返回错误信息给客户端或进行其他处理
        //}


        var callMaterialOrderAppService = _serviceProvider.GetRequiredService<ICallMaterialOrderAppService>();

        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)

        #region 事务

        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);

        try
        {
            var taskCode = gTask.Key;
            var order = await orderManager.GetByCodeAsync(taskCode);
            if (order != null)
            #region 数据处理

            //按照 原料标识 分组
            var groupTask = input.GroupBy(x => x.DataIdentifier);
            foreach (var gTask in groupTask)
            {
                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)
                //var product = await productProvider.FindByNameAsync(orderItem.PipeSectionName);
                //if (product == null)
                //{
                //    throw new UserFriendlyException($"工单[{orderItem.TaskCode}]创建失败");
                //    throw new UserFriendlyException($"产品名称[{orderItem.PipeSectionName}]不存在");
                //}
                //orderModels.Add(orderModelResult);

                //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.PipeSpecCode);
                foreach (var item in group)
                {
                    var prodOrderNo = "Order_" + item.Key;
                    var order = await orderManager.GetByCodeAsync(prodOrderNo);
                    if (order != null)
                    {
                        //throw new UserFriendlyException($"生产工单[{prodOrderNo}]已存在");
                        continue;
                    }

                    OrderModel orderModelForCut = new OrderModel()
                    {
                        Id = Guid.NewGuid(),
                        Code = prodOrderNo,
                        Source = "APS推送",
                        PlanStartTime = gTask.ToList().First().PlannedStartTime,
                        PlanFinishTime = gTask.ToList().First().PlannedEndTime,
                        PlanQty = 1,
                        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;//长度
                    orderModelForCut.ExtraProperties["DataIdentifier"] = gTask.ToList().First().DataIdentifier;//原料标识
                    orderModelForCut.ExtraProperties["MaterialMode"] = gTask.ToList().First().MaterialMode;//原料类型
                    orderModelForCut.ExtraProperties["PipeFittingCode"] = gTask.ToList().First().PipeFittingCode;//管段编号

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


                //保存到 scms_callmaterialorders 表中
                CallMaterialOrderCreateDto insertObjForOrder = new CallMaterialOrderCreateDto()
                {
                    CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.未执行,
                    DataIdentifier = gTask.Key,
                    MaterialMode = gTask.ToList().First().MaterialMode,
                    Quantity = 1
                };

                await callMaterialOrderAppService.CreateAsync(insertObjForOrder);
            }



            //throw new UserFriendlyException($"主动触发失败");
            //保存到  scms_workplans 表中
            foreach (var item in input)
            {
                var insertObj = ObjectMapper.Map<WorkPlanInput, WorkPlanCreateDto>(item);
                //insertObj.OrgMaterialCode = "1111";
                insertObj.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.未执行;
                insertObj.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.未生产;
                insertObj.Sort = 1;
                insertObj.CreatorId = userId;
                insertObj.CreatorName = userAccount;
                await workPlanAppService.CreateAsync(insertObj);
            }

            #endregion

            await uow.CompleteAsync();
        }


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

        }



        #endregion



        // 发布事件
@@ -150,4 +238,142 @@
        return response;
    }

    /// <summary>
    /// 验证原料标识相同的记录不能存在于两个不同的管段编号中
    /// </summary>
    /// <param name="inputs">作业计划输入参数列表</param>
    /// <returns>验证结果，包含是否通过验证及错误信息</returns>
    public static (bool isValid, string errorMessage) ValidateUniqueDataIdentifierPerPipeSection(List<WorkPlanInput> inputs)
    {
        if (inputs == null || !inputs.Any())
        {
            return (true, string.Empty);
        }

        // 使用Lookup分组，键为原料标识，值为对应的管段编号集合
        var dataIdentifierGroups = inputs.ToLookup(x => x.DataIdentifier, x => x.PipeSpecCode);

        foreach (var group in dataIdentifierGroups)
        {
            // 忽略空的原料标识
            if (string.IsNullOrEmpty(group.Key))
            {
                continue;
            }

            // 获取当前原料标识对应的唯一管段编号集合
            var uniquePipeSections = group.Distinct().ToList();

            // 如果存在多个不同的管段编号，则违反规则
            if (uniquePipeSections.Count > 1)
            {
                return (false, $"原料标识 '{group.Key}' 存在于多个不同的管段编号中: {string.Join(", ", uniquePipeSections)}");
            }
        }

        return (true, string.Empty);
    }


    /// <summary>
    /// 根据原料标识进行叫料操作
    /// </summary>
    /// <param name="dataIdentifier">原料标识</param>
    /// <param name="_serviceProvider">服务提供者</param>
    /// <returns>操作结果</returns>
    /// <exception cref="UserFriendlyException">当数据不存在或状态不允许叫料时抛出</exception>
    public async Task<MesOrderResponse> CallMaterialByDataIdentifier(Guid id, IServiceProvider _serviceProvider)
    {
        if (string.IsNullOrEmpty(id.ToString()))
        {
            throw new UserFriendlyException("原料标识不能为空");
        }

        var callMaterialOrderRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRepository>();
        var workPlanRepository = _serviceProvider.GetRequiredService<IWorkPlanRepository>();
        var callMaterialOrderRecordRepository = _serviceProvider.GetRequiredService<ICallMaterialOrderRecordRepository>();
        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();

        // 查找数据

        var callMaterialOrder = await callMaterialOrderRepository.GetAsync(id);
        if (callMaterialOrder == null)
        {
            throw new UserFriendlyException($"找不到叫料记录");
        }

        // 验证状态
        if (callMaterialOrder.CallMaterialStatus != Domain.Shared.Enums.CallMaterialStatusEnum.未执行)
        {
            throw new UserFriendlyException($"原料标识为 '{callMaterialOrder.DataIdentifier}' 的叫料记录状态为 '{callMaterialOrder.CallMaterialStatus}'，不允许叫料");
        }

        // 更新数据
        callMaterialOrder.WmsRetResult = "成功";
        callMaterialOrder.WmsTaskNo = GenerateRandomTaskNo();
        callMaterialOrder.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
        callMaterialOrder.LastModifierName = "SuperAdmin";

        await callMaterialOrderRepository.UpdateAsync(callMaterialOrder);

        //更新作业计划表
        var workPlanList = await workPlanRepository.FindByDataIdentifierAsync(callMaterialOrder.DataIdentifier);
        foreach (var item in workPlanList)
        {
            item.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
            item.LastModifierName = "SuperAdmin";
        }
        await workPlanRepository.UpdateManyAsync(workPlanList);

        //新增叫料记录表
        var callMaterialOrderRecord = new CallMaterialOrderRecord()
        {
            CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成,
            MaterialMode = callMaterialOrder.MaterialMode,
            DataIdentifier = callMaterialOrder.DataIdentifier,
            Quantity = 1,
            WmsRetResult = callMaterialOrder.WmsRetResult,
            WmsTaskNo = callMaterialOrder.WmsTaskNo,
            CreatorName = "SuperAdmin"
        };
        await callMaterialOrderRecordRepository.InsertAsync(callMaterialOrderRecord);

        //更新工单表的状态
        var pipeSpecCodeList = workPlanList.Select(x => x.PipeSpecCode).Distinct().ToList();
        foreach (var item in pipeSpecCodeList)
        {
            var prodOrderNo = "Order_" + item;
            var order = await orderManager.GetByCodeAsync(prodOrderNo);
            if (order != null)
            {
                order.ExtraProperties["CallMaterialStatus"] = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成.ToString();
            }
            await orderManager.UpdateAsync(order);
        }


        // 返回结果
        var response = new MesOrderResponse
        {
            Code = "000000",
            Fail = false,
            Mesg = "叫料成功",
            Success = true,
            Time = DateTime.UtcNow
        };
        return response;
    }

    /// <summary>
    /// 生成随机的WmsTaskNo
    /// </summary>
    /// <returns>随机生成的任务编号</returns>
    private string GenerateRandomTaskNo()
    {
        // 获取当前时间戳（从1970-01-01 00:00:00 UTC到现在的秒数）
        long timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();

        // 生成前缀
        return $"WMS{timestamp}";
    }
}