1.ServiceStack.Redis 依赖包变更为StackExchange.Redis

yl

2024-01-18 8024ec8c0300dcffa0caf4e2a030e068a9051bc2

1.ServiceStack.Redis 依赖包变更为StackExchange.Redis

 VueWebCoreApi/Controllers/AppAnalyticsController.cs

@@ -16,7 +16,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[App生产看板]
        /// <summary>

 VueWebCoreApi/Controllers/AppPersonalController.cs

@@ -16,7 +16,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[App个人计件工资]
        /// <summary>

 VueWebCoreApi/Controllers/BasicSettingController.cs

@@ -23,7 +23,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[组织架构,查询组织信息]
        /// <summary>

 VueWebCoreApi/Controllers/DeviceManagerController.cs

@@ -18,7 +18,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[设备类型查询]
        /// <summary>

 VueWebCoreApi/Controllers/ErpSyncMesController.cs

@@ -17,7 +17,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[物料管理：计量单位同步]
        /// <summary>

 VueWebCoreApi/Controllers/GeneralBasicDataController.cs

@@ -15,7 +15,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[组织架构基础资料]
        /// <summary>

 VueWebCoreApi/Controllers/GridReportController.cs

@@ -18,7 +18,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[MES工单打印1]
        /// <summary>

 VueWebCoreApi/Controllers/KanBanManagerentController.cs

@@ -15,7 +15,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[车间看板,上生产信息]
        /// <summary>

 VueWebCoreApi/Controllers/LoginController.cs

@@ -19,7 +19,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();
        //获取企业配置Enterprise
        private static readonly string Enterprise = AppSetting.GetAppSetting("Enterprise");

@@ -73,10 +73,10 @@

                    User loginUser = JsonConvert.DeserializeObject<User>(JsonConvert.SerializeObject(ms));
                    //如果redis登录用户中不存在当前用户
                    if (redis.Get<User>(ms.rediskey, 0) == null)
                    if (redis.GetStringKey<User>(ms.rediskey) == null)
                    {
                        //写入redis(注意：redis类里面的失效时间必须在key创建完成之后才生效)
                        redis.Set<User>(ms.rediskey, ms, redis.secondsTimeOut, 0);
                        redis.SetStringKey<User>(ms.rediskey, ms, TimeSpan.FromSeconds(redis.secondsTimeOut));
                        //写入登录操作记录 
                        LogHelper.DbOperateLog(ms.usercode, "登录", "登录了系统", ms.usertype);
                        mes.code = "200";
@@ -86,7 +86,7 @@
                    else //如果存在
                    {
                        //获取redis中当前用户信息
                        User r_loginUser = redis.Get<User>(ms.rediskey, 0);
                        User r_loginUser = redis.GetStringKey<User>(ms.rediskey);
                        //如果session中的用户usercode和redis中的用户usercode匹配
                        if ((r_loginUser.rediskey).Equals(loginUser.rediskey))
                        {
@@ -97,7 +97,7 @@
                        else
                        {
                            //重置过期时间(注意：redis类里面的失效时间必须在key创建完成之后才生效)
                            redis.Set<User>(loginUser.rediskey, loginUser, redis.secondsTimeOut, 0);
                            redis.SetStringKey<User>(loginUser.rediskey, loginUser, TimeSpan.FromSeconds(redis.secondsTimeOut));
                            //写入登录操作记录
                            LogHelper.DbOperateLog(ms.usercode, "登录", "登录了系统", ms.usertype);
                            mes.data = ms;
@@ -150,13 +150,13 @@
                        }
                    });
                    bool aa = DapperHelper.DoTransaction(list);
                    redis.Remove(us.rediskey, 0);//删除redis
                    redis.Set<User>(us.rediskey, us, redis.secondsTimeOut, 0);//写入redis
                    redis.KeyDelete(us.rediskey);//删除redis
                    redis.SetStringKey<User>(us.rediskey, us, TimeSpan.FromSeconds(redis.secondsTimeOut));//写入redis
                }
                else
                {
                    redis.Remove(us.rediskey, 0);//删除redis
                    redis.Set<User>(us.rediskey, us, redis.secondsTimeOut, 0);//写入redis
                    redis.KeyDelete(us.rediskey);//删除redis
                    redis.SetStringKey<User>(us.rediskey, us, TimeSpan.FromSeconds(redis.secondsTimeOut));//写入redis
                }
                //写入日志
                LogHelper.DbOperateLog(us.usercode, "强制下线", "被强制下线了", us.usertype);
@@ -288,10 +288,10 @@

                    User loginUser = JsonConvert.DeserializeObject<User>(JsonConvert.SerializeObject(ms));
                    //如果redis登录用户中不存在当前用户
                    if (redis.Get<User>(ms.rediskey, 0) == null)
                    if (redis.GetStringKey<User>(ms.rediskey) == null)
                    {
                        //写入redis(注意：redis类里面的失效时间必须在key创建完成之后才生效)
                        redis.Set<User>(ms.rediskey, ms, redis.secondsTimeOut, 0);
                        redis.SetStringKey<User>(ms.rediskey, ms, TimeSpan.FromSeconds(redis.secondsTimeOut));
                        //写入登录操作记录 
                        LogHelper.DbOperateLog(ms.usercode, "登录", "登录了系统", ms.usertype);
                        mes.code = "200";
@@ -301,17 +301,17 @@
                    else //如果存在
                    {
                        //获取redis中当前用户信息
                        User r_loginUser = redis.Get<User>(ms.rediskey, 0);
                        User r_loginUser = redis.GetStringKey<User>(ms.rediskey);
                        //如果session中的用户usercode和redis中的用户usercode匹配
                        if ((r_loginUser.rediskey).Equals(loginUser.rediskey))
                        {
                            redis.Remove(loginUser.rediskey, 0);//删除redis
                            redis.Set<User>(loginUser.rediskey, ms, redis.secondsTimeOut, 0);//写入redis
                            redis.KeyDelete(loginUser.rediskey);//删除redis
                            redis.SetStringKey<User>(loginUser.rediskey, ms, TimeSpan.FromSeconds(redis.secondsTimeOut));//写入redis
                        }
                        else
                        {
                            //重置过期时间(注意：redis类里面的失效时间必须在key创建完成之后才生效)
                            redis.Set<User>(loginUser.rediskey, loginUser, redis.secondsTimeOut, 0);
                            redis.SetStringKey<User>(loginUser.rediskey, loginUser, TimeSpan.FromSeconds(redis.secondsTimeOut));
                            //写入登录操作记录
                            LogHelper.DbOperateLog(ms.usercode, "登录", "登录了系统", ms.usertype);
                            mes.data = ms;

 VueWebCoreApi/Controllers/MouldManagerController.cs

@@ -20,7 +20,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[模具清单列表查询]
        /// <summary>

 VueWebCoreApi/Controllers/ProductModelController.cs

@@ -19,7 +19,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[计量单位组信息]
        /// <summary>

 VueWebCoreApi/Controllers/QualityManagementController.cs

@@ -18,7 +18,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[质量管理,缺陷定义查询列表]
        /// <summary>

 VueWebCoreApi/Controllers/ReportManagerController.cs

@@ -17,7 +17,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[生产进度报表]
        /// <summary>

 VueWebCoreApi/Controllers/SystemSettingController.cs

@@ -18,7 +18,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[编码规则获取可设置的功能菜单信息]
        /// <summary>

 VueWebCoreApi/Controllers/WorkOrderController.cs

@@ -24,7 +24,7 @@
    {
        //定义全局信息返回变量
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        #region[ERP订单查询]
        /// <summary>
@@ -282,6 +282,24 @@
        }
        #endregion

        #region[MES工单查找历史引用最新工序信息]
        /// <summary>
        /// MES工单查找历史引用最新工序信息
        /// </summary>
        /// <param name="wkshopcode">车间编码</param>
        /// <param name="partcode">产品编码</param>
        /// <returns></returns>
        [Route(template: "MesOrderNewStepContent")]
        [HttpPost]
        public JsonResult MesOrderNewStepContent(string wkshopcode, string partcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = WorkOrderBLL.MesOrderNewStepContent(wkshopcode, partcode, us);
            return Json(mes);
        }
        #endregion


        #region[MES工单派发提交]
        /// <summary>

 VueWebCoreApi/DLL/BLL/WorkOrderBLL.cs

@@ -95,6 +95,13 @@
        }
        #endregion

        #region[MES工单查找历史引用最新工序信息]
        public static ToMessage MesOrderNewStepContent(string wkshopcode, string partcode, User us)
        {
            return WorkOrderDAL.MesOrderNewStepContent(wkshopcode, partcode, us);
        }
        #endregion


        #region[MES工单派发提交]
        public static ToMessage MesOrderDistribution(string[] wocodelist, User us)

 VueWebCoreApi/DLL/DAL/LoginDAL.cs

@@ -384,11 +384,11 @@
        #region[登出]
        public static ToMessage LoginOut(User us)
        {
            RedisHelper redis = new RedisHelper();
            RedisCommon redis = new RedisCommon();
            try
            {
                //删除redis
                redis.Remove(Enterprise + "LoginUserID" + us.usertype + us.usercode, 0);
                redis.KeyDelete(Enterprise + "LoginUserID" + us.usertype + us.usercode);
                //写入日志
                LogHelper.DbOperateLog(us.usercode, "退出", "退出了系统", us.usertype);
                mes.code = "200";

 VueWebCoreApi/DLL/DAL/WorkOrderDAL.cs

@@ -1034,6 +1034,40 @@
        }
        #endregion

        #region[MES工单查找历史引用最新工序信息]
        public static ToMessage MesOrderNewStepContent(string wkshopcode, string partcode, User us)
        {
            var sql = "";
            List<object> list = new List<object>();
            var dynamicParams = new DynamicParameters();
            try
            {
                //MES工单查找历史引用最新工序信息
                sql = @"select S.wo_code,S.seq,S.step_code,S.stepprice,isbott,isend   from (
                        select top 1 wo_code   from TK_Wrk_Man  
                        where wkshp_code=@wkshopcode and materiel_code=@partcode
                        order by lm_date desc
                        ) as A
                        inner join TK_Wrk_Step S on A.wo_code=S.wo_code";
                dynamicParams.Add("@wkshopcode", wkshopcode);
                dynamicParams.Add("@partcode", partcode);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                mes.code = "200";
                mes.count = data.Rows.Count;
                mes.data = data;
                mes.message = "查询成功!";
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion


        #region[MES工单派发提交]
        public static ToMessage MesOrderDistribution(string[] wocodelist, User us)

 VueWebCoreApi/Tools/ChannelActionFilterAttribute.cs

@@ -15,7 +15,7 @@
    public class ChannelActionFilterAttribute: ActionFilterAttribute
    {
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        /// <summary>
        /// åœ¨Action执行前执行
@@ -30,10 +30,10 @@
                User us = JwtTools.Denocode(token.ToString());
                base.OnActionExecuting(context);
                //如果存在          
                if (redis.Get<User>(us.rediskey, 0) !=null)
                if (redis.GetStringKey<User>(us.rediskey) !=null)
                {
                    //获取redis中当前用户信息
                    User r_loginUser = redis.Get<User>(us.rediskey, 0);
                    User r_loginUser = redis.GetStringKey<User>(us.rediskey);
                    if (token != r_loginUser.token)
                    {
                        mes.code = "303";
@@ -44,7 +44,7 @@
                    else 
                    {
                        //重置过期时间
                        redis.KeyExpire(us.rediskey, redis.secondsTimeOut);
                        redis.SetExpire(us.rediskey, redis.secondsTimeOut);
                    }
                }
                else //如果redis登录用户中不存在当前用户

 VueWebCoreApi/Tools/ChannelActionFilterAttributeApp.cs

@@ -11,7 +11,7 @@
    public class ChannelActionFilterAttributeApp : ActionFilterAttribute
    {
        ToMessage mes = new ToMessage();
        RedisHelper redis = new RedisHelper();
        RedisCommon redis = new RedisCommon();

        /// <summary>
        /// åœ¨Action执行前执行

 VueWebCoreApi/Tools/RedisCommon.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,309 @@
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace VueWebCoreApi.Tools
{
    public class RedisCommon
    {
        //public static ILogger Log = UtilLogger<RedisCommon>.Log;//日志记录
        //redis数据库连接字符串
        private static readonly string RedisIpConnString = AppSetting.GetAppSetting("RedisConnIp");
        private static readonly string RedisPortConnString = AppSetting.GetAppSetting("RedisConnPort");
        private static readonly string RedisKeyTimeCont = AppSetting.GetAppSetting("RedisKeyTimeCont");


        private string _conn = RedisIpConnString+":"+RedisPortConnString;
        private int _db = 0;
        //默认缓存过期时间单位秒  
        public int secondsTimeOut = Convert.ToInt32(RedisKeyTimeCont);
        //静态变量 ä¿è¯å„模块使用的是不同实例的相同链接
        private static ConnectionMultiplexer connection;
        public RedisCommon() { }

        /// <summary>
        /// æž„造函数
        /// </summary>
        /// <param name="db"></param>
        /// <param name="connectStr"></param>
        public RedisCommon(int db, string connectStr)
        {
            _conn = connectStr;
            _db = db;
        }

        /// <summary>
        /// ç¼“存数据库，数据库连接
        /// </summary>
        public ConnectionMultiplexer CacheConnection
        {
            get
            {
                try
                {
                    if (connection == null || !connection.IsConnected)
                    {
                        connection = new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(_conn)).Value;
                    }
                }
                catch (Exception ex)
                {
                    //Log.LogError("RedisHelper->CacheConnection å‡ºé”™\r\n" + ex.ToString());
                    return null;
                }
                return connection;
            }
        }

        /// <summary>
        /// ç¼“存数据库
        /// </summary>
        public IDatabase CacheRedis => CacheConnection.GetDatabase(_db);

        #region --KEY/VALUE存取--

        /// <summary>
        /// å•æ¡å­˜å€¼
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="value">The value.</param>
        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
        public bool StringSet(string key, string value)
        {
            return CacheRedis.StringSet(key, value);
        }

        /// <summary>
        /// ä¿å­˜å•ä¸ªkey value
        /// </summary>
        /// <param name="key">Redis Key</param>
        /// <param name="value">保存的值</param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public bool StringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {
            return CacheRedis.StringSet(key, value, expiry);
        }

        /// <summary>
        /// ä¿å­˜å¤šä¸ªkey value
        /// </summary>
        /// <param name="arr">key</param>
        /// <returns></returns>
        public bool StringSet(KeyValuePair<RedisKey, RedisValue>[] arr)
        {
            return CacheRedis.StringSet(arr);
        }

        /// <summary>
        /// æ‰¹é‡å­˜å€¼
        /// </summary>
        /// <param name="keysStr">key</param>
        /// <param name="valuesStr">The value.</param>
        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
        public bool StringSetMany(string[] keysStr, string[] valuesStr)
        {
            var count = keysStr.Length;
            var keyValuePair = new KeyValuePair<RedisKey, RedisValue>[count];
            for (int i = 0; i < count; i++)
            {
                keyValuePair[i] = new KeyValuePair<RedisKey, RedisValue>(keysStr[i], valuesStr[i]);
            }

            return CacheRedis.StringSet(keyValuePair);
        }

        /// <summary>
        /// ä¿å­˜ä¸€ä¸ªå¯¹è±¡
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool SetStringKey<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        {
            string json = JsonConvert.SerializeObject(obj);
            return CacheRedis.StringSet(key, json, expiry);
        }

        /// <summary>
        /// è¿½åŠ å€¼
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void StringAppend(string key, string value)
        {
            ////追加值，返回追加后长度
            long appendlong = CacheRedis.StringAppend(key, value);
        }

        /// <summary>
        /// èŽ·å–单个key的值
        /// </summary>
        /// <param name="key">Redis Key</param>
        /// <returns></returns>
        public RedisValue GetStringKey(string key)
        {
            return CacheRedis.StringGet(key);
        }

        /// <summary>
        /// æ ¹æ®Key获取值
        /// </summary>
        /// <param name="key">键值</param>
        /// <returns>System.String.</returns>
        public string StringGet(string key)
        {
            try
            {
                return CacheRedis.StringGet(key);
            }
            catch (Exception ex)
            {
                //Log.LogError("RedisHelper->StringGet å‡ºé”™\r\n" + ex.ToString());
                return null;
            }
        }

        /// <summary>
        /// èŽ·å–多个Key
        /// </summary>
        /// <param name="listKey">Redis Key集合</param>
        /// <returns></returns>
        public RedisValue[] GetStringKey(List<RedisKey> listKey)
        {
            return CacheRedis.StringGet(listKey.ToArray());
        }

        /// <summary>
        /// æ‰¹é‡èŽ·å–值
        /// </summary>
        public string[] StringGetMany(string[] keyStrs)
        {
            var count = keyStrs.Length;
            var keys = new RedisKey[count];
            var addrs = new string[count];

            for (var i = 0; i < count; i++)
            {
                keys[i] = keyStrs[i];
            }
            try
            {

                var values = CacheRedis.StringGet(keys);
                for (var i = 0; i < values.Length; i++)
                {
                    addrs[i] = values[i];
                }
                return addrs;
            }
            catch (Exception ex)
            {
                //Log.LogError("RedisHelper->StringGetMany å‡ºé”™\r\n" + ex.ToString());
                return null;
            }
        }

        /// <summary>
        /// èŽ·å–一个key的对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T GetStringKey<T>(string key)
        {
            try
            {
                return JsonConvert.DeserializeObject<T>(CacheRedis.StringGet(key));
            }
            catch (Exception ex)
            {
                //return new T();
                return default(T);
            }
        }

        #endregion

        #region --删除设置过期--

        /// <summary>
        /// åˆ é™¤å•ä¸ªkey
        /// </summary>
        /// <param name="key">redis key</param>
        /// <returns>是否删除成功</returns>
        public bool KeyDelete(string key)
        {
            return CacheRedis.KeyDelete(key);
        }

        /// <summary>
        /// åˆ é™¤å¤šä¸ªkey
        /// </summary>
        /// <param name="keys">rediskey</param>
        /// <returns>成功删除的个数</returns>
        public long KeyDelete(RedisKey[] keys)
        {
            return CacheRedis.KeyDelete(keys);
        }

        /// <summary>
        /// åˆ¤æ–­key是否存储
        /// </summary>
        /// <param name="key">redis key</param>
        /// <returns></returns>
        public bool KeyExists(string key)
        {
            return CacheRedis.KeyExists(key);
        }

        /// <summary>
        /// é‡æ–°å‘½åkey
        /// </summary>
        /// <param name="key">就的redis key</param>
        /// <param name="newKey">新的redis key</param>
        /// <returns></returns>
        public bool KeyRename(string key, string newKey)
        {
            return CacheRedis.KeyRename(key, newKey);
        }

        /// <summary>
        /// åˆ é™¤hasekey
        /// </summary>
        /// <param name="key"></param>
        /// <param name="hashField"></param>
        /// <returns></returns>
        public bool HaseDelete(RedisKey key, RedisValue hashField)
        {
            return CacheRedis.HashDelete(key, hashField);
        }

        /// <summary>
        /// ç§»é™¤hash中的某值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool HashRemove(string key, string dataKey)
        {
            return CacheRedis.HashDelete(key, dataKey);
        }

        /// <summary>
        /// è®¾ç½®ç¼“存过期
        /// </summary>
        /// <param name="key"></param>
        /// <param name="datetime"></param>
        public void SetExpire(string key, int datetime)
        {
            CacheRedis.KeyExpire(key, DateTime.Now.AddSeconds(datetime));
        }
        #endregion
    }
}

 VueWebCoreApi/VueWebCoreApi.csproj

@@ -42,6 +42,7 @@
        <PackageReference Include="NPOI" Version="2.5.6" />
        <PackageReference Include="Quartz" Version="3.3.3" />
        <PackageReference Include="ServiceStack.Redis" Version="5.0.0" />
        <PackageReference Include="StackExchange.Redis" Version="2.7.10" />
        <PackageReference Include="Swashbuckle.AspNetCore" Version="5.0.0" />
        <PackageReference Include="System.Data.OleDb" Version="4.6.0" />
        <PackageReference Include="System.Data.SqlClient" Version="4.5.0" />