最新代码更改

wanshenmean

2024-11-06 98cd144e4d58dbfcc09a2ffb0dbb6925519088b3

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageTaskServices/Task/Dt_TaskService.cs

@@ -1,8 +1,11 @@
using Mapster;
using Masuit.Tools;
using WIDESEA_DTO.MOM;
using WIDESEA_DTO.WMS;
using WIDESEA_IStorageBasicRepository;
using WIDESEA_IStoragIntegrationServices;
using WIDESEA_StorageBasicRepository;
using WIDESEA_StoragIntegrationServices;

namespace WIDESEA_StorageOutTaskServices;

@@ -12,6 +15,7 @@
    private readonly IUnitOfWorkManage _unitOfWorkManage;
    private readonly IDt_OutOrderRepository _outOrderRepository;
    private readonly IStockInfoRepository _stockInfoRepository;
    private readonly IStockInfoDetailRepository _stockInfoDetailRepository;
    private readonly IDt_Task_HtyRepository _task_HtyRepository;
    private readonly IDt_OutOrderAndStockRepository _outOrderAndStockRepository;
    private readonly IDt_OutOrderAndStock_HtyRepository _outOrderAndStock_HtyRepository;
@@ -22,10 +26,11 @@
    private readonly IPointStackerRelationRepository _pointStackerRelationRepository;
    private readonly ITaskExecuteDetailRepository _taskExecuteDetailRepository;
    private readonly ILocationStatusChangeRecordRepository _locationStatusChangeRecordRepository;
    private readonly IBoxingInfoRepository _boxingInfoRepository;
    private readonly ICellStateService _cellStateService;
    private readonly IProcessApplyService _processApplyService;
    private readonly IDt_AreaInfoRepository _areaInfoRepository;
    private readonly IBoxingInfoRepository _boxingInfoRepository; //组盘
    private readonly ICellStateService _cellStateService; //电芯属性
    private readonly IProcessApplyService _processApplyService; //工艺路线
    private readonly IDt_AreaInfoRepository _areaInfoRepository; //区域
    private readonly IAgingInOrOutInputService _agingInOrOutInputService; //静置\陈化

    public Dt_TaskService(IDt_TaskRepository BaseDal,
                                IUnitOfWorkManage unitOfWorkManage,
@@ -44,7 +49,9 @@
                                IBoxingInfoRepository boxingInfoRepository,
                                ICellStateService cellStateService,
                                IProcessApplyService processApplyService,
                                IDt_AreaInfoRepository areaInfoRepository) : base(BaseDal)
                                IDt_AreaInfoRepository areaInfoRepository,
                                IAgingInOrOutInputService agingInOrOutInputService,
                                IStockInfoDetailRepository stockInfoDetailRepository) : base(BaseDal)
    {
        _unitOfWorkManage = unitOfWorkManage;
        _outOrderRepository = outOrderRepository;
@@ -63,14 +70,16 @@
        _cellStateService = cellStateService;
        _processApplyService = processApplyService;
        _areaInfoRepository = areaInfoRepository;
        _agingInOrOutInputService = agingInOrOutInputService;
        _stockInfoDetailRepository = stockInfoDetailRepository;
    }

    #region 外部接口方法

    #region 堆垛机出库任务完成
    #region 出库任务完成

    /// <summary>
    /// 堆垛机出库任务完成
    /// 出库任务完成
    /// </summary>
    /// <param name="saveModel">任务数据合集</param>
    /// <returns>返回结果集</returns>
@@ -79,17 +88,48 @@
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 更新库存状态
            // 设置库位状态为空闲
            stock.LocationInfo.LocationStatus = LocationEnum.Free.ObjToInt();
            // 设置库存状态为出库
            stock.StockInfoDetails.ForEach(x =>
            if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
            {
                x.Status = 2;
            });
                var process = await SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                     .FirstAsync(x => x.EquipmentName == task.Roadway);
                EquipmentParameterInfo info = JsonConvert.DeserializeObject<EquipmentParameterInfo>(process.ProcessValue);
                AgingOutputDto agingOutputDto = new AgingOutputDto()
                {
                    OpFlag = 1,
                    EquipmentCode = stock.LocationInfo.RoadwayNo,
                    TrayBarcode = stock.PalletCode,
                    SerialNos = stock.StockInfoDetails.Select(x => new SerialNoOutDto()
                    {
                        SlotNo = x.OrderNo.ToInt32(),
                        SerialNo = x.SerialNumber,
                        SerialNoResult = true,
                        ParameterInfo = new List<ParameterInfo>()
                        {
                             new ParameterInfo()
                             {
                                  LowerLomit =info.LowerControlLimit,
                                   UpperLimit = info.UpperControlLimit,
                                   ParameterResult = info.EquipmentAvailabilityFlag,
                                   ParameterCode = info.ParameterCode,
                                    ParameterDesc = info.Description,
                                     TargetValue = info.TargetValue,
                                      Value = info.TargetValue,
                                       DefectCode = info.UOMCode
                             }
                        }
                    }).ToList()
                };
            }
            // 更新库存状态
            var loation = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
            var detail = _stockInfoDetailRepository.QueryData(x => x.StockId == stock.Id);

            // 设置库位状态为空闲
            loation.LocationStatus = LocationEnum.Free.ObjToInt();


            // 更新任务状态
            task.TaskState = TaskOutStatusEnum.SC_OutFinish.ObjToInt();
            task.TaskState = TaskOutStatusEnum.OutFinish.ObjToInt();
            task.CurrentAddress = task.NextAddress;
            task.NextAddress = task.TargetAddress;

@@ -98,13 +138,15 @@
            // 事务处理
            // 开始事务
            _unitOfWorkManage.BeginTran();
            // 更新库存信息
            var isStockUpdated = _stockInfoRepository.UpdateData(stock);
            // 更新任务信息
            var isTaskUpdated = await Update(task);
            // 删除库存信息
            var isStockUpdated = _stockInfoRepository.DeleteDataById(stock.Id);
            // 删除库存信息
            var isStockDetailUpdated = _stockInfoDetailRepository.DeleteDataByIds(detail.Select(x => (object)x.Id).ToArray());
            // 删除任务信息
            var isTaskUpdated = BaseDal.DeleteDataById(task.TaskId);

            // 如果库存信息和任务信息都更新成功
            if (isStockUpdated && isTaskUpdated)
            if (isStockUpdated && isTaskUpdated && isStockDetailUpdated)
            {
                // 记录日志
                LogFactory.GetLog("任务完成").InfoFormat(true, "堆垛机出库完成", $"事务处理完成，库存状态更新：{isStockUpdated}，任务状态更新:{isTaskUpdated}");
@@ -179,28 +221,66 @@
        try
        {
            var boxing = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);
            var locationInf = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);

            var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
            // 创建库存实例模型
            DtStockInfo stock = new DtStockInfo()
            {
                PalletCode = task.PalletCode,
                LocationCode = task.TargetAddress,
                CreateDate = DateTime.Now,
                Creater = "system",
                IsFull = boxing.IsFull,
                StockInfoDetails = boxDetail,
                LocationInfo = new DtLocationInfo()
            };
            locationInf.LocationStatus = (int)LocationEnum.InStock;

            // 创建历史任务实例模型
            var taskHty = CreateHistoricalTask(task);

            // 修改货位信息为有货
            var locationInf = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);
            locationInf.LocationStatus = (int)LocationEnum.InStock;
            // 创建库存实例模型
            DtStockInfo stock;
            if (boxing == null)
            {
                // 空托盘

            LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务完成", $"货位地址：{task.TargetAddress},修改后货位数据：{locationInf}");
                stock = new DtStockInfo()
                {
                    PalletCode = task.PalletCode,
                    LocationCode = task.TargetAddress,
                    CreateDate = DateTime.Now,
                    Creater = "system",
                    IsFull = boxing.IsFull,
                    StockInfoDetails = new List<DtStockInfoDetail>()
                    {
                        new DtStockInfoDetail()
                        {
                             MaterielCode = "空托盘",
                             Id = 0,
                        }
                    }
                };
            }
            else
            {
                // 实盘
                var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
                // 创建库存实例模型
                stock = new DtStockInfo()
                {
                    PalletCode = task.PalletCode,
                    LocationCode = task.TargetAddress,
                    CreateDate = DateTime.Now,
                    Creater = "system",
                    IsFull = boxing.IsFull,
                    StockInfoDetails = boxDetail,
                };

                AgingInputDto agingInputDto = new AgingInputDto()
                {
                    SerialNos = boxing.BoxingInfoDetails
                        .Select(item => new SerialNoInDto { SerialNo = item.SerialNumber, PositionNo = item.OrderNo })
                        .ToList(),
                    TrayBarcode = task.PalletCode,
                    OpFlag = 1
                };
                var result = await _agingInOrOutInputService.GetOCVInputAsync(agingInputDto);
                stock.Remark = JsonConvert.DeserializeObject<ResponeAgingInputDto>(result.Data.ToString()).LinedProcessFeedbackTime;


                LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务完成", $"货位地址：{task.TargetAddress},修改后货位数据：{locationInf}");

            }

            // 执行数据库事务
            bool isResult = await ExecuteTransaction(stock, taskHty, locationInf, task.TaskId);
@@ -249,10 +329,15 @@
                LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                return await CompleteInboundTaskAsync(task);
            }
            else if (task.TaskType == (int)TaskInboundTypeEnum.InTray)
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "空托盘入库", "");
                return await CompleteInboundTaskAsync(task);
            }
            else
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "库存不存在也不是入库任务", "");
                return content.Error("库存不存在");
                LogFactory.GetLog("任务完成").InfoFormat(true, "任务状态异常", "");
                return content.Error("任务状态异常");
            }
        }
        LogFactory.GetLog("任务完成").InfoFormat(true, "验证库存是否存在", JsonConvert.SerializeObject(stock));
@@ -260,15 +345,20 @@
        if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
        {
            LogFactory.GetLog("任务完成").InfoFormat(true, "出库任务", "");
            if (task.TaskState == TaskOutStatusEnum.SC_OutExecuting.ObjToInt())
            if (task.TaskState == TaskOutStatusEnum.Line_OutFinish.ObjToInt())
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "堆垛机出库完成", "");
                return await CompleteStackTaskAsync(task, stock);
            }
            else
            else if (task.TaskState == TaskOutStatusEnum.SC_OutExecuting.ObjToInt())
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "库存不存在也不是入库任务", "");
                return content.Error("库存不存在");
            }
            else
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "任务状态异常", "");
                return content.Error("任务状态异常");
            }
        }
        else if (task.TaskType == (int)TaskTypeEnum.RelocationIn)
@@ -310,8 +400,14 @@
            // 如果状态为false，则返回content
            if (!content.Status) return content;

            // 调用GetProcessApplyAsync方法，获取工艺申请
            ProcessApplyDto process = await GetProcessApplyAsync(content);
            // 添加组盘信息
            // 将content.Data转换为ResultTrayCellsStatus对象
            var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.ToString());
            var boxing = await CreateBoxingInfo(result, input.PalletCode);

            // 调用GetProcessApplyAsync方法，获取工艺路线
            ProcessApplyDto process = await GetProcessApplyAsync(result);

            // 如果process为null，则返回content
            if (process == null) return content;

@@ -322,6 +418,10 @@
            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
            // 如果task不为null，则调用UpdateExistingTask方法，更新任务；否则调用CreateNewTask方法，创建新任务
            content = task != null ? await UpdateExistingTask(input, task) : await CreateNewTask(processResponse, input);
            if (content.Status)
            {
                var isBox = await _boxingInfoRepository.AddDataNavAsync(boxing);
            }
        }
        catch (Exception err)
        {
@@ -341,19 +441,32 @@
        return await _cellStateService.GetTrayCellStatusAsync(trayCells);
    }

    // 获取工艺申请
    private async Task<ProcessApplyDto> GetProcessApplyAsync(WebResponseContent content)
    // 获取组盘信息
    private async Task<DtBoxingInfo> CreateBoxingInfo(ResultTrayCellsStatus result, string palletCode)
    {
        // 如果状态为false，则返回null
        if (!content.Status) return null;
        return new DtBoxingInfo
        {
            PalletCode = palletCode,
            IsFull = true,
            BoxingInfoDetails = result.SerialNos.Select(serialNoObj => new DtBoxingInfoDetail
            {
                SerialNumber = serialNoObj.SerialNo,
                OrderNo = serialNoObj.PositionNo.ToString(),
                Status = serialNoObj.SerialNoStatus,
                MaterielCode = result.BindCode,
                Remark = result.TrayBarcodePropertys.ToJsonString(),
            }).ToList()
        };
    }

        // 将content.Data转换为ResultTrayCellsStatus对象
        var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
    // 获取工艺申请
    private async Task<ProcessApplyDto> GetProcessApplyAsync(ResultTrayCellsStatus content)
    {
        // 创建一个ProcessApplyDto对象，并赋值
        return new ProcessApplyDto()
        {
            WipOrderNo = result.BindCode,
            SerialNos = result.SerialNos.Select(item => new SerialNos
            //WipOrderNo = result.BindCode,
            SerialNos = content.SerialNos.Select(item => new SerialNos
            {
                SerialNo = item.SerialNo
            }).ToList()
@@ -381,6 +494,12 @@
                    .Where(x => x.EquipmentType == "陈化" && x.WipOrderNo == apply.WipOrderNo && x.ProductDesc == apply.ProductNo)
                    .ToList();

            case "1339":
            case "1406":
                return SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                    .Where(x => x.EquipmentType == "静置" && x.WipOrderNo == apply.WipOrderNo && x.ProductDesc == apply.ProductNo)
                    .ToList();

            default:
                return new List<Dt_EquipmentProcess>();
        }
@@ -397,7 +516,7 @@
        {
            var area = _areaInfoRepository.QueryFirst(x => x.AreaCode == "CH");

            var stockInfo = _stockInfoRepository.QueryData(x => x.Remark == area.AreaCode && x.StockInfoDetails.Any(z => z.MaterielCode == "空托盘")).OrderBy(x => x.CreateDate).FirstOrDefault();
            var stockInfo = _stockInfoRepository.QueryData(x => x.LocationInfo.AreaId == area.AreaID && x.StockInfoDetails.Any(z => z.MaterielCode == "空托盘")).OrderBy(x => x.CreateDate).FirstOrDefault();
            // 创建新任务实例
            var task = new Dt_Task
            {
@@ -444,6 +563,65 @@
    }

    #endregion 请求空托盘

    #region 陈化请求出库

    // 陈化请求出库
    public async Task<WebResponseContent> OutTrayByCh(string position)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var area = _areaInfoRepository.QueryFirst(x => x.AreaName == "陈化区");
            // 查询库存信息

            var stockInfo = _stockInfoRepository.QueryData(x => x.AreaCode == area.AreaCode && Convert.ToDateTime(x.Remark) < DateTime.Now && x.LocationInfo.LocationStatus == (int)LocationEnum.InStock).OrderBy(x => x.CreateDate).FirstOrDefault();
            // 创建新任务实例
            var task = new Dt_Task()
            {
                Grade = 1,
                Roadway = stockInfo.LocationInfo.RoadwayNo,
                TargetAddress = position,
                Dispatchertime = DateTime.Now,
                MaterialNo = "",
                NextAddress = position,
                OrderNo = null,
                PalletCode = stockInfo.PalletCode,
                SourceAddress = stockInfo.LocationCode,
                TaskState = (int)TaskOutStatusEnum.OutNew,
                TaskType = (int)TaskOutboundTypeEnum.OutTray,
                TaskNum = await BaseDal.GetTaskNo(),
                Creater = "Systeam"
            };
            var taskId = await BaseDal.AddDataAsync(task);
            bool isResult = taskId > 0;
            if (isResult)
            {
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = task.TaskNum.Value,
                    Grade = 1,
                    PalletCode = DateTime.Now.ToString("MMddHHmmss"),
                    RoadWay = task.Roadway,
                    SourceAddress = stockInfo.LocationCode,
                    TargetAddress = task.Roadway,
                    TaskState = (int)TaskOutStatusEnum.OutNew,
                    Id = 0,
                    TaskType = (int)TaskOutboundTypeEnum.OutTray
                };
                stockInfo.LocationInfo.LocationStatus = (int)LocationEnum.InStockDisable;
                _locationRepository.UpdateData(stockInfo.LocationInfo);
                content.OK(data: taskDTO);
            }
        }
        catch (Exception ex)
        {
            throw;
        }
        return content;
    }

    #endregion 陈化请求出库

    #endregion 外部接口方法

@@ -745,15 +923,6 @@
        DtLocationInfo location = new DtLocationInfo();
        int beforeStatus = 0;

        // 根据任务类型判断是出库任务还是入库任务
        //if (input.Type == (int)TaskTypeEnum.Outbound)
        //{
        //    // 处理出库任务
        //    toAddress = await GetRoadWayAsync(areaId, task.Roadway, input.Direction, input.Area, input.Type);
        //    taskState = (int)TaskOutStatusEnum.SC_OutFinish;
        //}
        //else
        //{
        // 处理入库任务
        location = await GetLocationDistributeAsync(task.Roadway);
        toAddress = location.LocationCode;
@@ -762,10 +931,8 @@

        // 更新货位信息
        location.LocationStatus = (int)LocationEnum.Lock;
        //}

        // 更新任务信息
        //task.SourceAddress = input.Position;
        task.CurrentAddress = input.Position;
        task.TargetAddress = toAddress;
        task.NextAddress = toAddress;
@@ -843,6 +1010,7 @@
            TaskNum = await BaseDal.GetTaskNo(),
            Creater = "Systeam"
        };

        // 尝试添加新任务
        var taskId = await BaseDal.AddDataAsync(task);
        bool isResult = taskId > 0;
@@ -852,6 +1020,7 @@
            isResult = await _taskExecuteDetailRepository.AddDetailAsync(task, false, TaskDescription.GetTaskUpdateDescription(input.PalletCode, input.Position, ToAddress, TaskInStatusEnum.InNew.GetIntegralRuleTypeEnumDesc()));
            if (isResult)
            {
                // 创建WMS任务
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = 0,