ZT_WMS/wms.api/Controllers/FjController.cs

using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using wms.dto;
using wms.dto.request;
using wms.dto.request.fj;
using wms.dto.request.share;
using wms.dto.response;
using wms.dto.response.fj;
using wms.service.IService;
using wms.sqlsugar.model.fj;
using wms.util.Ext;

namespace wms.api.Controllers
{
    /// <summary>
    /// 分拣库控制器
    /// </summary>
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class FjController : BaseController
    {
        /// <summary>
        ///  分拣服务 逻辑类
        /// </summary>
        private readonly IFJService _fjService;

        /// <summary>
        ///  日志
        /// </summary>
        private readonly ILogger<FjController> _logger;

        /// <summary>
        ///  映射器
        /// </summary>
        private readonly IMapper _mapper;

        #region 锁

        private static object lockerCurtainProductionOrder = new object();
        private static object lockerCurtainOrderStartCheck = new object();
        private static object lockerSpoolMaterialInfoTrans = new object();
        private static object lockerCurtainProductionStockOut = new object();
        private static object lockerProductionBack = new object();
        private static object lockerErrorMaterialStockOut = new object();
        private static object lockerBGradeMaterialStockOut = new object();
        private static object lockerlockerStockChange = new object();

        /// <summary>
        ///  人工组盘传输接口
        /// </summary>
        private static object lockerManualBuildStockTrans = new object();

        /// <summary>
        ///  一层工人创建创建空托盘库存
        /// </summary>
        private static object lockOneFloorWorkerBuildEmptyPalletsStock = new object();

        /// <summary>
        ///  申请货位
        /// </summary>
        private static object lockApplyStockInLoc = new object();

        /// <summary>
        ///  完成任务
        /// </summary>
        private static object lockerCompleteTask = new object();

        /// <summary>
        ///  手动出库任务
        /// </summary>
        private static object lockManualTask = new object();

        private static object lockerBomInfoTrans = new object();

        #endregion 锁

        /// <summary>
        ///  分拣控制器构造函数
        /// </summary>
        /// <param name="fjService">分拣服务 逻辑类</param>
        /// <param name="logger">日志</param>
        /// <param name="mapper">映射器</param>
        public FjController(IFJService fjService, ILogger<FjController> logger, IMapper mapper) : base(fjService)
        {
            _fjService = fjService;
            _logger = logger;
            _mapper = mapper;
        }

        /// <summary>
        ///  同步物料基础信息
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public string SyncMaterInfo(SyncMaterInfoRequest reqBody)
        {
            var result = new SRes();
            //_logger.LogInformation("请求参数：{@reqBody},{aa}", reqBody,1);
            FJSyncMaterInfoResponse resbody = JsonConvert.DeserializeObject<FJSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
            if (reqBody.SyncType == 1)
            {
                reqBody.PageIndex = 1;
                while (resbody.ResData != null && resbody.ResData.Any())
                {
                    _fjService.SyncMaterInfo(resbody.ResData);
                    reqBody.PageIndex++;
                    resbody = JsonConvert.DeserializeObject<FJSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                }
            }
            else if (reqBody.SyncType == 2)
            {
                //拿到增量
                var increconf = _fjService.GetSysConfigByCode(Const.MESMaterialInitIncrement);
                if (increconf != null)
                {
                    reqBody.StartTime = DateTime.Parse(increconf.SContent);
                    //reqBody.Count = int.Parse(increconf.Remark);
                    resbody = JsonConvert.DeserializeObject<FJSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                    if (resbody.ResData.Any())
                    {
                        if (_fjService.SyncMaterInfo(resbody.ResData))
                        {
                            var lastdata = resbody.ResData.OrderBy(p => p.UpdatedTime).Last();
                            _fjService.UpdateSysConfigModelColumns(new sqlsugar.model.UpdateModelColumns<fjSysConfig>()
                            {
                                Columns = it => new fjSysConfig { SContent = lastdata.UpdatedTime.ToString("yyyy-MM-dd HH:mm:ss.fff") },
                                WhereExpression = it => it.Code == Const.MESMaterialInitIncrement
                            });
                        }
                    }
                    else
                    {
                        result.ResCode = ResponseStatusCodeEnum.NoResult.GetHashCode();
                        result.ResMsg = ResponseStatusCodeEnum.NoResult.GetDescription();
                    }
                }
                else
                {
                    result.ResCode = ResponseStatusCodeEnum.AccountError.GetHashCode();
                    result.ResMsg = "没有配置信息" + Const.MESMaterialInitIncrement;
                }
            }
            else
            {
                if (!string.IsNullOrEmpty(reqBody.MatCode))
                {
                    resbody = JsonConvert.DeserializeObject<FJSyncMaterInfoResponse>(WmsServiceExportApi(reqBody));
                    if (resbody.ResData.Any())
                    {
                        if (_fjService.SyncMaterInfo(resbody.ResData))
                        {
                        }
                    }
                }
            }
            return result.ToCamelCaseString();
        }

        /// <summary>
        /// 物料主数据推送接口
        /// </summary>
        /// <param name="reqBody"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SyncMaterInfoList(FJSyncMaterInfoListRequest reqBody)
        {
            var res = new SRes();
            if (reqBody.ListInfo == null || !reqBody.ListInfo.Any())
            {
                res.ResCode = ResponseStatusCodeEnum.DocDetailNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.DocDetailNotExist.GetDescription();
                return res;
            }
            _fjService.SyncMaterInfo(_mapper.Map<List<FJSyncMaterInfoResponseItem>>(reqBody.ListInfo));
            return res;
        }

        /// <summary>
        /// 机台信息同步接口
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        [HttpPost(Name = "SyncMachineInfo")]
        public SyncMachineInfoResponse SyncMachineInfo(SyncMachineInfoRequest reqDto)
        {
            SyncMachineInfoResponse resbody = JsonConvert.DeserializeObject<SyncMachineInfoResponse>(WmsServiceExportApi(reqDto));
            if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode() && resbody.ResData != null && resbody.ResData.Any())
            {
                _fjService.SyncMachineInfo(resbody.ResData);
            }

            return resbody;
        }

        /// <summary>
        /// 帘线生产工单信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CurtainProductionOrder(CurtainProductionOrderRequest reqDto)
        {
            return ConcurrencyReqControl<CurtainProductionOrderRequest, SRes>(lockerCurtainProductionOrder, "CurtainProductionOrder" + reqDto.BillCode, reqDto.BillCode, reqDto, _fjService.CurtainProductionOrder);
        }

        /// <summary>
        /// 工单启动验证
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes CurtainOrderStartCheck(CurtainOrderStartCheckRequest reqDto)
        {
            return ConcurrencyReqControl<CurtainOrderStartCheckRequest, SRes>(lockerCurtainOrderStartCheck, "CurtainOrderStartCheck" + reqDto.BillCode, reqDto.BillCode, reqDto, _fjService.CurtainOrderStartCheck);
        }

        /// <summary>
        /// 湿拉工字轮/芯股信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes SpoolMaterialInfoTrans(SpoolMaterialInfoTransRequest reqDto)
        {
            return ConcurrencyReqControl<SpoolMaterialInfoTransRequest, SRes>(lockerSpoolMaterialInfoTrans, "SpoolMaterialInfoTrans" + reqDto.SpoolCode, reqDto.SpoolCode, reqDto, _fjService.SpoolMaterialInfoTrans);
        }

        /// <summary>
        /// 湿拉工字轮入库反馈接口
        /// </summary>
        /// <param name="billcode"></param>
        /// <returns></returns>
        [HttpPost(Name = "WetProductStockInFeedBack")]
        public SRes WetProductStockInFeedBack(string doccode)
        {
            var list = _fjService.GetBillFeedbackList(p => p.BillCode == doccode);
            var dtolist = _mapper.Map<List<WetProductStockInFeedBackRequestItem>>(list);
            var dto = new WetProductStockInFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            List<long> ids = list.Select(p => p.Id).ToList();
            List<string> doccodelist = list.Select(p => p.BillCode).ToList();
            if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
            {
                //更新推送表数据
                _fjService.UpdateBillFeedbackPushModelColumns(new sqlsugar.model.UpdateModelColumns<fjBillFeedbackPush>()
                {
                    Columns = it => new fjBillFeedbackPush { PostResult = 1, PostNum = it.PostNum + 1 },
                    WhereExpression = it => ids.Contains(it.Id)
                });
                //删除单据表数据
                _fjService.DeleteDoc(p => doccodelist.Contains(p.DocNo));
            }
            else
            {
                //更新推送表数据
                _fjService.UpdateBillFeedbackPushModelColumns(new sqlsugar.model.UpdateModelColumns<fjBillFeedbackPush>()
                {
                    Columns = it => new fjBillFeedbackPush { PostResult = 2, PostNum = it.PostNum + 1 },
                    WhereExpression = it => ids.Contains(it.Id)
                });
            }
            return resbody;
        }

        /// <summary>
        /// 帘线叫料接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost(Name = "CurtainProductionStockOut")]
        public SRes CurtainProductionStockOut(CurtainProductionStockOutRequest reqDto)
        {
            return ConcurrencyReqControl<CurtainProductionStockOutRequest, SRes>(lockerCurtainProductionStockOut, "CurtainProductionStockOut" + reqDto.BillCode, reqDto.BillCode, reqDto, _fjService.CurtainProductionStockOut);
        }

        /// <summary>
        /// 叫料信息反馈接口
        /// </summary>
        /// <param name="billcode"></param>
        /// <returns></returns>
        [HttpPost(Name = "CurtainProductionStockOutFeedBack")]
        public SRes CurtainProductionStockOutFeedBack(string doccode)
        {
            var list = _fjService.GetBillFeedbackList(p => p.BillCode == doccode && p.ApiCode == "CurtainProductionStockOutFeedBack" && p.PostResult == 0 || (p.PostResult == 2 && p.PostNum < 5));
            var dtolist = _mapper.Map<List<CurtainProductionStockOutFeedBackRequestItem>>(list);
            var dto = new CurtainProductionStockOutFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            List<long> ids = list.Select(p => p.Id).ToList();
            List<string> doccodelist = list.Select(p => p.BillCode).ToList();
            if (resbody.ResCode == ResponseStatusCodeEnum.Sucess.GetHashCode())
            {
                //更新推送表数据
                _fjService.UpdateBillFeedbackPushModelColumns(new sqlsugar.model.UpdateModelColumns<fjBillFeedbackPush>()
                {
                    Columns = it => new fjBillFeedbackPush { PostResult = 1, PostNum = it.PostNum + 1 },
                    WhereExpression = it => ids.Contains(it.Id)
                });
                //删除单据表数据
                _fjService.DeleteDoc(p => doccodelist.Contains(p.DocNo));
            }
            else
            {
                //更新推送表数据
                _fjService.UpdateBillFeedbackPushModelColumns(new sqlsugar.model.UpdateModelColumns<fjBillFeedbackPush>()
                {
                    Columns = it => new fjBillFeedbackPush { PostResult = 2, PostNum = it.PostNum + 1 },
                    WhereExpression = it => ids.Contains(it.Id)
                });
            }
            return resbody;
        }

        /// <summary>
        /// 生产退料/余料接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductionBack(FjProductionBackRequest reqDto)
        {
            return ConcurrencyReqControl<FjProductionBackRequest, SRes>(lockerProductionBack, "ProductionBack" + reqDto.BillCode, reqDto.BillCode, reqDto, _fjService.ProductionBack);
        }

        /// <summary>
        /// 余料反馈接口
        /// </summary>
        /// <param name="billcode"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ProductionLeftFeedBack(string doccode)
        {
            var list = _fjService.GetBillFeedbackList(p => p.BillCode == doccode);
            var dtolist = _mapper.Map<List<ProductionLeftFeedBackRequestItem>>(list);
            var dto = new ProductionLeftFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            return resbody;
        }

        /// <summary>
        /// 异常料出库单传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ErrorMaterialStockOut(FjErrorMaterialStockOutRequest reqDto)
        {
            return ConcurrencyReqControl<FjErrorMaterialStockOutRequest, SRes>(lockerErrorMaterialStockOut, "ErrorMaterialStockOut" + reqDto.BillCode, reqDto.BillCode, reqDto, _fjService.ErrorMaterialStockOut);
        }

        /// <summary>
        /// 异常料出库反馈接口
        /// </summary>
        /// <param name="billcode"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ErrorMaterialStockOutFeedBack(string doccode)
        {
            var list = _fjService.GetBillFeedbackList(p => p.BillCode == doccode);
            var dtolist = _mapper.Map<List<ErrorMaterialStockOutFeedBackRequestItem>>(list);
            var dto = new ErrorMaterialStockOutFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            return resbody;
        }

        /// <summary>
        /// B站叫料单传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes BGradeMaterialStockOut(BGradeMaterialStockOutRequest reqDto)
        {
            return ConcurrencyReqControl<BGradeMaterialStockOutRequest, SRes>(lockerBGradeMaterialStockOut, "BGradeMaterialStockOut" + reqDto.BillCode, reqDto.BillCode, reqDto, _fjService.BGradeMaterialStockOut);
        }

        /// <summary>
        /// B站出库反馈接口
        /// </summary>
        /// <param name="billcode"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes BGradeMaterialStockOutFeedBack(string doccode)
        {
            var list = _fjService.GetBillFeedbackList(p => p.BillCode == doccode);
            var dtolist = _mapper.Map<List<BGradeMaterialStockOutFeedBackRequestItem>>(list);
            var dto = new BGradeMaterialStockOutFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            return resbody;
        }

        /// <summary>
        /// 库存改判
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes StockChange(FjStockChangeRequest reqDto)
        {
            return ConcurrencyReqControl<FjStockChangeRequest, SRes>(lockerlockerStockChange, "StockChange" + reqDto.BillCode, reqDto.BillCode, reqDto, _fjService.StockChange);
        }

        /// <summary>
        /// 改判反馈接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes StockChangeFeedBack(string doccode)
        {
            var list = _fjService.GetBillFeedbackList(p => p.BillCode == doccode);
            var dtolist = _mapper.Map<List<StockChangeFeedBackRequestItem>>(list);
            var dto = new StockChangeFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            return resbody;
        }

        /// <summary>
        /// 实时库存查询接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetCurStockList(string reqDto)
        {
            return null;
        }

        /// <summary>
        /// 回库反馈接口（出库途中改判的，入库之后再次上传入库信息）
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes StockChangeStockInFeedBack(string doccode)
        {
            var list = _fjService.GetBillFeedbackList(p => p.BillCode == doccode);
            var dtolist = _mapper.Map<List<StockChangeStockInFeedBackRequestItem>>(list);
            var dto = new StockChangeStockInFeedBackRequest() { ListInfo = dtolist };
            SRes resbody = JsonConvert.DeserializeObject<SRes>(WmsServiceExportApi(dto));
            return resbody;
        }

        ///// <summary>
        ///// 人工组盘传输接口
        ///// </summary>
        ///// <param name="reqDto"></param>
        ///// <returns></returns>
        //[HttpPost]
        //public SRes ManualBuildStockTrans(BuildStockTransRequest reqDto)
        //{
        //    return ConcurrencyReqControl<BuildStockTransRequest, SRes>(lockerManualBuildStockTrans, "ManualBuildStockTrans" + reqDto.PalletCode, reqDto.PalletCode, reqDto, _fjService.ManualBuildStockTrans);
        //}

        /// <summary>
        /// 条码信息查询接口
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost]
        public string GetMesBarCodeInfo(string req)
        {
            return "";
        }

        /// <summary>
        /// BOM信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes BomInfoTrans(BomInfoTransRequest reqDto)
        {
            return ConcurrencyReqControl<BomInfoTransRequest, SRes>(lockerBomInfoTrans, "BomInfoTrans" + reqDto.BomCode, reqDto.BomCode, reqDto, _fjService.BomInfoTrans);
        }

        #region 一楼入库任务生成接口

        /// <summary>
        ///   一楼空托盘人工入库任务创建
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes OneFloorWorkerBuildEmptyPalletsStock(FJBuildEmptyPalletsStockRequest reqDto)
        {
            return ConcurrencyReqControl<FJBuildEmptyPalletsStockRequest, SRes>(lockOneFloorWorkerBuildEmptyPalletsStock, "OneFloorWorkerBuildEmptyPalletsStock" + reqDto.PalletCode, reqDto.StartLoc, reqDto, _fjService.OneFloorWorkerBuildEmptyPalletsStock);
        }

        #endregion 一楼入库任务生成接口

        /// <summary>
        ///   申请货位
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes ApplyStockInLoc(FJApplyStockInLocRequest reqDto)
        {
            return ConcurrencyReqControl<FJApplyStockInLocRequest, SRes<FJApplyStockInLocResponse>>(lockApplyStockInLoc, "ApplyStockInLoc" + reqDto.TaskNum, reqDto.PickUpEquipmentNo, reqDto, _fjService.ApplyStockInLoc);
        }

        /// <summary>
        /// 手动出库
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPost]
        public string ManualTask(FJManualTaskRequest request)
        {
            lock (lockManualTask)
            {
                return _fjService.ManualTask(request);
            }
        }

        /// <summary>
        /// 完成任务
        /// </summary>
        /// <param name="reqEntity"></param>
        /// <returns></returns>
        [HttpPost]
        public SRes<int> CompleteTask(CompleteTaskRequest reqDto)
        {
            lock (lockerCompleteTask)
            {
                return _fjService.CompleteTask(reqDto);
            }
        }

        #region 生成货位基础配置

        /// <summary>
        ///  分拣自动生成货位信息
        /// </summary>
        [HttpPost]
        public void FJAutoGenerateLocation()
        {
            _fjService.FJ1NorthAutoGenerateLocation();
            _fjService.FJSouthAutoGenerateLocation();
        }

        #endregion 生成货位基础配置
    }
}