333

schangxiang@126.com

2025-05-16 9796651f30deb9eee38c9d846255b293fbba15eb

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

@@ -12,6 +12,19 @@
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;
using CmsQueryExtensions.Entitys;
using CMS.Unit.RuntimeValue.Abstractions;
using CMS.Extensions.Variable;
using CMS.Plugin.TraceManagement.Abstractions.Models.Traces;
using CMS.Plugin.ProcessManagement.Abstractions;
using KissUtil.Extensions;
using CMS.Plugin.TraceManagement.Abstractions;
using CMS.Plugin.ProductManagement.Abstractions.Models;
using CMS.Plugin.MaterialManagement.Abstractions;

namespace CMS.Plugin.PipeLineLems.Application.Implements;

@@ -21,10 +34,167 @@
public class SharedService : CMSPluginAppService
{

    public async Task<MesOrderResponse> CommonCreatebyApsAsync(List<WorkPlanInput> input, IServiceProvider _serviceProvider,
        WorkPlanAppService workPlanAppService
        )
    /// <summary>
    /// 分拣功能
    /// </summary>
    /// <param name="_serviceProvider"></param>
    /// <param name="input"></param>
    /// <param name="myCurrentUser"></param>
    /// <returns></returns>
    public async Task<MesOrderResponse> CommonPick(IServiceProvider _serviceProvider, PickInput input, MyCurrentUser myCurrentUser)
    {
        //1、记录分拣记录表
        //2、更新作业计划表的状态 =已分拣
        //3、写入 分拣变量
        //4、写入追溯报表
        //5、物料组盘

        VariableService _variableService = _serviceProvider.GetRequiredService<VariableService>();
        var _workSectionManager = _serviceProvider.GetRequiredService<IWorkSectionManager>();
        var _workStationManager = _serviceProvider.GetRequiredService<IWorkStationManager>();
        var traceProvider = _serviceProvider.GetRequiredService<ITraceProvider>();
        var materialProvider = _serviceProvider.GetRequiredService<IMaterialProvider>();
        var workPlanAppService = _serviceProvider.GetRequiredService<IWorkPlanAppService>();

        //Dictionary<string, object?> keyValuePairs = new Dictionary<string, object?>
        //            {
        //                { "分拣托盘号","托盘1"},
        //                { "分拣方向", "短管装配"},
        //                { "分拣人", myCurrentUser.UserAccount }
        //            };
        //_variableService.WriteValueAsync(keyValuePairs);

        //根据工序名获取工序对象
        var workSection = await _workSectionManager.GetByNameAsync("分拣工序");
        var workStation = await _workStationManager.GetByNameAsync("分拣工位");
        //写入追溯报表
        var finishTime = DateTime.Now;
        TraceModel traceModel = new TraceModel()
        {
            SerialNumber = input.PipeSpecCode,
            WorkSectionId = workSection.Id,
            WorkSectionName = workSection.Name,
            WorkStationName = workStation.Name,

            FinishTime = finishTime,
            IsQualified = true,
            UnqualifiedReason = "",
            ProductModel = "",
            ProductName = "",

        };
        traceModel.Params = new List<TraceParamModel>();
        foreach (var item in workSection.ProcessParameters)
        {
            var value = "ssss";
            traceModel.Params.Add(new TraceParamModel()
            {
                Key = item.Key,
                Value = value.SafeString()
            });
        }
        //物料参数列表
        var firstWorkPlans = await workPlanAppService.GetListByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode);

        var firstWorkPlan = await workPlanAppService.GetSingleByFilterAsync(x => x.PipeSpecCode == input.PipeSpecCode);
        var rawPipe_DataIdentifier = await materialProvider.FindByNameAsync("原料管标识");
        var rawPipe_MaterialMode = await materialProvider.FindByNameAsync("原料管型号");
        var rawPipe_Batch = await materialProvider.FindByNameAsync("原料管批次");
        List<TraceMaterialModel> _MaterialParams = new List<TraceMaterialModel>();
        foreach (var item in workSection.MaterialParameters)
        {
            if (item.Name == "原料管型号")
            {
                _MaterialParams.Add(new TraceMaterialModel()
                {
                    Key = item.Key,
                    Quantity = 1,
                    MaterialId = rawPipe_MaterialMode.MaterialId,
                    MaterialDetailId = rawPipe_MaterialMode.MaterialDetails.First().Id,
                    Value = firstWorkPlan.MaterialMode

                });
            }
            if (item.Name == "原料管标识")
            {
                _MaterialParams.Add(new TraceMaterialModel()
                {
                    Key = item.Key,
                    Quantity = 1,
                    MaterialId = rawPipe_DataIdentifier.MaterialId,
                    MaterialDetailId = rawPipe_DataIdentifier.MaterialDetails.First().Id,
                    Value = firstWorkPlan.DataIdentifier,

                });
            }
            if (item.Name == "原料管批次")
            {
                _MaterialParams.Add(new TraceMaterialModel()
                {
                    Key = item.Key,
                    Quantity = 1,
                    MaterialId = rawPipe_Batch.MaterialId,
                    MaterialDetailId = rawPipe_Batch.MaterialDetails.First().Id,
                    Value = "111",//批次暂时写死

                });
            }
        };

        //配置过程参数(采集参数、配方参数)
        traceModel.Params = new List<TraceParamModel>();
        foreach (var item in workSection.ProcessParameters)
        {
            string _value = "";
            if (item.Name == "分拣方向")
            {
                _value = "短管装配";
            }
            if (item.Name == "分拣托盘号")
            {
                _value = input.ContinerNo;
            }
            if (item.Name == "分拣人")
            {
                _value = myCurrentUser.UserAccount;
            }
            //item.Key
            TraceParamModel traceParamModel = new TraceParamModel()
            {
                Key = item.Key,
                Value = _value
            };
            traceModel.Params.Add(traceParamModel);
        };

        traceModel.MaterialParams = _MaterialParams;

        await traceProvider.CreateTraceAsync(traceModel);

        var response = new MesOrderResponse
        {
            Code = "200",
            Data = "",
            Message = "处理成功",
            Time = DateTime.UtcNow
        };
        return response;
    }
    /// <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("输入参数不能为空");
@@ -51,6 +221,7 @@
        var orderManager = _serviceProvider.GetRequiredService<IOrderManager>();
        var productProvider = _serviceProvider.GetRequiredService<IProductProvider>();
        var formulaProvider = _serviceProvider.GetRequiredService<IFormulaProvider>();

        List<OrderModel> orderModels = new List<OrderModel>();

        #region 事务
@@ -100,7 +271,8 @@
                    var order = await orderManager.GetByCodeAsync(prodOrderNo);
                    if (order != null)
                    {
                        throw new UserFriendlyException($"生产工单[{prodOrderNo}]已存在");
                        //throw new UserFriendlyException($"生产工单[{prodOrderNo}]已存在");
                        continue;
                    }

                    OrderModel orderModelForCut = new OrderModel()
@@ -165,6 +337,7 @@
                    CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.未执行,
                    DataIdentifier = gTask.Key,
                    MaterialMode = gTask.ToList().First().MaterialMode,
                    CreatorName = userAccount,
                    Quantity = 1
                };

@@ -173,15 +346,17 @@




            //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.WorkPlanStatus = Domain.Shared.Enums.WorkPlanStatusEnum.未生产;
                insertObj.Sort = 1;
                insertObj.CreatorName = userAccount;
                insertObj.Remark = "系统导入";
                await workPlanAppService.CreateAsync(insertObj);
            }

@@ -191,12 +366,12 @@
        }
        catch (Exception)
        {

            await uow.RollbackAsync();
            throw;
        }
        finally
        {
            await uow.RollbackAsync();

        }


@@ -212,9 +387,7 @@
        {
            Code = "000000",
            Data = orderModels,
            Fail = false,
            Mesg = "处理成功",
            Success = true,
            Message = "处理成功",
            Time = DateTime.UtcNow
        };
        return response;
@@ -255,4 +428,118 @@

        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}'，不允许叫料");
        }

        //TODO:这里调用wms的叫料接口

        // 更新数据
        callMaterialOrder.MaterialBatch = GenerateRandomBatch();//wms返回的原料批次
        callMaterialOrder.WmsRetResult = "成功";
        callMaterialOrder.WmsTaskNo = GenerateRandomTaskNo();
        callMaterialOrder.CallMaterialStatus = Domain.Shared.Enums.CallMaterialStatusEnum.叫料完成;
        callMaterialOrder.LastModifierName = "SuperAdmin";

        await callMaterialOrderRepository.UpdateAsync(callMaterialOrder);

        //更新作业计划表
        var workPlanList = await workPlanRepository.GetListByFilterAsync(x => x.DataIdentifier == 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.叫料完成,
            MaterialBatch = callMaterialOrder.MaterialBatch,
            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 = "200",
            Message = "叫料成功",
            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}";
    }

    private string GenerateRandomBatch()
    {
        // 获取当前时间戳（从1970-01-01 00:00:00 UTC到现在的秒数）
        long timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds();

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