1

HuBingJie

2025-12-25 5ea48455463691678b806badbee198699a878b5a

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

@@ -555,16 +555,16 @@
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns></returns>
        public WebResponseContent Cancelinventory(int taskNum)
        public ApiResponse<object> Cancelinventory(string palletTaskDTO)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                // æŸ¥æ‰¾ä»»åŠ¡
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum &&(x.TaskStatus == TaskOutStatusEnum.OutNew.ObjToInt()|| x.TaskStatus == TaskRelocationStatusEnum.RelocationNew.ObjToInt()|| x.TaskStatus == TaskInStatusEnum.Line_InExecuting.ObjToInt()));
                Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == palletTaskDTO && (x.TaskStatus == TaskOutStatusEnum.OutNew.ObjToInt()|| x.TaskStatus == TaskRelocationStatusEnum.RelocationNew.ObjToInt()|| x.TaskStatus == TaskInStatusEnum.Line_InExecuting.ObjToInt()));
                if (task == null)
                {
                    return webResponse.Error($"未找到任务号为【{taskNum}】的任务信息");
                    return MESresponse($"未找到货位信息,条码：{palletTaskDTO}", false, 0);
                }

                bool res;
@@ -583,7 +583,7 @@
                        res = false;
                        break;
                }
                if (!res) return WebResponseContent.Instance.Error("任务状态异常");
                if (!res) return MESresponse($"任务状态异常", false, 0);

                Dt_StockInfo stockInfo = _stockRepository.QueryFirst(x => x.PalletCode == task.PalletCode);

@@ -598,10 +598,18 @@
                  .SetColumns(x => x.StockStatus == StockStatusEmun.入库完成.ObjToInt())
                  .Where(x => x.PalletCode == task.PalletCode)
                  .ExecuteCommand();
                    if (stockmsseg<=0)
                    {
                        return MESresponse($"无库存信息", false, 0);
                    }
                    locationmsseg = _locationInfoRepository.Db.Updateable<Dt_LocationInfo>()
          .SetColumns(x => x.LocationStatus == LocationStatusEnum.InStock.ObjToInt())
          .Where(x => x.LocationCode == stockInfo.LocationCode)
          .ExecuteCommand();
                    if (locationmsseg <= 0)
                    {
                        return MESresponse($"未找到货位信息,条码：{palletTaskDTO}", false, 0);
                    }
                    taskmsseg = BaseDal.DeleteData(task);
                }
                else
@@ -610,10 +618,14 @@
                    .SetColumns(x => x.LocationStatus == LocationStatusEnum.Free.ObjToInt())
                    .Where(x => x.LocationCode == stockInfo.LocationCode)
                    .ExecuteCommand();
                    if (locationmsseg <= 0)
                    {
                        return MESresponse($"未找到货位信息,条码：{palletTaskDTO}", false, 0);
                    }
                    stockmsseg = _stockRepository.DeleteData(stockInfo).ObjToInt();
                    taskmsseg = BaseDal.DeleteData(task);
                }
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId > 0 ? OperateTypeEnum.人工完成 : OperateTypeEnum.自动完成);
                BaseDal.DeleteAndMoveIntoHty(task,OperateTypeEnum.人工删除);
                //获取接口进行调取
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_WCS_IPAddress, SysConfigConst.WCSCancelinventory);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
@@ -621,62 +633,67 @@
                {
                    _unitOfWorkManage.RollbackTran();

                    return webResponse.Error($"任务手动取消失败，未配置WCS任务手动取消反馈接口");
                    return MESresponse($"手动取消失败未找到wcs的配置接口", false, 0);
                }
                var respon = HttpHelper.Get(WCSReceiveTaskAPI, JsonConvert.SerializeObject(task.TaskNum));
                string apiUrl = $"{WCSReceiveTaskAPI}?taskNum={task.TaskNum}";
                var respon = HttpHelper.Get(apiUrl);

                if (respon == null)
                {
                    _unitOfWorkManage.RollbackTran();

                    return webResponse.Error($"调取接口失败，反馈参数为空");
                    return MESresponse($"wcs调取接口失败返回参数为null", false, 0);
                }
                var response = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                if (!response.Success)
                if (!response.status)
                {
                    _unitOfWorkManage.RollbackTran();

                    return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                    return MESresponse($"WCS调取接口失败，反馈参数原因：{response.Message}", false, 0);
                }
                if (stockmsseg <= 0 && locationmsseg <= 0 && taskmsseg)
                    {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error("任务取消失败");
                    return MESresponse($"任务取消失败", false, 0);
                    }

                //获取接口进行调取
                var MESConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_MES_IPAddress, SysConfigConst.MEScancelTask);      //获取到MES全部类型的接口
                string MEScancelTask = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
                if (MEScancelTask == null)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"任务手动完成失败，未配置WCS任务手动完成反馈接口");
                }
                var MES = new
                {
                    businessId = task.MESbusinessId,
                    taskId = task.MEStaskId,
                    palletCode = task.PalletCode
                };
                var MESrespon = HttpHelper.Post(MEScancelTask, JsonConvert.SerializeObject(MES));
                if (respon == null)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"调取接口失败，反馈参数为空");
                }
                var MESresponse = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                if (!response.Success)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                }





                ////获取接口进行调取
                //var MESConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_MES_IPAddress, SysConfigConst.MEScancelTask);      //获取到MES全部类型的接口
                //string MEScancelTask = MESConfigsAPIInfo.ApiAddress + MESConfigsAPIInfo.ApiName;
                //if (MEScancelTask == null)
                //{
                //    _unitOfWorkManage.RollbackTran();
                //    return webResponse.Error($"任务手动取消失败，未配置MES任务手动取消反馈接口");
                //}
                //var MES = new
                //{
                //    businessId = task.MESbusinessId,
                //    taskId = task.MEStaskId,
                //    palletCode = task.PalletCode
                //};
                //var MESrespon = HttpHelper.Post(MEScancelTask, JsonConvert.SerializeObject(MES));
                //if (MESrespon == null)
                //{
                //    _unitOfWorkManage.RollbackTran();
                //    return webResponse.Error($"MES调取接口失败，反馈参数为空");
                //}
                //var MESresponse = JsonConvert.DeserializeObject<ApiResponse<object>>(MESrespon);
                //if (!MESresponse.Success)
                //{
                //    _unitOfWorkManage.RollbackTran();
                //    return webResponse.Error($"MES调取接口失败，反馈参数原因：{response.Message}");
                //}
                _unitOfWorkManage.CommitTran();
                return webResponse.OK("任务取消成功");
                return MESresponse($"任务取消成功", true, 1);
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return webResponse.Error($"取消任务失败，原因：{ex.Message}");
                return  MESresponse($"取消任务失败，原因：{ex.Message}", false, 0);
            }
        }

@@ -863,16 +880,16 @@
        /// <param name="taskNum"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent ManualTaskCompleted(int taskNum)
        public WebResponseContent ManualTaskCompleted(string palletTaskDTO)
        {
            WebResponseContent webResponse = new WebResponseContent();
            try
            {
                // æŸ¥æ‰¾ä»»åŠ¡
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == palletTaskDTO);
                if (task == null)
                {
                    return webResponse.Error($"未找到任务号为【{taskNum}】的任务信息");
                    return webResponse.Error($"未找到托盘编码为【{palletTaskDTO}】的任务信息");
                }


@@ -928,7 +945,7 @@

                taskmsseg = BaseDal.DeleteData(task);

                task_htymsseg = BaseDal.DeleteAndMoveIntoHty(task,OperateTypeEnum.人工完成);
                task_htymsseg = BaseDal.DeleteAndMoveIntoHty(task, OperateTypeEnum.人工完成);
                //获取接口进行调取
                var ConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_WCS_IPAddress, SysConfigConst.WCSManualTaskCompleted);      //获取到wcs全部类型的接口
                string WCSReceiveTaskAPI = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
@@ -937,19 +954,22 @@
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"任务手动完成失败，未配置WCS任务手动完成反馈接口");
                }
                var respon = HttpHelper.Get(WCSReceiveTaskAPI, JsonConvert.SerializeObject(task.TaskNum));

                string apiUrl = $"{WCSReceiveTaskAPI}?taskNum={task.TaskNum}";

                var respon = HttpHelper.Get(apiUrl);
                if (respon == null)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"调取接口失败，反馈参数为空");
                    return webResponse.Error($"WCS调取接口失败，反馈参数为空");
                }
                var response = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                if (!response.Success)
                if (!response.status)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                    return webResponse.Error($"WCS调取接口失败，反馈参数原因：{response.Message}");
                }
                if (!(resstock && task_htymsseg && taskmsseg && task.TaskType ==TaskOutboundTypeEnum.Outbound.ObjToInt() ? location1 : (location1 && location2)))
                if (!(resstock && task_htymsseg && taskmsseg && task.TaskType == TaskRelocationTypeEnum.Relocation.ObjToInt() ? (location1 && location2) : location1))
                    {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"任务手动完成失败");
@@ -957,29 +977,29 @@

                //获取接口进行调取
                var MESConfigsAPIInfo = _dt_ApiInfoService.GetConfigsByAPIInfo(CateGoryConst.CONFIG_MES_IPAddress, SysConfigConst.MESmockComplete);      //获取到wcs全部类型的接口
                string MESmockComplete = ConfigsAPIInfo.ApiAddress + ConfigsAPIInfo.ApiName;
                string MESmockComplete = MESConfigsAPIInfo.ApiAddress + MESConfigsAPIInfo.ApiName;
                if (MESConfigsAPIInfo == null)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"任务手动完成失败，未配置WCS任务手动完成反馈接口");
                    return webResponse.Error($"任务手动完成失败，未配置MES任务手动完成反馈接口");
                }
                var MES = new
                {
                    businessId = task.MESbusinessId,
                    taskId = task.MEStaskId,
                    palletCode = task.PalletCode
            };
                };
                var MESrespon = HttpHelper.Post(MESmockComplete, JsonConvert.SerializeObject(MES));
                if (respon == null)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"调取接口失败，反馈参数为空");
                    return webResponse.Error($"MES调取接口失败，反馈参数为空");
                }
                var MESresponse = JsonConvert.DeserializeObject<ApiResponse<object>>(respon);
                if (!response.Success)
                var MESresponse = JsonConvert.DeserializeObject<ApiResponse<object>>(MESrespon);
                if (!MESresponse.Success)
                {
                    _unitOfWorkManage.RollbackTran();
                    return webResponse.Error($"调取接口失败，反馈参数原因：{response.Message}");
                    return webResponse.Error($"MES调取接口失败，反馈参数原因：{response.Message}");
                }
                _unitOfWorkManage.CommitTran();
                return webResponse.OK("任务手动完成成功");