OMS.NET/GlobalArea.cs

using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using OMS.NET.Common;
using OMS.NET.DbClass;

namespace OMS.NET
{
    class GlobalArea
    {
        #region 用户登录列表相关
        private static readonly List<UserConnect> _UserConnectList = new();
        private static readonly object _UserConnectListLock = new();
        /// <summary>
        /// 连接客户端数量
        /// </summary>
        public static int ConnectClientsCount
        {
            get
            {
                lock (_UserConnectListLock)
                {
                    return _UserConnectList.Count;
                }
            }
        }
        public static int LoginUserCount
        {
            get
            {
                lock (_UserConnectListLock)
                {
                    return _UserConnectList
                    .Where(u => u.UserEmail != null)  // 过滤出UserEmail不为空的项
                    .Select(u => u.UserEmail) // 选择UserEmail
                    .Distinct().Count(); // 去重且计算数量
                }
            }
        }
        public static List<UserConnect> UserConnects
        {
            get
            {
                lock (_UserConnectListLock)
                {
                    return _UserConnectList;
                }
            }
        }
        /// <summary>
        /// 添加ws连接记录
        /// </summary>
        public static void AddUserConnect(string wsid, IPEndPoint iPEndPoint)
        {
            lock (_UserConnectListLock)
            {
                UserConnect userConnect = new(wsid, iPEndPoint);
                _UserConnectList.Add(userConnect);
            }
        }
        public static void RemoveUserConnectByID(string wsid)
        {
            lock (_UserConnectListLock)
            {
                UserConnect? userConnect = _UserConnectList.Find(u => u.ID == wsid);
                if (userConnect != null)
                {
                    _UserConnectList.Remove(userConnect);
                }
            }
        }

        public static bool LoginCheckByID(string wsid)
        {
            lock (_UserConnectListLock)
            {
                return _UserConnectList.Exists(u => u.ID == wsid && u.UserEmail != null);
            }
        }

        /// <summary>
        /// 通过wsid查询连接的Email信息
        /// </summary>
        /// <returns>Email信息，可能是空字符串</returns>
        public static string GetLoginEmailByID(string wsid)
        {
            lock (_UserConnectListLock)
            {
                return _UserConnectList.First(u => u.ID == wsid).UserEmail!;
            }
        }

        public static bool LoginCheckByEmail(string email)
        {
            lock (_UserConnectListLock)
            {
                return _UserConnectList.Exists(u => u.UserEmail == email);
            }
        }
        /// <summary>
        /// 添加登录记录
        /// </summary>
        public static void Login(string wsid, string email)
        {
            lock (_UserConnectListLock)
            {
                UserConnect? userConnect = _UserConnectList.Find(u => u.ID == wsid);
                if (userConnect != null)
                {
                    userConnect.UserEmail = email;
                }
            }
        }

        #endregion

        #region 服务器配置相关
        private static ServerConfig _ServerConfig = new();
        private static readonly object _ServerConfigLock = new();

        /// <summary>
        /// 提供只读服务器配置访问
        /// </summary>
        public static ServerConfig ServerConfig
        {
            get
            {
                lock (_ServerConfigLock)
                {
                    return _ServerConfig;
                }
            }
        }

        /// <summary>
        /// 提供完整的数据库连接字符串，带数据库名称
        /// </summary>
        public static string ConnectionStringWithDbName
        {
            get
            {
                lock (_ServerConfigLock)
                {
                    return _ServerConfig.ConnectionString + ";database=" + _ServerConfig.DataBaseName;
                }
            }
        }
        public static void LoadServerConfig()
        {
            lock (_ServerConfigLock)
            {
                string configPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"server.yaml");
                //读取配置文件
                _ServerConfig = new(configPath);
                Console.WriteLine("已读取到配置文件..." + Environment.NewLine + _ServerConfig.ToString());
            }
        }
        #endregion

        #region RSA加解密相关
        private static readonly RSA _Rsa = RSA.Create();
        private static readonly object _RsaLock = new();

        public static RSA Rsa
        {
            get
            {
                lock (_RsaLock)
                {
                    return _Rsa;
                }
            }
        }

        /// <summary>
        /// 导入指定私钥，如果不存在则创建并保存
        /// </summary>
        public static void LoadRsaPkey()
        {
            lock (_RsaLock)
            {
                string pkeyPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @".pkey");
                if (File.Exists(pkeyPath))
                {
                    DateTime lastModifyTime = File.GetLastWriteTime(pkeyPath);
                    bool isOneYearApart = Math.Abs((DateTime.Now - lastModifyTime).TotalDays) >= 365;
                    if (isOneYearApart)
                    {
                        File.WriteAllText(pkeyPath, Convert.ToBase64String(_Rsa.ExportPkcs8PrivateKey()));
                    }
                    else
                    {
                        string pkey = File.ReadAllText(pkeyPath);
                        Console.WriteLine("继续使用现有pkey: " + pkey);
                        _Rsa.ImportPkcs8PrivateKey(Convert.FromBase64String(pkey), out _);
                    }

                }
                else
                {
                    File.WriteAllText(pkeyPath, Convert.ToBase64String(_Rsa.ExportPkcs8PrivateKey()));
                    Console.WriteLine("创建pkey:" + File.ReadAllText(pkeyPath));
                }

            }
        }

        /// <summary>
        /// 以base64格式导出公钥字符串
        /// </summary>
        /// <returns>公钥字符串，base64格式</returns>
        public static string GetRsaPublickKey()
        {
            lock (_RsaLock)
            {
                return Convert.ToBase64String(_Rsa.ExportRSAPublicKey());
            }
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="base64">base64编码的密文</param>
        /// <returns>原文字符串 utf-8编码</returns>
        public static string DecryptFromBase64String(string base64)
        {
            lock (_RsaLock)
            {
                byte[] decrypt = _Rsa.Decrypt(Convert.FromBase64String(base64),
                                    RSAEncryptionPadding.Pkcs1);
                return Encoding.UTF8.GetString(decrypt);
            }
        }

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="src">原文字符串 utf-8编码</param>
        /// <returns>base64编码的密文</returns>
        public static string EncryptToBase64String(string src)
        {
            lock (_RsaLock)
            {
                byte[] encrypt = _Rsa.Encrypt(Encoding.UTF8.GetBytes(src),
                    RSAEncryptionPadding.Pkcs1);
                return Convert.ToBase64String(encrypt);
            }
        }

        #endregion

        #region 缓存与活动数据

        private static readonly List<AccountData> _AccountDataList = new();
        private static readonly object _AccountDataListLock = new();

        /// <summary>
        /// 缓存已查询用户数据,如果已存在则替换，需要在数据更新后调用
        /// </summary>
        public static void AddLoginAccountData(AccountData? accountData)
        {
            if (accountData == null) return;
            lock (_AccountDataListLock)
            {
                int index = _AccountDataList.FindIndex(u => u.UserEmail == accountData.UserEmail);
                if (index == -1)
                {
                    _AccountDataList.Add(accountData);
                }
                else
                {
                    _AccountDataList[index] = accountData;
                }
            }
        }

        /// <summary>
        /// 提供一个简单获取登录数据的方法，而不需要重复进行数据库查询
        /// </summary>
        public static AccountData? GetLoginAccountData(string? email)
        {
            if (email == null) return null;
            lock (_AccountDataListLock)
            {
                return _AccountDataList.Find(u => u.UserEmail == email);
            }
        }

        private static readonly List<LayerData> _LayerDataList = new();
        private static readonly object _LayerDataListLock = new();

        /// <summary>
        /// 从数据库中构建layerid 和 templateid的对应关系
        /// </summary>
        public static void BuildLayerData()
        {
            List<MapLayer> mapLayer = MapLayer.GetMapLayerList();
            lock (_LayerDataListLock)
            {
                foreach (MapLayer layer in mapLayer)
                {
                    LayerData layerData = new(null, layer);
                    if (layerData.Type != "order")
                    {
                        string temId = layerData.Structure!.AsArray().ElementAt(1)!["template"]!["id"]!.GetValue<string>();
                        layerData.TemplateId = temId;
                    }
                    _LayerDataList.Add(layerData);
                    Console.WriteLine($"{layerData.TemplateId}--{layerData.LayerId}");
                }
            }
        }

        public static LayerData? GetLayerDataByTemplateId(string templateId)
        {
            lock (_LayerDataListLock)
            {
                try
                {
                    return _LayerDataList.Where(x => x.TemplateId == templateId).First();
                }
                catch
                {
                    Log.Warn("通过模板id未获取到图层数据");
                    return null;
                }
            }
        }
        #endregion

        /// <summary>
        /// 默认loglevel为3，发布版本需要改成2
        /// </summary>
        private static Logger _Logger = new(3);
        private static readonly object _LoggerLock = new();

        public static Logger Log
        {
            get
            {
                lock (_LoggerLock)
                {
                    return _Logger;
                }
            }
        }

        public static string GetCurrentTime()
        {
            string format = "yyyy-MM-dd HH:mm:ss";
            return DateTime.Now.ToString(format);
        }

    }
}