wms / wms_NouYaWmsN5 · Files

using Infrastructure;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using WebRepository;

namespace WebApp
{
    /// <summary>
    /// 库存表
    /// </summary>

    public partial class InventoryApp
    {
        private IUnitWork _unitWork;
        public IRepository<Inventory> _app;
        public IRepository<Task> _appt;
        public IRepository<TaskDetail> _apptd;
        private static IHostingEnvironment _hostingEnvironment;
        ExcelHelper imp = new ExcelHelper(_hostingEnvironment);

        public InventoryApp(IUnitWork unitWork, IRepository<Inventory> repository, IRepository<Task> repositoryt, IRepository<TaskDetail> repositorytd, IHostingEnvironment hostingEnvironment)
        {
            _unitWork = unitWork;
            _app = repository;
            _appt = repositoryt;
            _apptd = repositorytd;
            _hostingEnvironment = hostingEnvironment;
        }

        public InventoryApp SetLoginInfo(LoginInfo loginInfo)
        {
            _app._loginInfo = loginInfo;
            _appt._loginInfo = loginInfo;
            _apptd._loginInfo = loginInfo;
            return this;
        }

        public TableData Load(PageReq pageRequest, Inventory entity)
        {
            //批次先进先出
            TableData tab = _app.Load(pageRequest, entity);
            List<Inventory> list = tab.data;
            if (list != null)
            {
                tab.data = list.OrderBy(n => n.CreateTime);
            }
            //return tab;
            //玻布禁止出库
            //TableData tab = _app.Load(pageRequest, entity);
            //List<Inventory> list = tab.data;
            //if (list != null)
            //{
            //    tab.data = list.Where(n => n.WarehouseType != "YCL_WareCell");
            //}
            return tab;
        }

        public void Ins(Inventory entity)
        {
            _app.Add(entity);
        }

        public void Upd(Inventory entity)
        {
            _app.Update(entity);
        }

        public void DelByIds(int[] ids)
        {
            _app.Delete(u => ids.Contains(u.Id.Value));
        }

        public Inventory FindSingle(Expression<Func<Inventory, bool>> exp)
        {
            return _app.FindSingle(exp);
        }

        public IQueryable<Inventory> Find(Expression<Func<Inventory, bool>> exp)
        {
            return _app.Find(exp);
        }

        public Response ImportIn(IFormFile excelfile)
        {
            Response result = new Infrastructure.Response();
            List<Inventory> exp = imp.ConvertToModel<Inventory>(excelfile);
            string sErrorMsg = "";

            for (int i = 0; i < exp.Count; i++)
            {
                try
                {
                    Inventory e = exp[i];
                    e.Id = null;
                    _app.Add(e);
                }
                catch (Exception ex)
                {
                    sErrorMsg += "第" + (i + 2) + "行:" + ex.Message + "<br>";
                    result.Message = sErrorMsg;
                    break;
                }
            }
            if (sErrorMsg.Equals(string.Empty))
            {
                if (exp.Count == 0)
                {
                    sErrorMsg += "没有发现有效数据, 请确定模板是否正确， 或是否有填充数据！";
                    result.Message = sErrorMsg;
                }
                else
                {
                    result.Message = "导入完成";
                }
            }
            else
            {
                result.Status = false;
                result.Message = result.Message;
            }
            return result;
        }

        public TableData ExportData(Inventory entity)
        {
            return _app.ExportData(entity);
        }

        public TableData Query(Inventory entity)
        {
            var result = new TableData();
            var data = _app.Find(EntityToExpression<Inventory>.GetExpressions(entity));

            GetData(data, result);
            result.count = data.Count();

            return result;
        }

        public void GetData(IQueryable<Inventory> data, TableData result, PageReq pageRequest = null)
        {
            _app.GetData(data, result, pageRequest);
        }

        #region 自定义方法
        /// <summary>
        /// 出库查看
        /// </summary>
        /// <param name="entitys"></param>
        //public void GoodsOut(List<Inventory> entitys)
        //{
        //    var taskNo = _app.GetTaskNo(TaskNo.出库自动分配);
        //    var task = new Task
        //    {
        //        TaskNo = taskNo,
        //        OrderCode = taskNo,
        //        BusinessType = BusinessType.出库_其他出库单
        //    };
        //    task.FirstStatus = task.LastStatus = TaskStatus.待下发任务;

        //    _unitWork.Add(task);

        //    foreach (var item in entitys)
        //    {
        //        var taskdetail = new TaskDetail
        //        {
        //            TaskNo = taskNo,
        //            OrderCode = taskNo,
        //            TaskType = TaskType.出库查看,
        //            ContainerCode = item.ContainerCode,
        //            MaterialCode = item.MaterialCode,
        //            MaterialName = _unitWork.Find<Material>(n => n.Code == item.MaterialCode).Select(a => a.Name).FirstOrDefault(),
        //            OderQty = item.Qty,
        //            HadQty = 0,
        //            ContainerQty = 0,
        //            InventoryId = item.Id,
        //            SourceLocation = item.LocationCode,
        //            Roadway = _unitWork.FindSingle<Location>(n => n.Code == item.LocationCode).Roadway,
        //            Status = TaskStatus.待下发任务,
        //            Priority = 0,
        //            CreateTime = DateTime.Now
        //        };
        //        _unitWork.Add(taskdetail);


        //        //建立盘点容器出库任务
        //        int ptdcount = _unitWork.Find<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.ContainerCode == item.ContainerCode && n.TaskType == TaskType.容器出库).Count();
        //        if (ptdcount < 1)
        //        {

        //            Task ptask = new Task();
        //            TaskDetail ptaskDetail = new TaskDetail();
        //            var ctaskNo = _app.GetTaskNo(TaskNo.查看容器出库);
        //            ptask.TaskNo = ctaskNo;
        //            ptask.OrderCode = ctaskNo;
        //            ptask.BusinessType = BusinessType.出库_其他出库单;
        //            ptask.FirstStatus = TaskStatus.待下发任务;
        //            ptask.LastStatus = TaskStatus.待下发任务;
        //            ptask.CreateTime = DateTime.Now;
        //            _appt.Add(ptask);

        //            ptaskDetail.TaskNo = ctaskNo;
        //            ptaskDetail.OrderCode = ctaskNo;
        //            ptaskDetail.TaskType = TaskType.出库查看;
        //            ptaskDetail.ContainerCode = item.ContainerCode;
        //            ptaskDetail.SourceLocation = item.LocationCode;
        //            ptaskDetail.OderQty = 0;
        //            ptaskDetail.ContainerQty = 0;
        //            ptaskDetail.HadQty = 0;
        //            ptaskDetail.Roadway = _unitWork.Find<Location>(n => n.Code == item.LocationCode).Select(a => a.Roadway).FirstOrDefault();
        //            ptaskDetail.Status = TaskStatus.待下发任务;
        //            ptaskDetail.Priority = 0;
        //            ptaskDetail.CreateTime = DateTime.Now;
        //            _apptd.Add(ptaskDetail);

        //        }

        //    }

        //}

        public TableData CheckLoad(PageReq pageRequest, Inventory entity)
        {
            var result = new TableData();
            var inventory = _app.Find(EntityToExpression<Inventory>.GetExpressions(entity)).Where(u => u.TaskStatus != "1");

            GetData(inventory, result, pageRequest);
            result.count = inventory.Count();

            return result;
        }

        public TableData FindInventoryApp(string materialCode)
        {
            TableData tab = new TableData();
            try
            {
                List<Inventory> invs = (from inventory in _unitWork.Find<Inventory>(n => n.MaterialCode == materialCode && n.ContainerStatus == ContainerStatus.有)
                                        join container in _unitWork.Find<Container>(x => x.IsLock == 0)
                                        on inventory.ContainerCode equals container.Code
                                        select inventory).ToList();
                tab.data = invs;
            }
            catch (Exception)
            {
                tab.data = null;
            }
            return tab;
        }
        /// <summary>
        /// 直接出库
        /// </summary>
        /// <param name="entitys"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        public Response TaskOutNoBack(List<Inventory> entitys, string station)
        {
            Response response = new Response();
            try
            {
                var containerCodes = entitys.GroupBy(n => n.ContainerCode);
                foreach (var con in containerCodes)
                {
                    //建立盘点容器出库任务
                    Inventory item = con.FirstOrDefault();
                    Container ConType = _unitWork.Find<Container>(n => n.Code == item.ContainerCode).FirstOrDefault();
                    Station Sta = _unitWork.Find<Station>(n => n.Code == station).FirstOrDefault();
                    if (Sta == null)
                    {
                        response.Code = 300;
                        response.Message = "站台错误！！！";
                        return response;
                    }
                    if (item.ContainerCode.Contains("BB") && Sta.IsPass == 1)
                    {
                        response.Code = 300;
                        response.Message = "玻布仓货物请在MES中出库！！！";
                        return response;
                    }
                    else if (item.ContainerCode.Contains("TB") && item.Retreat != "余料回库" && Sta.IsPass == 1)
                    {
                        response.Code = 300;
                        response.Message = "铜箔仓货物请在MES中出库！！！";
                        return response;
                    }
                    else if (item.ContainerCode.Contains("PP") && item.MaterialCode != "000" && Sta.IsPass == 1 && item.IsFold != "Isflod")
                    {
                        response.Code = 300;
                        response.Message = "PP仓货物请在MES中出库！！！";
                        return response;
                    }
                    else if (item.ContainerCode.Contains("PJ")  && Sta.IsPass == 1 )
                    {
                        response.Code = 300;
                        response.Message = "外卖PP仓货物请在MES中出库！！！";
                        return response;
                    }
                    else if (item.ContainerCode.Contains("CP")  && Sta.IsPass == 1 && item.SourceLine != "0")
                    {
                        response.Code = 300;
                        response.Message = "成品仓货物请在MES中出库！！！";
                        return response;
                    }
                    //if (ConType.Code.Contains("TB") && station.Contains("ProductStationD"))
                    //{
                    //    response.Code = 300;
                    //    response.Message = "铜箔仓叠配出库请在MES中出库！！！";
                    //    return response;
                    //}
                    if (ConType.Type == "s_1" && (station == "EntranceStationE02" || station == "EntranceStationE03"))
                    {
                        response.Code = 300;
                        response.Message = "选择托盘："+ item.ContainerCode + "为小托盘，选择出库站台："+ Sta.Name + "为大托盘站台，选择错误不允许出库！！！";
                        return response;
                    }
                    else if (ConType.Type == "s_2" && (station == "EntranceStationE01" || station == "EntranceStationE04"))
                    {
                        response.Code = 300;
                        response.Message = "选择托盘：" + item.ContainerCode + "为大托盘，选择出库站台：" + Sta.Name + "为小托盘站台，选择错误不允许出库！！！";
                        return response;
                    }
                    if (item.TaskStatus == InventoryTaskType.有盘点任务)
                    {
                        response.Code = 300;
                        response.Message = "库存托盘:" + item.ContainerCode + "正在盘点;";
                        continue;
                    }
                    if (Sta.Code == "ExitStationY02")
                    {
                        TaskDetail tad = _unitWork.Find<TaskDetail>(n =>
                                n.SourceLocation == "EntranceStationY02" &&
                                (n.TaskType == TaskType.整盘入库 || n.TaskType == TaskType.容器回库 || n.TaskType == TaskType.空容器入库))
                            .FirstOrDefault();
                        if (tad != null)
                        {
                            response.Code = 300;
                            response.Message = "正在执行托盘" + tad.ContainerCode + "的入库任务，请等待入库任务执行完成后操作。";
                            return response;
                        }
                    }
                    int ptdcount = _unitWork.Find<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.ContainerCode == item.ContainerCode).Count();
                    if (ptdcount < 1 && item.TaskStatus == InventoryTaskType.无任务)
                    {
                        Task ptask = new Task();
                        var ctaskNo = _app.GetTaskNo(TaskNo.容器出库);
                        ptask.TaskNo = ctaskNo;
                        ptask.OrderCode = ctaskNo;
                        ptask.BusinessType = BusinessType.出库_其他出库单;
                        ptask.FirstStatus = TaskStatus.待下发任务;
                        ptask.LastStatus = TaskStatus.待下发任务;
                        ptask.CreateTime = DateTime.Now;

                        TaskDetail ptaskDetail = new TaskDetail();
                        Station stat = _unitWork.Find<Station>(n => n.Code == item.LocationCode && n.Type == StationType.暂存区站台).FirstOrDefault();
                        if (stat != null)
                        {
                            ptaskDetail.TaskType = TaskType.站台到站台;
                            ptaskDetail.Roadway = _unitWork.Find<StationRoadway>(n => n.StationCode == item.LocationCode).Select(a => a.RoadWay).FirstOrDefault();
                        }
                        else
                        {
                            ptaskDetail.TaskType = TaskType.直接出库;
                            ptaskDetail.Roadway = _unitWork.Find<Location>(n => n.Code == item.LocationCode).Select(a => a.Roadway).FirstOrDefault();
                        }
                        ptaskDetail.TaskNo = ctaskNo;
                        ptaskDetail.OrderCode = ctaskNo;
                        ptaskDetail.ContainerCode = item.ContainerCode;
                        ptaskDetail.SourceLocation = item.LocationCode;
                        if (_unitWork.IsExist<Station>(n => n.Code == station && n.Type == StationType.暂存区站台))
                        {
                            Station s = new Station();
                            if (ptaskDetail.Roadway == 4)
                            {
                                s = (from sta in _unitWork.Find<Station>(n => n.Type == StationType.暂存区站台 && n.Containercode == "" && n.IsStop == 0)
                                     join sr in _unitWork.Find<StationRoadway>(a => a.RoadWay == ptaskDetail.Roadway)
                                     on sta.Code equals sr.StationCode
                                     select sta).OrderByDescending(x => x.Code).FirstOrDefault();
                            }
                            else
                            {
                                s = (from sta in _unitWork.Find<Station>(n => n.Type == StationType.暂存区站台 && n.Containercode == "" && n.IsStop == 0)
                                     join sr in _unitWork.Find<StationRoadway>(a => a.RoadWay == ptaskDetail.Roadway)
                                     on sta.Code equals sr.StationCode
                                     select sta).FirstOrDefault();
                            }
                            if (s != null)
                            {
                                //s.Containercode = item.ContainerCode;
                                //_unitWork.Update(s);
                            }
                            else
                            {
                                response.Code = 300;
                                response.Message += item.ContainerCode + "未找到缓存站台！";
                                continue;
                            }
                            ptaskDetail.DestinationLocation = s.Code;
                            ptaskDetail.Station = s.Code;
                        }
                        else
                        {
                            ptaskDetail.DestinationLocation = station;
                            ptaskDetail.Station = station;
                        }
                        _appt.Add(ptask);

                        ptaskDetail.OderQty = 0;
                        ptaskDetail.ContainerQty = 0;
                        ptaskDetail.HadQty = 0;
                        ptaskDetail.Status = TaskStatus.待下发任务;
                        ptaskDetail.Priority = 0;
                        ptaskDetail.CreateTime = DateTime.Now;
                        _apptd.Add(ptaskDetail);

                        item.TaskStatus = InventoryTaskType.任务锁定中;
                        _unitWork.Update(item);

                        List<Inventory> inventories = _unitWork.Find<Inventory>(n => n.ContainerCode == item.ContainerCode && n.Id != item.Id).ToList();
                        foreach (Inventory inv in inventories)
                        {
                            inv.TaskStatus = InventoryTaskType.任务锁定中;
                            _unitWork.Update(inv);
                        }
                    }
                    else
                    {
                        response.Code = 300;
                        response.Message = "托盘:" + item.ContainerCode + "已经有任务或库存任务不正确;";
                        continue;
                    }
                }
            }
            catch (Exception ex)
            {
                response.Code = 300;
                response.Message = ex.Message;
            }
            return response;
        }

        /// <summary>
        /// 盘点出库
        /// </summary>
        /// <param name="entitys"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        public Response CYCOutNoBack(List<Inventory> entitys, string station)
        {
            Response response = new Response();
            try
            {
                var containerCodes = entitys.GroupBy(n => n.ContainerCode);
                foreach (var con in containerCodes)
                {
                    //建立盘点容器出库任务
                    Inventory item = con.FirstOrDefault();
                    if (item.TaskStatus == InventoryTaskType.有盘点任务)
                    {
                        response.Code = 300;
                        response.Message += "托盘:" + item.ContainerCode + "正在盘点或者已盘点;";
                        continue;
                    }
                    int ptdcount = _unitWork.Find<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.ContainerCode == item.ContainerCode).Count();
                    if (ptdcount < 1 && item.TaskStatus == InventoryTaskType.无任务)
                    {
                        Task ptask = new Task();
                        var ctaskNo = _app.GetTaskNo(TaskNo.盘点);
                        ptask.TaskNo = ctaskNo;
                        ptask.OrderCode = ctaskNo;
                        ptask.BusinessType = BusinessType.出库_盘点出库;
                        ptask.FirstStatus = TaskStatus.待下发任务;
                        ptask.LastStatus = TaskStatus.待下发任务;
                        ptask.CreateTime = DateTime.Now;


                        TaskDetail ptaskDetail = new TaskDetail();
                        ptaskDetail.TaskType = TaskType.盘点;
                        ptaskDetail.Roadway = _unitWork.Find<Location>(n => n.Code == item.LocationCode).Select(a => a.Roadway).FirstOrDefault();
                        ptaskDetail.TaskNo = ctaskNo;
                        ptaskDetail.OrderCode = ctaskNo;
                        ptaskDetail.ContainerCode = item.ContainerCode;
                        ptaskDetail.SourceLocation = item.LocationCode;
                        ptaskDetail.DestinationLocation = station;
                        ptaskDetail.Station = station;
                        _appt.Add(ptask);

                        ptaskDetail.OderQty = 0;
                        ptaskDetail.ContainerQty = 0;
                        ptaskDetail.HadQty = 0;
                        ptaskDetail.Status = TaskStatus.待下发任务;
                        ptaskDetail.Priority = 0;
                        ptaskDetail.CreateTime = DateTime.Now;
                        _apptd.Add(ptaskDetail);

                        item.TaskStatus = InventoryTaskType.有盘点任务;
                        _unitWork.Update(item);

                        List<Inventory> inventories = _unitWork.Find<Inventory>(n => n.ContainerCode == item.ContainerCode && n.Id != item.Id).ToList();
                        foreach (Inventory inv in inventories)
                        {
                            inv.TaskStatus = InventoryTaskType.有盘点任务;
                            _unitWork.Update(inv);
                        }
                    }
                    else
                    {
                        response.Code = 300;
                        response.Message += "托盘:" + item.ContainerCode + "已经有任务;";
                        continue;
                    }
                }
            }
            catch (Exception ex)
            {
                response.Code = 300;
                response.Message = ex.Message;
            }
            return response;
        }

        /// <summary>
        /// 关闭盘点
        /// </summary>
        /// <param name="entitys"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        public Response CloseCYC(string region)
        {
            Response response = new Response();
            try
            {
                List<Inventory> list = _unitWork.Find<Inventory>(n => n.TaskStatus == InventoryTaskType.有盘点任务 && n.WarehouseType == region).ToList();
                foreach (Inventory inv in list)
                {
                    int ptdcount = _unitWork.Find<TaskDetail>(n => (n.Status >= TaskStatus.新建任务 && n.Status < TaskStatus.已经完成) && n.ContainerCode == inv.ContainerCode).Count();
                    if (ptdcount > 1)
                    {
                        inv.TaskStatus = InventoryTaskType.任务锁定中;
                    }
                    else
                    {
                        inv.TaskStatus = InventoryTaskType.无任务;
                    }
                    _unitWork.Update(inv);
                }
            }
            catch (Exception ex)
            {
                response.Code = 300;
                response.Message = ex.Message;
            }
            return response;
        }

        /// <summary>
        ///成品库木板补板逻辑
        /// </summary>
        public Response WoodenPalletOutApp(string type, string station)
        {
            Response response = new Response();
            try
            {
                if (_unitWork.IsExist<TaskDetail>(n => n.DestinationLocation == station))
                {
                    response.Code = 300;
                    response.Message = "该站台已存在出库任务！";
                    return response;
                }
                Task ptask = new Task();
                TaskDetail ptaskDetail = new TaskDetail();
                string woodStation = "";
                //根据板类型选择对应站台
                if (type.Contains("SWP"))
                {
                    woodStation = "InStationE08";
                }
                else if(type.Contains("BWP"))
                {
                    woodStation = "InStationE07";
                }

                Inventory inventory = _unitWork.Find<Inventory>(n => n.LocationCode == woodStation).FirstOrDefault();
                if (inventory == null)
                {
                    response.Code = 300;
                    response.Message = "拆分机上已经没有木板了，请补给木板！！";
                    return response;
                }
                else
                {
                    if (inventory.MaterialCode != type)
                    {
                        response.Code = 300;
                        response.Message = "拆分机上的木板类型不同，请从人工站台补给该类型木板！！";
                        return response;
                    }
                }

                //建立盘点容器出库任务
                var ctaskNo = _app.GetTaskNo(TaskNo.容器出库);
                ptask.TaskNo = ctaskNo;
                ptask.OrderCode = ctaskNo;
                ptask.BusinessType = BusinessType.出库_其他出库单;
                ptask.FirstStatus = TaskStatus.待下发任务;
                ptask.LastStatus = TaskStatus.待下发任务;
                ptask.CreateTime = DateTime.Now;
                _appt.Add(ptask);

                ptaskDetail = new TaskDetail();
                ptaskDetail.TaskNo = ctaskNo;
                ptaskDetail.OrderCode = ctaskNo;
                ptaskDetail.TaskType = TaskType.容器出库;
                ptaskDetail.DestinationLocation = station;
                ptaskDetail.Station = woodStation;
                ptaskDetail.Status = TaskStatus.新建任务;
                ptaskDetail.MaterialCode = type;

                ptaskDetail.OderQty = 0;
                ptaskDetail.ContainerQty = 0;
                ptaskDetail.HadQty = 0;
                ptaskDetail.Priority = 0;
                ptaskDetail.CreateTime = DateTime.Now;
                _apptd.Add(ptaskDetail);
            }
            catch (Exception ex)
            {
                response.Code = 300;
                response.Message = ex.Message;
            }
            return response;
        }
        /// <summary>
        ///删除库存数据
        /// </summary>
        public Response DelInv(List<Inventory> Invs)
        {
            Response response = new Response();
            response.Code = 200;
            try
            {
                foreach (var Inv in Invs)
                {
                    Inventory inventory = _unitWork.Find<Inventory>(n => n.Id == Inv.Id).FirstOrDefault();
                    if (inventory != null)
                    {
                        _unitWork.Delete(inventory);
                        InventoryTransaction inventoryTransaction = new InventoryTransaction
                        {
                            Type = "手动删除库存",
                            SourceCode = inventory.SourceCode,
                            ContainerCode = inventory.ContainerCode,
                            MaterialCode = inventory.MaterialCode,
                            Batch = inventory.Batch,
                            Lot = inventory.Lot,
                            Qty = inventory.Qty,
                            QrCode = inventory.QrCode,
                            Supplier = inventory.Supplier,
                            ResidualWeight = inventory.ResidualWeight,
                            Retreat = inventory.Retreat,
                            Specification = inventory.Specification,
                            NameDescription = inventory.NameDescription,
                            Unit = inventory.Unit,
                            Size = inventory.Size,
                            NumberofSheets = inventory.NumberofSheets,
                            Groupnum = inventory.Groupnum,
                            OldBatch = inventory.OldBatch,
                            Combo = inventory.Combo,
                            Status = inventory.Status,
                            LocationCode = inventory.LocationCode,
                            StackingNumber = inventory.StackingNumber,
                            CreateTime = inventory.CreateTime,
                            UpdateTime = DateTime.Now,
                            UpdateBy = "DelInv"
                        };
                        _unitWork.Add(inventoryTransaction);
                    }
                }
            }
            catch (Exception ex)
            {
                response.Code = 300;
                response.Message = ex.Message;
            }
            return response;
        }
        #endregion
    }
}