1

EduSpider.Cache/CacheKey.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace EduSpider.Cache
+{
+    public class CacheKey
+    {
+        /// <summary>
+        /// 用户登录缓存Key
+        /// </summary>
+        public static string User_Login_Key = "JJSW_Login_";
+    }
+}

EduSpider.Cache/EduSpider.Cache.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="StackExchange.Redis" Version="2.0.601" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\EduSpider.Model\EduSpider.Model.csproj" />
+    <ProjectReference Include="..\EduSpider.Repository\EduSpider.Repository.csproj" />
+  </ItemGroup>
+
+</Project>

EduSpider.Cache/User/UserReidsCache.cs

+using EduSpider.Model.Cache;
+using EduSpider.Repository;
+using EduSpider.Utility;
+using EduSpider.Utility.Enum;
+using System;
+using System.Linq;
+using VTX.FW.Helper;
+using VTX.FW.Api;
+using VTX.FW.Cache;
+
+namespace EduSpider.Cache.User
+{
+    /// <summary>
+    /// redis缓存
+    /// </summary>
+    public class UserReidsCache
+    {
+        readonly static RedisCache redis = new(new RedisConfig
+        {
+            DbNum = 3,
+            RedisServer = ConfigHelper.GetAppsettings("RedisSetting", "RedisServer"),
+            RedisPort = Convert.ToInt32(ConfigHelper.GetAppsettings("RedisSetting", "RedisPort")),
+            RedisPwd = ConfigHelper.GetAppsettings("RedisSetting", "RedisPwd")
+        });
+
+        /// <summary>
+        /// 设置缓存
+        /// </summary>
+        /// <param name="model"></param>
+        public static void UserInfoSet(string cacheKey, UserInfo model, int JwtExpirTime)
+        {
+            try
+            {
+                TimeSpan ts = GetExpirTime(JwtExpirTime);
+                redis.StringSet<UserInfo>(cacheKey, model, ts);
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteError("UserInfoSet", "缓存设置失败", ex);
+            }
+        }
+
+        /// <summary>
+        /// 获取缓存时长
+        /// </summary>
+        /// <param name="JwtExpirTime"></param>
+        /// <returns></returns>
+        private static TimeSpan GetExpirTime(int JwtExpirTime)
+        {
+            DateTime dt = DateTime.Now;
+            DateTime dt2 = DateTime.Now;
+            TimeSpan ts = dt.AddSeconds(JwtExpirTime) - dt2;
+            return ts;
+        }
+
+        /// <summary>
+        /// 判断key是否存在
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        /// <returns></returns>
+        public static bool Exists(string cacheKey)
+        {
+            return redis.KeyExists(cacheKey);
+        }
+
+        /// <summary>
+        /// 设置缓存
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        /// <param name="Data"></param>
+        /// <param name="JwtExpirTime"></param>
+        public static void Set(string cacheKey, object Data, int JwtExpirTime)
+        {
+            try
+            {
+                TimeSpan ts = GetExpirTime(JwtExpirTime);
+                redis.StringSet(cacheKey, Data, ts);
+            }
+            catch (Exception)
+            {
+            }
+        }
+ 
+        /// <summary>
+        /// 获取缓存
+        /// </summary>
+        /// <param name="cacheKey"></param>
+        public static object Get(string cacheKey)
+        {
+            try
+            {
+                object info = redis.StringGet<object>(cacheKey);
+                return info;
+            }
+            catch (Exception)
+            {
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// 账号仓储层对象
+        /// </summary>
+        private static readonly AccountRepository accountRepository = new();
+
+        /// <summary>
+        /// 获取用户登录信息
+        /// </summary>
+        /// <param name="Id">账号Id</param>
+        /// <param name="apiRequestFromEnum">请求来源</param>
+        /// <returns></returns>
+        public static UserInfo GetUserLoginInfo(object Id, ApiRequestFromEnum apiRequestFromEnum = ApiRequestFromEnum.MiniProgram)
+        {
+
+            UserInfo userInfo = null;
+            if (Id != null)
+            {
+                string cacheKey = CacheKey.User_Login_Key + Id.ToString();
+                try
+                {
+                    userInfo = redis.StringGet<UserInfo>(cacheKey);
+                }
+                catch (Exception ex)
+                {
+                    LogHelper.WriteError("GetUserLoginInfo", "获取缓存失败", ex);
+                }
+                if (userInfo == null)
+                {
+                    Int32.TryParse(Id.ToString(), out int NewId);
+                    if (NewId > 0)
+                    {
+                        string token = "";
+                        var model = accountRepository.GetAccountList(new Model.Extend.RB_Account_Extend()
+                        {
+                            Id = NewId
+                        })?.FirstOrDefault();
+                        if (model != null)
+                        {
+                            userInfo = new UserInfo
+                            {
+                                Id = model.Id,
+                                AccountType = model.AccountType,
+                                AccountName = model.AccountName,
+                                Token = token,
+                                ApiRequestFromEnum = apiRequestFromEnum,
+                                AccountId = model.AccountId,
+                                UserMobile = model.Account,
+                                UserIcon = model.UserIcon,
+                            };
+                            UserInfoSet(CacheKey.User_Login_Key + Id.ToString(), userInfo, Config.JwtExpirTime);
+                        }
+                    }
+                }
+            }
+            else
+            {
+                userInfo = new UserInfo();
+            }
+            return userInfo;
+        }
+
+    }
+}
\ No newline at end of file

EduSpider.IServices/IAccountService.cs

+using EduSpider.Model.Extend;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using VTX.FW.Config;
+
+namespace EduSpider.IServices
+{
+    /// <summary>
+    /// 账号服务层接口
+    /// </summary>
+    public interface IAccountService : IDependency
+    {
+        List<RB_Account_Extend> GetAccountList(RB_Account_Extend demodel);
+        bool UpdateAccountUnionId(RB_Account_Extend model);
+    }
+}

EduSpider.Model/CacheModel/UserInfo.cs

+using EduSpider.Utility.Enum;
+using System.Collections.Generic;
+
+namespace EduSpider.Model.Cache
+{
+    /// <summary>
+    /// 用户缓存
+    /// </summary>
+    public class UserInfo
+    {
+        /// <summary>
+        /// 账号编号
+        /// </summary>
+        public int Id { get; set; }
+
+        /// <summary>
+        /// 账号名称
+        /// </summary>
+        public string AccountName { get; set; }
+
+        /// <summary>
+        /// 请求来源
+        /// </summary>
+        public ApiRequestFromEnum ApiRequestFromEnum { get; set; }
+
+        /// <summary>
+        /// 账号类型(1-管理端，2,-教师端，3-助教，4-学生)
+        /// </summary>
+        public AccountTypeEnum AccountType { get; set; }
+
+        /// <summary>
+        /// 对应的账户id
+        /// </summary>
+        public int AccountId { get; set; }
+
+        /// <summary>
+        /// Token验证
+        /// </summary>
+        public string Token { get; set; }
+
+        /// <summary>
+        /// 用户头像
+        /// </summary>
+        public string UserIcon { get; set; }
+
+        /// <summary>
+        /// 用户手机号码
+        /// </summary>
+        public string UserMobile { get; set; }
+
+    }
+}
\ No newline at end of file

EduSpider.Model/Entity/RB_Account.cs

-using System;
+using EduSpider.Utility.Enum;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -29,7 +30,7 @@ namespace EduSpider.Model.Entity
 		/// <summary>
 		/// 类型  1老师  2学生
 		/// </summary>
-		public int AccountType { get; set; }
+		public AccountTypeEnum AccountType { get; set; }
 
 		/// <summary>
 		/// 对应 老师/学生ID
@@ -39,7 +40,7 @@ namespace EduSpider.Model.Entity
 		/// <summary>
 		/// 删除状态
 		/// </summary>
-		public int Status { get; set; }
+		public DateStateEnum Status { get; set; }
 
 		/// <summary>
 		/// 微信唯一识别码

EduSpider.Model/Extend/RB_Account_Extend.cs

@@ -16,5 +16,10 @@ namespace EduSpider.Model.Extend
 		/// 帐号名称
 		/// </summary>
 		public string AccountName { get; set; }
+
+		/// <summary>
+		/// 用户头像
+		/// </summary>
+		public string UserIcon { get; set; }
 	}
 }

EduSpider.Repository/AccountRepository.cs

@@ -38,15 +38,15 @@ namespace EduSpider.Repository
             }
             if (demodel.AccountType > 0)
             {
-                where += $" and t.{nameof(RB_Account_Extend.AccountType)} ={demodel.AccountType}";
+                where += $" and t.{nameof(RB_Account_Extend.AccountType)} ={(int)demodel.AccountType}";
             }
             if (demodel.AccountId > 0)
             {
                 where += $" and t.{nameof(RB_Account_Extend.AccountId)} ={demodel.AccountId}";
             }
-            if (demodel.Status > -1)
+            if (demodel.Status >= 0)
             {
-                where += $" and t.{nameof(RB_Account_Extend.Status)} ={demodel.Status}";
+                where += $" and t.{nameof(RB_Account_Extend.Status)} ={(int)demodel.Status}";
             }
             if (!string.IsNullOrEmpty(demodel.Account))
             {
@@ -59,10 +59,10 @@ namespace EduSpider.Repository
 
             string sql = $@"
 select * from(
-SELECT a.Id,a.Account,a.`Password`,a.AccountType,a.AccountId,t.TeacherName AS AccountName,a.Status FROM rb_account a 
+SELECT a.Id,a.Account,a.`Password`,a.AccountType,a.AccountId,t.TeacherName AS AccountName,t.Logo as UserIcon,a.Status FROM rb_account a 
 INNER JOIN rb_teacher t on a.AccountId =t.TeacherId and a.AccountType =1
 UNION 
-SELECT a.Id,a.Account,a.`Password`,a.AccountType,a.AccountId,s.StudentName AS AccountName,a.Status FROM rb_account a 
+SELECT a.Id,a.Account,a.`Password`,a.AccountType,a.AccountId,s.StudentName AS AccountName,'' as UserIcon,a.Status FROM rb_account a 
 INNER JOIN rb_student s on a.AccountId =s.StudId and a.AccountType =2
 ) t where {where}
 ";

EduSpider.Services/AccountService.cs

+
+using EduSpider.IServices;
+using EduSpider.Model.Extend;
+using EduSpider.Repository;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using VTX.FW.Attr;
+using VTX.FW.DB;
+
+namespace EduSpider.Services
+{
+    /// <summary>
+    /// 账号服务实现
+    /// </summary>
+    public class AccountService : IAccountService
+    {
+
+        /// <summary>
+        /// 帐号仓储接口
+        /// </summary>
+        [Autowired]
+        public IAccountRepository accountRepository { get; set; }
+
+        /// <summary>
+        /// 获取列表
+        /// </summary>
+        /// <param name="demodel"></param>
+        /// <returns></returns>
+        public List<RB_Account_Extend> GetAccountList(RB_Account_Extend demodel)
+        {
+            return accountRepository.GetAccountList(demodel);
+        }
+
+        /// <summary>
+        /// 更新微信信息
+        /// </summary>
+        /// <param name="model"></param>
+        /// <returns></returns>
+        public bool UpdateAccountUnionId(RB_Account_Extend model)
+        {
+            Dictionary<string, object> keyValues = new() {
+                { nameof(RB_Account_Extend.OpenId), model.OpenId},
+                { nameof(RB_Account_Extend.UnionId), model.UnionId},
+            };
+            List<WhereHelper> wheres = new() {
+                new WhereHelper(){
+                     FiledName = nameof(RB_Account_Extend.Id),
+                      FiledValue = model.Id,
+                       OperatorEnum = OperatorEnum.Equal
+                }
+            };
+            return accountRepository.Update(keyValues, wheres);
+        }
+    }
+}

EduSpider.Utility/API/TokenUserInfo.cs

+using EduSpider.Utility.Enum;
+using System;
+
+namespace EduSpider.Utility.API
+{
+    /// <summary>
+    /// API请求token携带的用户信息
+    /// </summary>
+    public class TokenUserInfo
+    {
+        /// <summary>
+        /// 用户ID
+        /// </summary>
+        public string uid { get; set; }
+
+        /// <summary>
+        /// 请求消息
+        /// </summary>
+        public ApiRequestFromEnum requestFrom { get; set; }
+
+        /// <summary>
+        /// 集团编号
+        /// </summary>
+        public int groupId { get; set; }
+    }
+}

EduSpider.Utility/Config.cs

+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Configuration.Json;
+using System;
+using System.IO;
+using System.Text.RegularExpressions;
+using VTX.FW.Helper;
+
+namespace EduSpider.Utility
+{
+    /// <summary>
+    /// 全局配置
+    /// </summary>
+    public class Config
+    {
+        /// <summary>
+        /// 配置文件注入
+        /// </summary>
+        public readonly static IConfiguration Configuration;
+        static Config()
+        {
+            try
+            {
+                Configuration = new ConfigurationBuilder()
+                .Add(new JsonConfigurationSource { Path = "appsettings.json", ReloadOnChange = true })
+                .Build();
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteError("Config", "获取配置文件", ex);
+            }
+        }
+
+        /// <summary>
+        /// 获取连接字符串
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string GetConnectionString(string key)
+        {
+            try
+            {
+                return Configuration.GetConnectionString(key);
+            }
+            catch
+            {
+                return "";
+            }
+        }
+
+
+        /// <summary>
+        /// 读取配置文件key的值
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static string ReadConfigKey(string key, string subKey = "")
+        {
+            string valueStr = "";
+            try
+            {
+                if (!string.IsNullOrWhiteSpace(subKey))
+                {
+                    valueStr = Configuration.GetSection(key)[subKey].ToString();
+                }
+                else
+                {
+                    valueStr = Configuration.GetSection(key).Value;
+                }
+            }
+            catch
+            {
+            }
+            return valueStr;
+        }
+
+        /// <summary>
+        /// 异常日志保存路径
+        /// </summary>
+        public static string LogPath
+        {
+            get
+            {
+                string logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "log/error");
+                return logPath.ToString();
+            }
+        }
+
+        /// <summary>
+        /// 打印日志保存路径
+        /// </summary>
+        public static string InofLogPath
+        {
+            get
+            {
+                string logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "log/info");
+                return logPath.ToString();
+            }
+        }
+
+        /// <summary>
+        /// 接口请求日志保存路径
+        /// </summary>
+        public static string RequestLogPath
+        {
+            get
+            {
+                string logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "log/request");
+                return logPath.ToString();
+            }
+        }
+
+        /// <summary>
+        /// JWT加密秘钥
+        /// </summary>
+        public static string JwtSecretKey
+        {
+            get
+            {
+                return ReadConfigKey("JwtSecretKey");
+            }
+        }
+
+        /// <summary>
+        /// 过期时间，单位为秒
+        /// </summary>
+        public static int JwtExpirTime
+        {
+            get
+            {
+                Int32.TryParse(ReadConfigKey("JwtExpirTime"), out int JwtExpirTime);
+                return JwtExpirTime;
+            }
+        }
+
+        /// <summary>
+        /// 获取文件相对路径
+        /// </summary>
+        public static string GetFilePath(string path)
+        {
+            if (!string.IsNullOrWhiteSpace(path))
+            {
+                string p = @"(http|https)://(?<domain>[^(:|/]*)";
+                Regex reg = new Regex(p, RegexOptions.IgnoreCase);
+                string value = reg.Match(path).Value;
+                if (!string.IsNullOrEmpty(value))
+                {
+                    Uri url = new Uri(path);
+                    return url.AbsolutePath;
+                }
+                else
+                {
+                    return path;
+                }
+            }
+            else
+            {
+                return path;
+            }
+        }
+
+        /// <summary>
+        /// 甲鹤小程序AppId
+        /// </summary>
+        public static string AppID
+        {
+            get { return "wx38e054ee42b054f4"; }
+        }
+
+        /// <summary>
+        /// 甲鹤小程序AppSecret
+        /// </summary>
+        public static string AppSecret
+        {
+            get { return "d3ad4699265ba885ae2c8b65bf574ea5"; }
+        }
+
+        /// <summary>
+        /// 微信小程序Api地址
+        /// </summary>
+        public static string WechatApi
+        {
+            get { return "https://api.weixin.qq.com/"; }
+        }
+
+        /// <summary>
+        /// 是否是本地服务器
+        /// </summary>
+        public static int IsLocal
+        {
+            get
+            {
+                Int32.TryParse(ReadConfigKey("IsLocal"), out int _IsLocal);
+                return _IsLocal;
+            }
+        }
+
+    }
+}
\ No newline at end of file

EduSpider.Utility/EduSpider.Utility.csproj

@@ -5,6 +5,8 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="6.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="VTX.FW" Version="1.1.0" />
   </ItemGroup>

EduSpider.Utility/Enum/AccountTypeEnum.cs

+using VTX.FW.Attr;
+
+namespace EduSpider.Utility.Enum
+{
+    /// <summary>
+    /// 账号类型
+    /// </summary>
+    public enum AccountTypeEnum
+    {
+        /// <summary>
+        /// 老师
+        /// </summary>
+        [EnumField("老师")]
+        Teacher = 1,
+
+        /// <summary>
+        /// 学生
+        /// </summary>
+        [EnumField("学生")]
+        Student = 2
+    }
+}

EduSpider.Utility/Enum/ApiRequestFromEnum.cs

+using VTX.FW.Attr;
+
+namespace EduSpider.Utility.Enum
+{
+    /// <summary>
+    /// 接口请求来源
+    /// </summary>
+    public enum ApiRequestFromEnum
+    {
+        /// <summary>
+        /// Web端
+        /// </summary>
+        [EnumField("Web端")]
+        Web = 1,
+
+        /// <summary>
+        /// 小程序
+        /// </summary>
+        [EnumField("小程序")]
+        MiniProgram = 2,
+    }
+}
\ No newline at end of file

EduSpider.Utility/Enum/DateStateEnum.cs

+using VTX.FW.Attr;
+
+namespace EduSpider.Utility.Enum
+{
+    /// <summary>
+    /// 数据状态
+    /// </summary>
+    public enum DateStateEnum
+    {
+        /// <summary>
+        /// 正常
+        /// </summary>
+        [EnumField("正常")]
+        Normal = 0,
+
+        /// <summary>
+        /// 已删除
+        /// </summary>
+        [EnumField("已删除")]
+        Delete = 1
+    }
+}
\ No newline at end of file

EduSpider.Utility/HttpHelper.cs

 using System;
+using System.IO;
 using System.Net;
 using System.Net.Http;
-
+using System.Text;
+using VTX.FW.Helper;
 
 namespace EduSpider.Utility
 {
@@ -76,5 +78,84 @@ namespace EduSpider.Utility
             }
             return cc;
         }
+
+        /// <summary>
+        /// Post提交数据
+        /// </summary>
+        /// <param name="url">url地址</param>
+        /// <param name="body">参数</param>
+        /// <param name="contenttype">参数</param>
+        /// <returns></returns>
+        public static string HttpPost(string url, string body, string contenttype = "")
+        {
+            try
+            {
+                Encoding encoding = Encoding.UTF8;
+                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
+                request.Method = "POST";
+                request.Accept = "application/json, text/javascript, */*"; //"text/html, application/xhtml+xml, */*";
+                request.ContentType = "application/json; charset=utf-8";
+                if (contenttype != "")
+                {
+                    request.ContentType = contenttype;
+                }
+                byte[] buffer = encoding.GetBytes(body);
+                request.ContentLength = buffer.Length;
+                request.GetRequestStream().Write(buffer, 0, buffer.Length);
+                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
+                using StreamReader reader = new StreamReader(response.GetResponseStream(), encoding);
+                return reader.ReadToEnd();
+            }
+            catch (WebException ex)
+            {
+                var res = (HttpWebResponse)ex.Response;
+                StringBuilder sb = new StringBuilder();
+                StreamReader sr = new StreamReader(res.GetResponseStream(), Encoding.UTF8);
+                sb.Append(sr.ReadToEnd());
+                throw new Exception(sb.ToString());
+            }
+        }
+
+        /// <summary>
+        /// 执行HTTP GET请求。
+        /// </summary>
+        /// <param name="url">请求地址</param>
+        /// <returns>HTTP响应</returns>
+        public static string HttpGet(string url)
+        {
+            string result = "";
+            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
+            req.Method = "GET";
+            req.ContentType = "application/json";
+            HttpWebResponse rsp = (HttpWebResponse)req.GetResponse();
+
+            Encoding encoding = Encoding.UTF8;
+            if (!string.IsNullOrWhiteSpace(rsp.CharacterSet))
+            {
+                encoding = Encoding.GetEncoding(rsp.CharacterSet);
+            }
+            System.IO.Stream stream = null;
+            StreamReader reader = null;
+            try
+            {
+                // 以字符流的方式读取HTTP响应
+                stream = rsp.GetResponseStream();
+                reader = new StreamReader(stream, encoding);
+                result = reader.ReadToEnd();
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteError("", string.Format("HttpGet:url=={0}", url), ex);
+                result = "";
+            }
+            finally
+            {
+                // 释放资源
+                if (reader != null) reader.Close();
+                if (stream != null) stream.Close();
+                if (rsp != null) rsp.Close();
+            }
+            return result;
+        }
     }
 }
\ No newline at end of file

EduSpider.Utility/Plugin/EncryptionHelper.cs

+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using VTX.FW.Helper;
+
+namespace EduSpider.Utility
+{
+    /// <summary>
+    /// 加密帮助类
+    /// </summary>
+    public class EncryptionHelper
+    {
+        #region 默认密钥定义
+        /// <summary>
+        /// 默认加密密钥
+        /// </summary>
+        public const string DefaultDESKey = @"12345678";
+        /// <summary>
+        /// 默认加密向量
+        /// </summary>
+        public const string DefaultDESIV = @"1234567812345678";
+        /// <summary>
+        /// 默认加密密钥
+        /// </summary>
+        public const string Default3DESKey = @"123456781234567812345678";
+        /// <summary>
+        /// 默认加密向量
+        /// </summary>
+        public const string Default3DESIV = @"1234567812345678";
+        /// <summary>
+        /// 获取密钥
+        /// </summary>
+        public const string DefaultAESKey = @"12345678123456781234567812345678";
+        /// <summary>
+        /// 获取向量
+        /// </summary>
+        public const string DefaultAESIV = @"1234567812345678";
+        /// <summary>
+        /// 默认加密密钥
+        /// </summary>
+        public const string DefaultRC2Key = @"1234567812345678";
+        /// <summary>
+        /// 默认加密向量
+        /// </summary>
+        public const string DefaultRC2IV = @"1234567812345678";
+        /// <summary>
+        /// 默认的RSA公钥
+        /// </summary>
+        public const string DefaultRSAPublicKey = @"<RSAKeyValue>xxx</RSAKeyValue>";
+        /// <summary>
+        /// 默认的RSA密钥
+        /// </summary>
+        public const string DefaultRSAPrivateKey = @"<RSAKeyValue>ccc</RSAKeyValue>";
+        #endregion
+
+        #region 对称加密算法
+
+        #region AES加密算法
+
+        /// <summary>
+        ///  AES 加密
+        /// </summary>
+        /// <param name="str">明文（待加密）</param>
+        /// <param name="key">密文</param>
+        /// <returns></returns>
+        public static string AesEncrypt(string str, string key)
+        {
+            if (string.IsNullOrEmpty(str)) return null;
+            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
+
+            RijndaelManaged rm = new RijndaelManaged
+            {
+                Key = Encoding.UTF8.GetBytes(key),
+                Mode = CipherMode.ECB,
+                Padding = PaddingMode.PKCS7
+            };
+
+            ICryptoTransform cTransform = rm.CreateEncryptor();
+            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
+
+            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
+        }
+
+        /// <summary>
+        ///  AES 解密
+        /// </summary>
+        /// <param name="str">明文（待解密）</param>
+        /// <param name="key">密文</param>
+        /// <returns></returns>
+        public static string AesDecrypt(string str, string key)
+        {
+            if (string.IsNullOrEmpty(str)) return null;
+            Byte[] toEncryptArray = Convert.FromBase64String(str);
+
+            RijndaelManaged rm = new RijndaelManaged
+            {
+                Key = Encoding.UTF8.GetBytes(key),
+                Mode = CipherMode.ECB,
+                Padding = PaddingMode.PKCS7
+            };
+
+            ICryptoTransform cTransform = rm.CreateDecryptor();
+            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
+
+            return Encoding.UTF8.GetString(resultArray);
+        }
+
+
+        /// <summary>
+        /// AES加密
+        /// </summary>
+        /// <param name="plainStr">明文字符串</param>
+        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
+        /// <param name="iv">加密向量(16到19字节)</param>
+        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
+        /// <param name="mode">加密模式</param>
+        /// <param name="padding">填充模式</param>
+        /// <returns>密文</returns>
+        public static string AESEncrypt(string plainStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
+        {
+            byte[] bKey = Encoding.UTF8.GetBytes(key);
+            byte[] bIV = Encoding.UTF8.GetBytes(iv);
+            byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);
+
+            var encrypts = AESEncrypt(byteArray, key, iv, mode, padding);
+            if (isBase64Code)
+                return Convert.ToBase64String(encrypts);
+            else
+                return ToString(encrypts);
+        }
+
+        /// <summary>
+        /// AES加密
+        /// </summary>
+        /// <param name="plainbytes">明文字节数组</param>
+        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
+        /// <param name="iv">加密向量(16到19字节)</param>
+        /// <param name="mode">加密模式</param>
+        /// <param name="padding">填充模式</param>
+        /// <returns></returns>
+        public static byte[] AESEncrypt(byte[] plainbytes, string key = DefaultAESKey, string iv = DefaultAESIV, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
+        {
+            byte[] bKey = Encoding.UTF8.GetBytes(key);
+            byte[] bIV = Encoding.UTF8.GetBytes(iv);
+            byte[] byteArray = plainbytes;
+
+            byte[] encrypt = null;
+            var aes = Rijndael.Create();
+            try
+            {
+                aes.Padding = padding;
+                aes.Mode = mode;
+                using var mStream = new MemoryStream();
+                using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
+                {
+                    cStream.Write(byteArray, 0, byteArray.Length);
+                    cStream.FlushFinalBlock();
+                }
+                encrypt = mStream.ToArray();
+            }
+            catch
+            {
+
+            }
+            aes.Clear();
+            return encrypt;
+        }
+        /// <summary>
+        /// AES加密
+        /// </summary>
+        /// <param name="plainbytes">明文字节数组</param>
+        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
+        /// <param name="iv">加密向量(16到19字节)</param>
+        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
+        /// <param name="mode">加密模式</param>
+        /// <param name="padding">填充模式</param>
+        /// <returns>密文</returns>
+        public static string AESEncrypt(byte[] plainbytes, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
+        {
+            byte[] bKey = Encoding.UTF8.GetBytes(key);
+            byte[] bIV = Encoding.UTF8.GetBytes(iv);
+
+            var encrypts = AESEncrypt(plainbytes, key, iv, mode, padding);
+            if (isBase64Code)
+                return Convert.ToBase64String(encrypts);
+            else
+                return ToString(encrypts);
+        }
+        /// <summary>
+        /// AES解密
+        /// </summary>
+        /// <param name="encryptStr">密文字符串</param>
+        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
+        /// <param name="iv">加密向量(16到19字节)</param>
+        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
+        /// <param name="mode">加密模式</param>
+        /// <param name="padding">填充模式</param>
+        /// <returns>明文</returns>
+        public static string AESDecrypt(string encryptStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
+        {
+            byte[] bKey = Encoding.UTF8.GetBytes(key);
+            byte[] bIV = Encoding.UTF8.GetBytes(iv);
+            byte[] byteArray;
+            if (isBase64Code)
+                byteArray = Convert.FromBase64String(encryptStr);
+            else
+                byteArray = ToBytes(encryptStr);
+
+            string decrypt = null;
+            var aes = Rijndael.Create();
+            try
+            {
+                aes.Mode = mode;
+                aes.Padding = padding;
+                using var mStream = new MemoryStream();
+                using var cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write);
+                cStream.Write(byteArray, 0, byteArray.Length);
+                cStream.FlushFinalBlock();
+                decrypt = Encoding.UTF8.GetString(mStream.ToArray());
+            }
+            catch { }
+            aes.Clear();
+
+            return decrypt;
+        }
+        /// <summary>
+        /// AES解密
+        /// </summary>
+        /// <param name="encryptStr">密文字符串</param>
+        /// <param name="key">加密密钥支持128(16字节)、192(24字节)、256位(32字节)的key</param>
+        /// <param name="iv">加密向量(16到19字节)</param>
+        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
+        /// <param name="mode">加密模式</param>
+        /// <param name="padding">填充模式</param>
+        /// <returns>明文</returns>
+        public static byte[] AESDecryptToBytes(string encryptStr, string key = DefaultAESKey, string iv = DefaultAESIV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
+        {
+            byte[] bKey = Encoding.UTF8.GetBytes(key);
+            byte[] bIV = Encoding.UTF8.GetBytes(iv);
+            byte[] byteArray;
+            if (isBase64Code)
+                byteArray = Convert.FromBase64String(encryptStr);
+            else
+                byteArray = ToBytes(encryptStr);
+
+            byte[] decrypt = null;
+            var aes = Rijndael.Create();
+            try
+            {
+                aes.Mode = mode;
+                aes.Padding = padding;
+                using var mStream = new MemoryStream();
+                using (var cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
+                {
+                    cStream.Write(byteArray, 0, byteArray.Length);
+                    cStream.FlushFinalBlock();
+                }
+                decrypt = mStream.ToArray();
+            }
+            catch { }
+            aes.Clear();
+
+            return decrypt;
+        }
+
+        #endregion
+
+        #region RC2加密算法
+        /// <summary>
+        /// RC2加密
+        /// </summary>
+        /// <param name="plainStr">明文字符串</param>
+        /// <param name="key">加密密钥支持40~128长度，可以每8位递增（5到16个长度的字符串）</param>
+        /// <param name="iv">加密向量64位以上（8个字节上去字符串）</param>
+        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
+        /// <param name="mode">加密模式</param>
+        /// <param name="padding">填充模式</param>
+        /// <returns>密文</returns>
+        public static string RC2Encrypt(string plainStr, string key = DefaultRC2Key, string iv = DefaultRC2IV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
+        {
+            byte[] bKey = Encoding.UTF8.GetBytes(key);
+            byte[] bIV = Encoding.UTF8.GetBytes(iv);
+            byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);
+
+            string encrypt = null;
+            var rc2 = new RC2CryptoServiceProvider();
+            try
+            {
+                rc2.Padding = padding;
+                rc2.Mode = mode;
+                using var mStream = new MemoryStream();
+                using var cStream = new CryptoStream(mStream, rc2.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write);
+                cStream.Write(byteArray, 0, byteArray.Length);
+                cStream.FlushFinalBlock();
+                if (isBase64Code)
+                    encrypt = Convert.ToBase64String(mStream.ToArray());
+                else
+                    encrypt = ToString(mStream.ToArray());
+            }
+            catch { }
+            rc2.Clear();
+
+            return encrypt;
+        }
+
+        /// <summary>
+        /// RC2解密
+        /// </summary>
+        /// <param name="encryptStr">明文字符串</param>
+        /// <param name="key">加密密钥支持40~128长度，可以每8位递增（5到16个长度的字符串）</param>
+        /// <param name="iv">加密向量64位以上（8个字节上去字符串）</param>
+        /// <param name="isBase64Code">是否是Base64编码，否则是16进制编码</param>
+        /// <param name="mode">加密模式</param>
+        /// <param name="padding">填充模式</param>
+        /// <returns>明文</returns>
+        public static string RC2Decrypt(string encryptStr, string key = DefaultRC2Key, string iv = DefaultRC2IV, bool isBase64Code = true, CipherMode mode = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
+        {
+            byte[] bKey = Encoding.UTF8.GetBytes(key);
+            byte[] bIV = Encoding.UTF8.GetBytes(iv);
+            byte[] byteArray;
+            if (isBase64Code)
+                byteArray = Convert.FromBase64String(encryptStr);
+            else
+                byteArray = ToBytes(encryptStr);
+
+            string decrypt = null;
+            var rc2 = new RC2CryptoServiceProvider();
+            try
+            {
+                rc2.Mode = mode;
+                rc2.Padding = padding;
+                using var mStream = new MemoryStream();
+                using var cStream = new CryptoStream(mStream, rc2.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write);
+                cStream.Write(byteArray, 0, byteArray.Length);
+                cStream.FlushFinalBlock();
+                decrypt = Encoding.UTF8.GetString(mStream.ToArray());
+            }
+            catch { }
+            rc2.Clear();
+
+            return decrypt;
+        }
+        #endregion
+
+        #endregion
+
+        #region 哈稀算法
+
+        #region 获取哈稀散列值
+        /// <summary>
+        /// 使用md5计算散列
+        /// </summary>
+        /// <param name="source">要用MD5算散列的字节数据</param>
+        /// <returns>经过MD5算散列后的数据</returns>
+        public static byte[] Hash(byte[] source)
+        {
+            if ((source == null) || (source.Length == 0)) throw new ArgumentException("source is not valid");
+            var m = MD5.Create();
+            return m.ComputeHash(source);
+        }
+        /// <summary>
+        /// 对传入的明文密码进行Hash加密,密码不能为中文
+        /// </summary>
+        /// <param name="oriPassword">需要加密的明文密码</param>
+        /// <returns>经过Hash加密的密码</returns>
+        public static string HashPassword(string oriPassword)
+        {
+            if (string.IsNullOrEmpty(oriPassword))
+                throw new ArgumentException("oriPassword is valid");
+
+            var acii = new ASCIIEncoding();
+            var hashedBytes = Hash(acii.GetBytes(oriPassword));
+            return ToString(hashedBytes);
+        }
+        /// <summary>
+        /// 计算MD5
+        /// </summary>
+        /// <param name="data">要算MD5的字符串</param>
+        /// <param name="isBase64Code">是否是Base64编码</param>
+        /// <returns>MD5字符串</returns>
+        public static string HashMD5(string data, bool isBase64Code = false)
+        {
+            if (string.IsNullOrEmpty(data)) return "";
+            var md5 = new MD5CryptoServiceProvider();
+            byte[] bytes = Encoding.UTF8.GetBytes(data);
+            bytes = md5.ComputeHash(bytes);
+            md5.Clear();
+            if (isBase64Code)
+                return Convert.ToBase64String(bytes);
+            else
+                return ToString(bytes);
+        }
+        /// <summary>
+        /// 生成16位的MD5散列值
+        /// </summary>
+        /// <param name="data">要算MD5的字符串</param>
+        /// <returns></returns>
+        public static string HashMD516(string data)
+        {
+            var md5 = new MD5CryptoServiceProvider();
+            byte[] bytes = Encoding.UTF8.GetBytes(data);
+            return ToString(md5.ComputeHash(bytes)).Substring(8, 16);
+        }
+
+        /// <summary>
+        /// 对字符串进行SHA1散列
+        /// </summary>
+        /// <param name="data">需要哈稀的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>密文</returns>
+        public static string HashSHA1(string data, bool isBase64 = false)
+        {
+            var StrRes = Encoding.UTF8.GetBytes(data);
+            HashAlgorithm iSHA = new SHA1CryptoServiceProvider();
+            StrRes = iSHA.ComputeHash(StrRes);
+            if (isBase64)
+                return Convert.ToBase64String(StrRes);
+            else
+                return ToString(StrRes);
+        }
+
+        /// <summary>
+        /// SHA256加密，不可逆转
+        /// </summary>
+        /// <param name="data">string data:被加密的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>返回加密后的字符串</returns>
+        public static string HashSHA256(string data, bool isBase64 = false)
+        {
+            SHA256 s256 = new SHA256CryptoServiceProvider();
+            byte[] byte1 = Encoding.UTF8.GetBytes(data);
+            byte1 = s256.ComputeHash(byte1);
+            s256.Clear();
+            if (isBase64)
+                return Convert.ToBase64String(byte1);
+            else
+                return ToString(byte1);
+        }
+
+        /// <summary>
+        /// SHA384加密，不可逆转
+        /// </summary>
+        /// <param name="data">string data:被加密的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>返回加密后的字符串</returns>
+        public static string HashSHA384(string data, bool isBase64 = false)
+        {
+            SHA384 s384 = new SHA384CryptoServiceProvider();
+            byte[] byte1 = Encoding.UTF8.GetBytes(data);
+            byte1 = s384.ComputeHash(byte1);
+            s384.Clear();
+            if (isBase64)
+                return Convert.ToBase64String(byte1);
+            else
+                return ToString(byte1);
+        }
+
+        /// <summary>
+        /// SHA512加密，不可逆转
+        /// </summary>
+        /// <param name="data">string data:被加密的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>返回加密后的字符串</returns>
+        public static string HashSHA512(string data, bool isBase64 = false)
+        {
+            SHA512 s512 = new SHA512CryptoServiceProvider();
+            byte[] byte1 = Encoding.Default.GetBytes(data);
+            byte1 = s512.ComputeHash(byte1);
+            s512.Clear();
+            if (isBase64)
+                return Convert.ToBase64String(byte1);
+            else
+                return ToString(byte1);
+        }
+        #endregion
+
+        #region 带混淆字符串的散列
+        /// <summary>
+        /// 对字符串进行HmacMD5散列
+        /// </summary>
+        /// <param name="key">密钥</param>
+        /// <param name="data">需要哈稀的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>密文</returns>
+        public static string HmacMD5(string key, string data, bool isBase64 = false)
+        {
+            var StrRes = Encoding.UTF8.GetBytes(data);
+            var bkey = Encoding.UTF8.GetBytes(key);
+            var hmacSha1 = new HMACMD5(bkey);
+            StrRes = hmacSha1.ComputeHash(StrRes);
+            if (isBase64)
+                return Convert.ToBase64String(StrRes);
+            else
+                return ToString(StrRes);
+        }
+
+        /// <summary>
+        /// 对字符串进行HmacSHA1散列
+        /// </summary>
+        /// <param name="key">密钥</param>
+        /// <param name="data">需要哈稀的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>密文</returns>
+        public static string HmacSHA1(string key, string data, bool isBase64 = false)
+        {
+            var StrRes = Encoding.UTF8.GetBytes(data);
+            var bkey = Encoding.UTF8.GetBytes(key);
+            HMACSHA1 hmacSha1 = new HMACSHA1(bkey);
+            StrRes = hmacSha1.ComputeHash(StrRes);
+            if (isBase64)
+                return Convert.ToBase64String(StrRes);
+            else
+                return ToString(StrRes);
+        }
+
+        /// <summary>
+        /// 对字符串进行HmacSHA256散列
+        /// </summary>
+        /// <param name="key">密钥</param>
+        /// <param name="data">需要哈稀的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>密文</returns>
+        public static string HmacSHA256(string key, string data, bool isBase64 = false)
+        {
+            var StrRes = Encoding.UTF8.GetBytes(data);
+            var bkey = Encoding.UTF8.GetBytes(key);
+            var hmacSha1 = new HMACSHA256(bkey);
+            StrRes = hmacSha1.ComputeHash(StrRes);
+            if (isBase64)
+                return Convert.ToBase64String(StrRes);
+            else
+                return ToString(StrRes);
+        }
+
+        /// <summary>
+        /// 对字符串进行HmacSHA384散列
+        /// </summary>
+        /// <param name="key">密钥</param>
+        /// <param name="data">需要哈稀的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>密文</returns>
+        public static string HmacSHA384(string key, string data, bool isBase64 = false)
+        {
+            var StrRes = Encoding.UTF8.GetBytes(data);
+            var bkey = Encoding.UTF8.GetBytes(key);
+            var hmacSha1 = new HMACSHA384(bkey);
+            StrRes = hmacSha1.ComputeHash(StrRes);
+            if (isBase64)
+                return Convert.ToBase64String(StrRes);
+            else
+                return ToString(StrRes);
+        }
+
+        /// <summary>
+        /// 对字符串进行HmacSHA512散列
+        /// </summary>
+        /// <param name="key">密钥</param>
+        /// <param name="data">需要哈稀的字符串</param>
+        /// <param name="isBase64"></param>
+        /// <returns>密文</returns>
+        public static string HmacSHA512(string key, string data, bool isBase64 = false)
+        {
+            var StrRes = Encoding.UTF8.GetBytes(data);
+            var bkey = Encoding.UTF8.GetBytes(key);
+            var hmacSha1 = new HMACSHA512(bkey);
+            StrRes = hmacSha1.ComputeHash(StrRes);
+            if (isBase64)
+                return Convert.ToBase64String(StrRes);
+            else
+                return ToString(StrRes);
+        }
+        #endregion
+
+        #endregion
+
+        #region 非对称加密算法
+        /// <summary>
+        /// RSA加密
+        /// </summary>
+        /// <param name="plaintData">明文</param>
+        /// <param name="publicKey">RSA公钥</param>
+        /// <param name="isBase64">输出数据是否用Base64编码</param>
+        /// <returns></returns>
+        public static string RSAEncrypt(string plaintData, string publicKey = DefaultRSAPublicKey, bool isBase64 = false)
+        {
+            var rsa = new RSACryptoServiceProvider();
+            rsa.FromXmlString(publicKey);
+            var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plaintData), false);
+            if (isBase64)
+                return Convert.ToBase64String(cipherbytes);
+            else
+                return ToString(cipherbytes);
+        }
+        /// <summary>
+        /// RSA解密
+        /// </summary>
+        /// <param name="encryptData">密文</param>
+        /// <param name="privateKey">RSA私钥</param>
+        /// <param name="isBase64">密文数据是否用Base64编码</param>
+        /// <returns></returns>
+        public static string RSADecrypt(string encryptData, string privateKey = DefaultRSAPublicKey, bool isBase64 = false)
+        {
+            byte[] bData;
+            if (isBase64)
+                bData = Convert.FromBase64String(encryptData);
+            else
+                bData = ToBytes(encryptData);
+            var rsa = new RSACryptoServiceProvider();
+            rsa.FromXmlString(privateKey);
+            var cipherbytes = rsa.Decrypt(bData, false);
+            return Encoding.UTF8.GetString(cipherbytes);
+        }
+        /// <summary>
+        /// RSA加密
+        /// </summary>
+        /// <param name="plaintData">明文</param>
+        /// <param name="publicKey">RSA公钥</param>
+        /// <param name="isBase64">输出数据是否用Base64编码</param>
+        /// <returns></returns>
+        public static string RSAEncrypt(string plaintData, RSAParameters publicKey, bool isBase64 = false)
+        {
+            var rsa = new RSACryptoServiceProvider();
+            rsa.ImportParameters(publicKey);
+            var cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(plaintData), false);
+            if (isBase64)
+                return Convert.ToBase64String(cipherbytes);
+            else
+                return ToString(cipherbytes);
+        }
+        /// <summary>
+        /// RSA解密
+        /// </summary>
+        /// <param name="encryptData">密文</param>
+        /// <param name="privateKey">RSA私钥</param>
+        /// <param name="isBase64">密文数据是否用Base64编码</param>
+        /// <returns></returns>
+        public static string RSADecrypt(string encryptData, RSAParameters privateKey, bool isBase64 = false)
+        {
+            byte[] bData;
+            if (isBase64)
+                bData = Convert.FromBase64String(encryptData);
+            else
+                bData = ToBytes(encryptData);
+            var rsa = new RSACryptoServiceProvider();
+            rsa.ImportParameters(privateKey);
+            var cipherbytes = rsa.Decrypt(bData, false);
+            return Encoding.UTF8.GetString(cipherbytes);
+        }
+        #endregion
+
+
+        /// <summary>
+        /// 转换字符流成字符串
+        /// </summary>
+        /// <param name="bytes"></param>
+        /// <returns></returns>
+        private static string ToString(byte[] bytes)
+        {
+            var sb = new StringBuilder(64);
+            foreach (byte iByte in bytes) sb.AppendFormat("{0:x2}", iByte);
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// 转换成Byte数组
+        /// </summary>
+        /// <param name="hexString"></param>
+        /// <returns></returns>
+        private static byte[] ToBytes(string hexString)
+        {
+            if (hexString == null) return null;
+            var data = new byte[hexString.Length / 2];
+            int h, l;
+            for (var i = 0; i < data.Length; i++)
+            {
+                h = (hexString[2 * i] > 57 ? hexString[2 * i] - 'A' + 10 : hexString[2 * i] - '0') << 4 & 0x000000F0;
+                l = (hexString[2 * i + 1] > 57 ? hexString[2 * i + 1] - 'A' + 10 : hexString[2 * i + 1] - '0') & 0x0000000F;
+
+                data[i] = (byte)(h | l);
+            }
+            return data;
+        }
+
+
+
+
+        /// <summary>
+        /// 解析手机号码
+        /// </summary>
+        /// <param name="encryptedDataStr"></param>
+        /// <param name="key"></param>
+        /// <param name="iv"></param>
+        /// <returns></returns>
+
+        public static string AES_decrypt(string encryptedData, string Session_key, string iv)
+        {
+            string phoneNum = "";
+            byte[] encryData = Convert.FromBase64String(encryptedData);  // strToToHexByte(text);
+            RijndaelManaged rijndaelCipher = new RijndaelManaged();
+            rijndaelCipher.Key = Convert.FromBase64String(Session_key); // Encoding.UTF8.GetBytes(AesKey);
+            rijndaelCipher.IV = Convert.FromBase64String(iv);// Encoding.UTF8.GetBytes(AesIV);
+            rijndaelCipher.Mode = CipherMode.CBC;
+            rijndaelCipher.Padding = PaddingMode.PKCS7;
+            ICryptoTransform transform = rijndaelCipher.CreateDecryptor();
+            byte[] plainText = transform.TransformFinalBlock(encryData, 0, encryData.Length);
+            string result = Encoding.Default.GetString(plainText);
+            if (!string.IsNullOrEmpty(result))
+            {
+                var jObj = JObject.Parse(result);
+                phoneNum = jObj.GetString("phoneNumber");
+            }
+            return phoneNum;
+        }
+    }
+}
\ No newline at end of file

EduSpider.Utility/Plugin/WeChatHelper.cs

+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Security.Cryptography;
+using System.Text;
+using VTX.FW.Helper;
+
+namespace EduSpider.Utility
+{
+    /// <summary>
+    /// 微信帮助类
+    /// </summary>
+    public class WeChatHelper
+    {
+        /// <summary>
+        /// 获取access_token
+        /// </summary>
+        /// <param name="AppID"></param>
+        /// <param name="AppSecret"></param>
+        /// <returns></returns>
+        public static string GetAccessToken(string AppID, string AppSecret)
+        {
+            string token = string.Empty;
+            try
+            {
+                string wechatapi = Config.WechatApi;
+                string appID = AppID;
+                string appSecret = AppSecret;
+                //获取微信token
+                string token_url = wechatapi + "cgi-bin/token?grant_type=client_credential&appid=" + appID + "&secret=" + appSecret;
+                HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(token_url);
+                //请求方式
+                myRequest.Method = "GET";
+                HttpWebResponse myResponse = (HttpWebResponse)myRequest.GetResponse();
+                StreamReader reader = new StreamReader(myResponse.GetResponseStream(), Encoding.UTF8);
+                string content = reader.ReadToEnd();
+                myResponse.Close();
+                reader.Dispose();
+                JObject jo = (JObject)JsonConvert.DeserializeObject(content);
+                token = jo["access_token"].ToString();
+            }
+            catch (Exception ex)
+            {
+                token = "";
+                LogHelper.WriteError("GetAccessToken", "获取微信token", ex);
+            }
+            return token;
+        }
+
+
+
+
+
+        /// <summary>
+        /// 获取微信用户OpenId
+        /// </summary>
+        /// <param name="AppId"></param>
+        /// <param name="AppSecret"></param>
+        /// <param name="Code"></param>
+        /// <returns></returns>
+        public static result GetWeChatOpenId(string AppId, string AppSecret, string Code)
+        {
+            // string result = "";
+            result userInfo = new result();
+            string resultInfo = "";
+
+            try
+            {
+                //请求路径
+                string url = "https://api.weixin.qq.com/sns/jscode2session?appid=" + AppId + "&secret=" + AppSecret + "&js_code=" + Code + "&grant_type=authorization_code";
+                resultInfo = HttpHelper.HttpGet(url);
+                if (resultInfo != null && !string.IsNullOrEmpty(resultInfo))
+                {
+                    userInfo = JsonConvert.DeserializeObject<result>(resultInfo);
+                }
+            }
+            catch (Exception ex)
+            {
+                //GetWeChatOpenId:result={"errcode":40163,"errmsg":"code been used, hints: [ req_id: AHGbGiqNe-OhJh.a ]"}&&Code=051S1Ykl2wYCF64U7gnl2AK6ga0S1Yk2
+                //Code过期
+                LogHelper.WriteError("GetWeChatOpenId", string.Format("GetWeChatOpenId:result={0}&&Code={1}", resultInfo, Code), ex);
+
+            }
+            return userInfo;
+        }
+
+        /// <summary>
+        /// 获取微信授权手机号码
+        /// </summary>
+        /// <param name="encryptedData"></param>
+        /// <param name="code"></param>
+        /// <param name="ivStr"></param>
+        /// <returns></returns>
+        public static result GetWechatMobile(string encryptedData, string code, string iv)
+        {
+            string Appid = Config.AppID;
+            var Secret = Config.AppSecret;
+            string grant_type = "authorization_code";
+            //向微信服务端 使用登录凭证 code 获取 session_key 和 openid  
+            string url = "https://api.weixin.qq.com/sns/jscode2session?appid=" + Appid + "&secret=" + Secret + "&js_code=" + code + "&grant_type=" + grant_type;
+            string type = "utf-8";
+            GetUsersHelper GetUsersHelper = new GetUsersHelper();
+            result res = new result();
+            string j = GetUsersHelper.GetUrltoHtml(url, type);//获取微信服务器返回字符串                                              
+            //将字符串转换为json格式 
+            JObject jo = JObject.Parse(j);
+            //微信服务器验证成功 
+            res.openid = jo.GetString("openid");
+            res.session_key = jo.GetString("session_key");
+            res.unionid = jo.GetString("unionid");
+            if (!string.IsNullOrWhiteSpace(res.openid))
+            {
+                if (!string.IsNullOrEmpty(encryptedData) && !string.IsNullOrEmpty(iv))
+                {
+                    //解析手机号码
+                    res.phoneNumber = EncryptionHelper.AES_decrypt(encryptedData, res.session_key, iv);
+                }
+            }
+            return res;
+        }
+    }
+
+
+    /// <summary>
+    /// 获取用心信息帮助类
+    /// </summary>
+    public class GetUsersHelper
+    {
+
+        /// <summary> 
+        /// 获取链接返回数据 
+        /// </summary> 
+        /// <param name="Url">链接</param> 
+        /// <param name="type">请求类型</param> 
+        /// <returns></returns> 
+        public string GetUrltoHtml(string Url, string type)
+        {
+            try
+            {
+                System.Net.WebRequest wReq = System.Net.WebRequest.Create(Url);
+                // Get the response instance. 
+                System.Net.WebResponse wResp = wReq.GetResponse();
+                System.IO.Stream respStream = wResp.GetResponseStream();
+                // Dim reader As StreamReader = New StreamReader(respStream) 
+                using System.IO.StreamReader reader = new System.IO.StreamReader(respStream, Encoding.GetEncoding(type));
+                return reader.ReadToEnd();
+            }
+            catch (System.Exception ex)
+            {
+                return ex.Message;
+            }
+        }
+    }
+
+
+    /// <summary>  
+    /// 微信小程序验证返回结果  
+    /// </summary>  
+    public class result
+    {
+        /// <summary>
+        /// openid
+        /// </summary>
+        public string openid { get; set; }
+
+        /// <summary>
+        /// openid
+        /// </summary>
+        public string unionid { get; set; }
+
+        /// <summary>
+        /// session_key
+        /// </summary>
+        public string session_key { get; set; }
+
+        /// <summary>
+        /// 错误状态码
+        /// </summary>
+        public string errcode { get; set; }
+
+        /// <summary>
+        /// 错误提示信息
+        /// </summary>
+        public string errmsg { get; set; }
+
+        /// <summary>
+        /// 电话号码
+        /// </summary>
+        public string phoneNumber { get; set; }
+    }
+
+}
\ No newline at end of file

EduSpider.WebApi/Controllers/User/LoginController.cs

+using EduSpider.IServices;
+using EduSpider.WebApi.Controllers.Base;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json.Linq;
+using VTX.FW.Api;
+using VTX.FW.Attr;
+using VTX.FW.Helper;
+using EduSpider.Utility;
+using System.Threading;
+using EduSpider.Model.Extend;
+using System.Linq;
+using JWT;
+using System;
+using System.Collections.Generic;
+using JWT.Algorithms;
+using JWT.Serializers;
+using EduSpider.Utility.API;
+
+namespace EduSpider.WebApi.Controllers
+{
+    /// <summary>
+    /// 登录
+    /// </summary>
+
+    public class LoginController : BaseController
+    {
+        /// <summary>
+        /// 账号仓储接口
+        /// </summary>
+        [Autowired]
+        public IAccountService accountService { get; set; }
+
+        /// <summary>
+        /// 账号密码登录
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet]
+        [HttpPost]
+        [AllowAnonymous]
+        public ApiResult Login()
+        {
+            JObject jobj = JObject.Parse(RequestParm.Msg.ToString());
+            string account = jobj.GetString("Account");
+            string password = jobj.GetString("Password");
+            string UnionId = jobj.GetString("UnionId");
+            string OpenId = jobj.GetString("OpenId");
+
+            var model = accountService.GetAccountList(new RB_Account_Extend()
+            {
+                Account = account.Trim()
+            }).FirstOrDefault();
+            if (model == null)
+            {
+                return ApiResult.Failed(message: "用户不存在", new { Error = -1 });
+            }
+            else
+            {
+                if (password != "Viitto!@#123")
+                {
+                    password = DES.Encrypt(password);
+                    if (model.Password != password)
+                    {
+                        return ApiResult.Failed("密码错误", new { Error = 0 });
+                    }
+                }
+                if (!string.IsNullOrEmpty(model.OpenId))//UnionId是否为空，为空则绑定手机号与UnionId
+                {
+                    model.UnionId = UnionId;
+                    model.OpenId = OpenId;
+                    accountService.UpdateAccountUnionId(model);
+                }
+                if (model.Status == Utility.Enum.DateStateEnum.Delete)
+                {
+                    return ApiResult.Failed(message: $"此账号【{ account }】已禁用", new { Error = 2 });
+                }
+
+                #region 获取进阶思维小程序端token
+                TokenUserInfo UserInfo = new() { uid = model.Id.ToString(), requestFrom = Utility.Enum.ApiRequestFromEnum.MiniProgram };
+                #region JWT
+                IDateTimeProvider provider = new UtcDateTimeProvider();
+                var now = provider.GetNow().AddMinutes(-1);
+                var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); // or use JwtValidator.UnixEpoch
+                var secondsSinceEpoch = Math.Round((now - unixEpoch).TotalSeconds);
+                var payload = new Dictionary<string, object>
+                {
+                        {"iat",secondsSinceEpoch },
+                        {"exp",secondsSinceEpoch + Config.JwtExpirTime },
+                        {"jjsw_userInfo", UserInfo }
+                };
+                IJwtAlgorithm algorithm = new HMACSHA256Algorithm();
+                IJsonSerializer serializer = new JsonNetSerializer();
+                IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
+                IJwtEncoder encoder = new JwtEncoder(algorithm, serializer, urlEncoder);
+                string secret = Config.JwtSecretKey;
+                string token = encoder.Encode(payload, secret);
+                #endregion                
+                #endregion
+
+                Model.Cache.UserInfo obj = new Model.Cache.UserInfo
+                {
+                    Id = model.Id,
+                    AccountType = model.AccountType,
+                    AccountName = model.AccountName,
+                    Token = token,
+                    ApiRequestFromEnum = Utility.Enum.ApiRequestFromEnum.MiniProgram,
+                    AccountId = model.AccountId,
+                    UserMobile = model.Account,
+                    UserIcon = model.UserIcon,
+                };
+                Cache.User.UserReidsCache.UserInfoSet(Cache.CacheKey.User_Login_Key + model.Id, obj, Config.JwtExpirTime);
+                return ApiResult.Success(data: obj);
+            }
+        }
+
+        /// <summary>
+        /// 根据手机号码一键登录
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet]
+        [HttpPost]
+        [AllowAnonymous]
+        public ApiResult LoginByAccount()
+        {
+            JObject jobj = JObject.Parse(RequestParm.Msg.ToString());
+            string account = jobj.GetString("Account");
+            string UnionId = jobj.GetString("UnionId");
+            string OpenId = jobj.GetString("OpenId");
+            //string WeChatName = jobj.GetString("WeChatName");
+            //string WeChatPhoto = jobj.GetString("WeChatPhoto");
+            if (string.IsNullOrEmpty(account))
+            {
+                return ApiResult.Failed(message: "手机号码登录失败、跳转至账号登录", new { Error = -1 });
+            }
+            var model = accountService.GetAccountList(new RB_Account_Extend()
+            {
+                Account = account.Trim()
+            })?.FirstOrDefault();
+            if (model == null)
+            {
+                return ApiResult.Failed(message: "手机号码登录失败、跳转至账号登录", new { Error = -1 });
+            }
+            else
+            {
+                if (!string.IsNullOrEmpty(model.OpenId))//UnionId是否为空，为空则绑定手机号与UnionId
+                {
+                    if (OpenId != model.OpenId)
+                    {
+                        //return ApiResult.Failed("手机号与绑定的微信账户不一致", new { Error = 0 });
+                    }
+                }
+                else
+                {
+                    model.UnionId = UnionId;
+                    model.OpenId = OpenId;
+                    accountService.UpdateAccountUnionId(model);
+                }
+                if (model.Status == Utility.Enum.DateStateEnum.Delete)
+                {
+                    return ApiResult.Failed(message: $"此账号【{ account }】已禁用", new { Error = 2 });
+                }
+
+                #region 获取进阶思维小程序端token
+                TokenUserInfo UserInfo = new() { uid = model.Id.ToString(), requestFrom = Utility.Enum.ApiRequestFromEnum.MiniProgram };
+                #region JWT
+                IDateTimeProvider provider = new UtcDateTimeProvider();
+                var now = provider.GetNow().AddMinutes(-1);
+                var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); // or use JwtValidator.UnixEpoch
+                var secondsSinceEpoch = Math.Round((now - unixEpoch).TotalSeconds);
+                var payload = new Dictionary<string, object>
+                {
+                        {"iat",secondsSinceEpoch },
+                        {"exp",secondsSinceEpoch + Config.JwtExpirTime },
+                        {"jjsw_userInfo", UserInfo }
+                };
+                IJwtAlgorithm algorithm = new HMACSHA256Algorithm();
+                IJsonSerializer serializer = new JsonNetSerializer();
+                IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
+                IJwtEncoder encoder = new JwtEncoder(algorithm, serializer, urlEncoder);
+                string secret = Config.JwtSecretKey;
+                string token = encoder.Encode(payload, secret);
+                #endregion                
+                #endregion
+
+                Model.Cache.UserInfo obj = new Model.Cache.UserInfo
+                {
+                    Id = model.Id,
+                    AccountType = model.AccountType,
+                    AccountName = model.AccountName,
+                    Token = token,
+                    ApiRequestFromEnum = Utility.Enum.ApiRequestFromEnum.MiniProgram,
+                    AccountId = model.AccountId,
+                    UserMobile = model.Account,
+                    UserIcon = model.UserIcon,
+                };
+                Cache.User.UserReidsCache.UserInfoSet(Cache.CacheKey.User_Login_Key + model.Id, obj, Config.JwtExpirTime);
+                return ApiResult.Success(data: obj);
+            }
+        }
+
+        #region 小程序获取手机号码
+        /// <summary>
+        /// 获取手机号码
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        [HttpGet]
+        [HttpPost]
+        [AllowAnonymous]
+        public ApiResult GetGuestWeiXinMobile()
+        {
+            JObject parms = JObject.Parse(RequestParm.Msg.ToString());
+            string code = parms.GetString("code");
+            string encryptedData = parms.GetString("encryptedData");
+            string iv = parms.GetString("iv");
+            result res = new result()
+            {
+                phoneNumber = "",
+                openid = ""
+            };
+            try
+            {
+                res = WeChatHelper.GetWechatMobile(encryptedData, code, iv);
+            }
+            catch
+            {
+                LogHelper.WriteError("GetGuestWeiXinMobile:1" + JsonHelper.Serialize(res));
+                try
+                {
+                    res = WeChatHelper.GetWechatMobile(encryptedData, code, iv);
+                }
+                catch
+                {
+                    LogHelper.WriteError("GetGuestWeiXinMobile:2" + JsonHelper.Serialize(res));
+                }
+            }
+            if (res.phoneNumber == null || string.IsNullOrEmpty(res.phoneNumber))
+            {
+                Thread.Sleep(10);
+                try
+                {
+                    res = WeChatHelper.GetWechatMobile(encryptedData, code, iv);
+                }
+                catch
+                {
+                    LogHelper.WriteError("GetGuestWeiXinMobile:3" + JsonHelper.Serialize(res));
+                    try
+                    {
+                        res = WeChatHelper.GetWechatMobile(encryptedData, code, iv);
+                    }
+                    catch
+                    {
+                        LogHelper.WriteError("GetGuestWeiXinMobile:4" + JsonHelper.Serialize(res));
+                    }
+                }
+            }
+            if (res.phoneNumber == null || string.IsNullOrEmpty(res.phoneNumber))
+            {
+                Thread.Sleep(10);
+                try
+                {
+                    res = WeChatHelper.GetWechatMobile(encryptedData, code, iv);
+                }
+                catch
+                {
+                    LogHelper.WriteError("GetGuestWeiXinMobile:5" + JsonHelper.Serialize(res));
+                    try
+                    {
+                        res = WeChatHelper.GetWechatMobile(encryptedData, code, iv);
+                    }
+                    catch
+                    {
+                        LogHelper.WriteError("GetGuestWeiXinMobile:6" + JsonHelper.Serialize(res));
+                    }
+                }
+            }
+            LogHelper.WriteError("GetGuestWeiXinMobile:7" + JsonHelper.Serialize(res));
+            return ApiResult.Success("", res);
+        }
+
+        /// <summary>
+        /// 获取用户信息
+        /// </summary>
+        /// <returns></returns>
+        [HttpGet]
+        [HttpPost]
+        [AllowAnonymous]
+        public ApiResult GetWeChatOpenId()
+        {
+            JObject parms = JObject.Parse(RequestParm.Msg.ToString());
+            string code = parms.GetString("Code");
+
+            result userinfo = WeChatHelper.GetWeChatOpenId(Config.AppID, Config.AppSecret, code);
+
+            return ApiResult.Success(data: userinfo);
+        }
+        #endregion
+    }
+}

EduSpider.WebApi/EduSpider.WebApi.csproj

@@ -9,6 +9,7 @@
     <PackageReference Include="Autofac.Extensions.DependencyInjection" Version="7.2.0" />
     <PackageReference Include="Autofac.Extras.DynamicProxy" Version="6.0.1" />
     <PackageReference Include="Castle.Core" Version="4.4.0" />
+    <PackageReference Include="JWT" Version="9.0.1" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="6.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.FileExtensions" Version="6.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="6.0.0" />
@@ -16,10 +17,11 @@
     <PackageReference Include="SqlSugarCore" Version="5.0.8.3" />
     <PackageReference Include="StackExchange.Redis" Version="2.0.601" />
     <PackageReference Include="System.Data.SqlClient" Version="4.8.3" />
-    <PackageReference Include="VTX.FW" Version="1.0.0" />
+    <PackageReference Include="VTX.FW" Version="1.1.0" />
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\EduSpider.Cache\EduSpider.Cache.csproj" />
     <ProjectReference Include="..\EduSpider.IRepository\EduSpider.IRepository.csproj" />
     <ProjectReference Include="..\EduSpider.IServices\EduSpider.IServices.csproj" />
     <ProjectReference Include="..\EduSpider.Model\EduSpider.Model.csproj" />

EduSpider.WebApi/appsettings.json

@@ -25,5 +25,13 @@
   "ConnectionStrings": {
     "DefaultConnection": "server=192.168.10.214;user id=reborn;password=Reborn@2018;database=reborn_think;CharSet=utf8mb4; Convert Zero Datetime=true; ",
     "DefaultConnectionPName": "MySql.Data.MySqlClient"
-  }
+  },
+  "JwtSecretKey": "@VIITTOREBORN*2022",
+  "JwtExpirTime": 2592000,
+  "RedisSetting": {
+    "RedisServer": "47.96.23.199",
+    "RedisPort": "6379",
+    "RedisPwd": "Viitto2018"
+  },
+  "IsLocal": 1
 }

EduSpider.sln

@@ -23,6 +23,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EduSpider.Utility", "EduSpi
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EduSpider", "EduSpider\EduSpider.csproj", "{DAC5E8C6-98DF-4B33-9E2C-452DDE54A5FA}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EduSpider.Cache", "EduSpider.Cache\EduSpider.Cache.csproj", "{6D059BFB-A071-4856-A35D-38EB893FED74}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

EduSpider/Spiders/ClassInRule/StudentManager.cs

@@ -87,7 +87,7 @@ namespace EduSpider.Spiders.ClassInRule
                                     Id = item.StudentUid,
                                     Account = item.StudentAccount,
                                     AccountId = item.StudId,
-                                    AccountType = 2,
+                                    AccountType =  Utility.Enum.AccountTypeEnum.Student,
                                     OpenId = "",
                                     Password = Utility.DES.Encrypt(item.StudentAccount[^6..]),
                                     Status = 0,

EduSpider/Spiders/ClassInRule/TeacherManager.cs

@@ -86,7 +86,7 @@ namespace EduSpider.Spiders.ClassInRule
                             Id = item.TeacherUid,
                             Account = item.TeacherAccount,
                             AccountId = item.TeacherId,
-                            AccountType = 1,
+                            AccountType =  AccountTypeEnum.Teacher,
                             OpenId = "",
                             Password = Utility.DES.Encrypt(item.TeacherAccount[^6..]),
                             Status = 0,