JC24WMS.git - Gitblit

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using AutoMapper;
using Model.ModelDto.SysDto;
using SqlSugar;
using WMS.DAL;
using WMS.Entity.BllCheckEntity;
using WMS.Entity.Context;
using WMS.Entity.DataEntity;
using WMS.Entity.SysEntity;
using WMS.IBLL.ILogServer;
using WMS.IBLL.ISysServer;
using WMS.IDAL.ISysInterface;
 
namespace WMS.BLL.SysServer
{
    public class ExceptionServer : IExceptionServer
    {
        private static readonly SqlSugarScope Db = DataContext.Db;
        private readonly IOperationSysServer _operation; //操作日志
        public IExceptionRepository ExceptionRst { get; set; }
        private readonly IMapper _mapper;
        public ExceptionServer(IExceptionRepository exceptionRst, IMapper mapper, IOperationSysServer operation)
        {
            ExceptionRst = exceptionRst;
            _mapper = mapper;
            _operation = operation;
        }
        /// <summary>
        /// 查询异常处理表信息
        /// </summary>
        /// <param name="palletNo">托盘号</param>
        /// <param name="excLocatNo">储位号</param>
        /// <param name="orderNo">单据号 入库单 出库单 移库单</param>
        /// <param name="taskNo">任务号</param>
        /// <param name="status">状态 0：未处理 1：已处理</param>
        /// <param name="text">处理描述</param>
        /// <param name="type">异常类型 0：空取 1：满入 2：双工位异常</param>
        /// <param name="page"></param>
        /// <param name="limit"></param>
        /// <returns></returns>
        public async Task<List<SysException>> GetExceptionList(string palletNo, string excLocatNo, string orderNo,
            string taskNo, string status, string text, string type, int page = 0, int limit = 10)
        {
            try
            {
                Expression<Func<SysException, bool>> item = Expressionable.Create<SysException>()
                    .AndIF(!string.IsNullOrWhiteSpace(palletNo), it => it.PalletNo.Contains(palletNo.Trim()))
                    .AndIF(!string.IsNullOrWhiteSpace(excLocatNo), it => it.ExcLocatNo.Contains(excLocatNo.Trim()))
                    .AndIF(!string.IsNullOrWhiteSpace(orderNo), it => it.OrderNo.Contains(orderNo.Trim()))
                    .AndIF(!string.IsNullOrWhiteSpace(taskNo), it => it.TaskNo.Contains(taskNo.Trim()))
                    .AndIF(!string.IsNullOrWhiteSpace(text), it => it.Text.Contains(text.Trim()))
                    .AndIF(!string.IsNullOrWhiteSpace(status), it => it.Status == type)
                    .AndIF(!string.IsNullOrWhiteSpace(type), it => it.Type == type)
                    .ToExpression();//注意 这一句 不能少
 
                var data = await ExceptionRst.GetAllByOrderPageAsync(item, limit, page, out int counts).ToListAsync();
                return data;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
        /// <summary>
        /// 添加异常处理信息
        /// </summary>
        /// <param name="type">异常类型 0：空取 1：满入 2：双工位异常</param>
        /// <param name="palletNo">托盘号</param>
        /// <param name="excLocatNo">储位号</param>
        /// <param name="orderNo">单据号 入库单 出库单 移库单</param>
        /// <param name="taskNo">任务号</param>
        /// <param name="text">处理描述</param> 
        /// <param name="userId">操作人</param>
        /// <returns></returns>
        public async Task<bool> AddException(string type, string palletNo, string excLocatNo, string orderNo, string taskNo, string text, int userId)
        {
            try
            {
                var exNo = new Common().GetMaxNo("EX");
                var num = await ExceptionRst.AddAsync(new SysException()
                {
                    Type = type,
                    ExceptionNo = exNo,
                    PalletNo = palletNo,
                    ExcLocatNo = excLocatNo,
                    OrderNo = orderNo,
                    TaskNo = taskNo,
                    Text = text,
                    CreateUser = userId
                });
                if (num > 0)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
 
 
        /// <summary>
        /// 获取异常处理信息列表
        /// </summary>
        /// <param name="exceptionNo">异常号</param>
        /// <param name="palletNo">托盘号</param>
        /// <param name="excLocatNo">异常储位</param>
        /// <param name="orderNo">关联单号</param>
        /// <param name="taskNo">关联任务号</param>
        /// <param name="type">异常类型</param>
        /// <param name="status">状态</param>
        /// <returns></returns>
        public List<ExceptionDto> GetTableList(string exceptionNo, string palletNo, string excLocatNo, string orderNo, string taskNo, string type, string status)
        {
            List<ExceptionDto> tablelist = ExceptionRst.GetExceptionList(exceptionNo, palletNo, excLocatNo, orderNo, taskNo, type, status);
            return tablelist;
        }
 
        /// <summary>
        /// 根据id获取异常信息
        /// </summary>
        /// <param name="id">异常id</param>
        /// <returns></returns>
        public SysException GetTableById(int id)
        {
            SysException table = ExceptionRst.GetExceptionById(id);
            return table;
        }
 
        /// <summary>
        /// 新增异常处理
        /// </summary>
        /// <param name="type">异常类型</param>
        /// <param name="palletNo">托盘号</param>
        /// <param name="excLocatNo">异常储位</param>
        /// <param name="orderNo">关联单号</param>
        /// <param name="taskNo">关联任务号</param>
        /// <param name="demo">备注</param>
        /// <param name="uid">创建人</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public async Task<int> InsertTableName(string type, string palletNo, string excLocatNo, string orderNo, string taskNo, string demo, int uid)
        {
            //捕获异常
            try
            {
                //获取最大异常号
                string ExceptionNo = ExceptionRst.GetMaxExceptionNo().ExceptionNo;
                //判断获取到的异常号是否为空
                if (!string.IsNullOrEmpty(ExceptionNo))
                {
                    ExceptionNo = "1000";
                }
                else
                {
                    ExceptionNo = (int.Parse(ExceptionNo) + 1).ToString();
                }
                int i = await ExceptionRst.InsertException(ExceptionNo, type, palletNo, excLocatNo, orderNo, taskNo, demo, uid);
                return i;
            }
            catch (Exception ex)
            {
                //抛出异常
                throw new Exception("新增异常处理", ex);
            }
        }
 
        /// <summary>
        /// 处理异常状态-空取异常
        /// </summary>
        /// <param name="tabledto">异常处理dto</param>
        /// <returns></returns>
        /// <exception cref="Exception">捕获异常</exception>
        public string EditStatus(ExceptionDto tabledto)
        {
            string strMessage = "";
            var time = DateTime.Now;
            try
            {               
                //异常处理表
                SysException exception = Db.Queryable<SysException>().First(m => m.Id == tabledto.Id);
                if (exception == null || exception.Status != "0")
                {
                    strMessage = "该异常不存在或已处理";
                    return strMessage;
                }
                //储位表
                SysStorageLocat storageLocat = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == exception.ExcLocatNo);
                if (storageLocat == null || storageLocat.Flag != "1")
                {
                    throw new Exception("储位不存在或状态异常！");
                }
                //库存明细表
                DataStockDetail stockDetail = Db.Queryable<DataStockDetail>().First(m => m.PalletNo == exception.PalletNo);
                if (stockDetail == null)
                {
                    throw new Exception("库存明细不存在！");
                }
                //库存总表
                DataStock stock = Db.Queryable<DataStock>().First(m => m.SkuNo == stockDetail.SkuNo && m.LotNo == stockDetail.LotNo);
                if (stock == null)
                {
                    throw new Exception("库存不存在！");
                }
 
                //开启事务
                Db.Ado.BeginTran();
                //异常处理表，将状态Status修改为：1，已处理
                exception.Status = "1";
                exception.Text = tabledto.Text;
                exception.Demo = tabledto.Demo;
                exception.UpdateUser = tabledto.UpdateUser;
                exception.UpdateTime = time;
 
                Db.Updateable(exception).ExecuteCommand();
 
                //找到货物处理
                if (tabledto.IsHasGoods == "0")
                {                    
                    //储位表, 将储位标志Flag修改为：0：正常
                    storageLocat.Flag = "0";
                    storageLocat.UpdateUser = tabledto.UpdateUser;
                    storageLocat.UpdateTime = time;
 
                    Db.Updateable(storageLocat).UpdateColumns(it => new { it.Flag, it.UpdateUser, it.UpdateTime }).ExecuteCommand();
                    //库存明细表，修改锁定数量LockQty=锁定数量LockQty-托盘数量，状态Status修改为：0：待分配
                    stockDetail.LockQty = stockDetail.LockQty - stockDetail.Qty;
                    stockDetail.Status = "0";
                    stockDetail.UpdateUser = tabledto.UpdateUser;
                    stockDetail.UpdateTime = time;
 
                    Db.Updateable(stockDetail).UpdateColumns(it => new { it.LockQty, it.Status, it.UpdateUser, it.UpdateTime }).ExecuteCommand();
                    //库存总表，修改锁定数量LockQty=锁定数量-托盘数量
                    stock.LockQty = Convert.ToInt32(stock.LockQty - stockDetail.Qty);
                    stock.UpdateUser = tabledto.UpdateUser;
                    stock.UpdateTime = time;
 
                    Db.Updateable(stock).UpdateColumns(it => new { it.LockQty, it.UpdateUser, it.UpdateTime }).ExecuteCommand();
                }
                else//未找到货物处理 
                {
                    //储位表,
                    storageLocat.Status = "0"; //将储位状态Status修改为：0，空储位,
                    storageLocat.Flag = "0";//将储位标志Flag修改为：0：正常
                    storageLocat.UpdateUser = tabledto.UpdateUser;
                    storageLocat.UpdateTime = time;
 
                    Db.Updateable(storageLocat).UpdateColumns(it => new {it.Status, it.Flag, it.UpdateUser, it.UpdateTime }).ExecuteCommand();
 
                    var crNo = new Common().GetMaxNo("CR");
                    var check = new BllStockCheck()
                    {
                        CRNo = crNo,
                        Status = 2,
                        Origin = "1",
                        CreateUser = tabledto.UpdateUser,
                        CreateTime = time
                    };
                    //添加盘点表
                    Db.Insertable(check).ExecuteCommand();
 
                    var detail = new BllStockCheckDetail()
                    {
                        CRNo = crNo,
                        PalletNo = exception.PalletNo,
                        Qty = stockDetail.Qty,
                        RealQty = 0,
                        CheckResult = 1,// 0：正常，1：异常
                        Status = 3,
                        SkuNo = stockDetail.SkuNo,
                        SkuName = stockDetail.SkuName,
                        Standard = stockDetail.Standard,
                        LotNo = stockDetail.LotNo,
                        LotText = stockDetail.LotText,
                        SupplierLot = stockDetail.SupplierLot,
                        TaskNo = exception.TaskNo,
 
                        CreateUser = tabledto.UpdateUser,
                        CreateTime = time
                    };
                    //添加盘点明细表
                    Db.Insertable(detail).ExecuteCommand();
 
                    var outStockBox = Db.Queryable<DataBoxInfo>().Where(m => m.IsDel == "0" && m.PalletNo == exception.PalletNo).ToList();
                    var logList = new List<BllStockCheckLog>();
                    foreach (var item in outStockBox)
                    {
                        var checkLog = new BllStockCheckLog()
                        {
                            CRNo = crNo,
                            PalletNo = exception.PalletNo,
                            BoxNo = item.BoxNo,
                            BoxNo2 = item.BoxNo2,
                            BoxNo3 = item.BoxNo3,
                            Qty = item.Qty,
                            RealQty = 0,
                            CheckResult = 1,
                            CheckDate = time,
                            CheckUserId = tabledto.UpdateUser,
                            SkuNo = item.SkuNo,
                            SkuName = item.SkuName,
                            Standard = item.Standard,
                            LotNo = item.LotNo,
                            LotText = item.LotText,
                            SupplierLot = item.SupplierLot,
 
                            CreateUser = tabledto.UpdateUser,
                            CreateTime = time
                        };
                        logList.Add(checkLog);
                    }
                    //添加盘点记录表
                    Db.Insertable(logList).ExecuteCommand();
                }
                //提交事务
                Db.Ado.CommitTran();
                //插入操作日志
                _operation.InsertOperation("仓库设置", "异常管理", exception.ExceptionNo, "编辑", $"处理了异常号为：{exception.ExceptionNo}的异常信息", Convert.ToInt32(exception.UpdateUser));
                return strMessage;
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                //抛出异常
                throw new Exception("处理状态异常", ex);
            }
        }
        /// <summary>
        /// 处理异常状态-满入异常
        /// </summary>
        /// <param name="tabledto"></param>
        /// <returns></returns>
        public string EditStatus2(ExceptionDto tabledto)
        {
            string strMessage = "";
            var time = DateTime.Now;
            try
            {
                //异常处理表
                SysException exception = Db.Queryable<SysException>().First(m => m.Id == tabledto.Id);
                if (exception == null || exception.Status != "0")
                {
                    strMessage = "该异常不存在或已处理";
                    return strMessage;
                }
                //储位表
                SysStorageLocat storageLocat = Db.Queryable<SysStorageLocat>().First(m => m.LocatNo == exception.ExcLocatNo);
                if (storageLocat == null || storageLocat.Flag != "1")
                {
                    throw new Exception("储位不存在或状态异常！");
                }               
                //开启事务
                Db.Ado.BeginTran();
                //异常处理表，将状态Status修改为：1，已处理
                exception.Status = "1";
                exception.Text = tabledto.Text;
                exception.Demo = tabledto.Demo;
                exception.UpdateUser = tabledto.UpdateUser;
                exception.UpdateTime = time;
 
                Db.Updateable(exception).ExecuteCommand();
                //储位表
                storageLocat.Status = "0";// 将储位状态Status修改为：0
                storageLocat.Flag = "0";//空储位,将储位标志Flag修改为：0：正常
                storageLocat.UpdateUser = tabledto.UpdateUser;
                storageLocat.UpdateTime = time;
 
                Db.Updateable(storageLocat).UpdateColumns(it => new { it.Status, it.Flag, it.UpdateUser, it.UpdateTime }).ExecuteCommand();
                //提交事务
                Db.Ado.CommitTran();
                //插入操作日志
                _operation.InsertOperation("仓库设置", "异常管理", exception.ExceptionNo, "编辑", $"处理了异常号为：{exception.ExceptionNo}的异常信息", Convert.ToInt32(exception.UpdateUser));
                return strMessage;
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                //抛出异常
                throw new Exception("处理状态异常", ex);
            }
        }
    }
}