DEMOMySql/MicroServices/Business/Business.Application/ResourceExamineManagement/MorderAppService.cs

using Business.Core.Enum;
using Business.Core.Utilities;
using Business.Domain;
using Business.EntityFrameworkCore.SqlRepositories;
using Business.ResourceExamineManagement.Dto;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using Volo.Abp.Application.Services;

namespace Business.ResourceExamineManagement
{
    public class MorderAppService : ApplicationService
    {
        #region 服务
        ///// <summary>
        ///// 生产工单主表
        ///// </summary>
        //private readonly IMongoDB<mo_mes_morder> _mo_mes_morder;
        ///// <summary>
        ///// 生产工单子表
        ///// </summary>
        //private readonly IMongoDB<mo_mes_moentry> _mo_mes_moentry;

        ///// <summary>
        ///// 在制工单占用记录表
        ///// </summary>
        //private readonly IMongoDB<mo_mes_mooccupy> _mo_mes_mooccupy;
        ///// <summary>
        ///// 销售订单
        ///// </summary>
        //private readonly IRepository<crm_seorder, long> _mysql_crm_seorder;
        ///// <summary>
        ///// 销售订单明细
        ///// </summary>
        //private readonly IRepository<crm_seorderentry, long> _mysql_crm_seorderentry;

        /// <summary>
        /// 资源检查入参
        /// </summary>
        public SeorderentryDto param = new SeorderentryDto();

        /// <summary>
        /// 产能检查
        /// </summary>
        private readonly ProductExamineAppService _productExamineAppService;
        /// <summary>
        ///  雪花算法
        /// </summary>
        SnowFlake snowFlake = new SnowFlake();

        /// <summary>
        /// 生产线明细表
        /// </summary>
        public List<ProdLineDetail> prodLines = new List<ProdLineDetail>();

        /// <summary>
        /// 标准工艺路径表
        /// </summary>
        public List<RoutingOpDetail> routingOps = new List<RoutingOpDetail>();

        /// <summary>
        /// 排产记录表
        /// </summary>
        public List<PeriodSequenceDet> periodSequences = new List<PeriodSequenceDet>();

        /// <summary>
        /// 工作日历
        /// </summary>
        public List<ShopCalendarWorkCtr> calendarWorks = new List<ShopCalendarWorkCtr>();

        /// <summary>
        /// 休息时间段
        /// </summary>
        public List<QualityLineWorkDetail> qualityLineWorks = new List<QualityLineWorkDetail>();

        /// <summary>
        /// 节假日
        /// </summary>
        public List<HolidayMaster> holidays = new List<HolidayMaster>();


        /// <summary>
        /// 工单
        /// </summary>
        public List<mo_mes_morder> mo_Mes_Morders = new List<mo_mes_morder>();
        /// <summary>
        /// 工单子表
        /// </summary>
        public List<mo_mes_moentry> mo_Mes_Moentry = new List<mo_mes_moentry>();
        /// <summary>
        /// 工单占用
        /// </summary>
        public List<mo_mes_mooccupy> mo_Mes_Mooccupies = new List<mo_mes_mooccupy>();


        private readonly ISqlRepository<rf_serialnumber> _rf_serialnumber;
        #endregion
        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="icitem"></param>
        /// <param name="icbom"></param>
        public MorderAppService(
            //IMongoDB<mo_mes_morder> mo_mes_morder,
            //IMongoDB<mo_mes_moentry> mo_mes_moentry,
            //IMongoDB<mo_mes_mooccupy> mo_mes_mooccupy,
            //IRepository<crm_seorder, long> mysql_crm_seorder,
            //IRepository<crm_seorderentry, long> mysql_crm_seorderentry,
            ProductExamineAppService productExamineAppService,
            ISqlRepository<rf_serialnumber> rf_serialnumber
            )
        {

            //_mo_mes_morder = mo_mes_morder;
            //_mo_mes_moentry = mo_mes_moentry;
            //_mo_mes_mooccupy = mo_mes_mooccupy;
            //_mysql_crm_seorder = mysql_crm_seorder;
            //_mysql_crm_seorderentry = mysql_crm_seorderentry;
            _productExamineAppService = productExamineAppService;
            _rf_serialnumber = rf_serialnumber;
        }
        #endregion

        /// <summary>
        /// 生成工单
        /// </summary>
        /// <param name="seorderentry">销售订单子表</param>
        /// <param name="BomNumber">Bom编号</param>
        /// <param name="version">Bom版本</param>
        /// <param name="number">物料编码</param>
        /// <param name="Quantity"></param>
        /// <param name="ParentId"></param>
        public Mes_MorderDto GenerateMorder(GenerateMorderDto generateMorderDto, int urgent)
        {
            //1.库存、在制工单检查完成后 当前BOM需要自制时 产生工单。

            //2.每一个销售订单行对应一个工单。
            //TODO:考虑性能问题 循环调用,后期改造传递数组，批量处理数据后,批量保存。

            mo_mes_morder mes_Morder = new mo_mes_morder();
            mes_Morder.GenerateNewId(snowFlake.NextId());
            mes_Morder.mysql_id = snowFlake.NextId();
            mes_Morder.bang_id = generateMorderDto.bang_id;
            mes_Morder.morder_type = generateMorderDto.morder_type;
            mes_Morder.parent_id = generateMorderDto.ParentId;
            //mes_Morder.morder_icitem_type
            mes_Morder.work_order_type = generateMorderDto.work_order_type;
            mes_Morder.morder_state = generateMorderDto.morder_state;
            mes_Morder.morder_no = GetMaxSerialNumber(418022612537413);//WWPO
            mes_Morder.fms_number = generateMorderDto.ic_Item.fms_number;
            mes_Morder.bom_number = generateMorderDto.BomNumber;
            mes_Morder.fmodel = generateMorderDto.ic_Item.model;
            mes_Morder.urgent = urgent;
            if (generateMorderDto.ParentId != null && generateMorderDto.moentry_sys_stime != null)
            {
                //最早的开工时间3天后、 最晚时间为订单承诺时间 - 采购提前期 - 质检提前期 - 入库提前期 - 发料提前期 = 最晚开工时间  最早或最晚为系统建议开工日期
                //var StartDate = DateTime.Now.Date.AddDays(3);
                mes_Morder.moentry_sys_stime = generateMorderDto.moentry_sys_stime;
                if (!string.IsNullOrEmpty(generateMorderDto.BomNumber))
                {
                    ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                    {
                        ItemNum = generateMorderDto.BomNumber,
                        PlanStart = generateMorderDto.moentry_sys_stime.Value,
                        QtyOrd = (int)generateMorderDto.Quantity.GetValueOrDefault()
                    };
                    _productExamineAppService.prodLines = prodLines;
                    _productExamineAppService.routingOps = routingOps;
                    _productExamineAppService.periodSequences = periodSequences;
                    _productExamineAppService.calendarWorks = calendarWorks;
                    _productExamineAppService.qualityLineWorks = qualityLineWorks;
                    _productExamineAppService.holidays = holidays;

                    var ProductiveDate = _productExamineAppService.ProductiveExamine(prodExamine);
                    //系统建议完工日期为 开工日期+产能检查时间=完工日期
                    //var Day = ProductiveDate / (60 * 10); //返回的分钟除以十个小时得出工作天数；
                    mes_Morder.moentry_sys_etime = ProductiveDate;
                    TimeSpan span = ProductiveDate - generateMorderDto.moentry_sys_stime.Value;
                    mes_Morder.morder_need_time = (decimal)span.TotalMinutes;
                }
            }

            mes_Morder.moentry_startup_status = 0;
            mes_Morder.tenant_id = param.company_id.GetValueOrDefault();
            mes_Morder.factory_id = param.factoryId;
            mes_Morder.company_id = param.company_id;
            mes_Morder.org_id = param.org_id;
            mes_Morder.product_code = generateMorderDto.number;
            mes_Morder.product_name = generateMorderDto.ic_Item.name;
            if (generateMorderDto.seorder != null)
            {
                mes_Morder.project_name = generateMorderDto.seorder.project_name;
            }
            mes_Morder.morder_date = DateTime.Now.Date.AddDays(1);
            //mes_Morder.morder_fstate = "计划";
            //TODO:目前没有取值位置
            mes_Morder.moentry_prd = null;
            mes_Morder.moentry_prdname = null;
            mes_Morder.moentry_wrkc = null;
            mes_Morder.moentry_wrkcname = null;
            mes_Morder.picking_qty = 0;
            //TODO:可删除主表字段
            mes_Morder.unit = generateMorderDto.ic_Item.unit;
            mes_Morder.morder_production_number = generateMorderDto.Quantity;
            mes_Morder.need_number = generateMorderDto.Quantity;
            mes_Morder.remaining_number = 0;
            mes_Morder.create_time = DateTime.Now;
            //生成工单子表数据
            mo_mes_moentry mes_Moentry = new mo_mes_moentry();
            mes_Moentry.GenerateNewId(snowFlake.NextId());
            mes_Moentry.mysql_id = snowFlake.NextId();
            mes_Moentry.bang_id = generateMorderDto.bang_id;
            mes_Moentry.moentry_moid = mes_Morder.mysql_id;
            mes_Moentry.moentry_mono = mes_Morder.morder_no;
            mes_Moentry.unit = generateMorderDto.ic_Item.unit;
            mes_Moentry.morder_production_number = generateMorderDto.Quantity;
            mes_Moentry.need_number = generateMorderDto.Quantity;
            mes_Moentry.remaining_number = 0;
            mes_Moentry.tenant_id = param.company_id.GetValueOrDefault();
            mes_Moentry.factory_id = param.factoryId;
            mes_Moentry.company_id = param.company_id;
            mes_Moentry.org_id = param.org_id;
            mes_Moentry.create_time = DateTime.Now;
            Mes_MorderDto mes_MorderDto = new Mes_MorderDto();
            mes_MorderDto.mes_Morders = new List<mo_mes_morder>();
            mes_MorderDto.mes_Moentries = new List<mo_mes_moentry>();
            mes_MorderDto.mes_Morders.Add(mes_Morder);
            mes_MorderDto.mes_Moentries.Add(mes_Moentry);

            if (generateMorderDto.seorderentry != null)
            {
                mes_Morder.planner_num = generateMorderDto.seorderentry.planner_no;
                mes_Morder.planner_name = generateMorderDto.seorderentry.planner_name;
                mes_Moentry.soentry_id = generateMorderDto.seorderentry.Id;
                mes_Moentry.fbill_no = generateMorderDto.seorderentry.bill_no;
                mes_Moentry.fentry_id = generateMorderDto.seorderentry.entry_seq.Value;
            }

            return mes_MorderDto;

            //using (TransactionScope scope = new TransactionScope())
            // {
            //_mes_morder.InsertOne(mes_Morder);
            //_mes_moentry.InsertOne(mes_Moentry);
            //scope.Complete();
            //}
        }

        /// <summary>
        /// 检查在制工单
        /// </summary>
        /// <param name="bomNumber">Bom编码</param>
        /// <param name="Quantity">需要数量</param>
        /// <param name="DeliverDate">交付日期</param>
        /// <param name="seorderentry_id">销售订单子表ID</param>
        /// <returns></returns>
        public virtual List<mo_mes_mooccupy> CheckMorder(string bomNumber, decimal Quantity, DateTime DeliverDate, crm_seorderentry seorderentry, mo_ic_item ic_Item, long bang_id)
        {
            if (string.IsNullOrEmpty(bomNumber))
            {
                //TODO：入参异常；
                return null;
            }
            //获取销售订单信息
            //var seorder = await _crm_seorder.FindAsync(x => x.Id == OrderId);
            //var seorderentry = await _mysql_crm_seorderentry.FindAsync(x => x.Id == seorderentry_id);
            //根据Bom编码查询出对应工单并且状态不为完成、关闭，非委外工单。
            //TODO:工单类型；

            //var morderList = await _mo_mes_morder.GetManyByCondition(x => x.bom_number == bomNumber && (x.morder_state != MorderEnum.Accomplish_state || x.morder_state != MorderEnum.Close_state
            //&& x.morder_icitem_type != MorderEnum.XgwyMorder) && !x.IsDeleted && x.tenant_id == seorderentry.tenant_id && x.bang_id == bang_id);

            //var morderList = mo_Mes_Morders.Where(x => x.bom_number == bomNumber).ToList();

            //获取物料详情
            //var ic_item = _ic_item.GetManyByCondition(x => x.number == seorderentry.item_number && x.tenant_id == seorderentry.tenant_id).Result.FirstOrDefault();

            //工单已被占用后要与占用表关联查询...减去占用量后 剩下生产数量可供下个销售工单使用。
            //var mes_mooccupyList = await _mo_mes_mooccupy.GetManyByCondition(x => x.moo_state == 1 && !x.IsDeleted && x.tenant_id == seorderentry.tenant_id
            //&& x.fitem_number == ic_Item.number && x.bang_id == bang_id);

            var mes_mooccupyList = mo_Mes_Mooccupies.Where(x => x.fitem_number == ic_Item.number);

            //首先满足需求数量工单其次判断是否满足交付日期、当数量不满足时继续查找最早交付日期订单 工单数量累加。
            //当前工单计划日期-1天 小于交付日期 && 计算生产数量-入库数据并且大于需求产品数量。
            var moentrys = mo_Mes_Moentry.Where(s => s.soentry_id == seorderentry.Id);
            //找到当前订单行生成的主工单
            var toMid = moentrys.Select(s => s.moentry_moid).ToList();
            var morderDataList = mo_Mes_Morders.Where(x => x.bom_number == bomNumber && x.morder_type == MorderEnum.JhMorder && x.moentry_sys_etime.GetValueOrDefault().AddDays(-1) < DeliverDate &&
            (x.morder_production_number - x.inventory_number - mes_mooccupyList.Where(p => p.moo_moid.GetValueOrDefault() == x.mysql_id)?.Sum(m => m.moo_qty)) > Quantity)
             .OrderByDescending(x => x.planner_end_date).ToList();

            List<mo_mes_mooccupy> mes_Mooccupies = new List<mo_mes_mooccupy>();
            //当数量或日期不满足的时候，寻找最早日期的工单
            if (morderDataList.Count == 0)
            {
                morderDataList = mo_Mes_Morders.Where(x => x.bom_number == bomNumber && (x.morder_type == MorderEnum.JhMorder || toMid.Contains(x.mysql_id)) && x.moentry_sys_etime.GetValueOrDefault().AddDays(-1) < DeliverDate).OrderByDescending(x => x.planner_end_date).ToList();
            }
            var QuantityNumber = 0.00m;
            //存在此数据满足当前BOM交付找到最早日期工单，则返回无需后续继续检查。
            foreach (var item in morderDataList)
            {
                //查询当前工单是否存在占用情况
                var mooccupies = mes_mooccupyList.Where(x => x.moo_moid.GetValueOrDefault() == item.mysql_id).ToList();
                //已占用数据
                var Sumqty = mooccupies.Count > 0 ? mooccupies.Sum(x => x.moo_qty) : 0.00m;
                //获取此工单剩余可占用数量
                var Sum = item.morder_production_number.GetValueOrDefault() - item.inventory_number.GetValueOrDefault() - Sumqty.GetValueOrDefault();
                if (Sum > 0)
                {
                    #region 注释
                    //if (Sumqty > 0 || item.inventory_number > 0)
                    //{
                    //    ProdExamineParamDto prodExamine = new ProdExamineParamDto()
                    //    {
                    //        bom_number = item.bom_number,
                    //        version = version,
                    //        packages = (int)(item.inventory_number + Sumqty).GetValueOrDefault(),
                    //        tenantId = item.tenant_id,
                    //        factoryId = item.factory_id.GetValueOrDefault()

                    //    };
                    //    //获取入库和已占用的数据的生产时长
                    //    var ProductiveDate = _productExamineAppService.ProductiveExamine(prodExamine);
                    //    var Day = ProductiveDate.Result / (60 * 10);
                    //    //工单被完全占用结束日期为工单结束时间
                    //    if (Quantity - (item.morder_production_number - item.inventory_number - Sumqty) == 0)
                    //    {

                    //        var date = item.moentry_sys_stime.GetValueOrDefault().AddDays((double)Day);
                    //        var endDate = item.moentry_sys_etime;
                    //    }
                    //    //工单未被完成占用计算结束日期
                    //    else if (item.morder_production_number - item.inventory_number - Sumqty - Quantity > 0)
                    //    {
                    //        var date = item.moentry_sys_stime.GetValueOrDefault().AddDays((double)Day);
                    //        ProdExamineParamDto EndprodExamine = new ProdExamineParamDto()
                    //        {
                    //            bom_number = item.bom_number,
                    //            version = version,
                    //            packages = (int)Quantity,
                    //            tenantId = item.tenant_id,
                    //            factoryId = item.factory_id.GetValueOrDefault()
                    //        };
                    //        var EndProductiveDate = _productExamineAppService.ProductiveExamine(EndprodExamine);
                    //        var EndDay = ProductiveDate.Result / (60 * 10);
                    //        var endDate = date.AddDays((double)EndDay);
                    //    }

                    //}

                    #endregion
                    //工单可占用数量-需求数量小于0时 占用工单全部可占用数量
                    if (Sum - Quantity <= 0)
                    {
                        QuantityNumber = Sum;
                    }
                    else
                    {
                        //工单可占用数量满足 需求数量时直接占用需求数量
                        QuantityNumber = Quantity;
                    }
                    var mes_Mooccupy = GetMooccupies(seorderentry, ic_Item, item, QuantityNumber, bang_id);
                    mes_Mooccupies.Add(mes_Mooccupy);
                    //当剩余需要数量大于0则继续寻找可占用工单，已满足需要数量停止循环查找
                    if (Quantity - Sum <= 0)
                    {
                        break;
                    }
                    Quantity = Quantity - Sum;
                }

            }
            #region 注释
            //  if (morderDataList.Count > 0)
            //  {
            //      //存在此数据满足当前BOM交付找到最早日期工单，则返回无需后续继续检查。
            //      var morder = morderDataList.OrderByDescending(x => x.planner_end_date);
            //      foreach (var item in morder)
            //      {
            //          var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == item.Id).ToList();
            //          if (mooccupies.Count > 0)
            //          {
            //              var Sumqty = mooccupies.Sum(x => x.moo_qty);
            //              //判断此工单剩下数量是否还有
            //              if (item.morder_production_number - item.inventory_number - Sumqty > 0)
            //              {
            //                  var Sum = item.morder_production_number - item.inventory_number - Sumqty;
            //                  //需要数量-（计划数量-入库数量-已占用量）
            //                  Quantity = Quantity - (item.morder_production_number - item.inventory_number - Sumqty);
            //                  if (Quantity > 0)
            //                  {
            //                      var mes_Mooccupy = GetMooccupies(seorderentry, ic_Item, item, Sum);
            //                      mes_Mooccupies.Add(mes_Mooccupy);
            //                  }
            //                  else
            //                  {
            //                      break;
            //                  }
            //              }
            //          }
            //      }
            //      await _mes_mooccupy.InsertMany(mes_Mooccupies);
            //      Number = 1;
            //  }
            //  else
            //  {
            //      // 寻找最早日期工单 &&  计算生产数量-入库数据并且大于需求产品数量后累加直到满足需求产品数量
            //      var morderListData = morderList.Where(x => x.planner_end_date.Value.AddDays(-1) < DeliverDate).OrderByDescending(x => x.planner_end_date).ToList();

            //      decimal? number = Quantity;
            //      foreach (var item in morderListData)
            //      {
            //          //查询出工单已占用总数量
            //          var mooccupies = mes_mooccupyList.Where(x => x.moo_moid == item.Id).ToList();

            //          var Sumqty = mooccupies.Count > 0 ? mooccupies.Sum(x => x.moo_qty) : 0.00m;
            //          //判断此工单剩下数量是否还有
            //          if (item.morder_production_number - item.inventory_number - Sumqty > 0)
            //          {
            //              var Sum = item.morder_production_number - item.inventory_number - Sumqty;
            //              //需要数量-（计划数量-入库数量-已占用量）
            //              Quantity = Quantity - (item.morder_production_number - item.inventory_number - Sumqty);
            //              if (Quantity > 0)
            //              {
            //                  var mes_Mooccupy = GetMooccupies(seorderentry, ic_Item, item, Sum);
            //                  mes_Mooccupies.Add(mes_Mooccupy);
            //              }
            //              else
            //              {
            //                  break;
            //              }
            //          }

            //          //var mes_Mooccupy = GetMooccupies(seorderentry, ic_Item, item, mooccupies);
            //          //mes_Mooccupies.Add(mes_Mooccupy);
            //          //需求数量-占用量后小于或等于0 停止循环占用工单
            //          //if (number - mes_Mooccupy.moo_qty <= 0)
            //          //{
            //          //    break;
            //          //}
            //      }
            //      var morderDatas = morderList.Where(x => x.planner_end_date.Value.AddDays(-1) > DeliverDate &&
            //(x.morder_production_number - x.inventory_number) > Quantity).ToList();
            //      if (number > 0)
            //      {
            //          Number = 3;
            //      }
            //      if (morderDatas.Count > 0)
            //      {
            //          Number = 2;
            //      }
            //      else
            //      {
            //          Number = 1;
            //      }
            //  }
            #endregion
            //TODO：返回占用数据，外层每个BOM根据占用工单数据判断是否满足。
            return mes_Mooccupies.OrderByDescending(s => s.moo_etime).ToList();
        }
        /// <summary>
        /// 拼接工单占用表
        /// </summary>
        /// <param name="seorderentry">销售订单子表</param>
        /// <param name="mysql_ic_item">物料详情表</param>
        /// <param name="item">工单表</param>
        /// <param name="mes_mooccupy">占用工单表</param>
        /// <returns></returns>
        public mo_mes_mooccupy GetMooccupies(crm_seorderentry seorderentry, mo_ic_item ic_item, mo_mes_morder item, decimal? number, long bang_id)
        {
            //生成mes_mooccupy工单占用表数据，代表多个工单被某个销售订单已占用。 
            mo_mes_mooccupy mes_Mooccupy = new mo_mes_mooccupy();
            mes_Mooccupy.GenerateNewId(snowFlake.NextId());
            mes_Mooccupy.mysql_id = snowFlake.NextId();
            mes_Mooccupy.bang_id = bang_id;
            mes_Mooccupy.moo_id_type = MorderEnum.Zyjc_Type;
            if (seorderentry != null)
            {
                mes_Mooccupy.moo_id_billid = seorderentry.Id;//销售子表ID
                mes_Mooccupy.fbill_no = seorderentry.bill_no;//销售订单号
                mes_Mooccupy.fentry_id = seorderentry.entry_seq.Value;//销售订单行
                mes_Mooccupy.org_id = seorderentry.org_id;
            }

            mes_Mooccupy.fitem_name = ic_item.name;//物料名称
            mes_Mooccupy.fitem_number = ic_item.number;
            mes_Mooccupy.fmodel = ic_item.model;//规格型号
            mes_Mooccupy.moo_moid = item.mysql_id;
            mes_Mooccupy.moo_mo = item.morder_no;
            //占用量=生产计划数量-入库数量-已被占用数量
            mes_Mooccupy.moo_qty = number;
            mes_Mooccupy.moo_stime = item.moentry_sys_stime;
            mes_Mooccupy.moo_etime = item.moentry_sys_etime;
            mes_Mooccupy.moo_state = 1;
            //mes_Mooccupy.moo_cbr = string.Empty;
            //mes_Mooccupy.moo_ctime = ;
            //mes_Mooccupy.moo_creason = string.Empty;
            mes_Mooccupy.company_id = param.company_id;//取销售子表企业ID
            mes_Mooccupy.factory_id = param.factoryId;
            mes_Mooccupy.org_id = param.org_id;
            return mes_Mooccupy;
        }

        /// <summary>
        /// 得到一个流水号的最大流水号
        /// </summary>
        /// <param name="id">流水号id</param>
        /// <param name="formData">json数据，可以用json中的某个字段值作为通配符字替换流水号格式。</param>
        /// <returns></returns>
        public string GetMaxSerialNumber(long id, JObject? formData = null)
        {
            var modelList = _rf_serialnumber.Select(s => s.Id == id);
            if (modelList == null || modelList.Count < 1)
            {
                return string.Empty;
            }
            var model = modelList[0];
            int max = model.CurrentNumber + 1;
            var date = DateTime.Now;
            var lastDate = model.LastTime;
            switch (model.NumberType)
            {
                case 1: //年流水
                    if (date.Year > lastDate.Year)
                    {
                        max = 1;
                    }
                    break;
                case 2: //月流水
                    if (date.Year > lastDate.Year || date.Month > lastDate.Month)
                    {
                        max = 1;
                    }
                    break;
                case 3: //日流水
                    if (date.Year > lastDate.Year || date.Month > lastDate.Month || date.Day > lastDate.Day)
                    {
                        max = 1;
                    }
                    break;
            }
            string number = max.ToString().PadLeft(model.NumberSize, '0');
            string serialNumber = string.IsNullOrWhiteSpace(model.Format) ? number
                : model.Format.ContainsIgnoreCase("{number}")
                ? model.Format.ReplaceIgnoreCase("{number}", number)
                : model.Format + number;
            //更新当前编号和最后时间
            model.LastTime = date;
            model.CurrentNumber = max;
            _rf_serialnumber.Update(model);
            return Wildcard.Replace(serialNumber, formData);
        }
    }
}