GroupBy/04-程式設計/Trunk/GroupBuy/ArsenalDB/CustomizeDBMgr.cs

//-----------------------------------------------------------------------
// <copyright file="CustomizeDBMgr.cs" company="Origtek">
//     CustomizeDBMgr belongs to Copyright (c) Origtek. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------

namespace OT.COM.ArsenalDB
{
    using Microsoft.Extensions.Configuration;
    using OT.COM.LogisticsUtil;
    using SoldierData;
    using System;
    using System.Collections.Concurrent;
    using System.Collections.Generic;
    using System.IO;

    /// <summary>
    /// Customize handle database 
    /// </summary>
    public partial class CustomizeDBMgr
    {
        /// <summary>
        /// Main database connection string
        /// </summary>
        private CustomizeDBMgr()
        {
            init();
        }

        private ConcurrentDictionary<string, string> _dicArsenalDBName = null;
        private ConcurrentDictionary<string, string> _dicConnections = null;
        private ConcurrentDictionary<string, string> _dicVirtualConnections = null;
        private ConcurrentDictionary<string, string> _dicRawData = null;

        private static readonly CustomizeDBMgr _inst = new CustomizeDBMgr();

        public ConcurrentDictionary<string, string> GetConnections()
        {
            return _dicConnections;
        }

        public static ConcurrentDictionary<string, string> VirtualConnections => _inst.GetVirtualConnections();

        public ConcurrentDictionary<string, string> GetVirtualConnections()
        {
            return _dicVirtualConnections;
        }

        public static ConcurrentDictionary<string, string> SettingData => _inst.GetSettingData();

        public ConcurrentDictionary<string, string> GetSettingData()
        {
            return _dicRawData;

        }

        public static string GetSettingSting(string i_sKey, string i_sDefaultValue = null)
        {
            string sRes = i_sDefaultValue;

            if (SettingData.ContainsKey(i_sKey))
            {
                sRes = SettingData[i_sKey];
            }

            return sRes;
        }

        public int ModifyConnections(string i_sConnectionID, string i_sConnectionData)
        {
            int nRes;
            do
            {
                if (_dicConnections.ContainsKey(i_sConnectionID))
                {
                    _dicConnections[i_sConnectionID] = i_sConnectionData;
                }
                else
                {
                    _dicConnections.TryAdd(i_sConnectionID, i_sConnectionData);
                }

                nRes = 0;
            }
            while (false);

            return nRes;
        }

        public string GetConnectString(string i_sConnectionID)
        {
            string sRes = null;

            if (_dicConnections.ContainsKey(i_sConnectionID))
            {
                sRes = _dicConnections[i_sConnectionID];
            }

            return sRes;
        }



        protected void init()
        {
            
#if DEBUG
            string sSettingFile = "appsettings.Development.json";
            if (!File.Exists(Path.Combine(Directory.GetCurrentDirectory(), sSettingFile)))
            {
                sSettingFile = "appsettings.json";
            }
#else
            string sSettingFile = "appsettings.json" ;
#endif

                var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())
       .AddJsonFile(sSettingFile, optional: true, reloadOnChange: true);

            IConfigurationRoot configuration = builder.Build();

            IEnumerable<IConfigurationSection> ics = configuration.GetSection("appSettings").GetChildren();

            ConcurrentDictionary<string, string> dicSetting = new ConcurrentDictionary<string, string>();
            foreach (IConfigurationSection ic in ics)
            {
                dicSetting.TryAdd(ic.Key, ic.Value);
            }

            Util.SetSetting(dicSetting);

            if (_dicConnections == null)
            {
                _dicConnections = new ConcurrentDictionary<string, string>();
                _dicRawData = new ConcurrentDictionary<string, string>();
                _dicArsenalDBName = new ConcurrentDictionary<string, string>();
                _dicVirtualConnections = new ConcurrentDictionary<string, string>();
                bool bUseSecret = Util.GetSettingBoolean("USESECRET");


                // web.config
                if (!bUseSecret)
                {
                    foreach (string sKey in dicSetting.Keys)
                    {
                        string sContent = Util.GetSettingString(sKey);
                        _dicRawData.TryAdd(sKey, sContent);
                    }
                }

                // Load SecretData
                string sRes = SecretData.GetData(out ConcurrentDictionary<string, string> dicData);

                if (sRes == null)
                {
                    foreach (string sKey in dicData.Keys)
                    {
                        if (!_dicRawData.ContainsKey(sKey))
                        {
                            _dicRawData.TryAdd(sKey, dicData[sKey]);
                        }
                    }

                }

                if (_dicRawData.ContainsKey("AllConnections"))
                {
                    string sAllConnections = _dicRawData["AllConnections"];
                    string[] saConnections = sAllConnections.Split(":;".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);

                    for (int iIdx = 0; iIdx < saConnections.Length; iIdx += 2)
                    {
                        string sConnectionName = saConnections[iIdx + 1];
                        string sDBName = saConnections[iIdx];

                        int iFind = sConnectionName.IndexOf("_");
                        string sContent = Util.GetSettingString(sConnectionName);
                        if (EntityUtil.GetForceDBType(sContent, out string sCleanConnectString) != null)
                        {
                            _dicConnections.TryAdd(sConnectionName, sCleanConnectString);
                        }
                        if (iFind != -1 )
                        {
                            _dicArsenalDBName.TryAdd(sDBName, sConnectionName.Substring(0, iFind));

                            _dicVirtualConnections.TryAdd(sDBName, _dicConnections[sConnectionName]);
                        }


                    }


                }
            }
        }

        static readonly ConcurrentDictionary<string, string> dicChangeConnect = new ConcurrentDictionary<string, string>();
        public static void ChangeAllConnections(string i_sKey, string i_sConnection)
        {
            if (dicChangeConnect.ContainsKey(i_sKey))
            {
                dicChangeConnect[i_sKey] = i_sConnection;
            }
            else
            {
                dicChangeConnect.TryAdd(i_sKey, i_sConnection);
            }
        }

        private static ConcurrentDictionary<string, DBConnectionInfo> _ConnectionMap = null;

        public static ConcurrentDictionary<string, DBConnectionInfo> ConnectionMap
        {
            get
            {
                if (_ConnectionMap == null)
                {
                    _ConnectionMap = _inst.GetConnectMap();
                }

                return _ConnectionMap;
            }
        }

        private ConcurrentDictionary<string, DBConnectionInfo> GetConnectMap()
        {
            string sAllConnections = GetSettingData()["AllConnections"];
            string[] saConnections = sAllConnections.Split(":;".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);



            ConcurrentDictionary<string, DBConnectionInfo> dicConnection = new ConcurrentDictionary<string, DBConnectionInfo>();

            for (int i = 0; i < saConnections.Length; i += 2)
            {

                DBConnectionInfo dbci = new DBConnectionInfo() { Name = saConnections[i] };
                string sKey = saConnections[i + 1];

                if (dicChangeConnect.ContainsKey(dbci.Name))
                {
                    sKey = dicChangeConnect[dbci.Name];
                }

                dbci.ConnectString = _dicConnections[sKey];

                dbci.DBTYPE = sKey.Split('_')[0];

                dicConnection.TryAdd(saConnections[i], dbci);

            }

            return dicConnection;
        }

        public static string SingleConnection => _inst._SingleConnection;

        internal string _SingleConnection
        {
            get
            {
                bool bUseSecret = Util.GetSettingBoolean("USESECRET");

                string sRes;
                if (!bUseSecret)
                {
                    sRes = Util.GetSettingString("UseSingleConnect");

                    if (string.IsNullOrEmpty(sRes))
                    {
                        sRes = string.Empty;
                    }

                }
                else
                {
                    SecretData.GetData(out ConcurrentDictionary<string, string> dicData);

                    if (dicData.ContainsKey("UseSingleConnect"))
                    {
                        sRes = dicData["UseSingleConnect"];
                    }
                    else
                    {
                        sRes = string.Empty;
                    }
                }

                return sRes;
            }
        }
    }
}