Blazor_WMS/NewWMSWebAPI/TaskService/Implement/ManagePreOut.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using Michelin_WebAPI.TaskServices.Interface;
using Microsoft.EntityFrameworkCore.Storage;
using System.Linq;
using EFCoreDatabase.Data;
using EFCoreDatabase.Entities;
using EFCoreDatabase.Repositories.Interface;
using Microsoft.Extensions.Logging;
using NewWMSWebAPI.Helper;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
using NewWMSWebAPI.Helper;
using NewWMSWebAPI.TaskService.Interface;

namespace Michelin_WebAPI.TaskServices.Implement
{
    public class ManagePreOut:IManagePreOut
    {
        private readonly DmDBContext _context;
        private readonly IManageRepository _manageRepository;
        private readonly IWhCellRepository _whCellRepository;
        private readonly IStorageRepository _storageRepository;
        private readonly IManageHelper _manageHelper;
        private readonly ILogger<ManagePreOut> _logger;
        public ManagePreOut(IManageRepository manageRepository, IWhCellRepository whCellRepository, IStorageRepository storageRepository, IManageHelper manageHelper, DmDBContext context, ILogger<ManagePreOut> logger)
        {
            _manageRepository = manageRepository;
            _whCellRepository = whCellRepository;
            _storageRepository = storageRepository;
            _manageHelper = manageHelper;
            _context = context;
            _logger = logger;
        }


        //public bool FabricateListCreate(List<MANAGE_MAIN> manageMains, out string sResult)
        //{
        //    //检查当前的manageMains中的雪花ID是否为同一个

        //    var snowFlakeList = manageMains.Select(x => x.BUCKET_GROUP).Distinct();
        //    //tlt20231211:当前雪花ID有问题：需要进行重新赋值，将所有的雪花ID重新赋值
        //    if (snowFlakeList.Any())
        //    {
        //        _logger.LogInformation($"1.ManageMains with old bucket_group number :{JsonConvert.SerializeObject(snowFlakeList)}");
               
        //       var bucketGroup = SnowFlake.SnowflakeIDcreator.nextId().ToString();

        //        foreach (var manageMain in manageMains)
        //        {
        //            manageMain.BUCKET_GROUP = bucketGroup;
        //        }
        //        _logger.LogInformation($"2.Because the bucket_group number is not same, Modified the Bucket_Group number :{bucketGroup};ManageMains :{JsonConvert.SerializeObject(manageMains.Select(x => new { x.STOCK_BARCODE, x.BUCKET_GROUP }).Distinct())} ");

        //    }

        //    bool bResult = true;
        //    sResult = string.Empty;
        //    var transaction = _context.Database.BeginTransaction();
        //    try
        //    {
                


        //        foreach (var manageMain in manageMains)
        //        {
        //            var bucketMain =
        //                _storageRepository.GetStorageMainByBucket(manageMain.STOCK_BARCODE);
        //            var bucketLists = _storageRepository.GetStorageLists(bucketMain.STORAGE_ID);

        //            var lstManageList = new List<MANAGE_LIST>();
        //            //根据autoMapper映射变量信息
        //            lstManageList.AddRange(bucketLists.Select(storageList => _mapper.Map<MANAGE_LIST>(storageList)));
        //            //tlt20230717：设置GOODS_PROPERTY8为本次出库桶数量
        //            foreach (var manageList in lstManageList)
        //            {
        //                manageList.GOODS_PROPERTY8 = manageMains.Count.ToString();
        //            }
        //            bResult = ManageCreate(manageMain, lstManageList, false, true, false, out sResult);
        //            if (!bResult) 
        //                break;
                    
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        bResult = false;
        //        Console.WriteLine(ex.Message);
        //        sResult = ex.Message;
        //        _logger.LogError($"FabricateListCreate Exception:{ex.Message}");
        //    }
        //    finally
        //    {
        //        if (bResult)
        //        {
        //            transaction.Commit();
        //        }
        //        else
        //        {
        //            transaction.Rollback();
        //        }
        //    }

        //    return bResult;
        //}


        public  bool ManageCreate(MANAGE_MAIN mMANAGE_MAIN,
                         List<MANAGE_LIST> lsMANAGE_LIST,
                         bool bTrans,
                         bool bAutoSendControl,
                         bool bComplete, out string sResult)
        {
            bool bResult = true;
            sResult = string.Empty;
            int MANAGE_ID = 0;

            WH_CELL mWH_CELL_START = _whCellRepository.GetCell(mMANAGE_MAIN.START_CELL_ID);
            WH_CELL mWH_CELL_END = _whCellRepository.GetCell(mMANAGE_MAIN.END_CELL_ID);

            try
            {


                _manageRepository.AddManageMain(mMANAGE_MAIN, out var manage_id);
                foreach (var mMANAGE_LIST in lsMANAGE_LIST)
                {
                    mMANAGE_LIST.MANAGE_ID = manage_id;
                    mMANAGE_LIST.PLAN_LIST_ID = 0;
                    _manageRepository.AddManageList(mMANAGE_LIST);
                }

                if (mWH_CELL_START != null)
                {
                    mWH_CELL_START.RUN_STATUS = "Selected";
                    bResult = _whCellRepository.UpdateCellStatus(mWH_CELL_START);

                    if (!bResult)
                    {
                        sResult = $"Update start position {mWH_CELL_START.CELL_CODE}status error\n{sResult}";
                        return false;
                    }
                }

                if (mWH_CELL_END != null)
                {
                    mWH_CELL_END.RUN_STATUS = "Selected";
                    bResult = _whCellRepository.UpdateCellStatus(mWH_CELL_END);

                    if (!bResult)
                    {
                        sResult = $"Update end position {mWH_CELL_END.CELL_CODE} status error\n{sResult}";

                        

                        return false;
                    }
                }
                MANAGE_ID = mMANAGE_MAIN.MANAGE_ID;
                //当出库任务为主库区，并且是立库区
                if (mWH_CELL_START is {WAREHOUSE_ID: 1, AREA_ID: 1})
                {
                    //倒库逻辑：
                    //tlt：判断预留倒库货位是否有货
                    //首先判断当前出库货位是否为远端货位
                    if (mWH_CELL_START.CELL_FORK_TYPE == "Far")
                    {
                        //判断近端是否有货：通过CELL_GROUP来判断当前货位的近端货位状态
                        WH_CELL dtCell = _context.Wh_Cell.FirstOrDefault(x =>
                            x.CELL_CODE != mWH_CELL_START.CELL_CODE && x.CELL_GROUP == mWH_CELL_START.CELL_CODE && x.CELL_FORK_TYPE == "Near" && x.CELL_STATUS != "Nohave");


                        //近端货位有货
                        if ( dtCell!=null)
                        {
                            //近端托盘判断：是否有任务存在
                            if (dtCell.RUN_STATUS != "Selected")
                            {
                                //无任务存在就要执行移库操作
                                //创建移库管理任务
                                MANAGE_MAIN mManageMain = new MANAGE_MAIN();
                                List<MANAGE_LIST> lstManageList = new List<MANAGE_LIST>();
                                //获取库存主信息
                                STORAGE_MAIN sStorageMain = _storageRepository.GetStorageMainByCellId(dtCell.CELL_ID);
                                List<STORAGE_LIST> tempStorageList;
                                if (sStorageMain != null)
                                {
                                    tempStorageList = _storageRepository.GetStorageLists(sStorageMain.STORAGE_ID);

                                }
                                else
                                {
                                    //错误：未找到库存信息
                                    sResult = "未找到近端库存信息";
                                    bResult = false;
                                    
                                    return false;
                                }

                                //添加管理任务
                                mManageMain.STOCK_BARCODE = sStorageMain.STOCK_BARCODE;
                                mManageMain.MANAGE_STATUS = "WaitingSend";
                                mManageMain.MANAGE_TYPE_CODE = "ManageMove";
                                mManageMain.MANAGE_BEGIN_TIME = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                                mManageMain.START_CELL_ID = sStorageMain.CELL_ID;
                                //终止货位获取：根据货货位分配原则来进行分配

                                bool tResult = GetMoveEndPosition(dtCell, out int endCellId);
                                //当前巷道预留倒库货位

                                if (tResult)
                                {
                                    mManageMain.END_CELL_ID = endCellId;
                                }
                                else
                                {
                                    //无可用货位
                                    sResult = "未找到倒库货位，无法倒库";
                                    bResult = false;
                                    
                                    return false;

                                }

                                mManageMain.MANAGE_OPERATOR = "AutoMove";
                                mManageMain.MANAGE_LEVEL = string.Empty;
                                mManageMain.MANAGE_REMARK = string.Empty;

                                

                                ////添加list
                                //foreach (STORAGE_LIST mSTORAGE_LIST in tempStorageList)
                                //{
                                //    //根据映射关系添加信息
                                //    var mManageList = _mapper.Map<MANAGE_LIST>(mSTORAGE_LIST);
                                     
                                //    ////////////////////////////////////////////////////////////////////

                                //    lstManageList.Add(mManageList);

                                //}
                                //根据终止节点下移库任务

                                bResult = _manageHelper.ManageMoveTaskCreate(mManageMain,
                                    lstManageList,
                                    false,
                                    false,
                                    true, out sResult);
                            }

                        }
                        else //无货的情况下，查看货位状态
                        {
                            //查看近端货位是否有入库任务
                            WH_CELL dtCELL = _context.Wh_Cell.First(x => x.CELL_GROUP == mWH_CELL_START.CELL_CODE &&
                                                                         x.CELL_FORK_TYPE == "Near" &&
                                                                         x.WAREHOUSE_ID == mWH_CELL_START.WAREHOUSE_ID);

                            if (dtCELL.RUN_STATUS == "Selected")
                            {
                                MANAGE_MAIN manageMain =
                                    _context.Manage_Main.FirstOrDefault(x => x.END_CELL_ID == dtCELL.CELL_ID);
                                if (manageMain != null)
                                {
                                    mMANAGE_MAIN.MANAGE_REMARK = "Block";
                                    _manageRepository.UpdateManageMain(mMANAGE_MAIN);

                                }
                            }

                        }


                    }

                    if (bAutoSendControl)
                    {
                        bResult = _manageHelper.ManageDownLoad(mMANAGE_MAIN.STOCK_BARCODE, false, out sResult);
                    }

                    if (!bResult)
                    {
                        return false;
                    }
                }
                sResult = $"Bucket {mMANAGE_MAIN.STOCK_BARCODE} create the unloading task success!";

            }
            catch (Exception ex)
            {
                
                bResult = false;

                sResult = ex.Message;
            }
            //finally
            //{
            //    if (bResult)
            //    {
            //        transaction.Commit();
            //    }
            //    else
            //    {
            //        transaction.Rollback();
            //    }
            //}
            return bResult;
        }

        /// <summary>
        /// 获取移库货位
        /// </summary>
        /// <param name="dtCell"></param>
        /// <param name="endCellId"></param>
        /// <returns></returns>
        public bool GetMoveEndPosition(WH_CELL dtCell, out int endCellId)
        {
            _logger.LogInformation($"Function:GetMoveEndPosition; start cell code:{dtCell.CELL_CODE};the begin time:{DateTime.Now.ToString(CultureInfo.InvariantCulture)}");
            endCellId = 0;
            #region 旧逻辑
            //var list = _context.Reserve_Cell.Where(y => y.DEVICE_CODE == dtCell.DEVICE_CODE).ToList();
            //var nearList = _context.Wh_Cell.Where(y => y.CELL_STATUS == "Nohave" && y.RUN_STATUS == "Enable" && y.CELL_FORK_TYPE == "Near" && y.WAREHOUSE_ID == dtCell.WAREHOUSE_ID && y.DEVICE_CODE == dtCell.DEVICE_CODE).ToList();

            //whCells = _context.Wh_Cell.Where(x =>
            //       x.DEVICE_CODE == dtCell.DEVICE_CODE && x.CELL_FORK_TYPE == "Far" &&
            //       x.CELL_STATUS == "Nohave" && x.RUN_STATUS == "Enable" && x.CELL_TYPE == "Cell" &&
            //       x.CELL_STORAGE_TYPE == "SinglePallet" && !list.Select(y => y.CELL_CODE).Contains(x.CELL_CODE) && nearList.Select(z => z.CELL_CODE).Contains(x.CELL_GROUP))
            //   .OrderBy(y => y.CELL_Y)
            //   .ThenByDescending(z => z.CELL_X).ThenBy(w => w.CELL_Z).ToList();
            //tlt20240109:替换获取货位逻辑


            //var whCells = _context.Wh_Cell.FromSqlRaw($@"SELECT CELL_ID,CELL_CODE,CELL_GROUP 
            //                               FROM WH_CELL WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' 
            //                                                  AND CELL_FORK_TYPE = 'Near' 
            //                                                  AND CELL_STATUS = 'Nohave'
            //                                                  AND RUN_STATUS = 'Enable'
            //                                                  AND CELL_TYPE = 'Cell'
            //                                                  AND CELL_STORAGE_TYPE = 'SinglePallet' 
            //                                               AND CELL_ID NOT IN ( SELECT CELL_ID FROM RESERVE_CELL ) 
            //                                               AND CELL_GROUP IN ( SELECT CELL_CODE FROM V_STORAGE_LIST WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' AND RUN_STATUS = 'Enable' AND CELL_STATUS = 'Full' AND CELL_FORK_TYPE = 'Far' ) 
            //                                                  ORDER BY CELL_Y,CELL_X DESC, CELL_Z").ToList();
            #endregion 

            var whCells = _context.Wh_Cell.FromSqlRaw($@"SELECT CELL_ID, WAREHOUSE_ID,AREA_ID,LOGIC_ID,CELL_NAME,CELL_CODE,CELL_TYPE,DEVICE_CODE,CELL_Z,CELL_X,CELL_Y,CELL_INOUT,CELL_MODEL,CELL_STATUS,RUN_STATUS,CELL_FORK_TYPE,CELL_LOGICAL_NAME,LANE_WAY,CELL_GROUP,SHELF_TYPE,SHELF_NEIGHBOUR,CELL_STORAGE_TYPE,LOCK_DEVICE_CODE,CELL_WIDTH,CELL_HEIGHT,LOCK_CELL_ID,BELONG_AREA,BELONG_ZCQ_ID,CELL_FLAG,CELL_TRANS_FLAG
                                           FROM WH_CELL WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' 
                                                              AND CELL_FORK_TYPE = 'Far' 
                                                              AND CELL_STATUS = 'Nohave'
                                                              AND RUN_STATUS = 'Enable'
                                                              AND CELL_TYPE = 'Cell'
                                                              AND CELL_STORAGE_TYPE = 'SinglePallet' 
	                                                          AND CELL_ID NOT IN ( SELECT CELL_ID FROM RESERVE_CELL ) 
	                                                          AND CELL_CODE IN ( SELECT CELL_GROUP FROM WH_CELL WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' AND RUN_STATUS = 'Enable' AND CELL_STATUS = 'Nohave' AND CELL_FORK_TYPE = 'Near' ) 
                                                              ORDER BY CELL_Y,CELL_X DESC, CELL_Z").ToList();
            
            #region 旧逻辑
            //Where(x =>
            //    x.DEVICE_CODE == dtCell.DEVICE_CODE && x.CELL_FORK_TYPE == "Far" &&
            //    x.CELL_STATUS == "Nohave" && x.RUN_STATUS == "Enable" && x.CELL_TYPE == "Cell" &&
            //    x.CELL_STORAGE_TYPE == "SinglePallet" && !list.Select(y => y.CELL_ID).Contains(x.CELL_ID) && nearList.Select(z => z.CELL_CODE).Contains(x.CELL_GROUP))
            //.OrderBy(y => y.CELL_Y)
            //.ThenByDescending(z => z.CELL_X).ThenBy(w => w.CELL_Z).ToList();
            #endregion
            //tlt20240109:选择远端有货且无任务，近端无货的货位
            if (whCells.Count > 0)
            {
                //返回数值
                string temp = whCells[0].CELL_CODE;
                endCellId = whCells[0].CELL_ID;//返回第一个符合条件的数值

            }
            else
            {

                #region 旧逻辑
                //var farList = _context.Wh_Cell.Where(y => y.CELL_STATUS == "Full" && y.RUN_STATUS == "Enable" && y.CELL_FORK_TYPE == "Far" && y.WAREHOUSE_ID == dtCell.WAREHOUSE_ID && y.DEVICE_CODE == dtCell.DEVICE_CODE).ToList();

                //whCells = _context.Wh_Cell.Where(x =>
                //        x.DEVICE_CODE == dtCell.DEVICE_CODE && x.CELL_FORK_TYPE == "Near" &&
                //        x.CELL_STATUS == "Nohave" && x.RUN_STATUS == "Enable" && x.CELL_TYPE == "Cell" &&
                //        x.CELL_STORAGE_TYPE == "SinglePallet" && !list.Select(y => y.CELL_CODE).Contains(x.CELL_CODE) && farList.Select(z => z.CELL_CODE).Contains(x.CELL_GROUP))
                //    .OrderBy(y => y.CELL_Y).ThenByDescending(z => z.CELL_X).ThenBy(w => w.CELL_Z).ToList();
                #endregion
                //获取远端有货，近端无货的货位，远端存在同属性货位
                whCells = _context.Wh_Cell.FromSqlRaw($@"SELECT CELL_ID, WAREHOUSE_ID,AREA_ID,LOGIC_ID,CELL_NAME,CELL_CODE,CELL_TYPE,DEVICE_CODE,CELL_Z,CELL_X,CELL_Y,CELL_INOUT,CELL_MODEL,CELL_STATUS,RUN_STATUS,CELL_FORK_TYPE,CELL_LOGICAL_NAME,LANE_WAY,CELL_GROUP,SHELF_TYPE,SHELF_NEIGHBOUR,CELL_STORAGE_TYPE,LOCK_DEVICE_CODE,CELL_WIDTH,CELL_HEIGHT,LOCK_CELL_ID,BELONG_AREA,BELONG_ZCQ_ID,CELL_FLAG,CELL_TRANS_FLAG  
                                           FROM WH_CELL WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' 
                                                              AND CELL_FORK_TYPE = 'Near' 
                                                              AND CELL_STATUS = 'Nohave'
                                                              AND RUN_STATUS = 'Enable'
                                                              AND CELL_TYPE = 'Cell'
                                                              AND CELL_STORAGE_TYPE = 'SinglePallet' 
	                                                          AND CELL_ID NOT IN ( SELECT CELL_ID FROM RESERVE_CELL ) 
	                                                          AND CELL_GROUP IN ( SELECT CELL_CODE FROM V_STORAGE_LIST WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' AND RUN_STATUS = 'Enable' AND CELL_STATUS = 'Full' AND CELL_FORK_TYPE = 'Far' ) 
                                                              ORDER BY CELL_Y,CELL_X DESC, CELL_Z").ToList();
                if (whCells.Count > 0)
                {
                    endCellId = whCells[0].CELL_ID;//返回第一个符合条件的数值
                }
                else
                {
                    #region 旧逻辑
                    //whCells = _context.Wh_Cell.Where(x =>
                    //        x.DEVICE_CODE == dtCell.DEVICE_CODE && x.CELL_FORK_TYPE == "Near" &&
                    //        x.CELL_STATUS == "Nohave" && x.RUN_STATUS == "Enable" && x.CELL_TYPE == "Cell" &&
                    //        x.CELL_STORAGE_TYPE == "SinglePallet" && list.Select(y => y.CELL_CODE).Contains(x.CELL_CODE))
                    //    .OrderBy(y => y.CELL_Y).ThenByDescending(z => z.CELL_X).ThenBy(w => w.CELL_Z).ToList();
                    #endregion
                    //选取本巷道的预留货位
                    whCells = _context.Wh_Cell.FromSqlRaw($@"SELECT CELL_ID, WAREHOUSE_ID,AREA_ID,LOGIC_ID,CELL_NAME,CELL_CODE,
                                                            CELL_TYPE,DEVICE_CODE,CELL_Z,CELL_X,CELL_Y,CELL_INOUT,CELL_MODEL,
                                                            CELL_STATUS,RUN_STATUS,CELL_FORK_TYPE,CELL_LOGICAL_NAME,LANE_WAY,
                                                            CELL_GROUP,SHELF_TYPE,SHELF_NEIGHBOUR,CELL_STORAGE_TYPE,LOCK_DEVICE_CODE,
                                                            CELL_WIDTH,CELL_HEIGHT,LOCK_CELL_ID,BELONG_AREA,BELONG_ZCQ_ID,CELL_FLAG,CELL_TRANS_FLAG 
                                           FROM WH_CELL WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' 
                                                              AND CELL_FORK_TYPE = 'Near' 
                                                              AND CELL_STATUS = 'Nohave'
                                                              AND RUN_STATUS = 'Enable'
                                                              AND CELL_TYPE = 'Cell'
                                                              AND CELL_STORAGE_TYPE = 'SinglePallet' 
	                                                          AND CELL_ID  IN ( SELECT CELL_ID FROM RESERVE_CELL WHERE DEVICE_CODE = '{dtCell.DEVICE_CODE}' AND FLAG = 1 ) 
                                                              ORDER BY CELL_Y,CELL_X DESC, CELL_Z").ToList();
                    if (whCells.Count > 0)
                    {
                        endCellId = whCells[0].CELL_ID;//返回第一个符合条件的数值
                       
                    }
                    else
                    {
                        //报错：当前巷道无可用倒库货位
                        return false;
                    }

                }
            }
            _logger.LogInformation($"Function:GetMoveEndPosition; start cell code:{dtCell.CELL_CODE};end cell code:{whCells[0]?.CELL_CODE};the end time:{DateTime.Now.ToString(CultureInfo.InvariantCulture)}");

            return true;
        }

    }
}