PR和PO编码规则调整

MicroServices/Business/Business.Application/ResourceExamineManagement/ResourceExamineAppService.cs

@@ -36,6 +36,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics;
 using Volo.Abp.Uow;
 using Spire.Pdf.Exporting.XPS.Schema;
+using Newtonsoft.Json.Linq;
 
 namespace Business.ResourceExamineManagement
 {
@@ -225,6 +226,7 @@ namespace Business.ResourceExamineManagement
         private readonly ISqlRepository<WorkOrdRouting> _workOrdRouting;
         private readonly ISqlRepository<WorkOrdMaster> _workOrdMaster;
         private readonly ISqlRepository<WorkOrdDetail> _workOrdDetail;
+        private readonly ISqlRepository<rf_serialnumber> _rf_serialnumber;
         /// <summary>
         /// 资源检查入参
         /// </summary>
@@ -352,7 +354,8 @@ namespace Business.ResourceExamineManagement
             ISqlRepository<WorkOrdMaster> workOrdMaster,
             ISqlRepository<WorkOrdDetail> workOrdDetail,
             ISqlRepository<NbrMaster> nbrMaster,
-            ISqlRepository<NbrDetail> nbrDetail
+            ISqlRepository<NbrDetail> nbrDetail,
+            ISqlRepository<rf_serialnumber> rf_serialnumber
             )
         {
             _mes_technique = mes_technique;
@@ -425,6 +428,7 @@ namespace Business.ResourceExamineManagement
             _itemMaster = itemMaster;
             _nbrMaster = nbrMaster;
             _nbrDetail = nbrDetail;
+            _rf_serialnumber = rf_serialnumber;
     }
         #endregion
 
@@ -1250,7 +1254,7 @@ namespace Business.ResourceExamineManagement
             }
 
             srm_Pr.GenerateNewId();
-            srm_Pr.pr_billno = returnlist.erp_cls == 2 ? getOrderNum("WWPR") : getOrderNum("PR");//pr单号
+            srm_Pr.pr_billno = returnlist.erp_cls == 2 ? GetMaxSerialNumber(416555183259717) : GetMaxSerialNumber(416188596088901);//pr单号
             srm_Pr.pr_mono = "";//关联工单号
             srm_Pr.entity_id = 1;//工单行号
             srm_Pr.pr_purchaseid = supplier.supplier_id;//供应商id  
@@ -1392,7 +1396,7 @@ namespace Business.ResourceExamineManagement
                     mo_srm_po_main po_Main = new mo_srm_po_main();
                     po_Main.id = help.NextId();
                     po_Main.mysql_id = help.NextId();
-                    po_Main.po_billno = getOrderNum("PO");
+                    po_Main.po_billno = GetMaxSerialNumber(416188684804165);
                     po_Main.po_purchaser = item.pr_purchaser;
                     po_Main.po_purchaser_no = item.pr_purchaser_num;
                     po_Main.po_ssend_date = DateTime.Now;
@@ -1516,7 +1520,7 @@ namespace Business.ResourceExamineManagement
                         mo_srm_po_main po_Main = new mo_srm_po_main();
                         po_Main.id = help.NextId();
                         po_Main.mysql_id = help.NextId();
-                        po_Main.po_billno = getOrderNum("PO");
+                        po_Main.po_billno = GetMaxSerialNumber(416188684804165);
                         po_Main.po_purchaser = item.pr_purchaser;
                         po_Main.po_purchaser_no = item.pr_purchaser_num;
                         po_Main.po_ssend_date = DateTime.Now;
@@ -1606,7 +1610,7 @@ namespace Business.ResourceExamineManagement
                     mo_srm_po_main po_Main = new mo_srm_po_main();
                     po_Main.id = help.NextId();
                     po_Main.mysql_id = help.NextId();
-                    po_Main.po_billno = getOrderNum("WWPO");
+                    po_Main.po_billno = GetMaxSerialNumber(416555323363397);//WWPO
                     po_Main.po_purchaser = item.pr_purchaser;
                     po_Main.po_purchaser_no = item.pr_purchaser_num;
                     po_Main.po_ssend_date = DateTime.Now;
@@ -1730,7 +1734,7 @@ namespace Business.ResourceExamineManagement
                         mo_srm_po_main po_Main = new mo_srm_po_main();
                         po_Main.id = help.NextId();
                         po_Main.mysql_id = help.NextId();
-                        po_Main.po_billno = getOrderNum("WWPO");
+                        po_Main.po_billno = GetMaxSerialNumber(416555323363397);
                         po_Main.po_purchaser = item.pr_purchaser;
                         po_Main.po_purchaser_no = item.pr_purchaser_num;
                         po_Main.po_ssend_date = DateTime.Now;
@@ -2509,5 +2513,55 @@ namespace Business.ResourceExamineManagement
                 _nbrDetail.Insert(nbrDetailList);
             }
         }
+
+        /// <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);
+        }
     }
 }

MicroServices/Business/Business.Core/Utilities/StringExtensions.cs

@@ -0,0 +1,646 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace Business.Core.Utilities
+{
+    public static class StringExtensions
+    {
+        /// <summary>
+        /// 去掉字符串所有空格
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static string TrimAll(this string? str)
+        {
+            return string.IsNullOrWhiteSpace(str) ? string.Empty : Regex.Replace(str, @"\s", "");
+        }
+
+        /// <summary>
+        /// 去掉空格，如果为null或Empty则返回string.Empty
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static string TrimNullOrEmpty(this string? str)
+        {
+            return string.IsNullOrEmpty(str) ? string.Empty : str.Trim();
+        }
+
+        /// <summary>
+        /// 转换为不为空的字符串
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns>如果字符串为null返回string.Empty，否则返回字符串本身。</returns>
+        public static string ToEmptyString(this string? str)
+        {
+            return string.IsNullOrEmpty(str) ? string.Empty : str;
+        }
+
+        /// <summary>
+        /// 将字符串分割为数组
+        /// </summary>
+        /// <param name="str">要分割的字符串</param>
+        /// <param name="separator">分隔符</param>
+        /// <param name="options">分割选项</param>
+        /// <returns>字符串数组</returns>
+        public static string[] SplitToArray(this string? str, string separator = ",", StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
+        {
+            return string.IsNullOrWhiteSpace(str) ? Array.Empty<string>() : str.Split(separator, options);
+        }
+
+        /// <summary>
+        /// 将字符串分割为long数组
+        /// </summary>
+        /// <param name="str">要分割的字符串</param>
+        /// <param name="separator">分隔符</param>
+        /// <param name="options">分割选项</param>
+        /// <returns>long List</returns>
+        public static List<long> SplitToLongList(this string? str, string separator = ",", StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
+        {
+            string[] array = str.SplitToArray(separator, options);
+            var list = new List<long>();
+            foreach (string a in array)
+            {
+                if (a.IsLong(out long l))
+                {
+                    list.Add(l);
+                }
+            }
+            return list;
+        }
+
+        /// <summary>
+        /// 将字符串分割为int数组
+        /// </summary>
+        /// <param name="str">要分割的字符串</param>
+        /// <param name="separator">分隔符</param>
+        /// <param name="options">分割选项</param>
+        /// <returns>int List</returns>
+        public static List<int> SplitToIntList(this string? str, string separator = ",", StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
+        {
+            string[] array = str.SplitToArray(separator, options);
+            var list = new List<int>();
+            foreach (string a in array)
+            {
+                if (a.IsInt(out int i))
+                {
+                    list.Add(i);
+                }
+            }
+            return list;
+        }
+
+
+        /// <summary>
+        /// 判断字符串是否是int类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static bool IsInt(this string? str)
+        {
+            return int.TryParse(str, out _);
+        }
+
+        /// <summary>
+        /// 判断字符串是否是int类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="i">如果是数字返回int</param>
+        /// <returns></returns>
+        public static bool IsInt(this string? str, out int i)
+        {
+            return int.TryParse(str, out i);
+        }
+
+        /// <summary>
+        /// 将字符串转换为int
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="defaultValue">转换失败时的默认值</param>
+        /// <returns></returns>
+        public static int ToInt(this string? str, int defaultValue = 0)
+        {
+            return str.IsInt(out int i) ? i : defaultValue;
+        }
+
+        /// <summary>
+        /// 判断字符串是否是long类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static bool IsLong(this string? str)
+        {
+            return long.TryParse(str, out _);
+        }
+
+        /// <summary>
+        /// 判断字符串是否是long类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="i">如果是数字返回long</param>
+        /// <returns></returns>
+        public static bool IsLong(this string? str, out long l)
+        {
+            return long.TryParse(str, out l);
+        }
+
+        /// <summary>
+        /// 将字符串转换为long
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="defaultValue">转换失败时的默认值</param>
+        /// <returns></returns>
+        public static long ToLong(this string? str, long defaultValue = 0)
+        {
+            return str.IsLong(out long l) ? l : defaultValue;
+        }
+
+        /// <summary>
+        /// 判断字符串是否是decimal类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static bool IsDecimal(this string? str)
+        {
+            return decimal.TryParse(str, out _);
+        }
+
+        /// <summary>
+        /// 判断字符串是否是decimal类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static bool IsDecimal(this string? str, out decimal d)
+        {
+            return decimal.TryParse(str, out d);
+        }
+
+        /// <summary>
+        /// 字符串转换为decimal类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="defaultValue">转换失败时的默认值</param>
+        /// <returns></returns>
+        public static decimal ToDecimal(this string? str, decimal defaultValue = 0)
+        {
+            return str.IsDecimal(out decimal d) ? d : defaultValue;
+        }
+
+        /// <summary>
+        /// 判断字符串是否是float类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static bool IsFloat(this string? str, out float f)
+        {
+            return float.TryParse(str, out f);
+        }
+
+        /// <summary>
+        /// 字符串转换为float类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="defaultValue">转换失败时的默认值</param>
+        /// <returns></returns>
+        public static float ToFloat(this string? str, float defaultValue = 0)
+        {
+            return str.IsFloat(out float f) ? f : defaultValue;
+        }
+
+        /// <summary>
+        /// 判断字符串是否是double类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static bool IsDouble(this string? str, out double d)
+        {
+            return double.TryParse(str, out d);
+        }
+
+        /// <summary>
+        /// 字符串转换为double类型数字
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="defaultValue">转换失败时的默认值</param>
+        /// <returns></returns>
+        public static double ToDouble(this string? str, double defaultValue = 0)
+        {
+            return str.IsDouble(out double d) ? d : defaultValue;
+        }
+
+        /// <summary>
+        /// 判断字符串是否为bool类型
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="b"></param>
+        /// <returns>如果字符串为"1"或"true"（不区分大小写，去掉所有空格）时返回true否则返回false</returns>
+        public static bool IsBool(this string? str)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return false;
+            }
+            string str1 = str.TrimAll();
+            return "true".EqualsIgnoreCase(str1) || "1".Equals(str1);
+        }
+
+        /// <summary>
+        /// 将字符串转换为bool
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns>如果字符串为1或true（不区分大小写），则返回true，否则返回false</returns>
+        public static bool ToBool(this string? str)
+        {
+            return str.IsBool();
+        }
+
+        /// <summary>
+        /// 判断一个字符串是否是日期时间类型
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="dt">输出转换后的日期时间</param>
+        /// <returns></returns>
+        public static bool IsDateTime(this string? str, out DateTime dt)
+        {
+            return DateTime.TryParse(str, out dt);
+        }
+
+        /// <summary>
+        /// 判断一个字符串是否是日期时间类型
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static bool IsDateTime(this string? str)
+        {
+            return str.IsDateTime(out _);
+        }
+
+        /// <summary>
+        /// 将字符串转换为时间时间
+        /// </summary>
+        /// <param name="str">要转换的字符串</param>
+        /// <param name="defaultValue">转换失败时返回的默认值</param>
+        /// <returns></returns>
+        public static DateTime ToDateTime(this string? str, DateTime defaultValue)
+        {
+            return str.IsDateTime(out DateTime dt) ? dt : defaultValue;
+        }
+
+        /// <summary>
+        /// 将字符串转换为时间时间
+        /// </summary>
+        /// <param name="str">要转换的字符串</param>
+        /// <param name="defaultValue">转换失败时返回的默认值</param>
+        /// <returns>如果转换失败则返回null</returns>
+        public static DateTime? ToDateTime(this string? str)
+        {
+            return str.IsDateTime(out DateTime dt) ? dt : new DateTime?();
+        }
+
+        /// <summary>
+        /// 比较字符串区分大小写
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="str1">要比较的字符串</param>
+        /// <returns>是否相同</returns>
+        public static bool EqualsCase(this string? str, string? str1)
+        {
+            return string.Equals(str, str1);
+        }
+
+        /// <summary>
+        /// 比较字符串是否与参数中任意一个字符串相等
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="strs">要比较的字符串</param>
+        /// <returns>是否与参数中任意一个字符串相等</returns>
+        public static bool EqualsAny(this string? str, params string[] strs)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return false;
+            }
+            foreach (string s in strs)
+            {
+                if (s.Equals(str))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 判断字符串与参数中的字符串都不相等
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="strs">要比较的字符串</param>
+        /// <returns></returns>
+        public static bool NotEqualsAny(this string? str, params string[] strs)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return false;
+            }
+            foreach (string s in strs)
+            {
+                if (s.Equals(str))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 比较字符串不区分大小写
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="str1">要比较的字符串</param>
+        /// <returns>是否相同</returns>
+        public static bool EqualsIgnoreCase(this string? str, string? str1)
+        {
+            return string.Equals(str, str1, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// 比较字符串是否与参数中任意一个字符串相等（不区分大小写）
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="strs">要比较的字符串</param>
+        /// <returns>是否与参数中任意一个字符串相等</returns>
+        public static bool EqualsAnyIgnoreCase(this string? str, params string[] strs)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return false;
+            }
+            foreach (string s in strs)
+            {
+                if (s.Equals(str, StringComparison.CurrentCultureIgnoreCase))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 判断字符串与参数中的字符串都不相等（不区分大小写）
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="strs">要比较的字符串</param>
+        /// <returns>是否与参数中任意一个字符串相等</returns>
+        public static bool NotEqualsAnyIgnoreCase(this string? str, params string[] strs)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return false;
+            }
+            foreach (string s in strs)
+            {
+                if (s.Equals(str, StringComparison.CurrentCultureIgnoreCase))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 判断字符串中是否包含str1字符串（区分大小写）
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="str1">被包含的字符串</param>
+        /// <param name="stringComparison">StringComparison</param>
+        /// <returns></returns>
+        public static bool ContainsCase(this string? str, string? str1)
+        {
+            return str != null && str1 != null && str.Contains(str1);
+        }
+
+        /// <summary>
+        /// 判断字符串中是否包含str1字符串（不区分大小写）
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="str1">被包含的字符串</param>
+        /// <returns></returns>
+        public static bool ContainsIgnoreCase(this string? str, string? str1)
+        {
+            return str != null && str1 != null && str.Contains(str1, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// 判断字符串出现的位置（为区分大小写）
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="str1">子字符串</param>
+        /// <returns></returns>
+        public static int IndexOfIgnoreCase(this string? str, string str1)
+        {
+            return str == null ? -1 : str.IndexOf(str1, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// 去掉开头的字符串
+        /// </summary>
+        /// <param name="str">要去掉的字符串</param>
+        /// <param name="trimString">开头的字符串</param>
+        /// <returns></returns>
+        public static string TrimStartString(this string? str, string trimString)
+        {
+            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.StartsWith(trimString) ? str : str.Substring(trimString.Length);
+        }
+
+        /// <summary>
+        /// 去掉开头的字符串（不区分大小写）
+        /// </summary>
+        /// <param name="str">要去掉的字符串</param>
+        /// <param name="trimString">开头的字符串</param>
+        /// <returns></returns>
+        public static string TrimStartStringIgnoreCase(this string? str, string trimString)
+        {
+            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.StartsWithIgnoreCase(trimString) ? str : str.Substring(trimString.Length);
+        }
+
+        /// <summary>
+        /// 去掉结尾的字符串
+        /// </summary>
+        /// <param name="str">要去掉的字符串</param>
+        /// <param name="trimString">结尾的字符串</param>
+        /// <returns></returns>
+        public static string TrimEndString(this string? str, string trimString)
+        {
+            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.EndsWith(trimString) ? str : str.Substring(0, str.Length - trimString.Length);
+        }
+
+        /// <summary>
+        /// 去掉结尾的字符串（不区分大小写）
+        /// </summary>
+        /// <param name="str">要去掉的字符串</param>
+        /// <param name="trimString">结尾的字符串</param>
+        /// <returns></returns>
+        public static string TrimEndStringIgnoreCase(this string? str, string trimString)
+        {
+            return string.IsNullOrWhiteSpace(str) ? string.Empty : !str.EndsWithIgnoreCase(trimString) ? str : str.Substring(0, str.Length - trimString.Length);
+        }
+
+        /// <summary>
+        /// 是否是以字符串数组参数中任意一个字符串开头的字符串
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="values">开头的字符串数组</param>
+        /// <returns></returns>
+        public static bool StartsWithAny(this string? str, params string[] values)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return false;
+            }
+            foreach (string value in values)
+            {
+                if (str.StartsWith(value))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 是否是以字符串数组参数中任意一个字符串开头的字符串
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="stringComparison">StringComparison, 可设置是否区分大小写</param>
+        /// <param name="values">开头的字符串数组</param>
+        /// <returns></returns>
+        public static bool StartsWithAny(this string? str, StringComparison stringComparison, params string[] values)
+        {
+            if (string.IsNullOrEmpty(str))
+            {
+                return false;
+            }
+            foreach (string value in values)
+            {
+                if (str.StartsWith(value, stringComparison))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// 判断字符串是否以某个字符串开头（不区分大小写）
+        /// </summary>
+        /// <param name="str">要判断的字符串</param>
+        /// <param name="startString">开头的字符串</param>
+        /// <returns></returns>
+        public static bool StartsWithIgnoreCase(this string? str, string startString)
+        {
+            return !string.IsNullOrEmpty(str) && str.StartsWith(startString, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// 判断字符串是否以某个字符串结尾（不区分大小写）
+        /// </summary>
+        /// <param name="str">要判断的字符串</param>
+        /// <param name="startString">结尾的字符串</param>
+        /// <returns></returns>
+        public static bool EndsWithIgnoreCase(this string? str, string startString)
+        {
+            return !string.IsNullOrEmpty(str) && str.EndsWith(startString, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// 替换字符串，不区分大不写
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="oldValue">要替换的字符串</param>
+        /// <param name="newValue">新字符串</param>
+        /// <returns></returns>
+        public static string ReplaceIgnoreCase(this string? str, string oldValue, string? newValue)
+        {
+            return string.IsNullOrEmpty(str) ? string.Empty : str.Replace(oldValue, newValue, StringComparison.CurrentCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// 将字符串转换为对应类型的对象
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <returns></returns>
+        public static object ToTypeObject(this string? str, out Type type)
+        {
+            if (string.IsNullOrEmpty(str) || str.EqualsIgnoreCase("null"))
+            {
+                type = typeof(string);
+                return string.Empty;
+            }
+            else if (str.IsInt(out int objInt))
+            {
+                type = typeof(int);
+                return objInt;
+            }
+            else if (str.IsLong(out long objLong))
+            {
+                type = typeof(long);
+                return objLong;
+            }
+            else if (Guid.TryParse(str, out Guid objGuid))
+            {
+                type = typeof(Guid);
+                return objGuid;
+            }
+            else if (str.IsFloat(out float objFloat))
+            {
+                type = typeof(float);
+                return objFloat;
+            }
+            else if (str.IsDouble(out double objDouble))
+            {
+                type = typeof(double);
+                return objDouble;
+            }
+            else if (str.IsDecimal(out decimal objDecimal))
+            {
+                type = typeof(decimal);
+                return objDecimal;
+            }
+            else if (str.IsDateTime(out DateTime objDateTime))
+            {
+                type = typeof(DateTime);
+                return objDateTime;
+            }
+            else if ("true".EqualsIgnoreCase(str) || "false".EqualsIgnoreCase(str))
+            {
+                type = typeof(bool);
+                return "true".EqualsIgnoreCase(str);
+            }
+            type = typeof(string);
+            return str;
+        }
+
+        /// <summary>
+        /// url编码
+        /// </summary>
+        /// <param name="str">要编码的url</param>
+        /// <returns></returns>
+        public static string UrlEncode(this string? url)
+        {
+            return string.IsNullOrWhiteSpace(url) ? string.Empty : Uri.EscapeDataString(url).Replace("'", "%27");
+        }
+
+        /// <summary>
+        /// url解码
+        /// </summary>
+        /// <param name="str">要解码的url</param>
+        /// <returns></returns>
+        public static string UrlDecode(this string? url)
+        {
+            return string.IsNullOrWhiteSpace(url) ? string.Empty : Uri.UnescapeDataString(url).Replace("%27", "'");
+        }
+    }
+}

MicroServices/Business/Business.Core/Utilities/Wildcard.cs

@@ -0,0 +1,153 @@
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Business.Core.Utilities
+{
+    /// <summary>
+    /// 通配符类
+    /// </summary>
+    public class Wildcard
+    {
+        /// <summary>
+        /// 所有通配符
+        /// </summary>
+        private static readonly string[] Wildcards = new string[] {
+            "{<UserId>}",//当前登录用户id
+            "{<UserName>}",//当前登录用户姓名
+            "{<UserAccount>}",//当前登录用户帐号
+            "{<UserDeptId>}",//当前登录用户所在部门id
+            "{<UserDeptName>}",//当前登录用户所在部门名称
+            "{<UserStationId>}",//当前登录用户所在岗位id
+            "{<UserStationName>}",//当前登录用户所在岗位名称
+            "{<UserWorkGroupId>}",//当前登录用户所在工作组id（如果有多个英文逗号,分隔）
+            "{<UserWorkGroupName>}",//当前登录用户所在工作组名称（如果有多个中文分号；分隔）
+            "{<UserUnitId>}",//当前登录用户所在单位id
+            "{<UserCompanyId>}",//当前登录用户所在单位id
+            "{<UserUnitName>}",//当前用户所在单位名称
+            "{<UserCompanyName>}",//当前用户所在单位名称
+            "{<UserOrganize>}",//当前用户组织关系（示例：研发部 \ 产品开发组）
+            "{<UserOrganizeRoot>}",//当前用户组织关系，包含根（示例：重庆云思维软件技术有限公司 \ 研发部 \ 产品开发组）
+            "{<UserSign>}",//用户签章，如果设置有签章图片返回图片，否则返回用户姓名。
+            "{<InitiatorId>}",//流程的发起者id
+            "{<InitiatorName>}",//流程的发起者姓名
+            "{<InitiatorDeptId>}",//流程发起者所在部门id
+            "{<InitiatorDeptName>}",//流程发起者所在部门名称
+            "{<InitiatorStationId>}",//流程发起者所在岗位id
+            "{<InitiatorStationName>}",//流程发起者所在岗位名称
+            "{<InitiatorUnitId>}",//流程发起者单位id
+            "{<InitiatorUnitName>}",//流程发起者单位名称
+            "{<ShortDate>}",//短日期格式yyyy-MM-dd
+            "{<LongDate>}",//长日期格式yyyy年M月d日
+            "{<ShortDateTime>}",//短日期时间格式yyyy-MM-dd HH:mm
+            "{<LongDateTime>}",//长日期时间格式yyyy年M月d日 H时m分
+            "{<ShortDateTimeSecond>}",//短日期时间格式yyyy-MM-dd HH:mm:ss
+            "{<LongDateTimeSecond>}",//长日期时间格式yyyy年M月d日 H时m分s秒
+            "{<FlowId>}",//流程id
+            "{<FlowName>}",//流程名称
+            "{<StepId>}",//步骤id
+            "{<StepName>}",//步骤名称
+            "{<TaskId>}",//任务id
+            "{<TaskTitle>}",//任务标题
+            "{<InstanceId>}",//实例id
+            "{<GroupId>}",//实例分组id
+            "{<LongId>}",//生成一个新的long数字id
+
+            "{Query<",//Get获取Url中的参数值 
+            "{Form<",//Post获取提交的值
+            "{Get<",//先Get如果没获取到再Post获取提交的值
+            "{DataRow<",//object参数传一个DataRow获取其中key列的值
+            "{DateTime<",//获取自定义格式的当前日期时间值，如{DateTime<yyyy-MM-dd HH:mm>}
+            "{Method<",//执行一个方法返回值，方法参数为object参数
+            "{JArray<",//从JArray中获取key列的值，多个用英文逗号分隔
+            "{JObject<",//从JObject中获取key的值
+            "{Json<",//从JObject中获取key的值和JObject功能相同
+            "{FlowTask<",//从FlowTask实体类字段获取key字段的值
+            "{User<",//从用户实体中获取key字段的值
+        };
+
+        /// <summary>
+        /// 得到通配符的值
+        /// </summary>
+        /// <param name="wildcardKey">通配符key</param>
+        /// <param name="obj">参数对象</param>
+        /// <returns></returns>
+        private static string GetValue(string wildcardKey, params object?[] objs)
+        {
+            if ("{<ShortDate>}".EqualsIgnoreCase(wildcardKey))
+            {
+                //短日期格式yyyy-MM-dd
+                return DateTime.Now.ToString("yyyy-MM-dd");
+            }
+            else if ("{<LongDate>}".EqualsIgnoreCase(wildcardKey))
+            {
+                //长日期格式yyyy年M月d日
+                return DateTime.Now.ToString("yyyy年M月d日");
+            }
+            else if ("{<ShortDateTime>}".EqualsIgnoreCase(wildcardKey))
+            {
+                //短日期时间格式yyyy-MM-dd HH:mm
+                return DateTime.Now.ToString("yyyy-MM-dd HH:mm");
+            }
+            else if ("{<LongDateTime>}".EqualsIgnoreCase(wildcardKey))
+            {
+                //长日期时间格式yyyy年M月d日 H时m分
+                return DateTime.Now.ToString("yyyy年M月d日 H时m分");
+            }
+            else if ("{<ShortDateTimeSecond>}".EqualsIgnoreCase(wildcardKey))
+            {
+                //短日期时间格式yyyy-MM-dd HH:mm:ss
+                return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
+            }
+            else if ("{<LongDateTimeSecond>}".EqualsIgnoreCase(wildcardKey))
+            {
+                //长日期时间格式yyyy年M月d日 H时m分s秒
+                return DateTime.Now.ToString("yyyy年M月d日 H时m分s秒");
+            }
+            return string.Empty;
+        }
+
+
+        /// <summary>
+        /// 替换通配符
+        /// </summary>
+        /// <param name="str">包含通配符的字符串</param>
+        /// <param name="obj">包含通配符值的对象</param>
+        /// <returns></returns>
+        public static string Replace(string? str, params object?[] objs)
+        {
+            if (string.IsNullOrWhiteSpace(str))
+            {
+                return string.Empty;
+            }
+            foreach (string wildcardKey in Wildcards)
+            {
+                while (str.ContainsIgnoreCase(wildcardKey))
+                {
+                    string wildcardKey1 = wildcardKey;
+                    string? value = string.Empty;
+                    //Get获取Url中的参数值 
+                    if ("{DateTime<".EqualsIgnoreCase(wildcardKey))
+                    {
+                        string key = str.Substring(str.IndexOfIgnoreCase("{DateTime<") + 10);
+                        string key1 = key.Substring(0, key.IndexOf(">}"));
+                        if (!string.IsNullOrWhiteSpace(key1))
+                        {
+                            wildcardKey1 = wildcardKey + key1 + ">}";
+                            value = DateTime.Now.ToString(key1);
+                        }
+                    }
+                    else
+                    {
+                        value = GetValue(wildcardKey, objs);
+                    }
+                    str = str.ReplaceIgnoreCase(wildcardKey1, value);
+                }
+            }
+            return str;
+        }
+    }
+}

MicroServices/Business/Business.EntityFrameworkCore/EntityFrameworkCore/DOP/BusinessDbContext.cs

@@ -144,6 +144,7 @@ namespace Business.EntityFrameworkCore
 
         public DbSet<LineMaster> LineMaster { get; set; }
 
+        public DbSet<rf_serialnumber> rf_serialnumber { get; set; }
 
         #endregion
 

MicroServices/Business/Bussiness.Model/Sale/rf_serialnumber.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Business.Model.Sale
+{
+    /// <summary>
+    /// 流水号设置表
+    /// </summary>
+    public class rf_serialnumber
+    {
+        /// <summary>
+        /// id
+        /// </summary>
+        public long Id { get; set; }
+
+        /// <summary>
+        /// 标题
+        /// </summary>
+        public string? Title { get; set; }
+
+        /// <summary>
+        /// 格式
+        /// </summary>
+        public string? Format { get; set; }
+
+        /// <summary>
+        /// 位数
+        /// </summary>
+        public int NumberSize { get; set; }
+
+        /// <summary>
+        /// 当前值
+        /// </summary>
+        public int CurrentNumber { get; set; }
+
+        /// <summary>
+        /// 类型 0：不重置 1：年流水 2：月流水 3：日流水
+        /// </summary>
+        public int NumberType { get; set; }
+
+        /// <summary>
+        /// 最后更新日期
+        /// </summary>
+        public DateTime LastTime { get; set; }
+    }
+}