分容组盘 电芯属性获取

刘磊

2024-11-26 00bf7fd07edc7f23c29c00c1193f55defb88b71d

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

@@ -2,6 +2,8 @@
using Mapster;
using Masuit.Tools;
using Masuit.Tools.Models;
using System.Diagnostics;
using WIDESEA_DTO;
using WIDESEA_DTO.MOM;
using WIDESEA_DTO.WMS;
using WIDESEA_IStorageBasicRepository;
@@ -10,13 +12,14 @@
using WIDESEA_StorageBasicRepository;
using WIDESEA_StorageTaskRepository;
using WIDESEA_StoragIntegrationServices;
using WIDESEAWCS_Model.Models;

namespace WIDESEA_StorageOutTaskServices;

public partial class Dt_TaskService : ServiceBase<Dt_Task, IDt_TaskRepository>, IDt_TaskService
{

    //#region 出库任务完成
    #region 出库任务完成


    //public async Task<WebResponseContent> CompleteStackTaskAsync(Dt_Task task, DtStockInfo stock)
@@ -145,7 +148,7 @@
    //    }
    //}

    //#endregion 出库任务完成
    #endregion 出库任务完成

    #region 移库任务完成

@@ -374,7 +377,7 @@
                        PalletCode = task.PalletCode,
                        RoadWay = task.Roadway,
                        SourceAddress = task.SourceAddress,
                        TargetAddress = task.Roadway,
                        TargetAddress = task.TargetAddress,
                        TaskState = task.TaskState.Value,
                        Id = 0,
                        TaskType = task.TaskType,
@@ -383,14 +386,14 @@
                }
            }

            // 创建一个TrayCellsStatusDto对象，并赋值
            TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
            {
                Software = "WMS",
                TrayBarcode = input.PalletCode,
                //EquipmentCode = "EQ_CWJZ01"
                EquipmentCode = input.EquiCodeMOM
            };
            //创建一个TrayCellsStatusDto对象，并赋值
           TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
           {
               Software = "WMS",
               TrayBarcode = input.PalletCode,
               //EquipmentCode = "EQ_CWJZ01"
               EquipmentCode = input.EquiCodeMOM
           };

            // 调用GetTrayCellStatusAsync方法，获取整盘电芯
            content = await GetTrayCellStatusAsync(trayCells);
@@ -403,35 +406,32 @@
            if (result.SerialNos.Count <= 0)
                return content.Error(result.MOMMessage);

            Console.WriteLine(result);
            // TODO 获取本地料框属性与整盘电芯属性获取的值进行对比，如果一致则继续，否则返回错误信息
            //var productions = await _productionRepository.QueryDataAsync(x => result.TrayBarcodePropertys.Select(x => x.TrayBarcodeProperty).ToList().Contains(x.TrayBarcodeProperty));
            //if (productions.Count <= 0)
            //    return content.Error("料框属性不存在");
            //Console.WriteLine(result);
            //// TODO 获取本地料框属性与整盘电芯属性获取的值进行对比，如果一致则继续，否则返回错误信息
            ////var productions = await _productionRepository.QueryDataAsync(x => result.TrayBarcodePropertys.Select(x => x.TrayBarcodeProperty).ToList().Contains(x.TrayBarcodeProperty));
            ////if (productions.Count <= 0)
            ////    return content.Error("料框属性不存在");

            // 调用CreateBoxingInfo方法，创建组盘信息

            var boxing = await CreateBoxingInfo(result, input.PalletCode);
            //// 调用CreateBoxingInfo方法，创建组盘信息
            var boxing =  CreateBoxingInfo(result, input.PalletCode);
            if (boxing == null) return content.Error("组盘失败");

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

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

            // 调用_processApplyService.GetProcessApplyAsync方法，获取工艺申请
            content = await _processApplyService.GetProcessApplyAsync(process);
            //// 调用_processApplyService.GetProcessApplyAsync方法，获取工艺申请
            //content = await _processApplyService.GetProcessApplyAsync(process);

            // 如果状态为false，则返回null
            if (!content.Status) return content.Error("工艺申请失败");
            //// 如果状态为false，则返回null
            //if (!content.Status) return content.Error("工艺申请失败");

            //// 调用GetProcessResponseAsync方法，获取工艺响应
            //var processResponse = await GetProcessResponseAsync(process, input.Position);

            List<string> strings = input.Position == "1088" ? new List<string>() { "CHSC01" } : new List<string>() { "JZSC01" };
            ////// 调用GetProcessResponseAsync方法，获取工艺响应
            ////var processResponse = await GetProcessResponseAsync(process, input.Position);
            // 调用CreateNewTask方法，创建新任务
            content = await CreateNewTask(input, strings);
            content = await CreateNewTask(input);
            if (content.Status)
            {
                var isBox = await _boxingInfoRepository.AddDataNavAsync(boxing);
@@ -443,11 +443,259 @@
            content.Error(err.Message);
            Console.WriteLine(err.Message);
        }

        // 返回content
        return content;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="input">请求参数</param>
    /// <param name="flag">实框空框标识</param>
    /// <returns></returns>
    private async Task<WebResponseContent> CreateNewTask(RequestTaskDto input)
    {
        WebResponseContent content = new WebResponseContent();

        //DtLocationInfo locationInfo = await RequestLocation(input);

        //if (locationInfo == null) throw new Exception("库位已满");

        var stationinfo = _stationManagerRepository.QueryFirst(x => x.stationChildCode == input.Position);

        if (stationinfo == null) throw new Exception("未知站台");


        var task = await CreateNewTaskByStation(input, stationinfo);

        // 创建新任务实例
        //var task = new Dt_Task
        //{
        //    CurrentAddress = input.Position,
        //    Grade = 1,
        //    Roadway = input.Roadways,
        //    TargetAddress = locationInfo.LocationCode,
        //    Dispatchertime = DateTime.Now,
        //    MaterialNo = "",
        //    NextAddress = input.Roadways,
        //    OrderNo = null,
        //    PalletCode = input.PalletCode,
        //    SourceAddress = stationinfo.stationLocation,
        //    TaskState = (int)TaskInStatusEnum.Line_InFinish,
        //    TaskType = (int)TaskInboundTypeEnum.Inbound,
        //    TaskNum = await BaseDal.GetTaskNo(),
        //    Creater = "Systeam"
        //};

        // 尝试添加新任务
        var taskId = await BaseDal.AddDataAsync(task);
        bool isResult = taskId > 0;
        if (isResult)
        {
            // 创建WMS任务
            WMSTaskDTO taskDTO = new WMSTaskDTO()
            {
                TaskNum = task.TaskNum.Value,
                Grade = 1,
                PalletCode = task.PalletCode,
                RoadWay = task.Roadway,
                SourceAddress = task.SourceAddress,
                TargetAddress = task.TargetAddress,
                TaskState = task.TaskState.Value,
                Id = 0,
                TaskType = task.TaskType,
            };
            content.OK(data: taskDTO);
        }
        else
            content.Error("添加任务失败");
        return content;
    }

    /// <summary>
    /// 根据请求参数和站台 做不同任务处理
    /// </summary>
    /// <param name="input"></param>
    /// <param name="stationManager"></param>
    /// <returns></returns>
    /// <exception cref="Exception"></exception>
    private async Task<Dt_Task> CreateNewTaskByStation(RequestTaskDto input, Dt_StationManager stationManager)
    {
        Dt_Task task = null;
        switch (stationManager.stationType)
        {
            case 6:
            case 1:
                task = await CreateInTaskAsync(input, stationManager); break;
            //case 2:
            //case 3:  //异常排出给WCS处理
            //case 4:
            case 5:
                task = await CreateInToOutTaskAsync(input, stationManager); break;
            case 7:
                task = await CreateEmptyOutTaskAsync(input, stationManager); break;
            default:
                throw new Exception("未知站台类型");
        }
        return task;
    }

    #region 直接出库任务
    private async Task<Dt_Task> CreateInToOutTaskAsync(RequestTaskDto input, Dt_StationManager stationManager)
    {
        if (stationManager.stationType != 5) throw new Exception("错误的调取");

        var targetStation = _stationManagerRepository.QueryFirst(x => x.stationPLC == stationManager.stationPLC && x.Roadway == stationManager.Roadway && x.stationType == 2);

        var task = new Dt_Task
        {
            CurrentAddress = input.Position,
            Grade = 1,
            Roadway = input.Roadways,
            TargetAddress = targetStation.stationLocation,
            Dispatchertime = DateTime.Now,
            MaterialNo = "",
            NextAddress = input.Roadways,
            OrderNo = null,
            PalletCode = input.PalletCode,
            SourceAddress = stationManager.stationLocation,
            TaskState = (int)TaskInStatusEnum.Line_InFinish,
            TaskType = (int)TaskOutboundTypeEnum.InToOut,
            TaskNum = await BaseDal.GetTaskNo(),
            Creater = "Systeam"
        };

        return task;
    }
    #endregion


    #region 入库任务
    private async Task<Dt_Task> CreateInTaskAsync(RequestTaskDto input, Dt_StationManager stationManager)
    {
        if (stationManager.stationType != 1 && stationManager.stationType != 6) throw new Exception("错误的调取");

        DtLocationInfo locationInfo = null;
        if (stationManager.stationType == 1 && stationManager.Roadway.Contains("FR"))
        {
            locationInfo = await RequestLocation(input, true);
        }
        else
        {
            locationInfo = await RequestLocation(input);
        }
        //DtLocationInfo locationInfo = await RequestLocation(input);

        if (locationInfo == null) throw new Exception("库位已满");

        if (stationManager.stationType == 1)
        {
            // 创建一个TrayCellsStatusDto对象，并赋值
            TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
            {
                Software = "WMS",
                TrayBarcode = input.PalletCode,
                //EquipmentCode = "EQ_CWJZ01"
                EquipmentCode = input.EquiCodeMOM
            };

            // 调用GetTrayCellStatusAsync方法，获取整盘电芯
            WebResponseContent content = await GetTrayCellStatusAsync(trayCells);
            // 如果状态为false，则返回content
            if (!content.Status) throw new Exception(content.Message);

            // 添加组盘信息
            // 将content.Data转换为ResultTrayCellsStatus对象
            var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
            if (result.SerialNos.Count <= 0) throw new Exception(result.MOMMessage);

            //Console.WriteLine(result);
            //// TODO 获取本地料框属性与整盘电芯属性获取的值进行对比，如果一致则继续，否则返回错误信息
            ////var productions = await _productionRepository.QueryDataAsync(x => result.TrayBarcodePropertys.Select(x => x.TrayBarcodeProperty).ToList().Contains(x.TrayBarcodeProperty));
            ////if (productions.Count <= 0)
            ////    return content.Error("料框属性不存在");

            //// 调用CreateBoxingInfo方法，创建组盘信息
            var boxing = CreateBoxingInfo(result, input.PalletCode);
            if (boxing == null) throw new Exception("组盘失败");

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

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

            //// 调用_processApplyService.GetProcessApplyAsync方法，获取工艺申请
            //content = await _processApplyService.GetProcessApplyAsync(process);

            //// 如果状态为false，则返回null
            //if (!content.Status) return content.Error("工艺申请失败");

            ////// 调用GetProcessResponseAsync方法，获取工艺响应
            ////var processResponse = await GetProcessResponseAsync(process, input.Position);
        }

        var task = new Dt_Task
        {
            CurrentAddress = input.Position,
            Grade = 1,
            Roadway = input.Roadways,
            TargetAddress = locationInfo.LocationCode,
            Dispatchertime = DateTime.Now,
            MaterialNo = "",
            NextAddress = input.Roadways,
            OrderNo = null,
            PalletCode = input.PalletCode,
            SourceAddress = stationManager.stationLocation,
            TaskState = (int)TaskInStatusEnum.Line_InFinish,
            TaskType = stationManager.stationType == 1 ? (int)TaskInboundTypeEnum.Inbound : (int)TaskInboundTypeEnum.InTray,
            TaskNum = await BaseDal.GetTaskNo(),
            Creater = "Systeam"
        };

        locationInfo.LocationStatus = (int)LocationEnum.FreeDisable;
        await UpdateLocationAsync(locationInfo);

        return task;
    }
    #endregion

    #region 库位分配
    /// <summary>
    /// 
    /// </summary>
    /// <param name="requestTask">请求参数</param>
    /// <returns></returns>
    private async Task<DtLocationInfo> RequestLocation(RequestTaskDto requestTask, bool isCheckRequest = false)
    {
        #region 获取货位
        try
        {
            List<DtLocationInfo> locations;
            if (isCheckRequest)
            {
                locations = await _locationRepository.QueryDataAsync(x => x.LocationStatus == (int)LocationEnum.Free && x.RoadwayNo == requestTask.Roadways && x.EnalbeStatus == 1 && x.LocationType == 2 && x.Remark == "1");
            }
            else
            {
                locations = await _locationRepository.QueryDataAsync(x => x.LocationStatus == (int)LocationEnum.Free && x.RoadwayNo == requestTask.Roadways && x.EnalbeStatus == 1 && x.LocationType == 1);
            }

            if (locations == null)
            {
                return null;
            }

            return locations.OrderBy(x => x.Layer).ThenBy(x => x.Column).ThenBy(x => x.Row).FirstOrDefault();
        }
        catch (Exception err)
        {
            Console.WriteLine(err.Message.ToString());
            return null;
        }
        #endregion 获取货位
    }
    #endregion

    // 获取工艺申请
    private async Task<ProcessApplyDto> GetProcessApplyAsync(RequestTaskDto input, ResultTrayCellsStatus content)
@@ -457,7 +705,7 @@
        {
            EquipmentCode = input.EquiCodeMOM,
            Software = "WMS",
            //WipOrderNo = result.BindCode,
            //WipOrderNo = result.BindCode,"
            SerialNos = content.SerialNos.Select(item => new SerialNos
            {
                SerialNo = item.SerialNo
@@ -465,61 +713,70 @@
        };
    }

    #endregion 请求任务入库
    #endregion 请求空框出库

    public async Task<Dt_Task> CreateEmptyOutTaskAsync(RequestTaskDto input, Dt_StationManager stationManager)
    {
        try
        {
            if (stationManager.stationType != 7) throw new Exception("错误的调取");

            var stockinfo = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
                .Includes(x => x.LocationInfo)
                //.Includes(x=>x.StockInfoDetails)
                .Where(x => !x.IsFull && x.LocationInfo.RoadwayNo == stationManager.Roadway)
                .OrderBy(x => x.CreateDate)
                .FirstAsync();

            if (stockinfo == null) return null;

            var task = new Dt_Task
            {
                CurrentAddress = input.Position,
                Grade = 1,
                Roadway = input.Roadways,
                TargetAddress = stationManager.stationLocation,
                Dispatchertime = DateTime.Now,
                MaterialNo = "",
                NextAddress = input.Roadways,
                OrderNo = null,
                PalletCode = input.PalletCode,
                SourceAddress = stockinfo.LocationCode,
                TaskState = (int)TaskOutStatusEnum.OutNew,
                TaskType = (int)TaskOutboundTypeEnum.OutTray,
                TaskNum = await BaseDal.GetTaskNo(),
                Creater = "Systeam"
            };

            return task;
        }
        catch (Exception ex)
        {

            throw new Exception(ex.Message);
        }
    }


    #region 直接出库任务完成
    public async Task<WebResponseContent> CompleteInToOutTaskAsync(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            //添加历史
            var taskHty = CreateHistoricalTask(task);

            //删除任务
            BaseDal.DeleteData(task);

    #region 任务状态更改

    /// <summary>
    /// 更新任务状态&出库解盘
    /// </summary>
    /// <param name="taskNum"></param>
    /// <param name="taskState"></param>
    /// <returns></returns>
    //public async Task<WebResponseContent> UpdateTaskStatus(int taskNum, int taskState)
    //{
    //    WebResponseContent content = new WebResponseContent();
    //    try
    //    {
    //        var task = await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
    //        if (task == null)
    //            return content.Error("未找到任务");

    //        if (taskState == (int)TaskOutStatusEnum.Line_OutFinish || taskState == (int)TaskOutStatusEnum.SC_OutFinish)
    //        {
    //            var taskHty = CreateHistoricalTask(task);
    //            await _unitOfWorkManage.UseTranAsync(async () =>
    //            {
    //                var asb = await BaseDal.DeleteDataByIdAsync(task.TaskId);
    //                var asbHty = await _task_HtyRepository.AddDataAsync(taskHty) > 0;
    //                if (asb && asbHty)
    //                    content.OK();
    //                else
    //                    throw new Exception();
    //            });
    //            content.OK();
    //        }
    //        else
    //        {
    //            task.TaskState = taskState;
    //            var asb = await BaseDal.UpdateDataAsync(task);
    //            if (asb)
    //                content.OK();
    //            else
    //                content.Error();
    //        }
    //    }
    //    catch (Exception ex)
    //    {
    //        content.Error(ex.Message);
    //    }
    //    return content;
    //}

            return content.OK();
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    #endregion

    //private WebResponseContent CheckInTask()

}