shgx_tz_mom/ZR.Service/mes/wms/WmOutOrderService.cs

using System;
using SqlSugar;
using Infrastructure.Attribute;
using ZR.Model;
using ZR.Repository;
using ZR.Service.mes.wms.IService;
using ZR.Model.MES.wms;
using ZR.Model.MES.wms.Dto;
using Mapster;
using System.Collections.Generic;
using System.Data;
using JinianNet.JNTemplate.Dynamic;
using System.Linq;
using System.Security.Cryptography.Xml;
using System.Collections;

namespace ZR.Service.mes.wms
{
    /// <summary>
    /// 出货单（物料+客户）Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IWmOutOrderService), ServiceLifetime = LifeTime.Transient)]
    public class WmOutOrderService : BaseService<WmOutOrder>, IWmOutOrderService
    {
        /// <summary>
        /// 查询出货单（物料+客户）列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<WmOutOrderDto> GetList(WmOutOrderQueryDto parm)
        {
            var predicate = Expressionable.Create<WmOutOrder>()
            .AndIF(!string.IsNullOrEmpty(parm.ShipmentNum), it => it.ShipmentNum.Contains(parm.ShipmentNum))
                .AndIF(!string.IsNullOrEmpty(parm.CustomNo), it => it.CustomNo.Contains(parm.CustomNo))
                .AndIF(parm.Year>0, it => it.Year == parm.Year)
                .AndIF(parm.Week>0, it => it.Year == parm.Week)
                .AndIF(parm.Date>0, it => it.Year == parm.Date)
                ;
            var response = Queryable()
                .Where(predicate.ToExpression())
                .ToPage<WmOutOrder, WmOutOrderDto>(parm);

            return response;
        }


        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="ShipmentNum"></param>
        /// <returns></returns>
        public WmOutOrder_material_num GetInfo(string ShipmentNum)
        {

            WmOutOrder WmOutOrderList = Context.Queryable<WmOutOrder>()
                   .Where(it => it.ShipmentNum == ShipmentNum)
                   .First();

            WmOutOrder_material_num wmOutOrderItem = null;

            if (WmOutOrderList != null)
            {
                wmOutOrderItem = WmOutOrderList.Adapt<WmOutOrder_material_num>();

                List<WmMaterialOutorder> moList = Context.Queryable<WmMaterialOutorder>()
                      .Where(it => it.FkOutorderId == WmOutOrderList.ShipmentNum)
                      .ToList();

                if (moList != null && moList.Count > 0)
                {
                    List<WmMaterialQuery_stockQuantityDto2> Material_stock = new List<WmMaterialQuery_stockQuantityDto2>();

                    foreach (var moItem in moList)
                    {
                        WmMaterial material = Context.Queryable<WmMaterial>().Where(it => it.Id == moItem.FkMaterialId).First();
                        if (material != null)
                        {
                            WmMaterialQuery_stockQuantityDto2 dto2 = material.Adapt<WmMaterialQuery_stockQuantityDto2>();
                            dto2.requireOutNum = moItem.OuthouseNum;
                            Material_stock.Add(dto2);
                        }

                    }
                    wmOutOrderItem.MaterialList = Material_stock;
                }
            }



            return wmOutOrderItem;
        }

        /// <summary>
        /// 添加出货单（物料+客户）
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WmOutOrder AddWmOutOrder(WmOutOrder_materialDto model)
        {
            string today_id = "EG" + DateTime.Now.ToString("yyMMdd");
            string last_outorder_ShipmentNum = Context.Queryable<WmOutOrder>().Where(it => it.ShipmentNum.StartsWith(today_id)).Max(it => it.ShipmentNum);
            if (string.IsNullOrEmpty(last_outorder_ShipmentNum))
            {
                model.ShipmentNum = today_id + "001";

            }
            else
            {
                int flow = int.Parse(last_outorder_ShipmentNum.Substring(last_outorder_ShipmentNum.Length - 3, 3)) + 1;
                model.ShipmentNum = today_id + flow.ToString("000");

            }
            WmOutOrder wmOutOrder = model.Adapt<WmOutOrder>();

            // 关联表也要新增
            if (model.MaterialList != null)
            {
                if (model.MaterialList.Count > 0)
                {
                    List<WmMaterialOutorder> materialOutorderList = new List<WmMaterialOutorder>();

                    foreach (var item in model.MaterialList)
                    {
                        WmMaterialOutorder materialOutorder = new WmMaterialOutorder();
                        materialOutorder.FkMaterialId = item.Id;
                        materialOutorder.FkOutorderId = model.ShipmentNum;
                        materialOutorder.OuthouseNum = item.requireOutNum;
                        materialOutorder.CreatedBy = model.CreatedBy;
                        materialOutorder.CreatedTime = DateTime.Now;
                        materialOutorderList.Add(materialOutorder);
                    };
                    int result = Context.Insertable(materialOutorderList).ExecuteCommand();
                }

            }

            return Context.Insertable(wmOutOrder).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改出货单（物料+客户）
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateWmOutOrder(WmOutOrder model)
        {
            //var response = Update(w => w.ShipmentNum == model.ShipmentNum, it => new WmOutOrder()
            //{
            //    CustomNo = model.CustomNo,
            //    CustomName = model.CustomName,
            //    CustomAddress = model.CustomAddress,
            //    Remarks = model.Remarks,
            //    Type = model.Type,
            //    Status = model.Status,
            //    Year = model.Year,
            //    Week = model.Week,
            //    Date = model.Date,
            //    CreatedBy = model.CreatedBy,
            //    CreatedTime = model.CreatedTime,
            //    UpdatedBy = model.UpdatedBy,
            //    UpdatedTime = model.UpdatedTime,
            //});
            //return response;
            return Update(model, true);
        }




        /// <summary>
        /// 获取用户信息
        /// </summary>
        /// <returns></returns> 
        public List<WmCustom> GetCustominfo()
        {

            return Context.Queryable<WmCustom>().ToList();

        }

        /// <summary>
        /// 查询物料记录表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public (List<WmMaterialQuery_stockQuantityDto>, int) GetmaterialList(WmMaterialQueryDto parm)
        {
            int total = 0;
            var predicate = Expressionable.Create<WmMaterial>()
                .AndIF(parm.Partnumber != null, it => it.Partnumber.Contains(parm.Partnumber))
                .AndIF(parm.U8InventoryCode != null, it => it.U8InventoryCode.Contains(parm.U8InventoryCode))
                .AndIF(parm.ProductName != null, it => it.ProductName.Contains(parm.ProductName))
                .AndIF(parm.Color != null, it => it.Color.Contains(parm.Color))
                .AndIF(parm.Specification != null, it => it.Specification.Contains(parm.Specification))
                .AndIF(parm.Description != null, it => it.Description.Contains(parm.Description))
                .AndIF(parm.Search1 != null, it => it.Search1.Contains(parm.Search1) || it.Search2.Contains(parm.Search1))
                .AndIF(parm.Status > -1, it => it.Status == parm.Status);


            List<WmMaterial> materialList = Context.Queryable<WmMaterial>()
                .Where(predicate.ToExpression()).OrderByDescending(it => it.CreatedTime)
                .ToPageList(parm.PageNum, parm.PageSize, ref total);


            List<WmMaterialQuery_stockQuantityDto> material_stockQuantity_list = new List<WmMaterialQuery_stockQuantityDto>();


            if (materialList.Count > 0)
            {
                foreach (WmMaterial item in materialList)
                {

                    WmMaterialQuery_stockQuantityDto wmMaterialQuery_Stock_item = item.Adapt<WmMaterialQuery_stockQuantityDto>();

                    int material_num = 0;
                    List<WmGoodsNowProduction> productioList = Context
                       .Queryable<WmGoodsNowProduction>()
                       .Where(it => it.Partnumber == item.Partnumber)
                       .ToList();

                    if (productioList.Count > 0)
                    {
                        foreach (var product in productioList)
                        {
                            material_num = material_num + (int)product.GoodsNumLogic;
                        }
                    }
                    wmMaterialQuery_Stock_item.stockQuantity = material_num;
                    material_stockQuantity_list.Add(wmMaterialQuery_Stock_item);


                }
            }
            return (material_stockQuantity_list, total);
        }




        /// <summary>
        /// 查询出货单的物料信息
        /// </summary>
        /// <param name="shipment_num"></param>
        /// <returns></returns>
        public List<WmMaterialQuery_print> Queryoutoder_matrials(string shipment_num)
        {

          List<WmMaterialQuery_print> stockList = Context.Queryable<WmMaterialOutorder>()
         .LeftJoin<WmMaterial>((mo, m) => mo.FkMaterialId == m.Id)
         .Where(mo => mo.FkOutorderId == shipment_num)
         .Select((mo, m) => new WmMaterialQuery_print()
         {
             //物料号
             Partnumber = m.Partnumber,
             // 描述
             ProductName = m.ProductName,
             //需求零件数
             RequireOutNum = mo.OuthouseNum
         }).ToList();


            if (stockList != null && stockList.Count > 0)
            {
                foreach (var stock in stockList)
                {
                    //现有箱数
                    stock.PackageNum = Context.Queryable<WmGoodsNowProduction>()
                        .Where(it => it.Partnumber == stock.Partnumber).Count();

                    //现有零件数
                    int? num = Context.Queryable<WmGoodsNowProduction>()
                        .Where(it => it.Partnumber == stock.Partnumber)
                        .Sum(it => it.GoodsNumLogic);
                    stock.ItemNum = num ?? 0;
                }
            }



            return stockList;



        }

        /// <summary>
        /// 生成出货单的出货计划
        /// </summary>
        /// <param name="shipment_num">出货单号</param>
        /// <returns></returns>
        public List<WmOutOrderPlan> Generate_outorderplan(string shipment_num)
        {

            List<WmOutOrderPlan> wmOutOrderPlans = new List<WmOutOrderPlan>();            
            // 获取当前出货单下的物料信息
            List<WmMaterialQuery_print> materialQuery_Prints = this.Queryoutoder_matrials(shipment_num);
            if (materialQuery_Prints != null && materialQuery_Prints.Count > 0)
            {
                // TODO 1.判断能否完整出货

                // TODO 2.生成出货单

                foreach (var material in materialQuery_Prints)
                {
                    //todo 判断要出多少货  按照最早工单和批次号 进行出货（重要算法）
                    //1. 这个物料要出多少货
                    int require_num = material.RequireOutNum;

                    // 物料号
                    string partnumber = material.Partnumber;
                    // 原始编号

                    // 该物料下 ，现有货物列表
                    
                    List<WmGoodsNowProduction> wmGoodsNowsList = Context.Queryable<WmGoodsNowProduction>()
                            .Where(it => it.Partnumber == partnumber)
                            .OrderByDescending(it => it.PackageCodeClient)
                            .ToList();
                    // TODO 1.根据入库时间，进行排序

                    // TODO 2.根据排序结果,检查数量是否达标(require_num<=accumulation_num)向最终结果数组进行添加
                    List< WmGoodsNowProduction > planList = new List<WmGoodsNowProduction>();


                    foreach (var witem in wmGoodsNowsList)
                    {
                        int accumulation_num = 0;
                        if (require_num >= accumulation_num)
                        {
                            WmOutOrderPlan orderPlan = new WmOutOrderPlan();
                            orderPlan.FkOutOrderId = shipment_num;

                            orderPlan.Patchcode = witem.PackageCodeClient;
                            orderPlan.MaterialCode = witem.Partnumber;
                            orderPlan.WarehouseCode = witem.LocationCode;
                            orderPlan.PackageNum = int.Parse(witem.PackageCodeClient.Split("_")[1]);
                            orderPlan.RequireNum = require_num;
                            orderPlan.Patchtime = Resolution_bath(witem.PackageCodeClient);
                            wmOutOrderPlans.Add(orderPlan);
                            // 实际值计算
                            accumulation_num = accumulation_num + witem.GoodsNumAction ?? 0;
                        }
                        else
                        {
                            // 超过要用零头箱
                            if (require_num - accumulation_num <= witem.GoodsNumAction)
                            {
                                WmOutOrderPlan orderPlan = new WmOutOrderPlan();
                                orderPlan.FkOutOrderId = shipment_num;

                                orderPlan.Patchcode = witem.PackageCodeClient;
                                orderPlan.Patchcode_short = witem.PackageCodeClient.Split("_")[0];
                                orderPlan.MaterialCode = witem.Partnumber;
                                orderPlan.WarehouseCode = witem.LocationCode;
                                orderPlan.PackageNum = 1; //短批次需求累加
                                orderPlan.RequireNum = require_num; //总需求
                                orderPlan.Patchtime = Resolution_bath(witem.PackageCodeClient);
                                wmOutOrderPlans.Add(orderPlan);

                                accumulation_num = accumulation_num + witem.GoodsNumAction ?? 0;

                            }

                            break;
                        }
                    }

                    // todo  把该物料下的箱子 按照短批次号 进行分组聚合
                    
                    if (wmOutOrderPlans.Count > 0)
                    {
                        var item = wmOutOrderPlans.GroupBy(it => it.Patchcode_short).Select(g => new
                        {
                            FkOutOrderId = g.Max(p => p.FkOutOrderId),
                            Patchcode = g.Max(p => p.Patchcode),
                            Patchcode_short = g.Max(p => p.Patchcode_short),
                            WarehouseCode = g.Max(p => p.WarehouseCode),
                            PackageNum = g.Count(),
                            RequireNum = g.Max(p => p.RequireNum),
                            Patchtime = g.Max(p => p.Patchtime),
                        });
                        wmOutOrderPlans.Clear();
                        wmOutOrderPlans.Add(item.Adapt<WmOutOrderPlan>());
                    }

                }
            }
            foreach (var witem in wmOutOrderPlans)
            {
                witem.Outorder = wmOutOrderPlans.IndexOf(witem) + 1;
            }


            return wmOutOrderPlans;

        }

        /// <summary>
        /// 根据出库单号与货物批次号，向出库记录添加数据，并且成品库表数据删除
        /// </summary>
        /// <param name="doMaterialOut"></param>
        /// <returns></returns>
        public (int, int) DoMaterialOut(WmDoMaterialOut_Dto doMaterialOut, string Createby)
        {
            int sum_delete = 0;
            int sum_insert = 0;
            string shipnumber = doMaterialOut.ShipmentNum;
            if (doMaterialOut.PatchCode != null && doMaterialOut.PatchCode.Length > 0)
            {
                foreach (var item in doMaterialOut.PatchCode)
                {
                    UseTran2(() =>
                    {
                        WmGoodsOutRecord record = new WmGoodsOutRecord();
                        record.Id = SnowFlakeSingle.Instance.NextId().ToString();
                        WmGoodsNowProduction nowProduction = Context.Queryable<WmGoodsNowProduction>()
                        .Where(it => it.PackageCodeClient == item).First();

                        if (nowProduction != null)
                        {
                            record.FkNowProductionId = nowProduction.Id;
                            record.PackageCodeClient = nowProduction.PackageCodeClient;
                            record.PackageCode = nowProduction.PackageCode;
                            record.PackageCodeOriginal = nowProduction.PackageCodeOriginal;
                            record.LocationCode = nowProduction.LocationCode;
                            record.Partnumber = nowProduction.Partnumber;
                            record.GoodsNumLogic = nowProduction.GoodsNumLogic;
                            record.GoodsNumAction = nowProduction.GoodsNumAction;
                            record.EntryWarehouseTime = nowProduction.EntryWarehouseTime;
                            record.OutTime = DateTime.Now;
                            record.CreatedTime = DateTime.Now;
                            record.CreatedBy = Createby;
                            record.FkOutOrderId = shipnumber;
                            sum_insert = Context.Insertable(record).ExecuteCommand();
                            sum_delete += Context.Deleteable<WmGoodsNowProduction>()
                            .Where(it => it.PackageCodeClient == item)
                            .ExecuteCommand();
                        }


                    });

                }
            }
            return (sum_delete, sum_insert);
        }

        public bool OverOutorderplan(string shipment_num)
        {
            int reult = Context.Updateable<WmOutOrder>().Where(it => it.ShipmentNum == shipment_num)
                  .SetColumns(it => it.Type == 2)
                  .ExecuteCommand();
            if (reult > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 传入批次号 解析出时间   BNW240318007_105
        /// </summary>
        /// <param name="bath_code"></param>
        /// <returns></returns>
        private string Resolution_bath(string bath_code)
        {
            if (string.IsNullOrEmpty(bath_code))
            {
                return "";
            }
            string temp = bath_code.Split("_")[0];
            return "20" + temp.Substring(2, 6);
        }
    }
}