JC34WMS.git - Gitblit

using Model.InterFaceModel;
using Model.ModelDto.BllAsnDto;
using Model.ModelVm.BllAsnVm;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using WMS.BLL.LogServer;
using WMS.DAL;
using WMS.Entity.BllAsnEntity;
using WMS.Entity.Context;
using WMS.Entity.SysEntity;
using WMS.IBLL.IBllAsnServer;
 
namespace WMS.BLL.BllAsnServer
{
    public class ProcurePlanServer : DbHelper<BllProcurePlanNotice>, IProcurePlanServer
    {
        #region 依赖注入 
        private static readonly SqlSugarScope Db = DataContext.Db;
 
        public ProcurePlanServer() : base(Db)
        {
        }
        #endregion
 
        /// <summary>
        /// 获取采购单信息
        /// </summary>
        /// <param name="model"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        public async Task<List<ProcurePlanNoticeDto>> GetProcurePlanNoticeList(ProcurePlanNoticeVm model, RefAsync<int> count)
        {
            var modelList = await Db.Queryable<BllProcurePlanNotice>()
                .LeftJoin<BllProcurePlanNoticeDetail>((tb1, tb2) => tb1.Id == tb2.ParentId)
                .LeftJoin<SysUserInfor>((tb1, tb2, tb3) => tb1.CreateUser == tb3.Id)
                .LeftJoin<SysUserInfor>((tb1, tb2, tb3, tb4) => tb1.UpdateUser == tb4.Id)
                .WhereIF(!string.IsNullOrWhiteSpace(model.Status), tb1 => tb1.Status == model.Status)
                .WhereIF(!string.IsNullOrWhiteSpace(model.StartTime), tb1 => tb1.CreateTime >= Convert.ToDateTime(model.StartTime))
                .WhereIF(!string.IsNullOrWhiteSpace(model.EndTime), tb1 => tb1.CreateTime <= Convert.ToDateTime(model.EndTime).AddDays(1))
                .WhereIF(!string.IsNullOrWhiteSpace(model.SkuName), (tb1,tb2) => tb2.SkuName.Contains(model.SkuName))
                .WhereIF(!string.IsNullOrWhiteSpace(model.SkuNo), (tb1,tb2) => tb2.SkuNo.Contains(model.SkuNo))
                .WhereIF(!string.IsNullOrWhiteSpace(model.CustomerName), (tb1,tb2) => tb2.CustomerName.Contains(model.CustomerName))
                .Where(tb1 => tb1.IsDel == "0")
                .OrderBy(tb1=>tb1.Status)
                .OrderByDescending(tb1 => tb1.CreateTime)
                .Distinct()
                .Select((tb1, tb2, tb3, tb4) => new ProcurePlanNoticeDto() {
                    Id = tb1.Id,
                    Status = tb1.Status,
                    OrderCode = tb1.OrderCode,
                    UserName = tb1.UserName,
                    CompleteTime = tb1.CompleteTime,
                    CreateTime = tb1.CreateTime,
                    CreateUserName = tb3.RealName,
                    UpdateTime = tb1.UpdateTime.ToString(),
                    UpdateUserName = tb4.RealName
                }).ToPageListAsync(model.Page, model.Limit, count);
             
            return modelList;
        }
        /// <summary>
        /// 获取采购单明细信息
        /// </summary>
        /// <param name="model"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        public async Task<List<ProcurePlanNoticeDetailDto>> GetProcurePlanNoticeDetailList(ProcurePlanNoticeDetailVm model, RefAsync<int> count)
        {
            var modelList = await Db.Queryable<BllProcurePlanNoticeDetail, SysUserInfor, SysUserInfor, SysMaterials, 
                SysUnit, SysPackag>((tb1, tb2, tb3, tb4, tb5, tb6) => new JoinQueryInfos(
                    JoinType.Left, tb1.CreateUser == tb2.Id,
                    JoinType.Left, tb1.UpdateUser == tb3.Id,
                    JoinType.Left, tb1.SkuNo == tb4.SkuNo,
                    JoinType.Left, tb4.UnitNo == tb5.UnitNo,
                    JoinType.Left, tb1.PackagNo == tb6.PackagNo))
                .Where(tb1 => tb1.ParentId == model.ParentId && tb1.IsDel == "0")
                .OrderByDescending(tb1 => tb1.SkuNo)
                .Distinct()
                .Select((tb1, tb2, tb3, tb4, tb5, tb6) => new ProcurePlanNoticeDetailDto()
                {
                    Id = tb1.Id,
                    ParentId = tb1.ParentId.ToString(),
                    OrderDetailCode = tb1.OrderDetailCode,
                    SkuNo = tb1.SkuNo,
                    SkuName = tb1.SkuName,
                    Standard = tb1.Standard,
                    Qty = tb1.Qty,
                    CompleteQty = tb1.CompleteQty,
                    PackagNo = tb1.PackagNo,
                    PackagName = tb6.PackagName,
                    UnitName = tb5.UnitName,
                    Status = tb1.Status,
                    CustomerNo = tb1.CustomerNo,
                    CustomerName = tb1.CustomerName,
                    CompleteTime = tb1.CompleteTime,
                    CreateTime = tb1.CreateTime,
                    CreateUserName = tb2.RealName,
                    UpdateTime = tb1.UpdateTime.ToString(),
                    UpdateUserName = tb3.RealName
 
                }).ToPageListAsync(model.Page, model.Limit, count);
 
            return modelList;
        }
        /// <summary>
        /// 通过采购单生成入库单据
        /// </summary>
        /// <param name="planDetailId"></param>
        /// <param name="userId"></param>
        public void CreateAsnByProcurePlan(int planDetailId,int userId)
        {
            try
            {
                //采购单明细
                var planDetail= Db.Queryable<BllProcurePlanNoticeDetail>().First(it => it.Id == planDetailId && it.IsDel == "0");
                if (planDetail == null)
                {
                    throw new Exception("未查询到采购单据明细信息");
                }
                //采购总单信息
                var planOrd = Db.Queryable<BllProcurePlanNotice>().First(it => it.Id == planDetail.ParentId && it.IsDel == "0");
                if (planOrd == null)
                {
                    throw new Exception("未查询到采购单据总单信息");
                }
                if (planOrd.Status == "3")
                {
                    throw new Exception("采购单据总单已关单");
                }
 
                // 根据客户编号获取客户名称
                var CustomerModel = Db.Queryable<SysCustomer>().First(it => it.CustomerNo == planDetail.CustomerNo && it.IsDel == "0");
                if (CustomerModel == null)
                {
                    throw new Exception("客户编号不存在!");
                }
                // 入库总表信息
                string asnNo = new Common().GetMaxNo("ASN");
                var asnModel = new BllArrivalNotice()
                {
                    ASNNo = asnNo,
                    Status = "0",//执行状态，0：等待执行
                    Type = "1",//单据类型，1：采购入库
                    Origin = "采购单",
                    CustomerNo = CustomerModel.CustomerNo,
                    CustomerName = CustomerModel.CustomerName,
                    OrderCode = planOrd.OrderCode,
                    CreateUser = userId
                };               
                // 获取物料详细信息
                var skuModel = Db.Queryable<SysMaterials>().First(it => it.SkuNo == planDetail.SkuNo && it.IsDel == "0");
                if (skuModel == null)
                {
                    throw new Exception("不存在当前物料信息!");
                }
                // 验证包装信息是否存在
                var packagModel = Db.Queryable<SysPackag>().First(it => it.PackagNo == planDetail.PackagNo && it.IsDel == "0");
                if (packagModel == null)
                {
                    throw new Exception("不存在当前包装信息!");
                }
                //入库单明细
                var detailModel = new BllArrivalNoticeDetail()
                {
                    ASNNo = asnNo,
                    SkuNo = skuModel.SkuNo,
                    SkuName = skuModel.SkuName,
                    Standard = skuModel.Standard,
                    LotNo = "",
                    LotText = "",
                    Qty = 0,
                    FactQty = 0,
                    CompleteQty = 0,
                    PackagNo = packagModel.PackagNo,
                    SupplierLot = "",
                    Status = "0",
                    IsSampling = "0",
                    InspectStatus = "0",
                    OrderDetailCode = planDetail.OrderDetailCode,
                    CreateUser = userId
                };
 
                //开启事务
                Db.BeginTran();
 
                // 插入入库单总表
                Db.Insertable(asnModel).ExecuteCommand();
                // 插入入库单明细
                Db.Insertable(detailModel).ExecuteCommand();
 
                //添加操作日志
                new OperationASNServer().AddLogOperationAsn("入库作业", "入库单据", asnNo, "添加", $"在采购单页面添加了单据号为{asnNo}的单据信息", userId);
 
                //提交事务
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                throw new Exception(ex.Message);
            }
        }
 
        /// <summary>
        /// 关闭采购单据
        /// </summary>
        /// <param name="Id"></param>
        /// <param name="userId"></param>
        public void CloseProcurePlan(int Id,int userId)
        {
            try
            {
                //采购总单信息
                var planOrd = Db.Queryable<BllProcurePlanNotice>().First(it => it.Id == Id && it.IsDel == "0" && it.Status == "2");
                if (planOrd == null)
                {
                    throw new Exception("未查询到采购单据总单信息");
                }
                //开启事务
                Db.BeginTran();
 
                planOrd.Status = "3";
                planOrd.UpdateUser = userId;
                planOrd.UpdateTime = DateTime.Now;
                //更新采购单状态
                Db.Updateable(planOrd).ExecuteCommand();
 
                //添加操作日志
                new OperationASNServer().AddLogOperationAsn("入库作业", "入库单据", planOrd.OrderCode, "关单", $"关闭了采购单据号为{planOrd.OrderCode}的采购单据信息", userId);
 
                //提交事务
                Db.CommitTran();
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                throw new Exception(ex.Message);
            }
        }
 
        #region 接口方法
        /// <summary>
        /// 上游系统下发创建采购单
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ErpModel CreateProcurePlan(ProcurePlanInfo model)
        {
            try
            {
                var resultModel = new ErpModel() { Success = -1, Message = "" };
               
                if (string.IsNullOrEmpty(model.OrderCode))
                {
                    resultModel.Message = "上游系统单号不可为空!";
                    return resultModel;
                }
                if (model.ProcurePlanDetails.Count <= 0)
                {
                    resultModel.Message = "采购单明细不可为空!";
                    return resultModel;
                }
 
                //开启事务
                Db.BeginTran();
 
                // 采购单总表信息
                var planModel = new BllProcurePlanNotice()
                {
                    Status = "0",                   
                    OrderCode = model.OrderCode,
                    UserName = model.Username  //制单人
                };
                // 插入采购单总表
                int parentId = Db.Insertable(planModel).ExecuteReturnIdentity();
 
                // 采购单明细表信息
                List<BllProcurePlanNoticeDetail> detailModels = new List<BllProcurePlanNoticeDetail>();
                foreach (ProcurePlanDetail asnDetailModel in model.ProcurePlanDetails)
                {
                    if (string.IsNullOrEmpty(asnDetailModel.SkuNo))
                    {
                        resultModel.Message = "物料编码不可为空!";
                        return resultModel;
                    }
                    if (asnDetailModel.Qty <= 0)
                    {
                        resultModel.Message = "数量不能为空!";
                        return resultModel;
                    }
                    if (string.IsNullOrEmpty(asnDetailModel.Customer))
                    {
                        resultModel.Message = "供应商不可为空!";
                        return resultModel;
                    }
 
                    // 获取物料详细信息
                    var skuModel = Db.Queryable<SysMaterials>().First(it => it.SkuNo == asnDetailModel.SkuNo && it.IsDel == "0");
                    if (skuModel == null)
                    {
                        resultModel.Message = "不存在当前物料信息!";
                        return resultModel;
                    }
 
                    // 根据客户编号获取客户名称
                    var CustomerModel = Db.Queryable<SysCustomer>().First(it => it.CustomerNo == asnDetailModel.Customer && it.IsDel == "0");
                    if (CustomerModel == null)
                    {
                        resultModel.Message = "供应商编号不存在!";
                        return resultModel;
                    }
 
                    //采购单明细信息
                    var detailModel = new BllProcurePlanNoticeDetail()
                    {
                        ParentId = parentId,
                        OrderDetailCode= asnDetailModel.OrderDetailCode,
                        SkuNo = asnDetailModel.SkuNo,
                        SkuName = skuModel.SkuName,
                        Standard = skuModel.Standard,
                        Qty = (decimal)asnDetailModel.Qty,
                        CompleteQty=0,
                        PackagNo = skuModel.PackagNo,
                        Status = "0",
                        CustomerNo = asnDetailModel.Customer,
                        CustomerName = CustomerModel.CustomerName,
                        CreateUser = 0
                    };
                    detailModels.Add(detailModel);
 
                    #region 入库单
                    // 入库总表信息
                    string asnNo = new Common().GetMaxNo("ASN");
                    var asnModel = new BllArrivalNotice()
                    {
                        ASNNo = asnNo,
                        Status = "0",//执行状态，0：等待执行
                        Type = "1",//单据类型，1：采购入库
                        Origin = "采购单",
                        CustomerNo = CustomerModel.CustomerNo,
                        CustomerName = CustomerModel.CustomerName,
                        OrderCode = model.OrderCode,
                        UserName = model.Username,
                        CreateUser = 0
                    };
                    // 插入入库总表信息
                    Db.Insertable(asnModel).ExecuteCommand();
                    //入库单明细
                    var arrDetailModel = new BllArrivalNoticeDetail()
                    {
                        ASNNo = asnNo,
                        SkuNo = skuModel.SkuNo,
                        SkuName = skuModel.SkuName,
                        Standard = skuModel.Standard,
                        LotNo = "",
                        LotText = "",
                        Qty = (decimal)asnDetailModel.Qty,
                        FactQty=0,
                        CompleteQty=0,
                        PackagNo = skuModel.PackagNo,
                        SupplierLot = "",
                        Status = "0",
                        IsSampling = "0",
                        InspectStatus = "0",
                        OrderDetailCode = asnDetailModel.OrderDetailCode,
                        CreateUser = 0
                    };
                    // 插入入库明细表信息
                    Db.Insertable(arrDetailModel).ExecuteCommand();
                    #endregion
 
                }
                // 插入采购单明细表
                Db.Insertable(detailModels).ExecuteCommand();
                Db.CommitTran();
 
                resultModel.Success = 0;
                resultModel.Message = "成功";
                return resultModel;
            }
            catch (Exception ex)
            {
                Db.RollbackTran();
                throw ex;
            }
        }
 
        #endregion
    }
}