适配新的数据库连接方式

ServiceCenter/Extensions/SqlExtension.cs

@@ -1,5 +1,5 @@
-using System.Linq.Expressions;
-using SqlSugar;
+using SqlSugar;
+using System.Linq.Expressions;
 
 namespace ServiceCenter.Extensions
 {
@@ -69,9 +69,9 @@ namespace ServiceCenter.Extensions
         /// <param name="scope"></param>
         /// <param name="updateObj"></param>
         /// <returns></returns>
-        public static IUpdateable<T> UpdateableRowLock<T>(this SqlSugarScopeProvider scope, T updateObj) where T : class, new() => scope.ScopedContext.Updateable<T>(updateObj).With(SqlWith.RowLock);
+        public static IUpdateable<T> UpdateableRowLock<T>(this SqlSugarProvider scope, T updateObj) where T : class, new() => scope.Updateable<T>(updateObj).With(SqlWith.RowLock);
 
-        public static bool UpdateWhereColumns<T>(this IUpdateable<T> db, Expression<Func<T, T>> columns,Expression<Func<T, bool>> whereExpression) where T : class, new()
+        public static bool UpdateWhereColumns<T>(this IUpdateable<T> db, Expression<Func<T, T>> columns, Expression<Func<T, bool>> whereExpression) where T : class, new()
         {
             return db.SetColumns(columns).Where(whereExpression).ExecuteCommand() > 0;
         }
@@ -83,7 +83,7 @@ namespace ServiceCenter.Extensions
         /// <param name="scope"></param>
         /// <param name="updateObj"></param>
         /// <returns></returns>
-        public static IUpdateable<T> UpdateableRowLock<T>(this SqlSugarScopeProvider scope, List<T> updateObj) where T : class, new() => scope.ScopedContext.Updateable<T>(updateObj).With(SqlWith.RowLock);
+        public static IUpdateable<T> UpdateableRowLock<T>(this SqlSugarProvider scope, List<T> updateObj) where T : class, new() => scope.Updateable<T>(updateObj).With(SqlWith.RowLock);
 
         /// <summary>
         ///  插入时使用行级锁
@@ -92,7 +92,7 @@ namespace ServiceCenter.Extensions
         /// <param name="scope"></param>
         /// <param name="updateObj"></param>
         /// <returns></returns>
-        public static IInsertable<T> InsertableRowLock<T>(this SqlSugarScopeProvider scope, T insertObj) where T : class, new() => scope.ScopedContext.Insertable<T>(insertObj).With(SqlWith.RowLock);
+        public static IInsertable<T> InsertableRowLock<T>(this SqlSugarProvider scope, T insertObj) where T : class, new() => scope.Insertable<T>(insertObj).With(SqlWith.RowLock);
 
         /// <summary>
         ///  插入时使用行级锁
@@ -101,7 +101,7 @@ namespace ServiceCenter.Extensions
         /// <param name="scope"></param>
         /// <param name="updateObj"></param>
         /// <returns></returns>
-        public static IInsertable<T> InsertableRowLock<T>(this SqlSugarScopeProvider scope, List<T> insertObj) where T : class, new() => scope.ScopedContext.Insertable<T>(insertObj).With(SqlWith.RowLock);
+        public static IInsertable<T> InsertableRowLock<T>(this SqlSugarProvider scope, List<T> insertObj) where T : class, new() => scope.Insertable<T>(insertObj).With(SqlWith.RowLock);
 
         /// <summary>
         ///  删除时使用行级锁
@@ -110,7 +110,7 @@ namespace ServiceCenter.Extensions
         /// <param name="scope"></param>
         /// <param name="deleteObj"></param>
         /// <returns></returns>
-        public static IDeleteable<T> DeleteableRowLock<T>(this SqlSugarScopeProvider scope, T deleteObj) where T : class, new() => scope.ScopedContext.Deleteable<T>(deleteObj).With(SqlWith.RowLock);
+        public static IDeleteable<T> DeleteableRowLock<T>(this SqlSugarProvider scope, T deleteObj) where T : class, new() => scope.Deleteable<T>(deleteObj).With(SqlWith.RowLock);
 
         /// <summary>
         ///  删除时使用行级锁
@@ -119,6 +119,6 @@ namespace ServiceCenter.Extensions
         /// <param name="scope"></param>
         /// <param name="deleteObj"></param>
         /// <returns></returns>
-        public static IDeleteable<T> DeleteableRowLock<T>(this SqlSugarScopeProvider scope, List<T> deleteObj) where T : class, new() => scope.ScopedContext.Deleteable<T>(deleteObj).With(SqlWith.RowLock);
+        public static IDeleteable<T> DeleteableRowLock<T>(this SqlSugarProvider scope, List<T> deleteObj) where T : class, new() => scope.Deleteable<T>(deleteObj).With(SqlWith.RowLock);
     }
-}
+}

ServiceCenter/SqlSugars/IdFactory.cs

@@ -0,0 +1,30 @@
+using SqlSugar.DistributedSystem.Snowflake;
+
+namespace ServiceCenter.SqlSugars
+{
+    public static class IdFactory
+    {
+        private static readonly object locker = new object();
+        private static IdWorker _idworker;
+
+        public static IdWorker GetInstance()
+        {
+            if (_idworker == null)
+            {
+                lock (locker)
+                {
+                    if (_idworker == null)
+                    {
+                        _idworker = new IdWorker(1, 1);
+                    }
+                }
+            }
+            return _idworker;
+        }
+
+        public static long NewId()
+        {
+            return GetInstance().NextId();
+        }
+    }
+}

ServiceCenter/SqlSugars/SqlSugarHelper.cs

@@ -1,197 +1,314 @@
-using Microsoft.Data.SqlClient;
-using Newtonsoft.Json.Linq;
-using SqlSugar;
-using System.Data;
+using SqlSugar;
+using System.Collections.Concurrent;
 
 namespace ServiceCenter.SqlSugars
 {
     /// <summary>
-    ///  ORM
+    /// ORM 辅助类
     /// </summary>
     public class SqlSugarHelper
     {
-        /// <summary>
-        /// 数据库连接
-        /// </summary>
-        private static SqlSugarScope? _Db { get; set; } = null;
-
-        /// <summary>
-        /// 默认数据库连接Key
-        /// </summary>
-        private static string _Default { get; set; } = "";
+        private static SqlSugarClient? _Db;
+        private static readonly ConcurrentDictionary<string, string> _tenants = new ConcurrentDictionary<string, string>();
 
         /// <summary>
-        /// PLC据库连接Key
+        /// 初始化数据库连接
         /// </summary>
-        private static string _PLCEX { get; set; } = "";
+        public static void Initialize(SqlSugarClient sqlSugarScope)
+        {
+            _Db = sqlSugarScope;
+        }
 
         /// <summary>
-        /// PLC据库连接Key
+        /// 设置默认数据库租户
         /// </summary>
-        public static string _PLC { get; set; } = "";
+        public static void SetDefault(string configId) => _tenants["Default"] = configId;
 
         /// <summary>
-        /// Dlog数据库连接Key
+        /// 设置Dlog数据库租户
         /// </summary>
-        private static string _Dlog { get; set; } = "";
+        public static void SetDlog(string configId) => _tenants["Dlog"] = configId;
 
         /// <summary>
-        ///  设置数据库连接Key
+        /// 设置PLC数据库租户
         /// </summary>
-        /// <param name="configId">默认多租户ID</param>
-        public static void SetDefault(string configId)
-        {
-            _Default = configId;
-        }
+        public static void SetPLC(string configId) => _tenants["PLC"] = configId;
 
         /// <summary>
-        ///  设置 Dlog数据库连接Key
+        /// 设置PLCEX数据库租户
         /// </summary>
-        /// <param name="configId">多租户Dlog ID</param>
-        public static void SetDlog(string configId)
-        {
-            _Dlog = configId;
-        }
+        public static void SetPLCEX(string configId) => _tenants["PLCEX"] = configId;
 
         /// <summary>
-        ///  设置 plc数据库连接Key
+        /// 添加或更新自定义租户配置
         /// </summary>
-        /// <param name="configId">多租户Dlog ID</param>
-        public static void SetPLC(string configId)
-        {
-            _PLC = configId;
-        }
+        public static void AddTenant(string tenantName, string configId) => _tenants[tenantName] = configId;
 
         /// <summary>
-        ///  设置 plc数据库连接Key
+        /// 默认数据库连接
         /// </summary>
-        /// <param name="configId">多租户Dlog ID</param>
-        public static void SetPLCEX(string configId)
-        {
-            _PLCEX = configId;
-        }
+        public SqlSugarProvider Default => GetTenant("Default");
 
         /// <summary>
-        /// 默认数据库连接Key
+        /// Dlog数据库连接
         /// </summary>
-        public SqlSugarScopeProvider Default
-        {
-            get
-            {
-                if (_Default == "") throw new Exception("请调用[SqlSugarHelper.SetDefault]方法设置默认数据库连接");
-                if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
-                return _Db.GetConnectionScope(_Default);
-            }
-        }
+        public SqlSugarProvider Dlog => GetTenant("Dlog");
 
         /// <summary>
-        /// Dlog数据库连接Key
+        /// PLC数据库连接
         /// </summary>
-        public SqlSugarScopeProvider Dlog
-        {
-            get
-            {
-                if (_Dlog == "") throw new Exception("请调用[SqlSugarHelper.SetDlog]方法设置默认数据库连接");
-                if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
-                return _Db.GetConnectionScope(_Dlog);
-            }
-        }
+        public SqlSugarProvider PLC => GetTenant("PLC");
 
         /// <summary>
-        /// plc数据库连接Key
+        /// PLCEX数据库连接
         /// </summary>
-        public SqlSugarScopeProvider PLC
-        {
-            get
-            {
-                if (_PLC == "") throw new Exception("请调用[SqlSugarHelper.SetPLC]方法设置默认数据库连接");
-                if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
-                return _Db.GetConnectionScope(_PLC);
-            }
-        }
+        public SqlSugarProvider PLCEX => GetTenant("PLCEX");
 
         /// <summary>
-        /// plc数据库连接Key
+        /// 获取指定租户的数据库连接
         /// </summary>
-        public SqlSugarScopeProvider PLCEX
+        public SqlSugarProvider GetTenant(string tenantName)
         {
-            get
+            if (!_tenants.TryGetValue(tenantName, out var configId) || string.IsNullOrEmpty(configId))
             {
-                if (_PLCEX == "") throw new Exception("请调用[SqlSugarHelper.SetPLC]方法设置默认数据库连接");
-                if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
-                return _Db.GetConnectionScope(_PLCEX);
+                string method = tenantName switch
+                {
+                    "Default" => "SetDefault",
+                    "Dlog" => "SetDlog",
+                    "PLC" => "SetPLC",
+                    "PLCEX" => "SetPLCEX",
+                    _ => "AddTenant"
+                };
+                throw new Exception($"请调用 [SqlSugarHelper.{method}] 方法设置 {tenantName} 数据库连接");
             }
+            if (_Db == null) throw new Exception("请调用 [SqlSugarHelper.Initialize] 初始化数据库连接");
+            return _Db.CopyNew().GetConnection(configId);
         }
 
         /// <summary>
-        ///  设置数据库连接
-        /// </summary>
-        /// <param name="sqlSugarScope"></param>
-        public static void SetDb(SqlSugarScope sqlSugarScope)
-        {
-            _Db = sqlSugarScope;
-        }
-
-        /// <summary>
-        /// 数据库连接
-        /// 注意需要
+        /// 主数据库连接对象
         /// </summary>
-        public SqlSugarScope Connect
-        {
-            get
-            {
-                return _Db ?? throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
-            }
-        }
+        public SqlSugarClient Connect => _Db ?? throw new Exception("数据库连接未初始化");
 
         /// <summary>
-        ///  执行事务
+        /// 执行默认连接事务操作
         /// </summary>
         /// <param name="act"></param>
-        /// <exception cref="Exception"></exception>
-        public static void Do(Action<SqlSugarHelper> act)
-        {
-            if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
-            var db = new SqlSugarHelper();
-            try
-            {
-                db.Connect.BeginTran();//开始事务
-                act(db);//执行委托
-                db.Connect.CommitTran();//提交事务
-            }
-            catch (Exception ex)
-            {
-                db.Connect.RollbackTran();//回滚事务
-                if (ex.Message.Contains("SqlTransaction")) throw new Exception($"{ex.Message}:{ex.StackTrace}");
-                throw new Exception(ex.Message);
-            }
-        }
+        public static void Do(Action<SqlSugarProvider> act) => Do("Default", act);
 
         /// <summary>
-        ///  直接返回查询结果
+        /// 执行指定连接事务操作
         /// </summary>
-        /// <typeparam name="T"></typeparam>
+        /// <param name="configId">连接ID</param>
         /// <param name="act"></param>
-        /// <returns></returns>
         /// <exception cref="Exception"></exception>
-        public static T Do<T>(Func<SqlSugarHelper, T> act)
+        public static void Do(string configId, Action<SqlSugarProvider> act)
         {
-            if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
-            var db = new SqlSugarHelper();
-            try
-            {
-                db.Connect.BeginTran();//开始事务
-                db.Connect.Ado.CommandTimeOut = 10;
-                var res = act(db);//执行委托
-                db.Connect.CommitTran();//提交事务
-                return res;
-            }
-            catch (Exception ex)
+            if (_Db == null) throw new Exception("数据库连接未初始化");
+            using (var helper = new SqlSugarHelper().GetTenant(configId))
             {
-                db.Connect.RollbackTran();//回滚事务
-                if (ex.Message.Contains("SqlTransaction")) throw new Exception($"{ex.Message}:{ex.StackTrace}");
-                throw new Exception(ex.Message);
+                try
+                {
+                    helper.AsTenant().BeginTran();
+                    act(helper);
+                    helper.AsTenant().CommitTran();
+                }
+                catch
+                {
+                    helper.AsTenant().RollbackTran();
+                    throw;
+                }
             }
         }
     }
+
+    ///// <summary>
+    /////  ORM
+    ///// </summary>
+    //public class SqlSugarHelper
+    //{
+    //    /// <summary>
+    //    /// 数据库连接
+    //    /// </summary>
+    //    private static SqlSugarClient? _Db { get; set; } = null;
+
+    //    /// <summary>
+    //    /// 默认数据库连接Key
+    //    /// </summary>
+    //    private static string _Default { get; set; } = "";
+
+    //    /// <summary>
+    //    /// PLC据库连接Key
+    //    /// </summary>
+    //    private static string _PLCEX { get; set; } = "";
+
+    //    /// <summary>
+    //    /// PLC据库连接Key
+    //    /// </summary>
+    //    public static string _PLC { get; set; } = "";
+
+    //    /// <summary>
+    //    /// Dlog数据库连接Key
+    //    /// </summary>
+    //    private static string _Dlog { get; set; } = "";
+
+    //    /// <summary>
+    //    ///  设置数据库连接Key
+    //    /// </summary>
+    //    /// <param name="configId">默认多租户ID</param>
+    //    public static void SetDefault(string configId)
+    //    {
+    //        _Default = configId;
+    //    }
+
+    //    /// <summary>
+    //    ///  设置 Dlog数据库连接Key
+    //    /// </summary>
+    //    /// <param name="configId">多租户Dlog ID</param>
+    //    public static void SetDlog(string configId)
+    //    {
+    //        _Dlog = configId;
+    //    }
+
+    //    /// <summary>
+    //    ///  设置 plc数据库连接Key
+    //    /// </summary>
+    //    /// <param name="configId">多租户Dlog ID</param>
+    //    public static void SetPLC(string configId)
+    //    {
+    //        _PLC = configId;
+    //    }
+
+    //    /// <summary>
+    //    ///  设置 plc数据库连接Key
+    //    /// </summary>
+    //    /// <param name="configId">多租户Dlog ID</param>
+    //    public static void SetPLCEX(string configId)
+    //    {
+    //        _PLCEX = configId;
+    //    }
+
+    //    /// <summary>
+    //    /// 默认数据库连接Key
+    //    /// </summary>
+    //    public SqlSugarProvider Default
+    //    {
+    //        get
+    //        {
+    //            if (_Default == "") throw new Exception("请调用[SqlSugarHelper.SetDefault]方法设置默认数据库连接");
+    //            if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
+    //            return _Db.CopyNew().GetConnection(_Default);
+    //        }
+    //    }
+
+    //    /// <summary>
+    //    /// Dlog数据库连接Key
+    //    /// </summary>
+    //    public SqlSugarProvider Dlog
+    //    {
+    //        get
+    //        {
+    //            if (_Dlog == "") throw new Exception("请调用[SqlSugarHelper.SetDlog]方法设置默认数据库连接");
+    //            if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
+    //            return _Db.CopyNew().GetConnection(_Dlog);
+    //        }
+    //    }
+
+    //    /// <summary>
+    //    /// plc数据库连接Key
+    //    /// </summary>
+    //    public SqlSugarProvider PLC
+    //    {
+    //        get
+    //        {
+    //            if (_PLC == "") throw new Exception("请调用[SqlSugarHelper.SetPLC]方法设置默认数据库连接");
+    //            if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
+    //            return _Db.CopyNew().GetConnection(_PLC);
+    //        }
+    //    }
+
+    //    /// <summary>
+    //    /// plc数据库连接Key
+    //    /// </summary>
+    //    public SqlSugarProvider PLCEX
+    //    {
+    //        get
+    //        {
+    //            if (_PLCEX == "") throw new Exception("请调用[SqlSugarHelper.SetPLC]方法设置默认数据库连接");
+    //            if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
+    //            return _Db.CopyNew().GetConnection(_PLCEX);
+    //        }
+    //    }
+
+    //    /// <summary>
+    //    ///  初始化 数据库连接
+    //    /// </summary>
+    //    /// <param name="sqlSugarScope"></param>
+    //    public static void Initialize(SqlSugarClient sqlSugarScope)
+    //    {
+    //        _Db = sqlSugarScope;
+    //    }
+
+    //    /// <summary>
+    //    /// 数据库连接
+    //    /// 注意需要
+    //    /// </summary>
+    //    public SqlSugarClient Connect
+    //    {
+    //        get
+    //        {
+    //            return _Db ?? throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
+    //        }
+    //    }
+
+    //    /// <summary>
+    //    ///  执行事务
+    //    /// </summary>
+    //    /// <param name="act"></param>
+    //    /// <exception cref="Exception"></exception>
+    //    public static void Do(Action<SqlSugarHelper> act)
+    //    {
+    //        if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
+    //        var db = new SqlSugarHelper();
+    //        try
+    //        {
+    //            db.Connect.BeginTran();//开始事务
+    //            act(db);//执行委托
+    //            db.Connect.CommitTran();//提交事务
+    //        }
+    //        catch (Exception ex)
+    //        {
+    //            db.Connect.RollbackTran();//回滚事务
+    //            if (ex.Message.Contains("SqlTransaction")) throw new Exception($"{ex.Message}:{ex.StackTrace}");
+    //            throw new Exception(ex.Message);
+    //        }
+    //    }
+
+    //    /// <summary>
+    //    ///  直接返回查询结果
+    //    /// </summary>
+    //    /// <typeparam name="T"></typeparam>
+    //    /// <param name="act"></param>
+    //    /// <returns></returns>
+    //    /// <exception cref="Exception"></exception>
+    //    public static T Do<T>(Func<SqlSugarHelper, T> act)
+    //    {
+    //        if (_Db == null) throw new Exception("请调用[SqlSugarHelper.SetDb]方法设置设置数据库连接");
+    //        var db = new SqlSugarHelper();
+    //        try
+    //        {
+    //            db.Connect.BeginTran();//开始事务
+    //            db.Connect.Ado.CommandTimeOut = 10;
+    //            var res = act(db);//执行委托
+    //            db.Connect.CommitTran();//提交事务
+    //            return res;
+    //        }
+    //        catch (Exception ex)
+    //        {
+    //            db.Connect.RollbackTran();//回滚事务
+    //            if (ex.Message.Contains("SqlTransaction")) throw new Exception($"{ex.Message}:{ex.StackTrace}");
+    //            throw new Exception(ex.Message);
+    //        }
+    //    }
+    //}
 }

WCS.Service/Worker.cs

@@ -1,12 +1,12 @@
 using MessagePack;
 using Newtonsoft.Json;
 using ServiceCenter;
-using ServiceCenter.Redis;
-using System.Text;
 using ServiceCenter.Extensions;
 using ServiceCenter.Logs;
+using ServiceCenter.Redis;
 using ServiceCenter.SqlSugars;
 using SqlSugar;
+using System.Text;
 using WCS.Core;
 using WCS.WorkEngineering;
 
@@ -127,10 +127,10 @@ namespace WCS.Service
                     {
                         IsNoReadXmlDescription = true,
                     },
-                  
                 });
-            };
-            SqlSugarHelper.SetDb(new SqlSugarScope(connectionConfigs));
+            }
+            ;
+            SqlSugarHelper.Initialize(new SqlSugarClient(connectionConfigs));
 
             ServiceHub.DbConnectionStrings.InitDB();
 
@@ -167,4 +167,4 @@ namespace WCS.Service
             LogHub.init();
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Extensions/DeviceExtension.cs

@@ -9,7 +9,6 @@ using WCS.Entity.Protocol.Robot;
 using WCS.Entity.Protocol.Station;
 using WCS.Entity.Protocol.Truss;
 using WCS.WorkEngineering.Model.WMS;
-using WCS.WorkEngineering.Systems;
 
 namespace WCS.WorkEngineering.Extensions
 {
@@ -306,7 +305,7 @@ namespace WCS.WorkEngineering.Extensions
         /// <param name="device">传入当前查询点对应的机械臂设备号</param>
         /// <param name="db">数据库连接信息</param>
         /// <returns></returns>
-        public static bool GetIsDirectPalletizing(this Device device, SqlSugarScopeProvider db)
+        public static bool GetIsDirectPalletizing(this Device device, SqlSugarProvider db)
         {
             var code = $"{device.Code}DirectPalletizing";
             var isDP = db.Queryable<fjSysConfig>().NoLock().Single(x => x.Code == code);

YWGC/FJK/WCS.WorkEngineering/Extensions/TaskExtension.cs

@@ -6,7 +6,6 @@ using SqlSugar;
 using WCS.Core;
 using WCS.Entity;
 using WCS.WorkEngineering.Model.WMS;
-using WCS.WorkEngineering.Systems;
 using TaskStatus = WCS.Entity.TaskStatus;
 
 namespace WCS.WorkEngineering.Extensions
@@ -24,7 +23,7 @@ namespace WCS.WorkEngineering.Extensions
         /// <param name="db">数据库上下文</param>
         /// <param name="curPoint">当前地址</param>
         /// <param name="desc">描述</param>
-        public static void AddWCS_TASK_DTL(this WCS_TaskInfo task, SqlSugarScopeProvider db, string curPoint, string desc) => task.AddWCS_TASK_DTL(db, curPoint, "", desc);
+        public static void AddWCS_TASK_DTL(this WCS_TaskInfo task, SqlSugarProvider db, string curPoint, string desc) => task.AddWCS_TASK_DTL(db, curPoint, "", desc);
 
         /// <summary>
         /// 更新任务执行记录
@@ -35,7 +34,7 @@ namespace WCS.WorkEngineering.Extensions
         /// <param name="curPoint">当前地址</param>
         /// <param name="nextPoint">下一个地址</param>
         /// <param name="desc">描述</param>
-        public static void AddWCS_TASK_DTL(this WCS_TaskInfo task, SqlSugarScopeProvider db, string curPoint, string nextPoint, string desc)
+        public static void AddWCS_TASK_DTL(this WCS_TaskInfo task, SqlSugarProvider db, string curPoint, string nextPoint, string desc)
         {
             db.InsertableRowLock(new WCS_TaskDtl
             {
@@ -57,7 +56,7 @@ namespace WCS.WorkEngineering.Extensions
         /// <param name="db">数据库上下文</param>
         /// <param name="curPoint">当前地址</param>
         /// <param name="desc">描述</param>
-        public static void AddWCS_TASK_DTL(this WCS_TaskOld task, SqlSugarScopeProvider db, string curPoint, string desc) => task.AddWCS_TASK_DTL(db, curPoint, "", desc);
+        public static void AddWCS_TASK_DTL(this WCS_TaskOld task, SqlSugarProvider db, string curPoint, string desc) => task.AddWCS_TASK_DTL(db, curPoint, "", desc);
 
         /// <summary>
         /// 更新任务执行记录
@@ -68,7 +67,7 @@ namespace WCS.WorkEngineering.Extensions
         /// <param name="curPoint">当前地址</param>
         /// <param name="nextPoint">下一个地址</param>
         /// <param name="desc">描述</param>
-        public static void AddWCS_TASK_DTL(this WCS_TaskOld task, SqlSugarScopeProvider db, string curPoint, string nextPoint, string desc)
+        public static void AddWCS_TASK_DTL(this WCS_TaskOld task, SqlSugarProvider db, string curPoint, string nextPoint, string desc)
         {
             db.InsertableRowLock(new WCS_TaskDtl
             {
@@ -86,7 +85,7 @@ namespace WCS.WorkEngineering.Extensions
         /// </summary>
         /// <param name="taskInfo"></param>
         /// <param name="db"></param>
-        public static void UpdateableOldTask(this WCS_TaskInfo taskInfo, SqlSugarScopeProvider db)
+        public static void UpdateableOldTask(this WCS_TaskInfo taskInfo, SqlSugarProvider db)
         {
             if (taskInfo.Status == TaskStatus.NewBuild) return;
 
@@ -113,7 +112,7 @@ namespace WCS.WorkEngineering.Extensions
         /// </summary>
         /// <param name="taskInfo"></param>
         /// <param name="db"></param>
-        public static void CompleteOrCancelTasks(this WCS_TaskInfo taskInfo, SqlSugarScopeProvider db)
+        public static void CompleteOrCancelTasks(this WCS_TaskInfo taskInfo, SqlSugarProvider db)
         {
             if (taskInfo.Status is not Entity.TaskStatus.Finish and not Entity.TaskStatus.Cancel) throw new KnownException("任务未完成或取消，无法执行WCS_TaskInfo与WCS_TaskOld同步动作", LogLevelEnum.Mid);
             // 任务完成或取消,进行相关同步动作
@@ -137,7 +136,7 @@ namespace WCS.WorkEngineering.Extensions
         /// </summary>
         /// <param name="taskInfo"></param>
         /// <param name="db"></param>
-        public static void Updateable(this WCS_TaskInfo taskInfo, SqlSugarScopeProvider db)
+        public static void Updateable(this WCS_TaskInfo taskInfo, SqlSugarProvider db)
         {
         }
 
@@ -147,7 +146,7 @@ namespace WCS.WorkEngineering.Extensions
         /// <param name="db">db</param>
         /// <param name="error"></param>
         /// <returns></returns>
-        public static void AddBaseErrorInfo(this BaseErrorInfo error, SqlSugarScopeProvider db)
+        public static void AddBaseErrorInfo(this BaseErrorInfo error, SqlSugarProvider db)
         {
             var errorinfoWcs = db.Queryable<BaseErrorInfo>().With(SqlWith.NoLock)
                 .Where(v => v.BusName == error.BusName && v.Message == error.Message && v.BarCode == error.BarCode).First();
@@ -170,9 +169,8 @@ namespace WCS.WorkEngineering.Extensions
         /// <returns></returns>
         public static void AddBaseErrorInfo(this BaseErrorInfo error)
         {
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var errorinfoWcs = db.Queryable<BaseErrorInfo>().With(SqlWith.NoLock)
                     .Where(v => v.BusName == error.BusName && v.Message == error.Message && v.BarCode == error.BarCode).First();
                 if (errorinfoWcs != null && (error.AddTime - errorinfoWcs.AddTime).TotalMinutes < 1)
@@ -208,10 +206,10 @@ namespace WCS.WorkEngineering.Extensions
         /// </summary>
         /// <param name="db">db</param>
         /// <returns></returns>
-        public static int GetAgvTaskId(this SqlSugarHelper db)
+        public static int GetAgvTaskId(this SqlSugarProvider db)
         {
             //最多任务号不再连续
-            var id = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().SplitTable(v => v.Take(2)).Max(v => v.ID);
+            var id = db.Queryable<WCS_AgvTaskInfo>().NoLock().SplitTable(v => v.Take(2)).Max(v => v.ID);
             return id + 1;
         }
 
@@ -249,7 +247,7 @@ namespace WCS.WorkEngineering.Extensions
         ///  初始化码垛信息
         /// </summary>
         /// <param name="task"></param>
-        public static void InitStackStructure(this WCS_TaskInfo task, SqlSugarScopeProvider db, World world)
+        public static void InitStackStructure(this WCS_TaskInfo task, SqlSugarProvider db, World world)
         {
             var billBomsetgrp = db.Queryable<BillBomsetgrp>().Single(x => x.IsStop == 0 && x.BomCode.Contains(task.MatCode));
             if (billBomsetgrp == null)

YWGC/FJK/WCS.WorkEngineering/Systems/AgvSystems.cs

@@ -1,12 +1,9 @@
-using FreeRedis;
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using PlcSiemens.Core.Extension;
 using ServiceCenter.Extensions;
 using ServiceCenter.Logs;
 using ServiceCenter.SqlSugars;
 using System.ComponentModel;
-using System.Security.Cryptography.Xml;
-using System.Threading.Tasks;
 using WCS.Core;
 using WCS.Entity;
 using WCS.Entity.Protocol.Station;
@@ -41,7 +38,7 @@ namespace WCS.WorkEngineering.Systems
                 //获取所有未结束的叫料及背负式补空AGV任务
                 SqlSugarHelper.Do(db =>
                 {
-                    agvTaskInfos = db.Default.Queryable<WCS_AgvTaskInfo>().ReadPast().Where(v => v.TaskType == AGVTaskType.CallMaterial)
+                    agvTaskInfos = db.Queryable<WCS_AgvTaskInfo>().ReadPast().Where(v => v.TaskType == AGVTaskType.CallMaterial)
                                                                          .Where(v => v.Status < AGVTaskStatus.MissionCompleted)
                                                                          .SplitTable(tabs => tabs.Take(2)).OrderBy(v => v.AddTime).ToList();
                 });
@@ -62,23 +59,23 @@ namespace WCS.WorkEngineering.Systems
                                     //取货点安全交互
                                     case AGVTaskStatus.RequestOrPermission2 when agv.Status != AGVTaskStatus.RequestOrPermission2:
                                         {
-                                            var taskInfoPick = db.Default.Queryable<WCS_TaskInfo>().NoLock().First(v => v.ID == agv.TaskId);
+                                            var taskInfoPick = db.Queryable<WCS_TaskInfo>().NoLock().First(v => v.ID == agv.TaskId);
                                             if (taskInfoPick == null) throw new Exception($"未找到对应的WCS任务{agv.TaskId}");
                                             agv.Status = AGVTaskStatus.RequestOrPermission2;
-                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
-                                            taskInfoPick.AddWCS_TASK_DTL(db.Default, "agv", $"允许AGV任务{agv.ID}在站台{agv.Station}取货");
+                                            db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                            taskInfoPick.AddWCS_TASK_DTL(db, "agv", $"允许AGV任务{agv.ID}在站台{agv.Station}取货");
                                             AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                             break;
                                         }
                                     case AGVTaskStatus.PutRequestOrPermission when agv.Status != AGVTaskStatus.PutRequestOrPermission:
                                         {
                                             agv.Status = AGVTaskStatus.PutRequestOrPermission;
-                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                            db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                             AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                             break;
                                         }
                                     case AGVTaskStatus.LeaveGet when agv.Status != AGVTaskStatus.LeaveGet:
-                                        var taskInfo = db.Default.Queryable<WCS_TaskInfo>().NoLock().First(v => v.ID == agv.TaskId);
+                                        var taskInfo = db.Queryable<WCS_TaskInfo>().NoLock().First(v => v.ID == agv.TaskId);
                                         if (taskInfo == null) throw new Exception($"未找到对应的WCS任务{agv.TaskId}");
                                         World.Log($"AGV取货结束:开始{agv.ID}--{agv.Station}");
                                         var devinfo = new Device<IStation520>(Device.All.First(x => x.Code == agv.Station), World);
@@ -95,7 +92,7 @@ namespace WCS.WorkEngineering.Systems
                                             }
                                         }
                                         agv.Status = AGVTaskStatus.LeaveGet;
-                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                        db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                         World.Log($"AGV取货结束:结束{agv.ID}--{agv.Station}");
                                         break;
                                     //完成任务
@@ -103,25 +100,25 @@ namespace WCS.WorkEngineering.Systems
                                         {
                                             if (agv.TaskType is AGVTaskType.CallForMaterial or AGVTaskType.ForkliftFilling or AGVTaskType.CallMaterial)
                                             {
-                                                var taskInfoFinish = db.Default.Queryable<WCS_TaskInfo>().RowLock().First(v => v.AgvTaskID == agv.ID);
+                                                var taskInfoFinish = db.Queryable<WCS_TaskInfo>().RowLock().First(v => v.AgvTaskID == agv.ID);
                                                 //if (taskInfo == null) throw new Exception($"未找到AGV任务{agv.ID}对应WCS任务");
                                                 //更新AGV任务状态
                                                 agv.Status = AGVTaskStatus.MissionCompleted;
-                                                db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                                db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                 //更新WCS任务状态
                                                 if (taskInfoFinish != null)
                                                 {
                                                     taskInfoFinish.Status = Entity.TaskStatus.Finish;
                                                     taskInfoFinish.EndTime = DateTime.Now;
-                                                    db.Default.UpdateableRowLock(taskInfoFinish).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                                                    taskInfoFinish.AddWCS_TASK_DTL(db.Default, "agv", "任务完成");
+                                                    db.UpdateableRowLock(taskInfoFinish).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                                                    taskInfoFinish.AddWCS_TASK_DTL(db, "agv", "任务完成");
                                                     taskInfos.Add(taskInfoFinish);
                                                 }
                                             }
                                             else
                                             {
                                                 agv.Status = AGVTaskStatus.MissionCompleted;
-                                                db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                                db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                             }
 
                                             break;
@@ -143,7 +140,7 @@ namespace WCS.WorkEngineering.Systems
                 //获取所有未结束的入库AGV任务
                 SqlSugarHelper.Do(db =>
                 {
-                    agvTaskInfos = db.Default.Queryable<WCS_AgvTaskInfo>()
+                    agvTaskInfos = db.Queryable<WCS_AgvTaskInfo>()
                                              .Where(v => v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot)
                                              .SplitTable(tabs => tabs.Take(2)).OrderBy(v => v.EditTime).ToList();
                 });
@@ -166,28 +163,28 @@ namespace WCS.WorkEngineering.Systems
                                             agv.AgvID = agv.ID.ToString();
                                             agv.Status = AGVTaskStatus.Confirm;
                                             agv.AgvStatus = AGVTaskStatus.Confirm;
-                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                            db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                         }
                                         //人工满托入库
                                         if (agv.TaskType == AGVTaskType.EnterDepot && (agv.Station == "2535" || agv.Station == "2935" || agv.Station == "2735" || agv.Station == "3135"))
                                         {
                                             //fjSysConfig config1 = new fjSysConfig();
-                                            var config1 = db.Default.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "FullPalletInMax");
+                                            var config1 = db.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "FullPalletInMax");
                                             if (config1 != null)
                                             {
-                                                if (!(db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status == TaskStatus.AGVExecution && x.BusType == "人工满托入库").Count() < config1.SContent.ToShort()))
+                                                if (!(db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status == TaskStatus.AGVExecution && x.BusType == "人工满托入库").Count() < config1.SContent.ToShort()))
                                                 {
                                                     throw new Exception($"人工组盘任务数已达{config1.SContent.ToShort()},暂停下发任务");
                                                 }
                                             }
                                             AgvApi.满托入库(agv.Position, agv.ID.ToString(), agv.Station);
-                                            var tasknew = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
+                                            var tasknew = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                             if (tasknew != null)
                                             {
                                                 tasknew.Status = TaskStatus.AGVExecution;
                                                 tasknew.EditTime = DateTime.Now;
-                                                db.Default.UpdateableRowLock(tasknew).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
-                                                tasknew.AddWCS_TASK_DTL(db.Default, "agv", "任务下发agv执行");
+                                                db.UpdateableRowLock(tasknew).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
+                                                tasknew.AddWCS_TASK_DTL(db, "agv", "任务下发agv执行");
                                             }
                                             else
                                             {
@@ -198,13 +195,13 @@ namespace WCS.WorkEngineering.Systems
                                         else if (agv.WorkShop == 222)
                                         {
                                             AgvApi.退料重绕(agv.Position, agv.ID.ToString(), agv.Station);
-                                            var tasknew = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
+                                            var tasknew = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                             if (tasknew != null)
                                             {
                                                 tasknew.Status = TaskStatus.AGVExecution;
                                                 tasknew.EditTime = DateTime.Now;
-                                                db.Default.UpdateableRowLock(tasknew).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
-                                                tasknew.AddWCS_TASK_DTL(db.Default, "agv", "任务下发agv执行");
+                                                db.UpdateableRowLock(tasknew).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
+                                                tasknew.AddWCS_TASK_DTL(db, "agv", "任务下发agv执行");
                                             }
                                             else
                                             {
@@ -225,7 +222,7 @@ namespace WCS.WorkEngineering.Systems
                                     //巷道分配
                                     case AGVTaskStatus.RequestOrPermission1 when agv.Status != AGVTaskStatus.Complete1:
                                         {
-                                            var task = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
+                                            var task = db.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                             if (task == null) throw new Exception($"未找到对应的WCS任务{agv.TaskId}");
                                             if (task.BusType != TaskBusType.帘线退料重绕.GetDescription())
                                             {
@@ -272,7 +269,7 @@ namespace WCS.WorkEngineering.Systems
                                                 //List<WCS_AgvTaskInfo> agvsNear = new List<WCS_AgvTaskInfo>(); //同库区另一侧的放货点已用点
                                                 //List<WCS_AgvTaskInfo> agvsAll = new List<WCS_AgvTaskInfo>(); //所有的放货点已用点
 
-                                                agvs = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && positionList.Contains(v.Station))
+                                                agvs = db.Queryable<WCS_AgvTaskInfo>().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && positionList.Contains(v.Station))
                                                     .SplitTable(v => v.Take(2)).ToList();
                                                 //agvsAll = db.Default.Queryable<WCS_AgvTaskInfo>().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && allPositionList.Contains(v.Station))
                                                 //    .SplitTable(v => v.Take(2)).ToList();
@@ -376,9 +373,9 @@ namespace WCS.WorkEngineering.Systems
                                                     World.Log($"任务执行过程:开始{agv.ID}-{JsonConvert.SerializeObject(devs.Select(x => x.Entity.Code).ToList())}");
                                                     agv.Status = AGVTaskStatus.Complete1;
                                                     agv.Station = devs.MinBy(x => x.Entity.Code).Entity.Code;
-                                                    db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                                    db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                     World.Log($"任务执行过程:完成agv任务更新{agv.ID}--{agv.Station}");
-                                                    task.AddWCS_TASK_DTL(db.Default, "皮盘返库任务分配巷道", agv.Station, $"任务分配至:{agv.Station}");
+                                                    task.AddWCS_TASK_DTL(db, "皮盘返库任务分配巷道", agv.Station, $"任务分配至:{agv.Station}");
                                                     World.Log($"任务执行过程:完成任务明细添加{agv.Station}");
                                                     AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                     World.Log($"任务执行过程:任务成功下发AGV{agv.AgvID}--{agv.Station}");
@@ -390,28 +387,28 @@ namespace WCS.WorkEngineering.Systems
                                             }
                                             else if (task.BusType == TaskBusType.帘线退料重绕.GetDescription())
                                             {
-                                                var con = db.Default.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "CRTLZone").SContent;
+                                                var con = db.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "CRTLZone").SContent;
                                                 var isUse = false || con != null && con == "1";
                                                 //首先判断退料输送线是否可放货
                                                 var ph_9001 = new Device<IStation523>(Device.All.First(x => x.Code == "9001"), World);
                                                 var ph_9101 = new Device<IStation523>(Device.All.First(x => x.Code == "9101"), World);
-                                                var flag1 = !db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && v.Station == "9001")
+                                                var flag1 = !db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && v.Station == "9001")
                                                     .SplitTable(v => v.Take(2)).Any() && !ph_9001.Data.Status.HasFlag(StationStatus.PH_Status);
-                                                var flag2 = !db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && v.Station == "9101")
+                                                var flag2 = !db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && v.Station == "9101")
                                                     .SplitTable(v => v.Take(2)).Any() && !ph_9101.Data.Status.HasFlag(StationStatus.PH_Status);
-                                                var taskApply = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
+                                                var taskApply = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                                 if (flag2)
                                                 {
                                                     if (taskApply != null)
                                                     {
                                                         agv.Status = AGVTaskStatus.Complete1;
                                                         agv.Station = "9101";
-                                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                                        db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                         AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                         taskApply.AddrTo = agv.Station;
-                                                        db.Default.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
+                                                        db.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
                                                         World.Log($"帘线退料重绕分配目标放货点,任务{agv.ID}分配至:{agv.Station}");
-                                                        taskApply.AddWCS_TASK_DTL(db.Default, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
+                                                        taskApply.AddWCS_TASK_DTL(db, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
                                                     }
                                                     else
                                                     {
@@ -425,12 +422,12 @@ namespace WCS.WorkEngineering.Systems
                                                     {
                                                         agv.Status = AGVTaskStatus.Complete1;
                                                         agv.Station = "9001";
-                                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                                        db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                         AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                         taskApply.AddrTo = agv.Station;
-                                                        db.Default.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
+                                                        db.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
                                                         World.Log($"帘线退料重绕分配目标放货点,任务{agv.ID}分配至:{agv.Station}");
-                                                        taskApply.AddWCS_TASK_DTL(db.Default, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
+                                                        taskApply.AddWCS_TASK_DTL(db, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
                                                     }
                                                     else
                                                     {
@@ -442,7 +439,7 @@ namespace WCS.WorkEngineering.Systems
                                                 {
                                                     List<string> allDevs = new List<string> { "9210", "9211", "9212", "9213", "9214",/* "9215", "9216", "9217", "9218" */};
 
-                                                    var agvStas = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && (allDevs.Contains(v.Station) || allDevs.Contains(v.Position)))
+                                                    var agvStas = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && (allDevs.Contains(v.Station) || allDevs.Contains(v.Position)))
                                                     .SplitTable(v => v.Take(2)).ToList();
                                                     var agvStaLists = agvStas.Select(x => x.Station).Distinct();
                                                     var devs = allDevs.Where(x => !agvStaLists.Contains(x)).ToList();
@@ -462,7 +459,7 @@ namespace WCS.WorkEngineering.Systems
                                                         foreach (var dev in devsPut)
                                                         {
                                                             if (!dev.Data3.Status.HasFlag(StationStatus.PH_Status) &&
-                                                                !db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && (v.Station == dev.Entity.Code || v.Position == dev.Entity.Code))
+                                                                !db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && (v.Station == dev.Entity.Code || v.Position == dev.Entity.Code))
                                                                 .SplitTable(v => v.Take(2)).Any())
                                                             {
                                                                 var sta = dev.Entity.Code;
@@ -482,11 +479,11 @@ namespace WCS.WorkEngineering.Systems
                                                                 }
                                                                 agv.Status = AGVTaskStatus.Complete1;
                                                                 agv.Station = dev.Entity.Code;
-                                                                db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                                                db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                                                 AgvApi.ContinueTask(agv.AgvID, agv.Station);
                                                                 taskApply.AddrTo = agv.Station;
-                                                                db.Default.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
-                                                                taskApply.AddWCS_TASK_DTL(db.Default, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
+                                                                db.UpdateableRowLock(taskApply).UpdateColumns(x => new { x.AddrTo }).ExecuteCommand();
+                                                                taskApply.AddWCS_TASK_DTL(db, "agv", $"帘线退料重绕分配目标放货点,任务分配至:{agv.Station}");
                                                                 World.Log($"帘线退料重绕分配目标放货点,任务{agv.ID}分配至:{agv.Station}");
                                                                 return;
                                                             }
@@ -510,7 +507,7 @@ namespace WCS.WorkEngineering.Systems
                                             if (agv.Station.IsNullOrEmpty()) throw new Exception($"无有效放货地址");
                                             //var dev = Device.All.First(x => x.Code == agv.Station);
                                             var devPut = new Device<IStation520, IStation521, IStation523>(Device.All.First(x => x.Code == agv.Station), World);
-                                            var taskPut = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
+                                            var taskPut = db.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                             var flag = false;
                                             if (taskPut == null)
                                             {
@@ -531,7 +528,7 @@ namespace WCS.WorkEngineering.Systems
                                                 {
                                                     throw new Exception($"{agv.Station}站台不在低位小车无法放货，请检查并处理");
                                                 }
-                                                var tasking = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot
+                                                var tasking = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot
                                                         && v.Station == agv.Station && v.GoodsSum == 1).SplitTable(tabs => tabs.Take(2)).First();
                                                 if (tasking != null)
                                                 {
@@ -540,7 +537,7 @@ namespace WCS.WorkEngineering.Systems
                                                 agv.GoodsSum = 1;
                                             }
                                             agv.Status = AGVTaskStatus.RequestOrPermission2;
-                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                            db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                             //taskPut.AddWCS_TASK_DTL(db.Default, "agv", $"允许agv任务{agv.ID}放货");
                                             if (taskPut.BusType != TaskBusType.帘线退料重绕.GetDescription() && taskPut.BusType != TaskBusType.重绕满托入库.GetDescription())
                                             {
@@ -557,11 +554,11 @@ namespace WCS.WorkEngineering.Systems
 
                                     //完成任务
                                     case AGVTaskStatus.MissionCompleted when agv.Status != AGVTaskStatus.MissionCompleted:
-                                        var taskold = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
+                                        var taskold = db.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                         if (agv.TaskType == AGVTaskType.EnterDepot)
                                         {
                                             agv.Status = AGVTaskStatus.MissionCompleted;
-                                            db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                            db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                             var devinfo = new Device<IStation520, IStation521>(Device.All.First(x => x.Code == agv.Station), World);
                                             if (taskold.BusType != TaskBusType.帘线退料重绕.GetDescription() && taskold.BusType != TaskBusType.重绕满托入库.GetDescription())
                                             {
@@ -570,43 +567,43 @@ namespace WCS.WorkEngineering.Systems
 
                                             if (taskold.LastInteractionPoint == "2" || taskold.BusType == TaskBusType.重绕满托入库.GetDescription() || taskold.BusType == TaskBusType.帘线退料重绕.GetDescription()) //如果是单独取空任务直接完成
                                             {
-                                                var task = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
+                                                var task = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                                 if (task != null)
                                                 {
                                                     task.Status = TaskStatus.Finish;
                                                     task.EndTime = DateTime.Now;
-                                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                                                    task.AddWCS_TASK_DTL(db.Default, "agv", "任务完成");
+                                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                                                    task.AddWCS_TASK_DTL(db, "agv", "任务完成");
                                                 }
                                             }
                                             else if (taskold.BusType == "人工满托入库")
                                             {
-                                                var task = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
+                                                var task = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                                 if (task != null)
                                                 {
                                                     task.Status = TaskStatus.ConveyorExecution;
                                                     devinfo.Data.TaskNumber = task.ID;
                                                     task.EndTime = DateTime.Now;
-                                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                                                    task.AddWCS_TASK_DTL(db.Default, "agv", "任务放货完成");
+                                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                                                    task.AddWCS_TASK_DTL(db, "agv", "任务放货完成");
                                                 }
                                             }
                                         }
                                         break;
 
                                     case AGVTaskStatus.Cancel when agv.Status != AGVTaskStatus.Cancel:
-                                        var taskold1 = db.Default.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
+                                        var taskold1 = db.Queryable<WCS_TaskOld>().NoLock().Where(x => x.Id == agv.TaskId).SplitTable(x => x.Take(2)).First();
                                         agv.Status = AGVTaskStatus.Cancel;
-                                        db.Default.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                        db.UpdateableRowLock(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                         if (taskold1.LastInteractionPoint == "2") //如果是单独取空任务直接取消
                                         {
-                                            var task = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
+                                            var task = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.ID == agv.TaskId).First();
                                             if (task != null)
                                             {
                                                 task.Status = TaskStatus.Cancel;
                                                 task.EndTime = DateTime.Now;
-                                                db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                                                task.AddWCS_TASK_DTL(db.Default, "agv", "任务取消");
+                                                db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                                                task.AddWCS_TASK_DTL(db, "agv", "任务取消");
                                             }
                                         }
                                         break;

YWGC/FJK/WCS.WorkEngineering/Systems/NoInteractionSystems.cs

@@ -35,29 +35,29 @@ namespace WCS.WorkEngineering.Systems
             SqlSugarHelper.Do(db =>
             {
                 //获取所有的新建任务，组盘任务不需要
-                taskInfos = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status == 0).ToList()
-                    .Where(x => x.Type != TaskType.SetPlate || (x.Type == TaskType.SetPlate && x.AddrFrom != "Robot") && x.BusType!="芯股用空托盘入库" && !x.BarCode.Contains("Error")).Select(x => x.ID).ToList();
+                taskInfos = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status == 0).ToList()
+                    .Where(x => x.Type != TaskType.SetPlate || (x.Type == TaskType.SetPlate && x.AddrFrom != "Robot") && x.BusType != "芯股用空托盘入库" && !x.BarCode.Contains("Error")).Select(x => x.ID).ToList();
                 var time = DateTime.Now.AddMinutes(-20);
                 var time1 = DateTime.Now.AddMinutes(-40);
-                var timeOut = db.Default.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "车间叫料" && x.Status < TaskStatus.StackerExecution && x.AddTime < time);
+                var timeOut = db.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "车间叫料" && x.Status < TaskStatus.StackerExecution && x.AddTime < time);
                 if (timeOut > 0) World.Log($"共有{timeOut}个车间叫料任务超过二十分钟未执行，请检查相关相关任务对应的堆垛机是否正常、堆垛机放货点是否卡任务等", LogLevelEnum.High);
 
-                var timeOut1 = db.Default.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "车间叫料" && x.Status < TaskStatus.StackerExecution && x.AddTime < time1);
+                var timeOut1 = db.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "车间叫料" && x.Status < TaskStatus.StackerExecution && x.AddTime < time1);
                 if (timeOut1 > 0) World.Log($"共有{timeOut1}个车间叫料任务超过四十分钟未执行，请检查相关相关任务对应的堆垛机是否正常、堆垛机放货点是否卡任务等", LogLevelEnum.High);
 
-                var timeOut2 = db.Default.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "皮盘入库" && x.Status < TaskStatus.StackerExecution && x.AddTime < time);
+                var timeOut2 = db.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "皮盘入库" && x.Status < TaskStatus.StackerExecution && x.AddTime < time);
                 if (timeOut2 > 0) World.Log($"共有{timeOut2}个皮盘入库任务超过二十分钟未执行，请检查相关相关任务及对应agv设备", LogLevelEnum.High);
 
-                var timeOut3 = db.Default.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "皮盘入库" && x.Status < TaskStatus.StackerExecution && x.AddTime < time1);
+                var timeOut3 = db.Queryable<WCS_TaskInfo>().NoLock().Count(x => x.BusType == "皮盘入库" && x.Status < TaskStatus.StackerExecution && x.AddTime < time1);
                 if (timeOut3 > 0) World.Log($"共有{timeOut3}个皮盘入库任务超过四十分钟未执行，请检查相关相关任务及对应agv设备", LogLevelEnum.High);
 
                 var time3 = DateTime.Now.AddHours(-24);
-                var timeOut4 = db.Default.Queryable<BillInvnow>().NoLock().Count(x => x.AddTime < time3 && x.ContGrpBarCode.Contains("TPB"));
+                var timeOut4 = db.Queryable<BillInvnow>().NoLock().Count(x => x.AddTime < time3 && x.ContGrpBarCode.Contains("TPB"));
                 if (timeOut4 > 0) World.Log($"共有{timeOut4}个库存信息超过24小时未执行，请检查相关库存信息并处理", LogLevelEnum.High);
 
                 var time4 = DateTime.Now.AddHours(-12);
-                var timeOut5 = db.Default.Queryable<WCS_Palletizing>().NoLock().Where(x => x.AddTime < time4 && !x.Finish).ToList();
-                if (timeOut5.Count > 0) World.Log($"共有{timeOut5.Count}个桁架码垛信息超过12小时未结束，请检查相关码垛信息并处理,具体在{JsonConvert.SerializeObject(timeOut5.Select(x=>x.PalletizingStation).ToList())}", LogLevelEnum.High);
+                var timeOut5 = db.Queryable<WCS_Palletizing>().NoLock().Where(x => x.AddTime < time4 && !x.Finish).ToList();
+                if (timeOut5.Count > 0) World.Log($"共有{timeOut5.Count}个桁架码垛信息超过12小时未结束，请检查相关码垛信息并处理,具体在{JsonConvert.SerializeObject(timeOut5.Select(x => x.PalletizingStation).ToList())}", LogLevelEnum.High);
             });
             if (!taskInfos.Any())
             {
@@ -73,7 +73,7 @@ namespace WCS.WorkEngineering.Systems
                 {
                     SqlSugarHelper.Do(db =>
                     {
-                        var task = db.Default.Queryable<WCS_TaskInfo>().RowLock().Where(t => t.ID == item && t.Status== TaskStatus.NewBuild).First();
+                        var task = db.Queryable<WCS_TaskInfo>().RowLock().Where(t => t.ID == item && t.Status == TaskStatus.NewBuild).First();
 
                         switch (task.Type)
                         {
@@ -82,8 +82,8 @@ namespace WCS.WorkEngineering.Systems
                                 {
                                     //更新任务状态
                                     task.Status = TaskStatus.WaitingToExecute;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化入库任务信息");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.Device, $"初始化入库任务信息");
                                     isEnd = true;
                                 }
                                 break;
@@ -103,11 +103,11 @@ namespace WCS.WorkEngineering.Systems
                                         AddWho = "WCS",
                                         AddTime = DateTime.Now
                                     };
-                                    db.Default.InsertableRowLock(agv).SplitTable().ExecuteCommand();
+                                    db.InsertableRowLock(agv).SplitTable().ExecuteCommand();
                                     task.AgvTaskID = agv.ID;
                                     task.Status = Entity.TaskStatus.WaitingToExecute;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AgvTaskID }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化单独返皮盘任务");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AgvTaskID }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.Device, $"初始化单独返皮盘任务");
                                 }
                                 else if (task.BusType == TaskBusType.芯股用空托盘入库.GetDescription()) return;
                                 else if (task.BusType == TaskBusType.人工满托入库.GetDescription())
@@ -127,23 +127,23 @@ namespace WCS.WorkEngineering.Systems
                                             "2S" => "3135",
                                             _ => "2535"
                                         },
-                                         AddWho = "WCS",
+                                        AddWho = "WCS",
                                         AddTime = DateTime.Now
                                     };
-                                    db.Default.InsertableRowLock(agv).SplitTable().ExecuteCommand();
+                                    db.InsertableRowLock(agv).SplitTable().ExecuteCommand();
                                     task.AgvTaskID = agv.ID;
                                     task.Device = task.WarehouseCode switch
                                     {
                                         "1N" => "TY1",
                                         "1S" => "TY2",
                                         "2N" => "TY3",
-                                        "2S" => "TY4",                                      
+                                        "2S" => "TY4",
                                         _ => "TY1"
                                     };
                                     task.Height = 1;
                                     task.Status = Entity.TaskStatus.WaitingToExecute;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.Device, x.Height }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化人工满托入库任务");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.Device, x.Height }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.Device, $"初始化人工满托入库任务");
                                 }
                                 else if (task.BusType == TaskBusType.UT人工满托入库.GetDescription())
                                 {
@@ -165,7 +165,7 @@ namespace WCS.WorkEngineering.Systems
                                         AddWho = "WCS",
                                         AddTime = DateTime.Now
                                     };
-                                    db.Default.InsertableRowLock(agv).SplitTable().ExecuteCommand();
+                                    db.InsertableRowLock(agv).SplitTable().ExecuteCommand();
                                     task.AgvTaskID = agv.ID;
                                     task.Device = task.WarehouseCode switch
                                     {
@@ -177,17 +177,17 @@ namespace WCS.WorkEngineering.Systems
                                     };
                                     task.Height = 1;
                                     task.Status = Entity.TaskStatus.WaitingToExecute;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.Device, x.Height }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化UT人工满托入库任务");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.Device, x.Height }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.Device, $"初始化UT人工满托入库任务");
                                 }
                                 else if (task.BusType == TaskBusType.重绕满托入库.GetDescription())
                                 {
                                     task.Status = Entity.TaskStatus.WaitingToExecute;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化入库任务信息");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.Device, $"初始化入库任务信息");
                                 }
                                 else if (task.BusType == TaskBusType.帘线退料重绕.GetDescription())
-                                {                                   
+                                {
                                     var agv = new WCS_AgvTaskInfo()
                                     {
                                         ID = db.GetAgvTaskId(),
@@ -199,13 +199,13 @@ namespace WCS.WorkEngineering.Systems
                                         Station = "9001",
                                         AddWho = "WCS",
                                         AddTime = DateTime.Now
-                                    };                                  
-                                    db.Default.InsertableRowLock(agv).SplitTable().ExecuteCommand();
+                                    };
+                                    db.InsertableRowLock(agv).SplitTable().ExecuteCommand();
                                     task.Status = Entity.TaskStatus.WaitingToExecute;
                                     task.AgvTaskID = agv.ID;
                                     task.AddrTo = agv.Station;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status,x.AgvTaskID,x.AddrTo }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化入库任务信息");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.AddrTo }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.Device, $"初始化入库任务信息");
                                 }
                                 else
                                 {
@@ -238,8 +238,8 @@ namespace WCS.WorkEngineering.Systems
                                     task.AddrNext = path1.Points[1].Code;
                                     task.SrmStation = task.BarCode.Contains("TPA") || task.BarCode.Contains("TPB") ? task.AddrFrom : path1.Points[2].Code;
 
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.Device, x.AddrNext, x.SrmStation }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化入库任务信息");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.Device, x.AddrNext, x.SrmStation }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.Device, $"初始化入库任务信息");
                                 }
 
                                 isEnd = true;
@@ -249,7 +249,7 @@ namespace WCS.WorkEngineering.Systems
                                 {
                                     if (task.Device.Contains("Robot")) //机器人任务
                                     {
-                                        var lastTask = db.Default.Queryable<WCS_TaskInfo>().NoLock().First(x => x.Type == TaskType.OutDepot && x.AddrTo == task.AddrTo && x.Status > TaskStatus.WaitingToExecute && x.Status < TaskStatus.Finish);
+                                        var lastTask = db.Queryable<WCS_TaskInfo>().NoLock().First(x => x.Type == TaskType.OutDepot && x.AddrTo == task.AddrTo && x.Status > TaskStatus.WaitingToExecute && x.Status < TaskStatus.Finish);
                                         if (lastTask != null)
                                         {
                                             World.Log($"等待任务结束:{task.AddrTo}上一组码垛任务未结束，等待{lastTask.ID}任务完成后开始初始化当前任务{task.ID}");
@@ -261,8 +261,8 @@ namespace WCS.WorkEngineering.Systems
                                         task.Col = pos[1].ToShort();
                                         task.Layer = pos[2].ToShort();
                                         task.Depth = pos[3].ToShort();
-                                        db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.Line, x.Col, x.Layer, x.Depth }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化出库任务信息,放货站台:{task.SrmStation}");
+                                        db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.Line, x.Col, x.Layer, x.Depth }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, task.Device, $"初始化出库任务信息,放货站台:{task.SrmStation}");
                                         isEnd = true;
                                     }
                                     else if (task.Device == "FJXG") //芯股仓库的任务
@@ -281,7 +281,7 @@ namespace WCS.WorkEngineering.Systems
                                                 AddWho = "WCS",
                                                 AddTime = DateTime.Now
                                             };
-                                            db.Default.InsertableRowLock(agv).SplitTable().ExecuteCommand();
+                                            db.InsertableRowLock(agv).SplitTable().ExecuteCommand();
                                         }
                                         var agvId = DateTime.Now.GetFormat(GetFormatterEnum.only) + task.ID;
                                         var agvTask = new WCS_AgvTaskInfo()
@@ -297,8 +297,8 @@ namespace WCS.WorkEngineering.Systems
                                             AgvID = agvId
                                         };
                                         //开始处理车间叫料AGV任务任务
-                                        db.Default.InsertableRowLock(agvTask).SplitTable().ExecuteCommand();
-                                        agvTask = db.Default.Queryable<WCS_AgvTaskInfo>().RowLock().SplitTable(x => x.Take(2)).Single(x => x.TaskId == task.ID && x.TaskType == AGVTaskType.CallMaterial);
+                                        db.InsertableRowLock(agvTask).SplitTable().ExecuteCommand();
+                                        agvTask = db.Queryable<WCS_AgvTaskInfo>().RowLock().SplitTable(x => x.Take(2)).Single(x => x.TaskId == task.ID && x.TaskType == AGVTaskType.CallMaterial);
                                         if (agvTask.Status != AGVTaskStatus.NewBuild)
                                         {
                                             World.Log($"AGV任务{agvTask.ID}状态不是新建", LogLevelEnum.High);
@@ -307,13 +307,13 @@ namespace WCS.WorkEngineering.Systems
                                         agvId = agvTask.AgvID;
                                         agvTask.Status = AGVTaskStatus.Confirm;
                                         agvTask.AgvStatus = AGVTaskStatus.Confirm;
-                                        db.Default.UpdateableRowLock(agvTask).UpdateColumns(x => new { x.AgvID, x.Status, x.AgvStatus }).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                        db.UpdateableRowLock(agvTask).UpdateColumns(x => new { x.AgvID, x.Status, x.AgvStatus }).SplitTable(x => x.Take(2)).ExecuteCommand();
                                         task.Status = TaskStatus.AGVExecution;
                                         task.AgvTaskID = agvTask.ID;
                                         task.EditTime = DateTime.Now;
                                         task.EditWho = "WCS";
-                                        db.Default.Updateable(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.EditTime, x.EditWho }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, task.AddrFrom, "AGV", $"任务下发至AGV{agvId}");
+                                        db.Updateable(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.EditTime, x.EditWho }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, task.AddrFrom, "AGV", $"任务下发至AGV{agvId}");
                                         var res = AgvApi.机台叫料(task.AddrFrom, task.WorkBench, agvId);
 
                                         isEnd = true;
@@ -359,8 +359,8 @@ namespace WCS.WorkEngineering.Systems
 
                                             //开始计算当前这个任务要从哪个站台出
                                             //计算两个站台小于取货完成数量的AGV任务
-                                            var agv1 = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[0]).Count();
-                                            var agv2 = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[1]).Count();
+                                            var agv1 = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[0]).Count();
+                                            var agv2 = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[1]).Count();
                                             task.SrmStation = "";
                                             //if (srmStation[0] == "2534"/* || srmStation[0] == "2934"*/)
                                             //{
@@ -370,7 +370,6 @@ namespace WCS.WorkEngineering.Systems
                                             {
                                                 task.AddrTo = agv1 > agv2 ? srmStation[1] : srmStation[0];
                                             }
-
                                         }
                                         if (task.SrmStation.IsNullOrEmpty()) //如果没有指定放货站台
                                         {
@@ -385,8 +384,8 @@ namespace WCS.WorkEngineering.Systems
 
                                         //更新任务状态
                                         task.Status = Entity.TaskStatus.WaitingToExecute;
-                                        db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.SrmStation, x.AddrTo, x.Status }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化出库任务信息,放货站台:{task.SrmStation}");
+                                        db.UpdateableRowLock(task).UpdateColumns(x => new { x.SrmStation, x.AddrTo, x.Status }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, task.Device, $"初始化出库任务信息,放货站台:{task.SrmStation}");
                                         isEnd = true;
                                     }
                                     else if (task.Device == "CR")
@@ -405,13 +404,13 @@ namespace WCS.WorkEngineering.Systems
                                                 AddWho = "WCS",
                                                 AddTime = DateTime.Now
                                             };
-                                            db.Default.InsertableRowLock(agv).SplitTable().ExecuteCommand();
+                                            db.InsertableRowLock(agv).SplitTable().ExecuteCommand();
                                         }
                                         //更新任务状态
                                         task.Status = Entity.TaskStatus.WaitingToExecute;
                                         task.AddrTo = task.WorkBench;
-                                        db.Default.UpdateableRowLock(task).UpdateColumns(x => new {x.Status , x.AddrTo }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化出库任务信息,重绕组盘区{task.AddrFrom}");
+                                        db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AddrTo }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, task.Device, $"初始化出库任务信息,重绕组盘区{task.AddrFrom}");
                                         isEnd = true;
                                         break;
                                     }
@@ -456,8 +455,8 @@ namespace WCS.WorkEngineering.Systems
 
                                             //开始计算当前这个任务要从哪个站台出
                                             //计算两个站台小于取货完成数量的AGV任务
-                                            var agv1 = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[0]).Count();
-                                            var agv2 = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[1]).Count();
+                                            var agv1 = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[0]).Count();
+                                            var agv2 = db.Queryable<WCS_TaskInfo>().NoLock().Where(x => x.Status <= TaskStatus.StackerExecution && x.AddrTo == srmStation[1]).Count();
                                             task.SrmStation = "";
                                             //if (srmStation[0] == "2534"/* || srmStation[0] == "2934"*/)
                                             //{
@@ -467,7 +466,6 @@ namespace WCS.WorkEngineering.Systems
                                             {
                                                 task.AddrTo = agv1 > agv2 ? srmStation[1] : srmStation[0];
                                             }
-
                                         }
                                         if (task.SrmStation.IsNullOrEmpty()) //如果没有指定放货站台
                                         {
@@ -496,12 +494,12 @@ namespace WCS.WorkEngineering.Systems
                                                 AddWho = "WCS",
                                                 AddTime = DateTime.Now
                                             };
-                                            db.Default.InsertableRowLock(agv).SplitTable().ExecuteCommand();
+                                            db.InsertableRowLock(agv).SplitTable().ExecuteCommand();
                                         }
                                         //更新任务状态
                                         task.Status = Entity.TaskStatus.WaitingToExecute;
-                                        db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.SrmStation, x.AddrTo, x.Status }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, task.Device, $"初始化出库任务信息,放货站台:{task.SrmStation}");
+                                        db.UpdateableRowLock(task).UpdateColumns(x => new { x.SrmStation, x.AddrTo, x.Status }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, task.Device, $"初始化出库任务信息,放货站台:{task.SrmStation}");
                                         isEnd = true;
                                     }
                                     break;
@@ -528,14 +526,13 @@ namespace WCS.WorkEngineering.Systems
             return dev.Code == nameof(NoInteractionSystems);
         }
 
-
         /// <summary>
         ///     获取AGV的目标站台
         /// </summary>
         /// <param name="task">任务信息</param>
         /// <param name="db">数据库操作对象</param>
         /// <returns>目标站台</returns>
-        private string GetAgvStation(WCS_TaskInfo task, SqlSugarHelper db)
+        private string GetAgvStation(WCS_TaskInfo task, SqlSugarProvider db)
         {
             // 默认站台
             var defaultStation = "2701";
@@ -570,7 +567,7 @@ namespace WCS.WorkEngineering.Systems
                 sta = task.WarehouseCode.Contains("N") ? stationPair.N : stationPair.S;
 
             // 配置值获取
-            var num = db.Default.Queryable<fjSysConfig>()
+            var num = db.Queryable<fjSysConfig>()
                 .NoLock()
                 .First(x => x.Code == "SameSideTaskNum")?.SContent.ToInt() ?? 5;
 
@@ -592,21 +589,21 @@ namespace WCS.WorkEngineering.Systems
             }
 
             // 配置值获取
-            num = db.Default.Queryable<fjSysConfig>()
+            num = db.Queryable<fjSysConfig>()
                 .NoLock()
                 .First(x => x.Code == "TasksInSameWarehouse")?.SContent.ToInt() ?? 10;
 
             // 判断是否需要在三个分拣中心中选取任务数量较少的一侧进行分配
             currentTaskCount = GetStationTaskCount(db, sta);
             var otherSide = stationMap.First(x => x.Value.N == sta || x.Value.S == sta);
-            currentTaskCount += GetStationTaskCount(db, otherSide.Value.N==sta ? otherSide.Value.S : otherSide.Value.N);
+            currentTaskCount += GetStationTaskCount(db, otherSide.Value.N == sta ? otherSide.Value.S : otherSide.Value.N);
             if (currentTaskCount > num)
             {
-                sta = db.Default.Queryable<WCS_AgvTaskInfo>()
+                sta = db.Queryable<WCS_AgvTaskInfo>()
                     .NoLock()
                     .Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 &&
                                 v.TaskType == AGVTaskType.EnterDepot &&
-                                (v.Station != "2535" && v.Station != "2735" && v.Station != "2935"  && v.Station != "3135" && !v.Station.StartsWith("9")))
+                                (v.Station != "2535" && v.Station != "2735" && v.Station != "2935" && v.Station != "3135" && !v.Station.StartsWith("9")))
                     .SplitTable(v => v.Take(2))
                     .ToList()
                     .GroupBy(x => x.Station)
@@ -622,9 +619,9 @@ namespace WCS.WorkEngineering.Systems
         /// <summary>
         ///     获取指定站台的任务数量
         /// </summary>
-        private int GetStationTaskCount(SqlSugarHelper db, string station)
+        private int GetStationTaskCount(SqlSugarProvider db, string station)
         {
-            return db.Default.Queryable<WCS_AgvTaskInfo>()
+            return db.Queryable<WCS_AgvTaskInfo>()
                 .NoLock()
                 .Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 &&
                             v.TaskType == AGVTaskType.EnterDepot && v.Station == station)
@@ -635,7 +632,7 @@ namespace WCS.WorkEngineering.Systems
         /// <summary>
         ///     获取北侧和南侧的任务数量
         /// </summary>
-        private (int NorthCount, int SouthCount) GetNorthAndSouthTaskCounts(SqlSugarHelper db,
+        private (int NorthCount, int SouthCount) GetNorthAndSouthTaskCounts(SqlSugarProvider db,
             (string N, string S) stationPair)
         {
             var northCount = GetStationTaskCount(db, stationPair.N);
@@ -649,7 +646,7 @@ namespace WCS.WorkEngineering.Systems
         /// <param name="task"></param>
         /// <param name="db"></param>
         /// <returns></returns>
-        private string GetAgvStation1(WCS_TaskInfo task, SqlSugarHelper db)
+        private string GetAgvStation1(WCS_TaskInfo task, SqlSugarProvider db)
         {
             string sta = "";
             var n = 0;
@@ -670,9 +667,10 @@ namespace WCS.WorkEngineering.Systems
             }
 
             #region 判断是否需要在同一分拣库的两侧进行均分
+
             //获取配置值
             var num = 5;
-            var config = db.Default.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "SameSideTaskNum");
+            var config = db.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "SameSideTaskNum");
             if (config != null)
             {
                 num = config.SContent.ToInt();
@@ -690,36 +688,36 @@ namespace WCS.WorkEngineering.Systems
             };
 
             //获取当前侧的已有任务数量
-            var staNumber = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v =>
+            var staNumber = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v =>
                     v.Status >= AGVTaskStatus.Confirm &&
                     v.Status < AGVTaskStatus.Complete1 &&
                     v.TaskType == AGVTaskType.EnterDepot && v.Station == sta)
                 .SplitTable(v => v.Take(2)).Count();
             //当前侧任务数量已大于配置任务数量
-            if (staNumber > num) 
+            if (staNumber > num)
             {
                 //同侧之间均分
                 if (warehouseCode.Contains("1"))
                 {
-                    n = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station=="2501")
+                    n = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station == "2501")
                         .SplitTable(v => v.Take(2)).Count();
-                    s = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station=="2701")
+                    s = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station == "2701")
                         .SplitTable(v => v.Take(2)).Count();
                     sta = n > s ? "2701" : "2501";
                 }
                 else if (warehouseCode.Contains("2"))
                 {
-                    n = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station=="2901")
+                    n = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station == "2901")
                         .SplitTable(v => v.Take(2)).Count();
-                    s = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station=="3101")
+                    s = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station == "3101")
                         .SplitTable(v => v.Take(2)).Count();
                     sta = n > s ? "3101" : "2901";
                 }
                 else if (warehouseCode.Contains("3"))
                 {
-                    n = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station=="3301")
+                    n = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station == "3301")
                         .SplitTable(v => v.Take(2)).Count();
-                    s = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station=="3501")
+                    s = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot && v.Station == "3501")
                         .SplitTable(v => v.Take(2)).Count();
                     sta = n > s ? "3501" : "3301";
                 }
@@ -729,34 +727,33 @@ namespace WCS.WorkEngineering.Systems
                 }
             }
 
-            #endregion
+            #endregion 判断是否需要在同一分拣库的两侧进行均分
 
             #region 判断是否需要在三个分拣中心中选取任务数量较少的一侧进行分配
 
-            staNumber = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v =>
+            staNumber = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v =>
                     v.Status >= AGVTaskStatus.Confirm &&
                     v.Status < AGVTaskStatus.Complete1 &&
                     v.TaskType == AGVTaskType.EnterDepot && v.Station == sta)
                 .SplitTable(v => v.Take(2)).Count();
-            num = 10; 
-            config = db.Default.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "TasksInSameWarehouse");
+            num = 10;
+            config = db.Queryable<fjSysConfig>().NoLock().First(x => x.Code == "TasksInSameWarehouse");
             if (config != null)
             {
                 num = config.SContent.ToInt();
             }
             if (staNumber > num)
             {
-                sta = db.Default.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot
-                        && (v.Station != "2535" && v.Station != "2735" && v.Station != "2935"  && v.Station != "3135" && !v.Station.StartsWith("9")))//过滤掉人工满托入库和重绕区任务
+                sta = db.Queryable<WCS_AgvTaskInfo>().NoLock().Where(v => v.Status >= AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.Complete1 && v.TaskType == AGVTaskType.EnterDepot
+                        && (v.Station != "2535" && v.Station != "2735" && v.Station != "2935" && v.Station != "3135" && !v.Station.StartsWith("9")))//过滤掉人工满托入库和重绕区任务
                     .SplitTable(v => v.Take(2)).ToList().GroupBy(x => x.Station).Select(x => new { x.Key, Count = x.Count() }).MinBy(x => x.Count).Key;
             }
 
-            #endregion
+            #endregion 判断是否需要在三个分拣中心中选取任务数量较少的一侧进行分配
 
             return sta;
         }
 
-
         /// <summary>
         /// 获取AGV返空可用目标站台
         /// </summary>

YWGC/FJK/WCS.WorkEngineering/Systems/RGVSystems.cs

@@ -80,10 +80,8 @@ namespace WCS.WorkEngineering.Systems
                             }
                             World.Log($"任务处理:扫码结果-{bcrCode}");
                             var taskNumber = 0;
-                            SqlSugarHelper.Do(_db =>
+                            SqlSugarHelper.Do(db =>
                             {
-                                var db = _db.Default;
-
                                 //检查库存表是否有残留库存信息
                                 var inv = db.Queryable<BillInvnow>().OrderByDescending(x => x.AddTime).First(x => x.ContGrpBarCode == bcrCode);
                                 if (inv != null && inv.IsTorsChk)
@@ -112,14 +110,18 @@ namespace WCS.WorkEngineering.Systems
                                                 task.AddWCS_TASK_DTL(db, obj.Entity.Code, "", "取消任务");
                                             }
                                             break;
+
                                         case "InvEcecState_In":
                                             World.Log($"托盘条码{bcrCode}已有对应库存信息，请确认条码是否重复并更换！", LogLevelEnum.Mid);
                                             break;
+
                                         case "InvEcecState_OutGoing":
                                             World.Log($"【{obj.Entity.Code}】上的托盘 【{bcrCode}】存在出库中库存信息,请检查对应托盘条码是否存在未完成的出库任务！！！！！", LogLevelEnum.High);
                                             break;
                                     }
-#region 1
+
+                                    #region 1
+
                                     //删除库存
                                     //var invNow = db.Queryable<BillInvnow>().Where(x => x.ContGrpBarCode == bcrCode).OrderByDescending(x => x.AddTime).First();
                                     //if (invNow.IsTorsChk) //是一楼码垛入库
@@ -144,11 +146,12 @@ namespace WCS.WorkEngineering.Systems
                                     //        db.Updateable(task).ExecuteCommand();
                                     //        task.AddWCS_TASK_DTL(db, obj.Entity.Code, "", "取消任务");
                                     //    }
-                                    //}                                
+                                    //}
                                     //return;
-#endregion
+
+                                    #endregion 1
                                 }
-                                else if(inv != null)
+                                else if (inv != null)
                                 {
                                     World.Log($"【{obj.Entity.Code}】上的托盘 【{bcrCode}】存在对应库存信息,请检查确认！！！", LogLevelEnum.High);
                                     return;
@@ -244,9 +247,8 @@ namespace WCS.WorkEngineering.Systems
                                 isPalletizing = destPosition!.HasFlag(DeviceFlags.桁架码垛位, DeviceFlags.环形库码垛工位);
                                 short countQty = 0;
                                 short shortCode = 0;
-                                SqlSugarHelper.Do(_db =>
+                                SqlSugarHelper.Do(db =>
                                 {
-                                    var db = _db.Default;
                                     if (isPalletizing)
                                     {
                                         if (destPosition.HasFlag(DeviceFlags.桁架码垛位))
@@ -430,9 +432,8 @@ namespace WCS.WorkEngineering.Systems
                     //非拆盘机起始任务
                     //站台中的任务号
                     WCS_TaskInfo task = null;
-                    SqlSugarHelper.Do(_db =>
+                    SqlSugarHelper.Do(db =>
                     {
-                        var db = _db.Default;
                         var taskInfo = db.Queryable<WCS_TaskInfo>().First(p => p.ID == dev.Data.TaskNumber && p.Status == TaskStatus.ConveyorExecution);
                         if (taskInfo == null)
                         {

YWGC/FJK/WCS.WorkEngineering/Systems/SrmSystems.cs

@@ -74,7 +74,7 @@ namespace WCS.WorkEngineering.Systems
                     #region 获取完成任务
 
                     //根据DB521任务号获取对应任务
-                    var task = db.Default.Queryable<WCS_TaskInfo>().First(v => v.ID == obj.Data2.TaskFinishiId) ?? throw new KnownException($"堆垛机完成任务号{obj.Data2.TaskFinishiId},在WCS当前任务信息中未找到对应任务。", LogLevelEnum.High);
+                    var task = db.Queryable<WCS_TaskInfo>().First(v => v.ID == obj.Data2.TaskFinishiId) ?? throw new KnownException($"堆垛机完成任务号{obj.Data2.TaskFinishiId},在WCS当前任务信息中未找到对应任务。", LogLevelEnum.High);
                     if (task.Status != Entity.TaskStatus.StackerExecution) throw new KnownException($"任务{task.ID}状态是{task.Status.GetDescription()}.堆垛机完成任务需要对应任务状态处于堆垛机执行中", LogLevelEnum.High);
 
                     #endregion 获取完成任务
@@ -86,8 +86,8 @@ namespace WCS.WorkEngineering.Systems
                             //完成任务
                             task.Status = Entity.TaskStatus.Finish;
                             task.EndTime = DateTime.Now;
-                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                            task.AddWCS_TASK_DTL(db.Default, task.AddrTo, "入库任务结束");
+                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                            task.AddWCS_TASK_DTL(db, task.AddrTo, "入库任务结束");
                             break;
 
                         case TaskType.OutDepot:
@@ -95,8 +95,8 @@ namespace WCS.WorkEngineering.Systems
                             if (devs.Contains(task.SrmStation))
                             {
                                 task.Status = Entity.TaskStatus.StackerCompleted;
-                                db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
-                                task.AddWCS_TASK_DTL(db.Default, task.SrmStation, "出库任务到达放货站台");
+                                db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
+                                task.AddWCS_TASK_DTL(db, task.SrmStation, "出库任务到达放货站台");
                             }
                             else
                             {
@@ -108,16 +108,16 @@ namespace WCS.WorkEngineering.Systems
                                         {
                                             task.Status = Entity.TaskStatus.Finish;
                                             var dev = new Station(Device.All.FirstOrDefault(v => v.Code == task.SrmStation) ?? throw new KnownException($"未找到{task.SrmStation}信息", LogLevelEnum.High), this.World);
-                                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
-                                            task.AddWCS_TASK_DTL(db.Default, task.SrmStation, "出库任务到达放货站台");
+                                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
+                                            task.AddWCS_TASK_DTL(db, task.SrmStation, "出库任务到达放货站台");
                                         }
                                         else
                                         {
                                             task.Status = Entity.TaskStatus.StackerCompleted;
                                             var dev = new Station(Device.All.FirstOrDefault(v => v.Code == task.SrmStation) ?? throw new KnownException($"未找到{task.SrmStation}信息", LogLevelEnum.High), this.World);
                                             dev.Data.TaskNumber = task.ID;
-                                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
-                                            task.AddWCS_TASK_DTL(db.Default, task.SrmStation, "出库任务到达放货站台");
+                                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
+                                            task.AddWCS_TASK_DTL(db, task.SrmStation, "出库任务到达放货站台");
                                         }
 
                                         break;
@@ -125,8 +125,8 @@ namespace WCS.WorkEngineering.Systems
                                     case OutTypeEnum.半自动手动出库任务:
                                         task.Status = Entity.TaskStatus.Finish;
                                         task.EditTime = DateTime.Now;
-                                        db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, task.SrmStation, "半自动手动出库任务结束");
+                                        db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, task.SrmStation, "半自动手动出库任务结束");
                                         break;
                                 }
                             }
@@ -136,15 +136,15 @@ namespace WCS.WorkEngineering.Systems
                         case TaskType.TransferDepot:
                             task.Status = Entity.TaskStatus.Finish;
                             task.EndTime = DateTime.Now;
-                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                            task.AddWCS_TASK_DTL(db.Default, task.AddrTo, "移库任务结束");
+                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                            task.AddWCS_TASK_DTL(db, task.AddrTo, "移库任务结束");
                             break;
 
                         case TaskType.EmptyInit:
                             task.Status = Entity.TaskStatus.Finish;
                             task.EndTime = DateTime.Now;
-                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                            task.AddWCS_TASK_DTL(db.Default, task.AddrTo, "空轮初始化任务结束");
+                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                            task.AddWCS_TASK_DTL(db, task.AddrTo, "空轮初始化任务结束");
                             break;
                     }
                     taskInfo = task;
@@ -190,7 +190,7 @@ namespace WCS.WorkEngineering.Systems
             SqlSugarHelper.Do(db =>
             {
                 //获取当前堆垛机的所有未完成任务
-                var tasks = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(v => v.Device == obj.Entity.Code && v.Status < Entity.TaskStatus.Finish);
+                var tasks = db.Queryable<WCS_TaskInfo>().NoLock().Where(v => v.Device == obj.Entity.Code && v.Status < Entity.TaskStatus.Finish);
                 //任务集合是否有处于堆垛机执行状态的任务
                 if (tasks.Any(v => v.Status == Entity.TaskStatus.StackerExecution)) throw new KnownException($"有任务处于堆垛机执行状态", LogLevelEnum.High);
 
@@ -217,14 +217,14 @@ namespace WCS.WorkEngineering.Systems
                 SqlSugarHelper.Do(db =>
                    {
                        //获取一条当前堆垛机优先级最高的新建移库任务
-                       var task = db.Default.Queryable<WCS_TaskInfo>().Where(v => v.Device == obj.Entity.Code && v.Type == TaskType.TransferDepot && v.Status == Entity.TaskStatus.NewBuild)
+                       var task = db.Queryable<WCS_TaskInfo>().Where(v => v.Device == obj.Entity.Code && v.Type == TaskType.TransferDepot && v.Status == Entity.TaskStatus.NewBuild)
                                                                       .OrderByDescending(v => v.Priority)
                                                                       .First() ?? throw new KnownException("未找到移库任务", LogLevelEnum.High);
                        //任务状态改为堆垛机执行中
                        task.Status = Entity.TaskStatus.StackerExecution;
                        task.StartTime = DateTime.Now;
-                       db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.StartTime }).ExecuteCommand();
-                       task.AddWCS_TASK_DTL(db.Default, task.AddrFrom, task.Device, $"堆垛机{obj.Entity.Code}开始执行任务");
+                       db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.StartTime }).ExecuteCommand();
+                       task.AddWCS_TASK_DTL(db, task.AddrFrom, task.Device, $"堆垛机{obj.Entity.Code}开始执行任务");
                        taskInfo = task;
                    });
                 if (taskInfo == null) throw new KnownException("数据更新错误", LogLevelEnum.High);
@@ -289,7 +289,7 @@ namespace WCS.WorkEngineering.Systems
                 SqlSugarHelper.Do(db =>
                 {
                     //根据有货设备的任务号获取所有类型为入库状态为输送机执行中的任务
-                    var tasks = db.Default.Queryable<WCS_TaskInfo>().Where(v => (v.Status == TaskStatus.ConveyorExecution || v.Status == TaskStatus.RgvExecution || v.Status == TaskStatus.RgvCompleted)
+                    var tasks = db.Queryable<WCS_TaskInfo>().Where(v => (v.Status == TaskStatus.ConveyorExecution || v.Status == TaskStatus.RgvExecution || v.Status == TaskStatus.RgvCompleted)
                                                                                   && (arrIn.Select(p => p.Data.TaskNumber).Contains(v.ID) || arrIn.Select(p => p.Data2.TaskNumber).Contains(v.ID))
                                                                                   && (v.Type == TaskType.EnterDepot || v.Type == TaskType.EmptyInit)).ToList();
                     if (!tasks.Any()) throw new KnownException("无可用任务", LogLevelEnum.Mid);
@@ -312,8 +312,8 @@ namespace WCS.WorkEngineering.Systems
                     task.LastInteractionPoint = station.Entity.Code;
                     task.EditWho = "WCS";
                     task.EditTime = DateTime.Now;
-                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AddrTo, x.LastInteractionPoint, x.EditWho, x.EditTime }).ExecuteCommand();
-                    task.AddWCS_TASK_DTL(db.Default, station.Entity.Code, task.AddrTo, "任务下发堆垛机执行");
+                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AddrTo, x.LastInteractionPoint, x.EditWho, x.EditTime }).ExecuteCommand();
+                    task.AddWCS_TASK_DTL(db, station.Entity.Code, task.AddrTo, "任务下发堆垛机执行");
 
                     taskInfo = task;
                 });
@@ -377,7 +377,7 @@ namespace WCS.WorkEngineering.Systems
                    var allOutCode = arrOut.Select(v => v.Entity.Code).ToList();
 
                    //按条件先后排序获取一条排序后第一条结果1.优先级2.所在楼层与本次优先执行楼层
-                   var task = db.Default.Queryable<WCS_TaskInfo>().RowLock().Where(v => v.Status == TaskStatus.WaitingToExecute && allOutCode.Contains(v.SrmStation) && v.Type == TaskType.OutDepot).ToList()
+                   var task = db.Queryable<WCS_TaskInfo>().RowLock().Where(v => v.Status == TaskStatus.WaitingToExecute && allOutCode.Contains(v.SrmStation) && v.Type == TaskType.OutDepot).ToList()
                                                                   .OrderByDescending(v => v.Priority)
                                                                   .ThenByDescending(v => v.Floor == floor ? 1 : 0)
                                                                   .ThenBy(v => v.AddTime)
@@ -385,8 +385,8 @@ namespace WCS.WorkEngineering.Systems
                    task.Status = TaskStatus.StackerExecution;
                    task.LastInteractionPoint = task.Device;
                    task.EditWho = "WCS";
-                   db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.LastInteractionPoint, x.EditWho }).ExecuteCommand();
-                   task.AddWCS_TASK_DTL(db.Default, task.Device, task.SrmStation, "任务下发堆垛机执行");
+                   db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.LastInteractionPoint, x.EditWho }).ExecuteCommand();
+                   task.AddWCS_TASK_DTL(db, task.Device, task.SrmStation, "任务下发堆垛机执行");
                    taskInfo = task;
                });
 

YWGC/FJK/WCS.WorkEngineering/Systems/UpLoadSystems.cs

@@ -1,7 +1,6 @@
-using System.ComponentModel;
-using System.Threading.Tasks;
-using ServiceCenter.Extensions;
+using ServiceCenter.Extensions;
 using ServiceCenter.SqlSugars;
+using System.ComponentModel;
 using WCS.Core;
 using WCS.Entity;
 using WCS.Entity.Protocol.Station;
@@ -24,13 +23,12 @@ public class UpLoadSystems : DeviceSystem<Device<IStation520>>
 
     public override void Do(Device<IStation520> obj)
     {
-        //更新出库放货完成状态
-        SqlSugarHelper.Do(_db =>
+        //更新出库放货完成状态_
+        SqlSugarHelper.Do(db =>
         {
             var taskIdList = new List<WCS_TaskInfo>();
             var nowTime = DateTime.Now;
 
-            var db = _db.Default;
             var taskList = db.Queryable<WCS_TaskInfo>().UpdLock().Where(x => x.Uploaded != TaskStatus.ConveyorExecution && x.Status == TaskStatus.StackerCompleted && x.Type == TaskType.OutDepot).ToList();
 
             var isEnd = false;
@@ -50,7 +48,6 @@ public class UpLoadSystems : DeviceSystem<Device<IStation520>>
                 {
                     World.Log($"出库任务完成同步:出库放货完成状态同步失败:{task.ID}[{res.ResMsg}]");
                 }
-                
             }
 
             //拆分防止锁表
@@ -65,26 +62,25 @@ public class UpLoadSystems : DeviceSystem<Device<IStation520>>
         });
 
         //环形库组盘任务/立库入库任务/二楼立库出库//芯股叫料 更新完成
-        SqlSugarHelper.Do(_db =>
+        SqlSugarHelper.Do(db =>
         {
             var taskIdList = new List<WCS_TaskOld>();
             var nowTime = DateTime.Now;
-            var db = _db.Default;
             var taskList = db.Queryable<WCS_TaskOld>().NoLock()
                 .Where(x => ((x.Type == TaskType.SetPlate && x.WarehouseCode.Contains("R"))
                             || ((x.Type == TaskType.EnterDepot || x.Type == TaskType.OutDepot) && !x.WarehouseCode.Contains("R"))
-                            || (x.Type == TaskType.EnterDepot && x.WarehouseCode.Contains("CRZP"))   
+                            || (x.Type == TaskType.EnterDepot && x.WarehouseCode.Contains("CRZP"))
                             || (x.Type == TaskType.OutDepot && x.Device == "CR")
                             || (x.Type == TaskType.OutDepot && x.AddrFrom.Contains("NSTJ") && x.AddrTo.Contains("NSTJ")))
                            && x.Status == TaskStatus.Finish && x.Uploaded != TaskStatus.Finish)
                 .SplitTable(x => x.Take(2)).ToList();
 
             var isEnd = false;
-            foreach (var taskId in taskList.Select(x=>x.Id))
+            foreach (var taskId in taskList.Select(x => x.Id))
             {
                 if (isEnd) continue;
-                var task=db.Queryable<WCS_TaskOld>().UpdLock().Where(x => x.Id == taskId).SplitTable(x=>x.Take(2)).First();
-                if (task==null)
+                var task = db.Queryable<WCS_TaskOld>().UpdLock().Where(x => x.Id == taskId).SplitTable(x => x.Take(2)).First();
+                if (task == null)
                 {
                     World.Log($"入库任务完成同步:没有找到对应的任务:[{taskId}]");
                     continue;
@@ -104,7 +100,6 @@ public class UpLoadSystems : DeviceSystem<Device<IStation520>>
                 {
                     World.Log($"入库任务完成同步:入库完成状态同步失败:{taskId}[{res.ResMsg}]");
                 }
-               
             }
 
             //拆分防止锁表

YWGC/FJK/WCS.WorkEngineering/Systems/一楼叠盘机入库.cs

@@ -23,8 +23,6 @@ namespace WCS.WorkEngineering.Systems
     {
         protected override bool ParallelDo => true;
 
-        
-
         public override void Do(Device<IStation520, IStation521, IStation523> obj)
         {
             obj.入库站点是否被禁止();
@@ -81,9 +79,8 @@ namespace WCS.WorkEngineering.Systems
                 //    barcode = "TPA";
                 //}
 
-                SqlSugarHelper.Do(_db =>
+                SqlSugarHelper.Do(db =>
                 {
-                    var db = _db.Default;
                     var isTask = db.Queryable<WCS_TaskInfo>().NoLock().Any(v => v.BarCode.Contains(barcode) && v.AddrFrom == obj.Entity.Code && v.Type == TaskType.EnterDepot);
                     //验证是否有对应的任务
                     if (!isTask)
@@ -157,4 +154,4 @@ namespace WCS.WorkEngineering.Systems
             return dev.HasFlag(Extensions.DeviceFlags.一楼叠盘机);
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Systems/一楼扫码入库.cs

@@ -90,10 +90,8 @@ namespace WCS.WorkEngineering.Systems
                     World.Log($"扫码异常{barcode}，请检查扫码器", LogLevelEnum.Mid);
                     return;
                 }
-                SqlSugarHelper.Do(_db =>
+                SqlSugarHelper.Do(db =>
                 {
-                    var db = _db.Default;
-
                     //var barcode = "TAP00001";
                     //验证是否有对应的任务
 

YWGC/FJK/WCS.WorkEngineering/Systems/二楼拆盘机自动补空托盘组.cs

@@ -22,8 +22,6 @@ namespace WCS.WorkEngineering.Systems
     {
         protected override bool ParallelDo => true;
 
-        
-
         public override void Do(Device<IStation520, IStation521, IStation523> obj)
         {
             // 拆盘机没有光电
@@ -36,10 +34,8 @@ namespace WCS.WorkEngineering.Systems
                 World.Log($"{obj.Entity.Code}找不到对应放货点");
                 return;
             }
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
-
                 //验证是否有对应的任务
                 if (db.Queryable<WCS_TaskInfo>().NoLock().Any(v => v.AddrTo == obj.Entity.Code && v.Status < Entity.TaskStatus.Finish)) return;
                 var res = WmsApi.ApplyEmptyPalletGroupOutStorage(obj.Entity.Code, tunnel.Code.GetLastDigit(), obj.Entity.HasFlag(DeviceFlags.拆盘机) ? PalletType.Pallet09 : PalletType.PalletNo09);
@@ -53,4 +49,4 @@ namespace WCS.WorkEngineering.Systems
             return dev.HasFlag(DeviceFlags.拆盘机);
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Systems/分拣主线/满轮主线预写入目标地址.cs

@@ -54,9 +54,8 @@ namespace WCS.WorkEngineering.Systems
                 {
                     WCS_TaskInfo taskInfo = null;
                     fjSysConfig config = new fjSysConfig();
-                    SqlSugarHelper.Do(_db =>
+                    SqlSugarHelper.Do(db =>
                     {
-                        var db = _db.Default;
                         var task = db.Queryable<WCS_TaskInfo>().NoLock().First(x => x.BarCode == bcrCode && x.Status == TaskStatus.NewBuild);
                         if (task == null)
                         {

YWGC/FJK/WCS.WorkEngineering/Systems/分拣支线/桁架分流点.cs

@@ -55,9 +55,8 @@ namespace WCS.WorkEngineering.Systems.分拣支线
             }
 
             WCS_TaskInfo taskInfo = null;
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var task =
                     db.Queryable<WCS_TaskInfo>()
                         .First(v => v.ID == obj.Data2.TaskNumber && v.Status < TaskStatus.FinishOfShunt) ??
@@ -89,7 +88,7 @@ namespace WCS.WorkEngineering.Systems.分拣支线
         /// <param name="taskInfo"></param>
         /// <param name="obj"></param>
         /// <returns></returns>
-        public bool Allot(SqlSugarScopeProvider db, WCS_TaskInfo taskInfo,
+        public bool Allot(SqlSugarProvider db, WCS_TaskInfo taskInfo,
             Device<IStation520, IStation521, IStation523> obj)
         {
             var nowTime = DateTime.Now;

YWGC/FJK/WCS.WorkEngineering/Systems/分拣支线/环形库分流点.cs

@@ -58,10 +58,8 @@ namespace WCS.WorkEngineering.Systems
             if (nextAdd == 9999) return;
             var goodsType = obj.Data4.Length.ToInt();
             int taskId = 0;
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
-
                 WCS_TaskInfo? taskInfo = null;
 
                 #region 处理异常任务
@@ -303,14 +301,14 @@ namespace WCS.WorkEngineering.Systems
                         }
 
                         #region 判断是否存在未结束码垛信息
-                        
+
                         var maDuoXinXiList = db.Queryable<BillRingPalletizingInfo>().Where(x => maDuoZhanTaiList.Contains(x.MaDuoGongWei) && x.Out == false).ToList();
                         if (!maDuoXinXiList.Any(x => x.BomCode == taskInfo.MatCode && x.HaveQty < x.HWCountQty)) //没有未结束的当前规格的码垛信息
                         {
                             //按照站台进行分组，找到一个没有分配过码垛任务的站台，或者是一个码垛任务数量较少的站台
                             var maDuoZhanTaiGroup = maDuoXinXiList.GroupBy(x => x.MaDuoGongWei).ToList();
                             var maDuoZhanTai = "";
-                            
+
                             if (maDuoZhanTaiGroup.Count == 1)
                             {
                                 //获取没有用到的码垛站台信息
@@ -318,11 +316,10 @@ namespace WCS.WorkEngineering.Systems
                             }
                             else if (maDuoZhanTaiGroup.Count == 0)
                             {
-                                
                                 maDuoZhanTai = maDuoZhanTaiList.FirstOrDefault();
                             }
                             else
-                            {                               
+                            {
                                 maDuoZhanTai = maDuoZhanTaiGroup.Select(x => new { x.Key, x.First().AddTime, Count = x.Count() })
                                .OrderBy(x => x.Count).ThenBy(x => x.AddTime).First().Key;
                             }
@@ -500,7 +497,7 @@ namespace WCS.WorkEngineering.Systems
         /// <summary>
         ///  编辑流向
         /// </summary>
-        public void EditFlow(WCS_TaskInfo task, string warehouseCode, SqlSugarScopeProvider db, string locCode)
+        public void EditFlow(WCS_TaskInfo task, string warehouseCode, SqlSugarProvider db, string locCode)
         {
             WmsApi.EditorialFlow(new FjEditorialFlowRequest() { TaskId = task.ID, LocCode = locCode, WareCode = warehouseCode });
             task.WarehouseCode = warehouseCode;
@@ -542,7 +539,7 @@ namespace WCS.WorkEngineering.Systems
         /// <param name="devTaskNumber">设备中的任务号</param>
         /// <param name="goodsType">产品类型,即外检结果</param>
         /// <returns></returns>
-        private bool HandleExceptionTask(SqlSugarScopeProvider db, WCS_TaskInfo? taskInfo, string addrFrom, int devTaskNumber, int goodsType)
+        private bool HandleExceptionTask(SqlSugarProvider db, WCS_TaskInfo? taskInfo, string addrFrom, int devTaskNumber, int goodsType)
         {
             var type = goodsType.ToString();
             //找到一条起点是当前位置且状态小于2的任务
@@ -587,7 +584,7 @@ namespace WCS.WorkEngineering.Systems
         /// <param name="wareHouse">仓库信息</param>
         /// <param name="maDuoGongWei">码垛工位</param>
         /// <returns></returns>
-        private bool CreateStackingInfo(SqlSugarScopeProvider db, WCS_TaskInfo taskInfo, BaseWarehouse wareHouse, string maDuoGongWei)
+        private bool CreateStackingInfo(SqlSugarProvider db, WCS_TaskInfo taskInfo, BaseWarehouse wareHouse, string maDuoGongWei)
         {
             var bomsetGrp = db.Queryable<BillBomsetgrp>().NoLock().First(x => x.IsStop == 0 && x.BomCode.Contains(taskInfo.MatCode));
             if (bomsetGrp == null)
@@ -607,7 +604,7 @@ namespace WCS.WorkEngineering.Systems
             //跟据垛形信息生成
             var ringPalletizingInfo = new BillRingPalletizingInfo
             {
-                Id = IdFactory.NewId(),
+                Id = ServiceCenter.SqlSugars.IdFactory.NewId(),
                 WareHouseId = wareHouse.Id,
                 BomSetGrpId = bomsetGrp.Id,
                 HWCountQty = bomsetGrp.HWCountQty,

YWGC/FJK/WCS.WorkEngineering/Systems/机台叫料生成AGV任务.cs

@@ -46,9 +46,8 @@ namespace WCS.WorkEngineering.Systems
                 return;
             }
 
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var task = db.Queryable<WCS_TaskInfo>().ReadPastUpdLock().Single(x => x.Uploaded == TaskStatus.ConveyorExecution && x.Status == TaskStatus.ConveyorExecution && x.ID == obj.Data.TaskNumber
                                     && x.Type == TaskType.OutDepot);
                 if (task == null)
@@ -65,7 +64,7 @@ namespace WCS.WorkEngineering.Systems
                     //开始处理车间叫料AGV任务任务
                     db.InsertableRowLock(new WCS_AgvTaskInfo()
                     {
-                        ID = _db.GetAgvTaskId(),
+                        ID = db.GetAgvTaskId(),
                         TaskType = AGVTaskType.CallMaterial,
                         Status = AGVTaskStatus.NewBuild,
                         TaskId = task.ID,

YWGC/FJK/WCS.WorkEngineering/Systems/桁架码垛/二次码垛任务到RGV取货位处理.cs

@@ -31,9 +31,8 @@ namespace WCS.WorkEngineering.Systems.桁架码垛
             WCS_Palletizing palletizing = null;
             WCS_TaskInfo task = null;
 
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var soDev = obj.Entity.Sources.First();
                 var taskInfo = db.Queryable<WCS_TaskInfo>().Where(x => x.SrmStation == soDev.Code && x.Status == TaskStatus.StackerCompleted).OrderBy(x => x.EditTime).First();
                 if (taskInfo == null) return;
@@ -64,4 +63,4 @@ namespace WCS.WorkEngineering.Systems.桁架码垛
             return dev.Code is "1606" or "1616" or "1626" or "1636" or "1646" or "1656";
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Systems/桁架码垛/创建二次码垛出库任务.cs

@@ -17,13 +17,10 @@ namespace WCS.WorkEngineering.Systems.桁架码垛
     {
         protected override bool ParallelDo => true;
 
-        
-
         public override void Do(Device<IStation520> obj)
         {
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var palls = db.Queryable<WCS_Palletizing>().ReadPastUpdLock().Where(x => !x.Finish && x.isItHalf).ToList();
                 foreach (var pall in palls)
                 {
@@ -51,4 +48,4 @@ namespace WCS.WorkEngineering.Systems.桁架码垛
             return dev.Code == nameof(TrussCreateTwoOut);
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Systems/桁架码垛/桁架.cs

@@ -43,9 +43,8 @@ namespace WCS.WorkEngineering.Systems
             {
                 var isFinish = false;
                 var isEnd = false; //是否强制结盘
-                SqlSugarHelper.Do(_db =>
+                SqlSugarHelper.Do(db =>
                 {
-                    var db = _db.Default;
                     List<int> ids = new List<int>() { obj.Data2.PalletizingRowId1, obj.Data2.PalletizingRowId2 };
                     var palletizingRow = db.Queryable<WCS_PalletizingRow>().Includes(x => x.CacheLine, c => c.Locations)
                                                                                                 .Includes(x => x.Locs)
@@ -216,10 +215,8 @@ namespace WCS.WorkEngineering.Systems
 
             List<WCS_PalletizingRow> palletizingRowList = null;
             WCS_Palletizing palletizing = null;
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
-
                 #region 获取当前优先执行侧
 
                 try

YWGC/FJK/WCS.WorkEngineering/Systems/桁架码垛/桁架码垛工位任务结束处理.cs

@@ -34,9 +34,8 @@ namespace WCS.WorkEngineering.Systems
             }
             WCS_TaskInfo task = null;
             //找到对应的码垛数据
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var palletizing = db.Queryable<WCS_Palletizing>().Single(x => x.PalletizingStation == obj.Entity.Code && !x.Finish);
 
                 var TaskNoList = obj.Data5.GetTaskNoList().Where(x => x > 0).ToList();

YWGC/FJK/WCS.WorkEngineering/Systems/桁架码垛/桁架缓存放行点.cs

@@ -82,9 +82,8 @@ namespace WCS.WorkEngineering.Systems
 
             #region 计算当前缓存线是否已全部分配任务
 
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var cacheLine = db.Queryable<WCS_CacheLine>().Includes(x => x.Locations).Single(x => x.LocationNo == obj.Entity.Code.ToShort());
 
                 //是否所有的位已全部分配位置
@@ -108,9 +107,8 @@ namespace WCS.WorkEngineering.Systems
             WCS_TaskInfo task = null;
             short nextAdd = 0;
             int isSideNum = 0;
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 //先找到下一个地址对应的缓存信息
                 var lineCache = db.Queryable<WCS_CacheLine>().Includes(x => x.Locations).Single(x => x.InStock == true && x.LocationNo == nextCode && x.Locations.Any(s => s.TaskId == obj.Data2.TaskNumber));
                 if (lineCache == null)

YWGC/FJK/WCS.WorkEngineering/Systems/环形库/机械臂cs.cs

@@ -66,10 +66,10 @@ namespace WCS.WorkEngineering.Systems
                 SqlSugarHelper.Do(db =>
                 {
                     World.Log($"机械臂任务处理:开始--完成任务{obj.Data2.TaskFinishId1}--{obj.Data2.TaskFinishId2}", LogLevelEnum.Low);
-                    var isDP = obj.Entity.GetIsDirectPalletizing(db.Default);
+                    var isDP = obj.Entity.GetIsDirectPalletizing(db);
 
                     //根据DB521任务号获取对应任务
-                    var taskInfoList = db.Default.Queryable<WCS_TaskInfo>().Where(v => v.ID == obj.Data2.TaskFinishId1 || v.ID == obj.Data2.TaskFinishId2).ToList();
+                    var taskInfoList = db.Queryable<WCS_TaskInfo>().Where(v => v.ID == obj.Data2.TaskFinishId1 || v.ID == obj.Data2.TaskFinishId2).ToList();
                     foreach (var task in taskInfoList.Where(task => task.Status == Entity.TaskStatus.StackerExecution))
                     {
                         //根据任务类型做不同的处理
@@ -81,16 +81,16 @@ namespace WCS.WorkEngineering.Systems
                                     //完成任务
                                     task.Status = Entity.TaskStatus.ConveyorExecution;
                                     task.EndTime = DateTime.Now;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.AddrTo, "直接码垛任务完成码垛");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.AddrTo, "直接码垛任务完成码垛");
                                 }
                                 else
                                 {
                                     //完成任务
                                     task.Status = Entity.TaskStatus.Finish;
                                     task.EndTime = DateTime.Now;
-                                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                                    task.AddWCS_TASK_DTL(db.Default, task.AddrTo, "入库任务结束");
+                                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                                    task.AddWCS_TASK_DTL(db, task.AddrTo, "入库任务结束");
                                 }
                                 break;
 
@@ -99,16 +99,16 @@ namespace WCS.WorkEngineering.Systems
 
                                 task.Status = Entity.TaskStatus.StackerCompleted;
                                 task.EditTime = DateTime.Now;
-                                db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
-                                task.AddWCS_TASK_DTL(db.Default, task.AddrTo, "出库任务结束");
+                                db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EditTime }).ExecuteCommand();
+                                task.AddWCS_TASK_DTL(db, task.AddrTo, "出库任务结束");
 
                                 break;
 
                             case TaskType.TransferDepot:
                                 task.Status = Entity.TaskStatus.Finish;
                                 task.EndTime = DateTime.Now;
-                                db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
-                                task.AddWCS_TASK_DTL(db.Default, task.AddrTo, "移库任务结束");
+                                db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.EndTime }).ExecuteCommand();
+                                task.AddWCS_TASK_DTL(db, task.AddrTo, "移库任务结束");
                                 break;
                         }
                         tasks.Add(task);
@@ -150,11 +150,11 @@ namespace WCS.WorkEngineering.Systems
             var isDP = false; //当前机械臂是否直接码垛
             SqlSugarHelper.Do(db =>
             {
-                isDP = obj.Entity.GetIsDirectPalletizing(db.Default);
+                isDP = obj.Entity.GetIsDirectPalletizing(db);
                 var code = $"RobotMaxConsecutiveStorageCount{obj.Entity.Code.Last()}";
-                inMaxQuantity = db.Default.Queryable<fjSysConfig>().First(x => x.Code == code).SContent.ToInt();
+                inMaxQuantity = db.Queryable<fjSysConfig>().First(x => x.Code == code).SContent.ToInt();
                 //获取当前堆垛机的所有未完成任务 ,就算查到了未提交的事务也无所谓，无非下一个周期再执行一次
-                taskss = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(v => v.Status < Entity.TaskStatus.Finish && v.Device == obj.Entity.Code).ToList();
+                taskss = db.Queryable<WCS_TaskInfo>().NoLock().Where(v => v.Status < Entity.TaskStatus.Finish && v.Device == obj.Entity.Code).ToList();
                 //任务集合是否有处于堆垛机执行状态的任务
                 if (taskss.Any(v => v.Status == Entity.TaskStatus.StackerExecution)) throw new KnownException($"有任务处于堆垛机执行状态", LogLevelEnum.High);
             });
@@ -197,10 +197,10 @@ namespace WCS.WorkEngineering.Systems
                 {
                     foreach (var dev in devGroup)
                     {
-                        var task = db.Default.Queryable<WCS_TaskInfo>().First(v => v.Type == TaskType.SetPlate && v.Status == Entity.TaskStatus.FinishOfShunt && dev.Data2.TaskNumber == v.ID);
+                        var task = db.Queryable<WCS_TaskInfo>().First(v => v.Type == TaskType.SetPlate && v.Status == Entity.TaskStatus.FinishOfShunt && dev.Data2.TaskNumber == v.ID);
                         if (task == null) continue;
 
-                        if (db.Default.Queryable<WCS_TaskInfo>().Where(x => x.WmsTask == task.WmsTask && x.AddrTo == task.AddrTo && x.Status < TaskStatus.Finish).Count() > 1)
+                        if (db.Queryable<WCS_TaskInfo>().Where(x => x.WmsTask == task.WmsTask && x.AddrTo == task.AddrTo && x.Status < TaskStatus.Finish).Count() > 1)
                         {
                             throw new KnownException($"当前码垛编号与任务{task.ID}码垛编号重复，请联系工程师确认是否有误", LogLevelEnum.High);
                         }
@@ -209,8 +209,8 @@ namespace WCS.WorkEngineering.Systems
                         task.SrmStation = dev.Entity.Code;
                         task.Device = obj.Entity.Code;
                         task.EditWho = "WCS";
-                        db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AddrTo, x.Line, x.Col, x.Layer, x.Depth, x.LastInteractionPoint, x.SrmStation, x.Device, x.EditWho }).ExecuteCommand();
-                        task.AddWCS_TASK_DTL(db.Default, dev.Entity.Code, task.AddrTo, "任务下发机械臂执行");
+                        db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AddrTo, x.Line, x.Col, x.Layer, x.Depth, x.LastInteractionPoint, x.SrmStation, x.Device, x.EditWho }).ExecuteCommand();
+                        task.AddWCS_TASK_DTL(db, dev.Entity.Code, task.AddrTo, "任务下发机械臂执行");
                         taskList.Add(new(task, dev));
                     }
                 });
@@ -373,7 +373,7 @@ namespace WCS.WorkEngineering.Systems
                     {
                         foreach (var dev in devGroup)
                         {
-                            var task = db.Default.Queryable<WCS_TaskInfo>().First(v => v.Type == TaskType.SetPlate && v.Status == Entity.TaskStatus.FinishOfShunt && dev.Data2.TaskNumber == v.ID);
+                            var task = db.Queryable<WCS_TaskInfo>().First(v => v.Type == TaskType.SetPlate && v.Status == Entity.TaskStatus.FinishOfShunt && dev.Data2.TaskNumber == v.ID);
                             if (task == null) continue;
 
                             task.Status = Entity.TaskStatus.StackerExecution;
@@ -381,8 +381,8 @@ namespace WCS.WorkEngineering.Systems
                             task.SrmStation = dev.Entity.Code;
                             task.Device = obj.Entity.Code;
                             task.EditWho = "WCS";
-                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AddrTo, x.Line, x.Col, x.Layer, x.Depth, x.LastInteractionPoint, x.SrmStation, x.Device, x.EditWho }).ExecuteCommand();
-                            task.AddWCS_TASK_DTL(db.Default, dev.Entity.Code, task.AddrTo, "任务下发机械臂执行");
+                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.AddrTo, x.Line, x.Col, x.Layer, x.Depth, x.LastInteractionPoint, x.SrmStation, x.Device, x.EditWho }).ExecuteCommand();
+                            task.AddWCS_TASK_DTL(db, dev.Entity.Code, task.AddrTo, "任务下发机械臂执行");
                             taskList.Add(new(task, dev));
                         }
                     });
@@ -503,13 +503,13 @@ namespace WCS.WorkEngineering.Systems
                             v.Data4.Type
                         }).ToList();
                         //两个工位同时码垛，并不会一个执行一次，只有一个托盘任务全部执行完毕，才会继续执行下一个，先生成任务的码垛工位会优先执行
-                        var taskInfos = db.Default.Queryable<WCS_TaskInfo>().NoLock().Where(v =>
+                        var taskInfos = db.Queryable<WCS_TaskInfo>().NoLock().Where(v =>
                                 (v.Status == TaskStatus.WaitingToExecute || v.Status == TaskStatus.ConveyorExecution) &&
                                 v.Type == TaskType.OutDepot && v.Device == obj.Entity.Code)
                             .ToList().Where(v => allOutCode.Any(x => v.SrmStation == x.Code && v.PalletType == x.Type))
                             .ToList();
 
-                        var deliveryTask = db.Default.Queryable<WCS_TaskInfo>().Where(x => x.Status > 0 && x.Type == TaskType.Delivery).ToList().Select(x => x.AddrTo);
+                        var deliveryTask = db.Queryable<WCS_TaskInfo>().Where(x => x.Status > 0 && x.Type == TaskType.Delivery).ToList().Select(x => x.AddrTo);
                         taskInfos = taskInfos.Where(x => deliveryTask.Contains(x.SrmStation)).ToList();
                         if (!taskInfos.Any())
                         {
@@ -598,8 +598,8 @@ namespace WCS.WorkEngineering.Systems
                             task.StartTime = DateTime.Now;
                             task.EditWho = "WCS";
                             nextAdd = task.SrmStation;
-                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.LastInteractionPoint, x.StartTime, x.EditWho }).ExecuteCommand();
-                            task.AddWCS_TASK_DTL(db.Default, task.Device, task.SrmStation, "任务下发机械臂执行");
+                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.Status, x.LastInteractionPoint, x.StartTime, x.EditWho }).ExecuteCommand();
+                            task.AddWCS_TASK_DTL(db, task.Device, task.SrmStation, "任务下发机械臂执行");
                             taskInfoList.Add(task);
                         }
                     });

YWGC/FJK/WCS.WorkEngineering/Systems/环形库/环形库分配货位.cs

@@ -58,7 +58,7 @@ namespace WCS.WorkEngineering.Systems.环形库
             //开始获取货位号
             SqlSugarHelper.Do(db =>
             {
-                var task = db.Default.Queryable<WCS_TaskInfo>().First(v => obj.Data2.TaskNumber == v.ID);
+                var task = db.Queryable<WCS_TaskInfo>().First(v => obj.Data2.TaskNumber == v.ID);
                 if (task == null)
                 {
                     World.Log($"未找到任务[{obj.Data2.TaskNumber}]，请人工接入处理！！！！");
@@ -82,17 +82,17 @@ namespace WCS.WorkEngineering.Systems.环形库
                     World.Log($"未检索到对应的机械臂设备号", LogLevelEnum.High);
                     return;
                 }
-                if (robot.GetIsDirectPalletizing(db.Default))
+                if (robot.GetIsDirectPalletizing(db))
                 {
                     //获取对应的码垛信息
-                    var ringPalletizingInfo = db.Default.Queryable<BillRingPalletizingInfo>().Single(x => x.Id == task.TaskGroupKey.ToLong());
+                    var ringPalletizingInfo = db.Queryable<BillRingPalletizingInfo>().Single(x => x.Id == task.TaskGroupKey.ToLong());
                     // 获取对应码垛工位所有的码垛信息
-                    var ringPalletizingInfos = db.Default.Queryable<BillRingPalletizingInfo>().Where(x => x.MaDuoGongWei == ringPalletizingInfo.MaDuoGongWei && x.Out == false).ToList();
+                    var ringPalletizingInfos = db.Queryable<BillRingPalletizingInfo>().Where(x => x.MaDuoGongWei == ringPalletizingInfo.MaDuoGongWei && x.Out == false).ToList();
                     if (ringPalletizingInfos.Count > 1) //有多条需判断是否能进行放行
                     {
                         //获取所有此码垛工位所有已经分配的任务
                         var ringPalletizingMaDuoGongWeilList = ringPalletizingInfos.Select(x => x.Id.ToString()).ToList();
-                        var tasks = db.Default.Queryable<WCS_TaskInfo>().Where(x => ringPalletizingMaDuoGongWeilList.Contains(x.TaskGroupKey) && x.Status < TaskStatus.Finish && x.ProdLine == 1).ToList();
+                        var tasks = db.Queryable<WCS_TaskInfo>().Where(x => ringPalletizingMaDuoGongWeilList.Contains(x.TaskGroupKey) && x.Status < TaskStatus.Finish && x.ProdLine == 1).ToList();
                         //暂时不考虑同一个码垛工位，会有出现第一条信息还没被放行，第二条码垛信息就被创建的情况
                         if (tasks.GroupBy(x => x.TaskGroupKey).Count() != 1)
                         {
@@ -107,8 +107,8 @@ namespace WCS.WorkEngineering.Systems.环形库
                             task.Device = obj.Entity.Code;
                             task.ProdLine = 1; //标识放行
                             task.EditWho = "WCS";
-                            db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.AddrTo, x.LastInteractionPoint, x.ProdLine, x.Device, x.EditWho }).ExecuteCommand();
-                            task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, task.AddrTo, $"直接码垛放行{task.AddrTo}");
+                            db.UpdateableRowLock(task).UpdateColumns(x => new { x.AddrTo, x.LastInteractionPoint, x.ProdLine, x.Device, x.EditWho }).ExecuteCommand();
+                            task.AddWCS_TASK_DTL(db, obj.Entity.Code, task.AddrTo, $"直接码垛放行{task.AddrTo}");
                             //var invNow = db.Default.Queryable<BillInvnow>().NoLock().First(x => x.ContGrpBarCode == task.BarCode);
                             //默认信息
                             sideNum = 1;
@@ -127,8 +127,8 @@ namespace WCS.WorkEngineering.Systems.环形库
                         task.Device = obj.Entity.Code;
                         task.ProdLine = 1; //标识放行
                         task.EditWho = "WCS";
-                        db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.AddrTo, x.LastInteractionPoint, x.ProdLine, x.Device, x.EditWho }).ExecuteCommand();
-                        task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, task.AddrTo, $"直接码垛放行{task.AddrTo}");
+                        db.UpdateableRowLock(task).UpdateColumns(x => new { x.AddrTo, x.LastInteractionPoint, x.ProdLine, x.Device, x.EditWho }).ExecuteCommand();
+                        task.AddWCS_TASK_DTL(db, obj.Entity.Code, task.AddrTo, $"直接码垛放行{task.AddrTo}");
                         //var invNow = db.Default.Queryable<BillInvnow>().NoLock().First(x => x.ContGrpBarCode == task.BarCode);
                         //默认信息
                         sideNum = 1;
@@ -151,9 +151,9 @@ namespace WCS.WorkEngineering.Systems.环形库
                     task.LastInteractionPoint = obj.Entity.Code;
                     task.Device = obj.Entity.Code;
                     task.EditWho = "WCS";
-                    db.Default.UpdateableRowLock(task).UpdateColumns(x => new { x.AddrTo, x.Line, x.Col, x.Layer, x.Depth, x.LastInteractionPoint, x.Device, x.EditWho }).ExecuteCommand();
-                    task.AddWCS_TASK_DTL(db.Default, obj.Entity.Code, task.AddrTo, $"任务分配货位{task.AddrTo}");
-                    var invNow = db.Default.Queryable<BillInvnow>().NoLock().First(x => x.ContGrpBarCode == task.BarCode);
+                    db.UpdateableRowLock(task).UpdateColumns(x => new { x.AddrTo, x.Line, x.Col, x.Layer, x.Depth, x.LastInteractionPoint, x.Device, x.EditWho }).ExecuteCommand();
+                    task.AddWCS_TASK_DTL(db, obj.Entity.Code, task.AddrTo, $"任务分配货位{task.AddrTo}");
+                    var invNow = db.Queryable<BillInvnow>().NoLock().First(x => x.ContGrpBarCode == task.BarCode);
                     sideNum = invNow.SideNum;
                     taskInfo = task;
                 }

YWGC/FJK/WCS.WorkEngineering/Systems/环形库码垛结束.cs

@@ -30,9 +30,8 @@ namespace WCS.WorkEngineering.Systems
         public override void Do(Device<IStation520, IStation521, IStation523, IRobot530, IRobot531> obj)
         {
             var isForcedEnding = false;
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;             
                 var code = $"ForcedEndStation{obj.Entity.Code}";
                 var isForcedEnd = db.Queryable<fjSysConfig>().NoLock().First(x => x.Code == code);
                 if (isForcedEnd != null && isForcedEnd.SContent.ToShort() == 1)
@@ -44,17 +43,15 @@ namespace WCS.WorkEngineering.Systems
             if ((!obj.Data5.CmdType.HasFlag(RobotCmdType.End)) && obj.Data4.CmdType != 0) obj.Data4.CmdType = 0;
             if (!obj.Data3.Status.HasFlag(StationStatus.PH_Status)) return;
             if (!obj.Data5.CmdType.HasFlag(RobotCmdType.End) && !isForcedEnding) return;
-            if ((obj.Data5.MaxQuantity != obj.Data5.Quantity || obj.Data5.Quantity == 0 || obj.Data5.MaxQuantity == 0)&& !isForcedEnding) throw new KnownException($"码垛数量异常:最大码垛数量[{obj.Data5.MaxQuantity}]已码数量{obj.Data5.Quantity}", LogLevelEnum.High);
+            if ((obj.Data5.MaxQuantity != obj.Data5.Quantity || obj.Data5.Quantity == 0 || obj.Data5.MaxQuantity == 0) && !isForcedEnding) throw new KnownException($"码垛数量异常:最大码垛数量[{obj.Data5.MaxQuantity}]已码数量{obj.Data5.Quantity}", LogLevelEnum.High);
             WCS_TaskInfo task = null;
 
-            
             //找到对应的码垛数据
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var taskNoList = obj.Data5.GetTaskNoList().ToList();
                 var tasks = db.Queryable<WCS_TaskInfo>().RowLock().Where(x => taskNoList.Contains(x.ID) && x.Status == TaskStatus.ConveyorExecution).ToList();
-              
+
                 if (tasks.Count() > 0 && tasks.Count() != obj.Data5.MaxQuantity && !isForcedEnding)
                 {
                     World.Log($"任务数量{tasks.Count()}-最大码垛数量{obj.Data5.MaxQuantity}");
@@ -62,14 +59,14 @@ namespace WCS.WorkEngineering.Systems
                 }
 
                 //获取id值用于直接码垛判断
-                var taskGroup = tasks.First().Type == TaskType.SetPlate ? tasks.First().TaskGroupKey : "";                
+                var taskGroup = tasks.First().Type == TaskType.SetPlate ? tasks.First().TaskGroupKey : "";
                 var deliveryTask = db.Queryable<WCS_TaskInfo>().RowLock().Single(x => x.Type == TaskType.Delivery && x.AddrTo == obj.Entity.Code && x.Status >= TaskStatus.RgvExecution && x.Status < TaskStatus.Finish) ?? throw new KnownException($"未找到当前站台对应的托盘搬运任务", LogLevelEnum.High);
                 var taskInfo = db.Queryable<WCS_TaskInfo>().RowLock().Single(x => x.Status == TaskStatus.WaitingToExecute && x.AddrFrom == obj.Entity.Code && x.Type == TaskType.EnterDepot);
                 if (deliveryTask.Status != TaskStatus.RgvCompleted) throw new KnownException($"搬运任务状态异常:{deliveryTask.ID}", LogLevelEnum.High);
                 if (taskInfo == null)
                 {
                     var task = db.Queryable<WCS_TaskInfo>().NoLock().Single(x => x.Status <= TaskStatus.RgvExecution && x.AddrFrom == obj.Entity.Code && x.Type == TaskType.EnterDepot);
-                    
+
                     if (task != null)
                     {
                         World.Log($"环线库码垛工位[{obj.Entity.Code}]存在状态为[{task.Status.GetDescription()}]的任务，任务号是[{task.ID}].请找到此任务确认并进行处理");
@@ -85,7 +82,7 @@ namespace WCS.WorkEngineering.Systems
                         {
                             var ringPallet = db.Queryable<BillRingPalletizingInfo>().First(x => x.Id.ToString() == taskGroup && x.Out == false);
                             if (ringPallet != null)
-                            { 
+                            {
                                 ringPallet.Out = true;
                                 db.UpdateableRowLock(ringPallet).UpdateColumns(x => new { x.Out }).ExecuteCommand();
                             }
@@ -114,7 +111,7 @@ namespace WCS.WorkEngineering.Systems
                             //obj.Data.GoodsStart = obj.Entity.Code.ToShort();
                             //obj.Data.GoodsEnd = task.AddrNext.ToShort();
                             //obj.Data4.CmdType = RobotCmdType.End;
-                        }                                               
+                        }
                     }
                     catch (Exception e)
                     {
@@ -155,7 +152,7 @@ namespace WCS.WorkEngineering.Systems
                                 //obj.Data.GoodsStart = obj.Entity.Code.ToShort();
                                 //obj.Data.GoodsEnd = task.AddrNext.ToShort();
                                 //obj.Data4.CmdType = RobotCmdType.End;
-                            }                            
+                            }
                         }
                         catch (Exception exception)
                         {
@@ -192,7 +189,7 @@ namespace WCS.WorkEngineering.Systems
             obj.Data4.CmdType = RobotCmdType.End;
         }
 
-        public void UpdateScontent(SqlSugarScopeProvider db,string device)
+        public void UpdateScontent(SqlSugarProvider db, string device)
         {
             var code = $"ForcedEndStation{device}";
             var isForcedEnd = db.Queryable<fjSysConfig>().NoLock().First(x => x.Code == code);

YWGC/FJK/WCS.WorkEngineering/Systems/码垛区域生成空托盘任务.cs

@@ -32,9 +32,8 @@ namespace WCS.WorkEngineering.Systems
             {
                 objDev.Entity.SetFlag("LastIsTruss", 1);
                 WCS_Palletizing palletizing = null;
-                SqlSugarHelper.Do(_db =>
+                SqlSugarHelper.Do(db =>
                 {
-                    var db = _db.Default;
                     //取一个时间最靠前的,没有绑定码垛工位的码垛记录
                     var palletizingInfoList = db.Queryable<WCS_Palletizing>().Where(x => x.PalletizingStation == null && !x.Finish && !x.isItHalf).OrderBy(x => x.AddTime).ToList();
                     if (!palletizingInfoList.Any())
@@ -107,7 +106,7 @@ namespace WCS.WorkEngineering.Systems
                 objDev.Entity.SetFlag("LastIsTruss", 2);
                 SqlSugarHelper.Do(db =>
                 {
-                    var taskInfo = db.Default.Queryable<WCS_TaskInfo>().RowLock().Where(x => x.Status == TaskStatus.NewBuild && x.BusType == "芯股用空托盘入库").ToList();
+                    var taskInfo = db.Queryable<WCS_TaskInfo>().RowLock().Where(x => x.Status == TaskStatus.NewBuild && x.BusType == "芯股用空托盘入库").ToList();
                     var isEnd = false;
                     foreach (var info in taskInfo)
                     {
@@ -165,8 +164,8 @@ namespace WCS.WorkEngineering.Systems
                             info.AddrTo = "SRM";
                             info.Height = 1;
                             info.Status = TaskStatus.WaitingToExecute;
-                            db.Default.UpdateableRowLock(info).UpdateColumns(x => new { x.AddrFrom, x.Device, x.AddrNext, x.SrmStation, x.Status, x.AddrTo, x.Height }).ExecuteCommand();
-                            info.AddWCS_TASK_DTL(db.Default, info.Device, $"初始化芯股用空托盘入库任务信息");
+                            db.UpdateableRowLock(info).UpdateColumns(x => new { x.AddrFrom, x.Device, x.AddrNext, x.SrmStation, x.Status, x.AddrTo, x.Height }).ExecuteCommand();
+                            info.AddWCS_TASK_DTL(db, info.Device, $"初始化芯股用空托盘入库任务信息");
                             dev.Data.TaskNumber = info.ID;
                             dev.Data.GoodsEnd = info.AddrNext.ToShort();
                             isEnd = true;
@@ -190,9 +189,8 @@ namespace WCS.WorkEngineering.Systems
                     {
                         continue;
                     }
-                    SqlSugarHelper.Do(_db =>
+                    SqlSugarHelper.Do(db =>
                     {
-                        var db = _db.Default;
                         var isDP = GetIsDirectPalletizing(obj.Entity.Parent.Code, db);
                         KeyValuePair<short, short> ringPallet = new KeyValuePair<short, short>();
                         if (isDP) //直接码垛
@@ -287,7 +285,7 @@ namespace WCS.WorkEngineering.Systems
         /// <param name="devCode"></param>
         /// <param name="db"></param>
         /// <returns></returns>
-        public bool GetIsDirectPalletizing(string devCode, SqlSugarScopeProvider db)
+        public bool GetIsDirectPalletizing(string devCode, SqlSugarProvider db)
         {
             var code = $"{devCode}DirectPalletizing";
             var isDP = db.Queryable<fjSysConfig>().Single(x => x.Code == code);

YWGC/FJK/WCS.WorkEngineering/Systems/重绕区/叫料生成AGV任务.cs

@@ -1,13 +1,7 @@
-using Microsoft.OpenApi.Extensions;
-using ServiceCenter.Extensions;
+using ServiceCenter.Extensions;
 using ServiceCenter.Logs;
 using ServiceCenter.SqlSugars;
-using System;
-using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using WCS.Core;
 using WCS.Entity;
 using WCS.Entity.Protocol.Station;
@@ -38,10 +32,9 @@ namespace WCS.WorkEngineering.Systems.重绕区
                 World.Log($"设备无光电");
                 return;
             }
-                       
-            SqlSugarHelper.Do(_db =>
+
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var task = db.Queryable<WCS_TaskInfo>().ReadPastUpdLock().Single(x => x.Status == TaskStatus.WaitingToExecute && x.AddrFrom == obj.Entity.Code
                                     && x.Type == TaskType.OutDepot);
                 if (task == null)
@@ -58,7 +51,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
                     //开始处理叫料AGV任务任务
                     db.InsertableRowLock(new WCS_AgvTaskInfo()
                     {
-                        ID = _db.GetAgvTaskId(),
+                        ID = db.GetAgvTaskId(),
                         TaskType = AGVTaskType.CallMaterial,
                         Status = AGVTaskStatus.NewBuild,
                         TaskId = task.ID,
@@ -98,4 +91,4 @@ namespace WCS.WorkEngineering.Systems.重绕区
             return dev.HasFlag(DeviceFlags.重绕区叫料工位);
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Systems/重绕区/扫码入库.cs

@@ -2,12 +2,7 @@
 using ServiceCenter.Extensions;
 using ServiceCenter.Logs;
 using ServiceCenter.SqlSugars;
-using System;
-using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using WCS.Core;
 using WCS.Entity;
 using WCS.Entity.Protocol.BCR;
@@ -55,7 +50,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
             }
             SqlSugarHelper.Do(db =>
             {
-                WCS_TaskInfo task = null;              
+                WCS_TaskInfo task = null;
                 try
                 {
                     //获取托盘条码
@@ -70,12 +65,11 @@ namespace WCS.WorkEngineering.Systems.重绕区
                         World.Log($"扫码异常{barcode}，请检查扫码器", LogLevelEnum.Mid);
                         return;
                     }
-                    SqlSugarHelper.Do(_db =>
+                    SqlSugarHelper.Do(db =>
                     {
-                        var db = _db.Default;
                         //找到对应的任务
                         var taskInfo = db.Queryable<WCS_TaskInfo>().First(v => v.BarCode == barcode && v.Type == TaskType.EnterDepot && v.Status < Entity.TaskStatus.Finish);
-                        if (taskInfo == null) return; 
+                        if (taskInfo == null) return;
                         if (taskInfo.Status != Entity.TaskStatus.WaitingToExecute) return;
                         {
                             taskInfo.Status = Entity.TaskStatus.ConveyorExecution;
@@ -102,7 +96,6 @@ namespace WCS.WorkEngineering.Systems.重绕区
                     _ => 9999
                 };
                 obj.Data.VoucherNo++;
-
             });
         }
 
@@ -111,4 +104,4 @@ namespace WCS.WorkEngineering.Systems.重绕区
             return dev.Code is "9125";
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Systems/重绕区/组盘缓存生成AGV任务.cs

@@ -2,12 +2,7 @@
 using ServiceCenter.Extensions;
 using ServiceCenter.Logs;
 using ServiceCenter.SqlSugars;
-using System;
-using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using WCS.Core;
 using WCS.Entity;
 using WCS.Entity.Protocol.Station;
@@ -42,9 +37,8 @@ namespace WCS.WorkEngineering.Systems.重绕区
                 return;
             }
 
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
                 var task = db.Queryable<WCS_TaskInfo>().ReadPastUpdLock().Single(x => x.Status == TaskStatus.ConveyorExecution && x.ID == obj.Data2.TaskNumber);
                 if (task == null)
                 {
@@ -59,7 +53,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
                 {
                     db.InsertableRowLock(new WCS_AgvTaskInfo()
                     {
-                        ID = _db.GetAgvTaskId(),
+                        ID = db.GetAgvTaskId(),
                         TaskType = AGVTaskType.EnterDepot,
                         Status = AGVTaskStatus.NewBuild,
                         TaskId = task.ID,
@@ -92,7 +86,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
                     if (!dev.Data3.Status.HasFlag(StationStatus.PH_Status) && !db.Queryable<WCS_AgvTaskInfo>().RowLock().SplitTable(x => x.Take(2)).Any(x => x.Station == dev.Entity.Code && x.TaskType == AGVTaskType.EnterDepot
                     && x.Status < AGVTaskStatus.MissionCompleted))
                     {
-                        var res = WmsApi.GetFlatLocalIn(obj.Data2.TaskNumber,"T1",dev.Entity.Code,1);
+                        var res = WmsApi.GetFlatLocalIn(obj.Data2.TaskNumber, "T1", dev.Entity.Code, 1);
                         if (res.ResCode == ResponseStatusCodeEnum.Sucess && res.ResData.CellNo == dev.Entity.Code)
                         {
                             sta = dev.Entity.Code;
@@ -106,7 +100,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
                         {
                             continue;
                         }
-                        break;    
+                        break;
                         //sta = dev.Entity.Code;
                         //break;
                     }
@@ -123,7 +117,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
                 task.EditWho = "WCS";
                 task.AddrFrom = obj.Entity.Code;
                 task.AddrTo = agvTask.Station;
-                db.Updateable(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.EditTime, x.EditWho,x.AddrFrom, x.AddrTo }).ExecuteCommand();
+                db.Updateable(task).UpdateColumns(x => new { x.Status, x.AgvTaskID, x.EditTime, x.EditWho, x.AddrFrom, x.AddrTo }).ExecuteCommand();
                 task.AddWCS_TASK_DTL(db, obj.Entity.Code, "AGV", $"任务下发至AGV{agvId},目标缓存货位{agvTask.Station}");
                 AgvApi.组盘入库(obj.Entity.Code, agvTask.Station, agvId);
             });
@@ -134,4 +128,4 @@ namespace WCS.WorkEngineering.Systems.重绕区
             return dev.Code is "9126";
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/Systems/重绕区/退料搬运.cs

@@ -1,12 +1,6 @@
 using ServiceCenter.Extensions;
-using ServiceCenter.Logs;
 using ServiceCenter.SqlSugars;
-using System;
-using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using WCS.Core;
 using WCS.Entity;
 using WCS.Entity.Protocol.Station;
@@ -14,7 +8,6 @@ using WCS.WorkEngineering.Extensions;
 using WCS.WorkEngineering.WebApi.Controllers;
 using WCS.WorkEngineering.WebApi.Models.WMS.Response;
 using WCS.WorkEngineering.Worlds;
-using TaskStatus = WCS.Entity.TaskStatus;
 
 namespace WCS.WorkEngineering.Systems.重绕区
 {
@@ -26,17 +19,14 @@ namespace WCS.WorkEngineering.Systems.重绕区
 
         public override void Do(Device<IStation520, IStation521, IStation523> obj)
         {
-
             if (!obj.Data3.Status.HasFlag(StationStatus.PH_Status))
             {
                 World.Log($"设备无光电");
                 return;
             }
 
-            SqlSugarHelper.Do(_db =>
+            SqlSugarHelper.Do(db =>
             {
-                var db = _db.Default;
-
                 var ph_9001 = new Device<IStation523>(Device.All.First(x => x.Code == "9001"), World);
                 var ph_9101 = new Device<IStation523>(Device.All.First(x => x.Code == "9101"), World);
                 var flag1 = !db.Queryable<WCS_AgvTaskInfo>().Where(v => v.Status > AGVTaskStatus.Confirm && v.Status < AGVTaskStatus.MissionCompleted && v.TaskType == AGVTaskType.EnterDepot && v.Station == "9001")
@@ -68,7 +58,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
                         //开始处理叫料AGV任务任务
                         db.InsertableRowLock(new WCS_AgvTaskInfo()
                         {
-                            ID = _db.GetAgvTaskId(),
+                            ID = db.GetAgvTaskId(),
                             TaskType = AGVTaskType.EnterDepot,
                             Status = AGVTaskStatus.NewBuild,
                             TaskId = 9001,
@@ -78,7 +68,7 @@ namespace WCS.WorkEngineering.Systems.重绕区
                             AddWho = "WCS",
                             AddTime = DateTime.Now,
                             AgvID = agvId
-                        }).SplitTable().ExecuteCommand();                       
+                        }).SplitTable().ExecuteCommand();
                     }
                 }
             });
@@ -89,4 +79,4 @@ namespace WCS.WorkEngineering.Systems.重绕区
             return dev.Code is "9210" or "9211" or "9212" or "9213" or "9214";
         }
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/WebApi/Controllers/WcsController.cs

@@ -1,15 +1,12 @@
 using Microsoft.AspNetCore.Mvc;
-using Newtonsoft.Json;
 using PlcSiemens.Core.Extension;
 using ServiceCenter;
 using ServiceCenter.Extensions;
-using ServiceCenter.Redis;
 using ServiceCenter.SqlSugars;
 using System.Net.NetworkInformation;
 using System.Text;
 using WCS.Core;
 using WCS.Entity;
-using WCS.Entity.Protocol.DataStructure;
 using WCS.Entity.Protocol.SRM;
 using WCS.WorkEngineering.Extensions;
 using WCS.WorkEngineering.Systems;
@@ -83,7 +80,7 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                     {
                         foreach (var item in req.TaskIds)
                         {
-                            var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item && t.Status < Entity.TaskStatus.Finish).First();
+                            var task = db.Queryable<WCS_TaskInfo>().Where(t => t.ID == item && t.Status < Entity.TaskStatus.Finish).First();
                             if (task != null)
                             {
                                 //验证wms是否能取消
@@ -91,9 +88,9 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                 //if (res == null) continue;
 
                                 switch (task.Type)
-                                {                                   
+                                {
                                     case TaskType.EnterDepot:
-                                        if (task.Status > Entity.TaskStatus.WaitingToExecute  || (task.BusType != "皮盘入库" && task.BusType != "重绕满托入库"))
+                                        if (task.Status > Entity.TaskStatus.WaitingToExecute || (task.BusType != "皮盘入库" && task.BusType != "重绕满托入库"))
                                         {
                                             response.ResDataList.Add(new HandleTaskResponse()
                                             {
@@ -117,12 +114,12 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                             continue;
                                         }
 
-                                        break;                                                                      
+                                        break;
 
                                     default:
                                         throw new ArgumentOutOfRangeException();
                                 }
-                                
+
                                 var cancelRes = WmsApi.CancelTask(item);
                                 if (cancelRes.ResCode != ResponseStatusCodeEnum.Sucess)
                                 {
@@ -133,10 +130,10 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                         Message = cancelRes.ResMsg,
                                     });
                                     continue;
-                                } 
+                                }
 
                                 //找到对应的AGV任务
-                                var agv = db.Default.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
+                                var agv = db.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
                                 if (agv != null)
                                 {
                                     if (!agv.AgvID.IsNullOrEmpty())
@@ -146,15 +143,15 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                     }
                                     agv.Status = AGVTaskStatus.Cancel;
                                     agv.AgvStatus = AGVTaskStatus.Cancel;
-                                    db.Default.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                    db.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                 }
                                 //更新任务状态
                                 task.Status = Entity.TaskStatus.Cancel;
                                 task.EndTime = DateTime.Now;
                                 task.EditWho = req.User;
                                 task.ManualRemarks = req.ManualRemarks;
-                                db.Default.Updateable(task).UpdateColumns(x => new { x.Status, x.EndTime, x.EditTime, x.ManualRemarks }).ExecuteCommand();
-                                task.AddWCS_TASK_DTL(db.Default, "未知", "任务取消");
+                                db.Updateable(task).UpdateColumns(x => new { x.Status, x.EndTime, x.EditTime, x.ManualRemarks }).ExecuteCommand();
+                                task.AddWCS_TASK_DTL(db, "未知", "任务取消");
                             }
                             else
                             {
@@ -174,7 +171,7 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                     {
                         foreach (var item in req.TaskIds)
                         {
-                            var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
+                            var task = db.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                             if (task == null) continue;
                             if (task.BusType != "车间叫料" && task.BusType != "芯股站台送空托")
                             {
@@ -187,7 +184,7 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                 continue;
                             }
 
-                            if (!db.Default.Queryable<WCS_TaskDtl>().SplitTable(v => v.Take(2)).Any(v => v.ParentTaskCode == task.ID && v.Desc.Contains("允许AGV任务")))
+                            if (!db.Queryable<WCS_TaskDtl>().SplitTable(v => v.Take(2)).Any(v => v.ParentTaskCode == task.ID && v.Desc.Contains("允许AGV任务")))
                             {
                                 response.ResDataList.Add(new HandleTaskResponse()
                                 {
@@ -248,7 +245,8 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                                                 Message = $"不能完成堆垛机执行任务",
                                                             });
                                                             continue;
-                                                    };
+                                                    }
+                                                    ;
                                                 }
                                                 break;
 
@@ -275,7 +273,7 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                         //if (cancelRes == null) continue;
 
                                         //找到对应的AGV任务
-                                        var agv = db.Default.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
+                                        var agv = db.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
                                         if (agv != null)
                                         {
                                             //if (!agv.AgvID.IsNullOrEmpty())
@@ -285,15 +283,15 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                             //}
                                             agv.Status = AGVTaskStatus.MissionCompleted;
                                             agv.AgvStatus = AGVTaskStatus.MissionCompleted;
-                                            db.Default.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                            db.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                         }
                                         //更新任务状态
                                         task.Status = Entity.TaskStatus.Finish;
                                         task.EndTime = DateTime.Now;
                                         task.EditWho = req.User;
                                         task.ManualRemarks = req.ManualRemarks;
-                                        db.Default.Updateable(task).UpdateColumns(x => new { x.Status, x.EndTime, x.EditWho, x.ManualRemarks }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, "未知", "任务完成");
+                                        db.Updateable(task).UpdateColumns(x => new { x.Status, x.EndTime, x.EditWho, x.ManualRemarks }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, "未知", "任务完成");
                                         break;
                                     }
                                 case TaskType.EnterDepot:
@@ -345,11 +343,11 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                                 throw new ArgumentOutOfRangeException();
                                         }
 
-                                        //var cancelRes = WmsApi.CancelTask(item);                                      
+                                        //var cancelRes = WmsApi.CancelTask(item);
                                         //if (cancelRes == null) continue;
 
                                         //找到对应的AGV任务
-                                        var agv = db.Default.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
+                                        var agv = db.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID && v.AgvStatus < AGVTaskStatus.MissionCompleted).SplitTable(v => v.Take(2)).First();
                                         if (agv != null)
                                         {
                                             //if (!agv.AgvID.IsNullOrEmpty())
@@ -359,7 +357,7 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                             //}
                                             agv.Status = AGVTaskStatus.MissionCompleted;
                                             agv.AgvStatus = AGVTaskStatus.MissionCompleted;
-                                            db.Default.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                            db.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                         }
                                         //更新任务状态
                                         task.Status = Entity.TaskStatus.Finish;
@@ -367,8 +365,8 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                         task.EditWho = req.User;
                                         task.ManualRemarks = req.ManualRemarks;
 
-                                        db.Default.Updateable(task).UpdateColumns(x => new { x.Status, x.EndTime, x.EditTime, x.ManualRemarks }).ExecuteCommand();
-                                        task.AddWCS_TASK_DTL(db.Default, "未知", "任务完成");
+                                        db.Updateable(task).UpdateColumns(x => new { x.Status, x.EndTime, x.EditTime, x.ManualRemarks }).ExecuteCommand();
+                                        task.AddWCS_TASK_DTL(db, "未知", "任务完成");
                                         break;
                                     }
                                 case TaskType.SetPlate:
@@ -393,7 +391,7 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                     {
                         foreach (var item in req.TaskIds)
                         {
-                            var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
+                            var task = db.Queryable<WCS_TaskInfo>().Where(t => t.ID == item).First();
                             if (task != null)
                             {
                                 switch (task.Type)
@@ -456,12 +454,12 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                 }
 
                                 //找到对应的AGV任务
-                                var agv = db.Default.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID).SplitTable(v => v.Take(2)).First();
+                                var agv = db.Queryable<WCS_AgvTaskInfo>().RowLock().Where(v => v.ID == task.AgvTaskID).SplitTable(v => v.Take(2)).First();
                                 if (agv != null)
                                 {
                                     agv.Status = AGVTaskStatus.NewBuild;
                                     agv.AgvStatus = AGVTaskStatus.NewBuild;
-                                    db.Default.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
+                                    db.Updateable(agv).SplitTable(x => x.Take(2)).ExecuteCommand();
                                 }
 
                                 task.Status = task.Floor switch
@@ -471,8 +469,8 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                     _ => task.Status
                                 };
 
-                                task.AddWCS_TASK_DTL(db.Default, "AGV", "重新下发AGV任务");
-                                db.Default.Updateable(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
+                                task.AddWCS_TASK_DTL(db, "AGV", "重新下发AGV任务");
+                                db.Updateable(task).UpdateColumns(x => new { x.Status }).ExecuteCommand();
                             }
                             else
                             {
@@ -492,11 +490,10 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                     {
                         foreach (var item in req.TaskIds)
                         {
-                            var task = db.Default.Queryable<WCS_TaskInfo>().Where(t => t.ID == item && t.Status < Entity.TaskStatus.Finish).First();
+                            var task = db.Queryable<WCS_TaskInfo>().Where(t => t.ID == item && t.Status < Entity.TaskStatus.Finish).First();
                             if (task != null)
                             {
-
-                                if (task.Status > Entity.TaskStatus.WaitingToExecute )
+                                if (task.Status > Entity.TaskStatus.WaitingToExecute)
                                 {
                                     response.ResDataList.Add(new HandleTaskResponse()
                                     {
@@ -512,8 +509,8 @@ namespace WCS.WorkEngineering.WebApi.Controllers
                                 task.EditWho = req.User;
                                 task.Priority = req.Priority;
                                 task.ManualRemarks = req.ManualRemarks;
-                                db.Default.Updateable(task).UpdateColumns(x => new { x.Priority, x.EditWho, x.EditTime, x.ManualRemarks }).ExecuteCommand();
-                                task.AddWCS_TASK_DTL(db.Default, "未知", $"调整优先级至{task.Priority}");
+                                db.Updateable(task).UpdateColumns(x => new { x.Priority, x.EditWho, x.EditTime, x.ManualRemarks }).ExecuteCommand();
+                                task.AddWCS_TASK_DTL(db, "未知", $"调整优先级至{task.Priority}");
                             }
                             else
                             {
@@ -655,4 +652,4 @@ namespace WCS.WorkEngineering.WebApi.Controllers
 
         #endregion 设备IP相关
     }
-}
+}

YWGC/FJK/WCS.WorkEngineering/WorkStart.cs

@@ -346,10 +346,10 @@ namespace WCS.WorkEngineering
 
                 #region 外检信息
 
-            //    List<ShapeInfo> shapeInfo = new List<ShapeInfo>
-            //{
-            //    new ShapeInfo(new int[] { 2732,2532 }, "10.30.37.89"),
-            //};
+                //    List<ShapeInfo> shapeInfo = new List<ShapeInfo>
+                //{
+                //    new ShapeInfo(new int[] { 2732,2532 }, "10.30.37.89"),
+                //};
 
                 //foreach (var item in shapeInfo)
                 //{
@@ -891,6 +891,7 @@ namespace WCS.WorkEngineering
                 var conv2 = Device.All.FirstOrDefault(x => x.Code == "3132");
                 conv2.AddFlag(DeviceFlags.外检);
                 conv2.AddProtocol<IStation91>(1274, 91, "10.30.37.97");
+
                 #endregion 外检信息
 
                 #endregion 初始化输送机相关信息
@@ -1395,10 +1396,10 @@ namespace WCS.WorkEngineering
 
                 #region 外检信息
 
-            //    List<ShapeInfo> shapeInfo = new List<ShapeInfo>
-            //{
-            //    new ShapeInfo(new int[] { 3332,3532 }, "10.30.37.105")
-            //};
+                //    List<ShapeInfo> shapeInfo = new List<ShapeInfo>
+                //{
+                //    new ShapeInfo(new int[] { 3332,3532 }, "10.30.37.105")
+                //};
 
                 //foreach (var item in shapeInfo)
                 //{
@@ -1416,6 +1417,7 @@ namespace WCS.WorkEngineering
                 var conv2 = Device.All.FirstOrDefault(x => x.Code == "3532");
                 conv2.AddFlag(DeviceFlags.外检);
                 conv2.AddProtocol<IStation91>(1274, 91, "10.30.37.105");
+
                 #endregion 外检信息
 
                 #endregion 初始化输送机相关信息
@@ -1886,6 +1888,7 @@ namespace WCS.WorkEngineering
                         device.AddProtocol<IBCR81>(pos, 81, item.Ip);
                     }
                 }
+
                 #endregion 重绕区扫码器
             }
 
@@ -1914,7 +1917,6 @@ namespace WCS.WorkEngineering
                      {DeviceFlags.重绕区叫料工位, new List<string>(){ "9201", "9202","9203", "9204","9205", "9206","9207", "9208","9209",
                                                                 "9210", "9211","9212", "9213","9214","9215"/*,"9216", "9217","9218","9219",
                                                                  "9220","9221","9222","9223","9224"*/}}
-
                  };
                 Parallel.ForEach(devices, device =>
                 {
@@ -1970,7 +1972,7 @@ namespace WCS.WorkEngineering
                      { DeviceFlags.桁架缓存放行点, new List<string>(){  "1266", "1280", "1294", "1308", "1322", "1336", "1350", "1364", "1378", "1391", "1466", "1480", "1494", "1508", "1522", "1536", "1550", "1564", "1578", "1591"} },
                      { DeviceFlags.桁架09缓存放行点, new List<string>(){/* "1266", "1280", "1294", "1308", "1322", "1336",  "1466", "1480", "1494", "1508", */} },
                      { DeviceFlags.桁架09异常缓存放行点, new List<string>(){  "1391" , "1591" } },
-                     { DeviceFlags.桁架18缓存放行点, new List<string>(){   
+                     { DeviceFlags.桁架18缓存放行点, new List<string>(){
                                                                         "1266", "1280", "1294", "1308", "1322", "1336", "1350", "1364", "1378",
                                                                         "1466", "1480", "1494", "1508" ,"1522", "1536" , "1550", "1564", "1578", } },
                      { DeviceFlags.桁架取货点, new List<string>(){"1261", "1275", "1289", "1303", "1317", "1331", "1345", "1359", "1373", "1386" , "1461", "1475", "1489", "1503", "1517", "1531", "1545", "1559", "1573", "1586" } },
@@ -2006,74 +2008,52 @@ namespace WCS.WorkEngineering
         /// <param name="datas"></param>
         public static void InitDB(this List<DataBaseConnectionString> datas)
         {
-            //初始化数据库
-            SqlSugarHelper.Do(db =>
+            foreach (var connectionString in datas!)
             {
-                foreach (var connectionString in datas!)
+                switch (connectionString.Key)
                 {
-                    var _db = db.Connect.GetConnectionScope(connectionString.Key);
-                    switch (connectionString.Key)
-                    {
-                        case "WCSDB"://WCS基本数据库
-                            SqlSugarHelper.SetDefault(connectionString.Key);
-                            //_db.CodeFirst.InitTables(typeof(WCS_PlcData));
-                            //_db.CodeFirst.InitTables(typeof(WCS_TaskInfo));
-                            //_db.CodeFirst.InitTables(typeof(WCS_TaskDtl));
-                            //_db.CodeFirst.InitTables(typeof(WCS_TaskOld));
-                            //_db.CodeFirst.InitTables(typeof(WCS_AgvTaskInfo));
-                            //_db.CodeFirst.InitTables(typeof(WCS_Palletizing));
-                            //_db.CodeFirst.InitTables(typeof(WCS_PalletizingLayer));
-                            //_db.CodeFirst.InitTables(typeof(BillRingPalletizingInfo));
-                            //_db.CodeFirst.InitTables(typeof(WCS_PalletizingRow));
-                            //_db.CodeFirst.InitTables(typeof(WCS_PalletizingLoc));
-                            //_db.CodeFirst.InitTables(typeof(WCS_CacheLine));
-                            //_db.CodeFirst.InitTables(typeof(WCS_CacheLineLoc));
+                    case "Default"://WCS基本数据库
+                        SqlSugarHelper.SetDefault(connectionString.Key);
+                        break;
 
-                            break;
+                    //case "WCSDlog"://WCS日志数据库
+                    //    SqlSugarHelper.SetDlog(connectionString.Key);
+                    //    break;
 
-                        case "WCSDlog"://WCS日志数据库
+                    //case "PLC"://PLC
+                    //    SqlSugarHelper.SetPLC(connectionString.Key);
+                    //    break;
 
-                            break;
+                    default:
+                        SqlSugarHelper.AddTenant(connectionString.Key, connectionString.Key);
+                        break;
+                }
+                SqlSugarHelper.Do(connectionString.Key, db =>
+                {
+                    switch (connectionString.Key)
+                    {
+                        case "Default"://WCS基本数据库
+
+                            db.CodeFirst.InitTables(typeof(WCS_PlcData));
+                            db.CodeFirst.InitTables(typeof(WCS_TaskInfo));
+                            db.CodeFirst.InitTables(typeof(WCS_TaskDtl));
+                            db.CodeFirst.InitTables(typeof(WCS_TaskOld));
+                            db.CodeFirst.InitTables(typeof(WCS_AgvTaskInfo));
+                            db.CodeFirst.InitTables(typeof(WCS_Palletizing));
+                            db.CodeFirst.InitTables(typeof(WCS_PalletizingLayer));
+                            db.CodeFirst.InitTables(typeof(BillRingPalletizingInfo));
+                            db.CodeFirst.InitTables(typeof(WCS_PalletizingRow));
+                            db.CodeFirst.InitTables(typeof(WCS_PalletizingLoc));
+                            db.CodeFirst.InitTables(typeof(WCS_CacheLine));
+                            db.CodeFirst.InitTables(typeof(WCS_CacheLineLoc));
 
-                        case "PLC"://PLC
-
-                            SqlSugarHelper.SetPLC(connectionString.Key);
-
-                            //_db.DbMaintenance.CreateDatabase();
-                            //_db.CodeFirst.InitTables<WCS_Log>();
-                            //_db.CodeFirst.InitTables<WCS_SRM520>();
-                            //_db.CodeFirst.InitTables<WCS_SRM521>();
-                            //_db.CodeFirst.InitTables<WCS_SRM537>();
-                            //_db.CodeFirst.InitTables<WCS_RGV520>();
-                            //_db.CodeFirst.InitTables<WCS_RGV521>();
-                            //_db.CodeFirst.InitTables<WCS_BCR80>();
-                            //_db.CodeFirst.InitTables<WCS_BCR81>();
-                            //_db.CodeFirst.InitTables<WCS_BCR83>();
-                            //_db.CodeFirst.InitTables<WCS_Station520>();
-                            //_db.CodeFirst.InitTables<WCS_Station521>();
-                            //_db.CodeFirst.InitTables<WCS_Station523>();
-                            //_db.CodeFirst.InitTables<WCS_Station524>();
-                            //_db.CodeFirst.InitTables<WCS_Station525>();
-                            //_db.CodeFirst.InitTables<WCS_Station90>();
-                            //_db.CodeFirst.InitTables<WCS_Station91>();
-                            //_db.CodeFirst.InitTables<WCS_Truss520>();
-                            //_db.CodeFirst.InitTables<WCS_Truss521>();
-                            //_db.CodeFirst.InitTables<WCS_Truss523>();
-                            //_db.CodeFirst.InitTables<WCS_Truss530>();
-                            //_db.CodeFirst.InitTables<WCS_Truss531>();
-                            //_db.CodeFirst.InitTables<WCS_Robot520>();
-                            //_db.CodeFirst.InitTables<WCS_Robot521>();
-                            //_db.CodeFirst.InitTables<WCS_Robot522>();
-                            //_db.CodeFirst.InitTables<WCS_Robot530>();
-                            //_db.CodeFirst.InitTables<WCS_Robot531>();
-                            //var a = false;
                             break;
 
-                        default: //其他库
+                        default:
                             break;
-                    };
-                };
-            });
+                    }
+                });
+            }
         }
     }