1

HuBingJie

10 小时以前 4ac3f08f416685db0e218df55750d94556030330

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -21,15 +21,22 @@
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using System.DirectoryServices.Protocols;
using System.Net;
using System.Reflection.Emit;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.OtherEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Const;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Task;
using WIDESEA_DTO.ToMes;
using WIDESEA_IBasicService;
using WIDESEA_IInboundService;
using WIDESEA_IOutboundService;
@@ -49,6 +56,9 @@
        private readonly IRepository<Dt_LocationInfo> _locationInfoRepository;
        private readonly IRepository<Dt_RoadwayInfo> _roadwayInforepository;
        private readonly IBasicService _basicService;
        private readonly IDt_ApiInfoService _dt_ApiInfoService;
        private readonly ILocationStatusChangeRecordService _locationStatusChangeRecordService;
        private readonly IStationMangerService _stationMangerService;

        public IRepository<Dt_Task> Repository => BaseDal;

@@ -58,11 +68,7 @@
                {nameof(Dt_Task.CreateDate),OrderByType.Asc},
            };

        public List<int> TaskTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_StockInfo> stockRepository, IBasicService basicService, IRepository<Dt_Warehouse> warehouseRepository, IRepository<Dt_LocationInfo> locationInfoRepository, IRepository<Dt_RoadwayInfo> roadwayInforepository) : base(BaseDal)
        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_StockInfo> stockRepository, IBasicService basicService, IRepository<Dt_Warehouse> warehouseRepository, IRepository<Dt_LocationInfo> locationInfoRepository, IRepository<Dt_RoadwayInfo> roadwayInforepository, IDt_ApiInfoService dt_ApiInfoService, ILocationStatusChangeRecordService locationStatusChangeRecordService, IStationMangerService stationMangerService) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
@@ -71,7 +77,15 @@
            _warehouseRepository = warehouseRepository;
            _locationInfoRepository = locationInfoRepository;
            _roadwayInforepository = roadwayInforepository;
            _dt_ApiInfoService = dt_ApiInfoService;
            _locationStatusChangeRecordService = locationStatusChangeRecordService;
            _stationMangerService=stationMangerService;
        }
        public int GetTaskNum(string sequenceName)
        {
            return Db.Ado.GetScalar($"SELECT NEXT VALUE FOR {sequenceName}").ObjToInt();
        }

        /// <summary>
        /// ä»»åŠ¡ä¿¡æ¯æŽ¨é€è‡³WCS
        /// </summary>
@@ -85,34 +99,201 @@
                {
                    x.AGVArea = agvDescription;
                });
                string url = AppSettings.Get("WCSApiAddress");
                if (string.IsNullOrEmpty(url))
                {
                    return WebResponseContent.Instance.Error($"未找到WCSApi地址,请检查配置文件");
                }
                string response = HttpHelper.Post($"{url}/api/Task/ReceiveTask", taskDTOs.Serialize());

                return JsonConvert.DeserializeObject<WebResponseContent>(response) ?? WebResponseContent.Instance.Error("返回错误");
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_WCS_IPAddress, SysConfigConst.WCSReceiveTask);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;

                var respon = HttpHelper.Post(WCSReceiveTaskAPI, JsonConvert.SerializeObject(taskDTOs));
                if (respon != null)
                {
                    WebResponseContent respone = JsonConvert.DeserializeObject<WebResponseContent>(respon.ToString());
                    if (respone.Status)
                    {
                        return WebResponseContent.Instance.OK();
                    }
                    else
                    {
                        return WebResponseContent.Instance.Error($"下发出库失败，原因：{respone.Message}！");
                    }
                }
                else
                {
                    return WebResponseContent.Instance.Error("任务下发失败！");
                }
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        


        /// <summary>
        /// åˆ¤æ–­å··é“内移库
        /// </summary>
        /// <param name="TaskNum"></param>
        /// <param name="SourceAddress"></param>
        /// <returns></returns>
        public WebResponseContent IsRelocations(int TaskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                List<Dt_LocationInfo> loca = new List<Dt_LocationInfo>();

                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == TaskNum);
                if (task == null) return content.Error($"未找到该任务信息，任务号：{TaskNum}");
                string Locatask = task.SourceAddress;

                //获取到深库位编号
                Dt_LocationInfo DeepLocation = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == Locatask);
                if(DeepLocation == null) return content.Error($"未找到该货位信息,货位编号:{Locatask}");

                //进行获取浅库位编号
                int locrow = DeepLocation.Row == 1 ? 2 : 3;
                Dt_LocationInfo ShallowLocation = _basicService.LocationInfoService.Repository.QueryFirst(x =>x.Row== locrow && x.Layer== DeepLocation.Layer && x.Column== DeepLocation.Column && x.RoadwayNo== DeepLocation.RoadwayNo);
                if (ShallowLocation == null) return content.Error($"未找到货位编号:{Locatask}的浅货位");

                if (ShallowLocation.LocationStatus == (int)LocationStatusEnum.Free)
                {
                    return content.OK(data: task);  //直接返回当前查询的任务
                }


                //如果有货，则生成移库任务
                if (ShallowLocation.LocationStatus == (int)LocationStatusEnum.InStock)
                {
                    Dt_StockInfo dt_Stock = _stockRepository.QueryFirst(x => x.LocationCode == ShallowLocation.LocationCode);
                    if (dt_Stock == null) return content.Error($"货位编号:{Locatask}的浅货位库存异常，请检查！！！");

                    //进行获取新的库位
                    Dt_LocationInfo? Nextlocation = _basicService.LocationInfoService.GetLocation(DeepLocation.RoadwayNo);//获取到新库位
                    if (Nextlocation == null)
                    {
                        return content.Error($"货位分配失败,未找到可分配货位");
                    }
                    ShallowLocation.LocationStatus = (int)LocationStatusEnum.Lock;
                    Nextlocation.LocationStatus = (int)LocationStatusEnum.Lock;
                    loca.Add(ShallowLocation);
                    loca.Add(Nextlocation);

                    _unitOfWorkManage.BeginTran();
                    //生成移动任务
                    Dt_Task dt_Task = new()
                    {
                        PalletCode = dt_Stock.PalletCode,
                        TaskNum = GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                        Roadway = Nextlocation.RoadwayNo,
                        TaskType = TaskRelocationTypeEnum.Relocation.ObjToInt(),
                        TaskStatus = TaskRelocationStatusEnum.RelocationNew.ObjToInt(),
                        SourceAddress = ShallowLocation.LocationCode,
                        TargetAddress = Nextlocation.LocationCode,
                        CurrentAddress = ShallowLocation.LocationCode,
                        NextAddress = Nextlocation.LocationCode,
                        Grade = 1,
                        Creater = "WMS",
                        Depth = ShallowLocation.Depth,
                        CreateDate = DateTime.Now,
                    };

                    _locationInfoRepository.AddData(loca);
                    BaseDal.AddData(dt_Task);   //新增任务
                    _unitOfWorkManage.CommitTran();

                    return content.OK(data: dt_Task);
                }
                else
                {
                    return content.Error($"货位编号:{Locatask}的浅货位状态异常，浅货位编号：{ShallowLocation.LocationCode}");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                throw;
            }
        }

        /// <summary>
        /// ä»»åŠ¡å®Œæˆ
        /// </summary>
        /// <param name="taskNum">任务编号</param>
        /// <param name="HowWorks">模式（1：自动，2：手动）</param>
        /// <returns></returns>
        public WebResponseContent TaskCompleted(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();

            Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
            if (task == null) return WebResponseContent.Instance.Error("未找到任务信息");
            switch (task.TaskType)
            {
                case (int)TaskRelocationTypeEnum.Relocation:
                    return RelocationInTaskCompleted(task);
                case (int)TaskInboundTypeEnum.Inbound:
                    return InboundTaskCompleted(task);
                case (int)TaskOutboundTypeEnum.Outbound:
                    return OutboundTaskCompleted(task);
                default: return content.Error($"任务类型错误，任务号：{task.TaskNum}");
            }
        }

        /// <summary>
        /// ç§»åº“完成方法
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public WebResponseContent RelocationInTaskCompleted(Dt_Task task)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                Dt_StockInfo stockInfo = _stockRepository.QueryFirst(x => x.PalletCode == task.PalletCode);
                Dt_LocationInfo locationpoint = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.SourceAddress);
                Dt_LocationInfo locationEnd = _basicService.LocationInfoService.Repository.QueryFirst(x => x.LocationCode == task.TargetAddress);
                List<Dt_LocationInfo> loca = new List<Dt_LocationInfo>();
                stockInfo.LocationCode = locationEnd.LocationCode;
                stockInfo.StockStatus = StockStatusEmun.已入库.ObjToInt();
                locationpoint.LocationStatus = LocationStatusEnum.Free.ObjToInt();
                locationEnd.LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                loca.Add(locationpoint);
                loca.Add(locationEnd);

                _unitOfWorkManage.BeginTran();
                _stockRepository.UpdateData(stockInfo);
                _basicService.LocationInfoService.Repository.UpdateData(loca);
                BaseDal.DeleteData(task);
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);

                WebResponseContent content=MES_TransferCompletionFeedback(task);
                if (!content.Status)
                {
                    _unitOfWorkManage.RollbackTran();
                    return content;
                }
                    
                _unitOfWorkManage.CommitTran();
                return webResponse.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return webResponse.Error($"移库任务完成失败，任务id：{task.TaskNum}");
                throw;
            }
            
        }

        /// <summary>
        /// å…¥åº“任务完成
        /// </summary>
        /// <param name="tasknum"></param>
        /// <returns></returns>
        public WebResponseContent InboundTaskCompleted(int taskNum)
        public WebResponseContent InboundTaskCompleted(Dt_Task task)
        {
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该任务信息");
                }
                Dt_Warehouse warehouse = _warehouseRepository.QueryFirst(x => x.WarehouseId == task.WarehouseId);
                Dt_StockInfo stockInfo = _stockRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == task.PalletCode && x.WarehouseId == task.WarehouseId).First();
                if (stockInfo == null)
@@ -130,6 +311,7 @@
                }
                dt_LocationInfo.LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                stockInfo.StockStatus = StockStatusEmun.入库完成.ObjToInt();

                _unitOfWorkManage.BeginTran();
                //修改货位状态为有货
                _locationInfoRepository.UpdateData(dt_LocationInfo);
@@ -137,6 +319,15 @@
                _stockRepository.UpdateData(stockInfo);
                //删除任务添加历史
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId > 0 ? OperateTypeEnum.人工完成 : OperateTypeEnum.自动完成);


                /*WebResponseContent content = TaskCompletionFeedback(task);
                if (!content.Status)
                {
                    _unitOfWorkManage.RollbackTran();
                    return content;
                }*/

                _unitOfWorkManage.CommitTran();
            }
            catch (Exception)
@@ -146,5 +337,271 @@
            }
            return WebResponseContent.Instance.OK();
        }

        /// <summary>
        /// å‡ºåº“任务完成
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public WebResponseContent OutboundTaskCompleted(Dt_Task task)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                Dt_StockInfo stockInfo = _stockRepository.QueryFirst(x => x.PalletCode == task.PalletCode);
                if (stockInfo == null) return webResponse.Error($"任务编号：{task.TaskNum},未找到托盘：{stockInfo.PalletCode}的库存信息");
                Dt_LocationInfo locationInfo = _locationInfoRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
                if (locationInfo == null) return webResponse.Error($"任务编号：{task.TaskNum},未找到托盘：{stockInfo.PalletCode}的货位信息");


                stockInfo.StockStatus = StockStatusEmun.出库完成.ObjToInt();
                
                int beforeStatus = locationInfo.LocationStatus;
                locationInfo.LocationStatus =(int)LocationStatusEnum.Free;
                task.TaskStatus = TaskOutStatusEnum.OutFinish.ObjToInt();

                _unitOfWorkManage.BeginTran();

                _stockRepository.DeleteData(stockInfo);
                _locationInfoRepository.UpdateData(locationInfo);   //修改成空货位

                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                _locationStatusChangeRecordService.AddLocationStatusChangeRecord(locationInfo, beforeStatus, StockStatusEmun.出库完成.ObjToInt(), "1", task.TaskNum);
                /*WebResponseContent content = TaskCompletionFeedback(task);
                if (!content.Status)
                {
                    _unitOfWorkManage.RollbackTran();
                    return content;
                }*/

                _unitOfWorkManage.CommitTran();
                return webResponse.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return webResponse.Error($"出库任务完成失败，任务id：{task.TaskNum},错误原因：{ex.Message}");
                throw;
            }
            
        }







        //==============================================移库完成反馈接口====================================================
        /// <summary>
        /// ä¸Šä¼ ç§»åº“任务完成给MES
        /// </summary>
        /// <param name="dt_Task"></param>
        /// <returns></returns>
        public WebResponseContent MES_TransferCompletionFeedback(Dt_Task dt_Task)
        {
            WebResponseContent webResponse = new WebResponseContent();

            try
            {
                TransferRequest transferRequest = new TransferRequest()
                {
                    //业务id，任务id后续进行更改
                    businessId = "1",
                    TaskId = "1",
                    SourceLocationCode = dt_Task.SourceAddress,
                    LocationCode = dt_Task.TargetAddress,
                    PalletCode = dt_Task.PalletCode,
                    Status = "FINISH",
                    ErrorStatus = "NORMAL",
                    ErrorInfo = "",
                };

                //获取接口进行调取
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_MES_IPAddress, SysConfigConst.MESTransferCompletionFeedback);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
                if (WCSReceiveTaskAPI == null)
                {
                    return webResponse.Error($"出库失败，未配置MES移库完成反馈接口");
                }
                var respon = HttpHelper.Post(WCSReceiveTaskAPI, JsonConvert.SerializeObject(transferRequest));
                if (respon != null)
                {
                    var response = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                    if (response.Success)
                    {
                        return webResponse.OK();
                    }
                    else
                    {
                        return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                    }
                }
                else
                {
                    return webResponse.Error($"调取接口失败，反馈参数为空");
                }
            }
            catch (Exception ex)
            {
                return webResponse.Error($"移库任务上传失败！原因：{ex.Message}");
                throw;
            }
        }


        /// <summary>
        /// ä¸Šä¼ å‡ºå…¥åº“任务完成给MES
        /// </summary>
        /// <param name="dt_Task"></param>
        /// <returns></returns>
        public WebResponseContent TaskCompletionFeedback(Dt_Task dt_Task)
        {
            WebResponseContent webResponse = new WebResponseContent();

            try
            {
                TaskNotification transferRequest = new TaskNotification()
                {
                    //业务id，任务id后续进行更改
                    TaskId = "1",   //任务id
                    BusinessId = "1",   //业务id
                    PalletCode = dt_Task.PalletCode,
                    SubPalletCode = "",//子托盘编码
                    LocationCode = dt_Task.SourceAddress,
                    ErrorStatus = "NORMAL",
                    ErrorInfo = "",
                };

                //获取接口进行调取
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_MES_IPAddress, SysConfigConst.MESTaskFeedback);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
                if (WCSReceiveTaskAPI == null)
                {
                    return webResponse.Error($"任务反馈MES失败，未配置MES任务完成反馈接口");
                }
                var respon = HttpHelper.Post(WCSReceiveTaskAPI, JsonConvert.SerializeObject(transferRequest));
                if (respon != null)
                {
                    var response = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                    if (response.Success)
                    {
                        return webResponse.OK();
                    }
                    else
                    {
                        return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                    }
                }
                else
                {
                    return webResponse.Error($"调取接口失败，反馈参数为空");
                }
            }
            catch (Exception ex)
            {
                return webResponse.Error($"任务任务上传失败！原因：{ex.Message}");
                throw;
            }
        }

        public ApiResponse<object> MESresponse(string Message, bool Success)
        {
            ApiResponse<object> apiResponse = new ApiResponse<object>();
            apiResponse.Message = Message;
            apiResponse.Success = Success;
            apiResponse.Code = 1;
            return apiResponse;
        }




        /// <summary>
        /// åˆ›å»ºè´§ä½
        /// </summary>
        /// <param name="locationInfo"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ApiResponse<object> createLocation(List<LocationInfoDto> locationInfo)
        {
            List<Dt_LocationInfo> dt_LocationInfoList = new List<Dt_LocationInfo>();
            foreach (var item in locationInfo)
            {
                Dt_LocationInfo dt_LocationInfo = new Dt_LocationInfo()
                {
                    LocationCode = item.locationCode,
                    LocationName = item.locationName,
                    RoadwayNo = item.roadwayNo,
                    Row = item.row,
                    Column = item.column,
                    Layer = item.layer,
                    Depth = (int)item.depth,
                    LocationType = item.locationType,
                    LocationStatus = item.locationStatus,
                    EnableStatus = item.enableStatus == true ? 1 : 0,
                    Remark = item.remark,
                    CreateDate = DateTime.Now,
                    Creater = App.User.UserName,
                };
                dt_LocationInfoList.Add(dt_LocationInfo);
            }
            int res = _locationInfoRepository.AddData(dt_LocationInfoList);
            if (res <= 0)
            {
                return MESresponse($"创建货位失败",false);
            }
            return MESresponse($"", true);
        }

        /// <summary>
        /// ä¿®æ”¹è´§ä½
        /// </summary>
        /// <param name="locationInfo"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ApiResponse<object> updateLocation(LocationInfoDto locationInfo)
        {
            Dt_LocationInfo dt_LocationInfo = new Dt_LocationInfo()
            {
                LocationCode = locationInfo.locationCode,
                LocationName = locationInfo.locationName,
                RoadwayNo = locationInfo.roadwayNo,
                Row = locationInfo.row,
                Column = locationInfo.column,
                Layer = locationInfo.layer,
                Depth = (int)locationInfo.depth,
                LocationType = locationInfo.locationType,
                LocationStatus = locationInfo.locationStatus,
                EnableStatus = locationInfo.enableStatus == true ? 1 : 0,
                Remark = locationInfo.remark,
                CreateDate = DateTime.Now,
            };
            bool res = _locationInfoRepository.Db.Updateable(dt_LocationInfo)
    .Where(x => x.LocationCode == dt_LocationInfo.LocationCode)
    .ExecuteCommand() > 0;
            if (!res)
            {
                return MESresponse($"修改货位失败",false);
            }
            return MESresponse($"", true);
        }

        /// <summary>
        /// åˆ é™¤è´§ä½
        /// </summary>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public ApiResponse<object> deleteLocation(List<string> locationCode)
        {
            WebResponseContent webResponseContent = new WebResponseContent();
            int res = _locationInfoRepository.Db.Deleteable<Dt_LocationInfo>().Where(x => locationCode.Contains(x.LocationCode)).ExecuteCommand();
            if (res <= 0)
            {
                return MESresponse($"删除货位失败",false);
            }
            return MESresponse($"", true);
        }
    }
}