vStationURM/Common/Vinno.vCloud.Common.License.Standard/Licenses/LicenseManager.cs

using System;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Vinno.vCloud.Common.License.Licenses
{
    /// <summary>
    /// Manager License record, includes create, update ，check license and etc.
    /// </summary>
    public class LicenseManager : IDisposable
    {
        #region CurrentLicense Method
        /// <summary>
        /// Current CurrentLicense Version 
        /// </summary>
        public static string CurrentVersion => "1.0.0";
        private License _currentLicense;

        /// <summary>
        /// "FirstStartUpTimeFileName"
        /// </summary>
        private string startupFileName = "6ea2ed30fd97d3a907557904e1038a3e.vl";
        /// <summary>
        /// Gets or Sets a vlaue that the current license
        /// </summary>
        public License CurrentLicense
        {
            get => _currentLicense;
            set => _currentLicense = value;
        }
        /// <summary>
        ///Gets or Sets a vlaue that first StartTime  Licnese 
        /// </summary>
        internal StartupLicnese StartupLicnese { get; private set; }
        /// <summary>
        ///Gets VerifyResult  when Verify current us count
        /// </summary>
        /// <param name="uscount">current us count</param>
        /// <returns>None : No Current CurrentLicense,FailAndExceedMaxUsCount: CurrentLicense.MaxUsCount> uscount,Successd: uscount>_currentLicense.MaxUsCount  </returns>
        public VerifyResult VerifyMaxUsCount(int uscount)
        {
            if (_currentLicense == null)
            {
                return VerifyResult.None;
            }
            return _currentLicense.MaxUsCount > uscount ? VerifyResult.Succeeded : VerifyResult.FailAndExceedMaxUsCount;
        }
        /// <summary>
        /// Gets VerifyResult  when Verify current Account Count
        /// </summary>
        /// <param name="accountCount">current used account Count</param>
        /// <returns>None : No Current CurrentLicense,FailAndExceedMaxAccountCount: CurrentLicense.MaxAccountCount> accountCount,Successd: accountCount>_currentLicense.MaxAccountCount</returns>
        public VerifyResult VerifyAccountCount(int accountCount)
        {
            if (_currentLicense == null)
            {
                return VerifyResult.None;
            }
            return _currentLicense.MaxAccountCount > accountCount ? VerifyResult.Succeeded : VerifyResult.FailAndExceedMaxAccountCount;
        }
        /// <summary>
        ///Gets VerifyResult  when Verify current dateTime
        /// </summary>
        /// <param name="utcdateTime">UTC DateTime </param>
        /// <returns>None : No Current CurrentLicense,FailAndExceedExpirationDate: CurrentLicense.ExpirationUtcDate> utcdateTime,Successd: utcdateTime>_currentLicense.ExpirationUtcDate</returns>
        public VerifyResult VerifyExceedExpirationDate(DateTime dateTime)
        {
            if (_currentLicense == null)
            {
                return VerifyResult.None;
            }
            return (_currentLicense.ExpirationUtcDate - dateTime).TotalMinutes <= 0 ? VerifyResult.FailAndExceedExpirationDate : VerifyResult.Succeeded;
        }

        /// <summary>
        /// Gets Verify License Result when Load License File and Verify License
        /// </summary>
        /// <param name="currentDirectoryAbsolutePath">currrent Absolute server Directory Path</param>
        /// <param name="verifyResultinfo"> return verify License Result info</param>
        /// <returns>Verify Result(enum)</returns>
        public VerifyResult LoadLicenseFile(string currentDirectoryAbsolutePath, out string verifyResultinfo)
        {
            var licfiles = Directory.GetFiles(currentDirectoryAbsolutePath, "*.lic").OrderByDescending(x => new FileInfo(x).LastWriteTimeUtc).ToArray();
            string licfilePah = string.Empty;
            string stlicfilePah = Path.Combine(currentDirectoryAbsolutePath, startupFileName);
            if (licfiles.Length >= 1)
            {
                licfilePah = licfiles[0];
            }
            return VerifyLicenseFile(licfilePah, out verifyResultinfo, stlicfilePah, false);
        }

        public DateTime GetSystemFirstStartupTime(string currentDirectoryAbsolutePath)
        {
            string stlicfilePah = Path.Combine(currentDirectoryAbsolutePath, startupFileName);
            if (File.Exists(stlicfilePah))
            {
                var fileInfo = new FileInfo(stlicfilePah);
                return fileInfo.CreationTime;
            }
            else {
                return DateTime.UtcNow;
            }
           
        }

        /// <summary>
        /// Gets Verify Result when  Verify License
        /// </summary>
        /// <param name="licenseAbsolutePath">license Absolute path</param>
        /// <param name="verifyResultinfo">return verify Lincese Result info </param>
        /// <param name="startupFileAbsolutePath"> first start up File Absolute Path</param>
        /// <param name="verifyOnly"> is or no only verify</param>
        /// <returns>VerifyResult</returns>
        public VerifyResult VerifyLicenseFile(string licenseAbsolutePath, out string verifyResultinfo, string startupFileAbsolutePath = null, bool verifyOnly = true)
        {
            var verifty = VerifyResult.Failed;
            try
            {
                if (!verifyOnly)
                {
                    LoadStartupLicnese(startupFileAbsolutePath);
                }
                CurrentLicense = GetLicensefromFilePath(licenseAbsolutePath);
                if (CurrentLicense != null)
                {
                    return GetVerifyResult(out verifyResultinfo, verifyOnly);
                }
            }
            catch (Exception e)
            {
                verifyResultinfo = $"VerifyLicnese:{verifty}\r\nLoad CurrentLicense Error:{e.StackTrace}";
                return verifty;
            }
            verifyResultinfo = $"VerifyLicnese:{verifty}";
            return verifty;
        }
        /// <summary>
        ///  Gets a value that current expiration days
        /// </summary>
        /// <param name="currentUTCDateTime">current UTC DateTime</param>
        /// <returns></returns>
        private int GetCurrentExpirationDays(DateTime currentUTCDateTime)
        {
            if (_currentLicense != null) return (_currentLicense.ExpirationUtcDate - currentUTCDateTime).Days;
            return 0;
        }
        private VerifyResult GetVerifyResult(out string verifyResultinfo, bool verifyOnly)
        {
            var verifty = VerifyResult.Succeeded;
            verifyResultinfo = string.Empty;
            if (!verifyOnly && StartupLicnese != null)
            {
                if (CurrentLicense.LicenseType == LicenseType.Trial && CurrentLicense.ExpirationDay > 0)
                {
                    CurrentLicense.ExpirationUtcDate = StartupLicnese.FirstStartupUtcDate.AddDays(CurrentLicense.ExpirationDay);
                }
                var veriftyDate = VerifyExceedExpirationDate(DateTime.Now);
                var verifyLocalInfo = VerifyLocalInfo(CurrentLicense.Identification);
                if (veriftyDate == VerifyResult.Succeeded)
                {
                    if (verifyLocalInfo == VerifyResult.Succeeded)
                        verifty = VerifyResult.Succeeded;
                    else
                        verifty = VerifyResult.FailAndExceedLocalInfo;
                }
                else
                {
                    if (verifyLocalInfo == VerifyResult.Succeeded)
                        verifty = VerifyResult.FailAndExceedExpirationDate;
                    else
                        verifty = VerifyResult.Failed;
                }
                if (verifty == VerifyResult.Succeeded)
                {
                    verifyResultinfo = $"{ CurrentLicense.LicenseType.ToString()} period is running." + verifyResultinfo;
                    StartTimer();
                }
                verifyResultinfo = $"{GetCurrentExpirationDays(DateTime.Now)} days left and " +
                        $"expired by {CurrentLicense.ExpirationUtcDate}. " +
                        $"it supports {CurrentLicense.MaxAccountCount} FLYINSONO client accounts and {CurrentLicense.MaxUsCount} ultrasonic machines.";
                if (!string.IsNullOrEmpty(CurrentLicense.Identification))
                    verifyResultinfo += $"Identification:{CurrentLicense.Identification}";
            }
            return verifty;
        }
        /// <summary>
        /// Gets License from license Absolute path
        /// </summary>
        /// <param name="licenseAbsolutepath">license Absolute path</param>
        private License GetLicensefromFilePath(string licenseAbsolutepath)
        {
            if (File.Exists(licenseAbsolutepath))
            {
                var text = File.ReadAllText(licenseAbsolutepath);
                var decrypttext = AesHelper.Decrypt(text);
                var licnese = LicenseFileHelper.FromFile(decrypttext);
                return licnese;
            }
            return new License()
            {
                LicenseType = LicenseType.Trial,
                Version = CurrentVersion,
                LicenseId = Guid.NewGuid().ToString(),
                MaxAccountCount = 15,
                MaxUsCount = 15,
                ExpirationDay = 15,
                Remarks = "Default Trial License"
            };
        }
        /// <summary>
        /// Load Start up Licnese File or Create StartupLicnese and save File 
        /// </summary>
        /// <param name="startupFileAbsolutePath">Absolute Path</param>
        private void LoadStartupLicnese(string startupFileAbsolutePath)
        {
            if (startupFileAbsolutePath != null && File.Exists(startupFileAbsolutePath))
            {
                var text = File.ReadAllText(startupFileAbsolutePath);
                var decrypttext = AesHelper.Decrypt(text);
                StartupLicnese = LicenseFileHelper.StartupLicneseFromFile(decrypttext);
            }
            else
            {
                StartupLicnese = new StartupLicnese
                {
                    FirstStartupUtcDate = DateTime.UtcNow
                };
                var xml = LicenseFileHelper.StartupLicneseToFile(StartupLicnese);
                var encryptxml = AesHelper.Encrypt(xml);
                File.WriteAllText(startupFileAbsolutePath ?? throw new ArgumentNullException(nameof(startupFileAbsolutePath)), encryptxml);
            }
        }
        /// <summary>
        /// Export License and Save File
        /// </summary>
        /// <param name="license">license</param>
        /// <param name="path">Save File Path</param>
        /// <returns> is or no export successed</returns>
        public bool ExportLicenseFile(License license, string path, Stream userToolStream)
        {
            try
            {
                var xml = LicenseFileHelper.LinceseToFile(license);
                var encryptxml = AesHelper.Encrypt(xml);
               
               
                var launcher = path + "\\License loading tool.exe";
                using (userToolStream)
                {
                    using (var launcherStream = File.Create(launcher))
                    {
                        userToolStream.CopyTo(launcherStream);
                    }
                }
                using (var fs = new FileStream(launcher, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite))
                {
                    using (var br = new BinaryWriter(fs))
                    {
                        fs.Position = fs.Length;
                        var startPosition = (int)fs.Position;
                        var data = Encoding.UTF8.GetBytes(encryptxml);
                        br.Write(data);
                        br.Write(startPosition);
                        br.Write(data.Length);
                    }
                }
                return true;
            }
            catch (Exception e)
            {
                throw new Exception("Export Error", e);
            }
        }

        public DateTime GetLocalFirstStartupDateTime()
        {
            return StartupLicnese?.FirstStartupUtcDate.ToLocalTime() ?? DateTime.MinValue;
        }

        /// <summary>
        ///Gets VerifyResult  when Verify current Local Infomation
        /// </summary>
        /// <param name="utcdateTime">UTC DateTime </param>
        /// <returns>None : No Current CurrentLicense,FailAndExceedExpirationDate: CurrentLicense.ExpirationUtcDate> utcdateTime,Successd: utcdateTime>_currentLicense.ExpirationUtcDate</returns>
        public VerifyResult VerifyLocalInfo(string id)
        {
            if (_currentLicense == null)
            {
                return VerifyResult.None;
            }
            if (string.IsNullOrEmpty(id))
                return VerifyResult.Succeeded;
            id = id.Replace("-", "");
            var mac = GetLocalInfo.GetMacAddress();
            if (mac.Contains(id))
            {
                return VerifyResult.Succeeded;
            }
            else
            {
                return VerifyResult.Failed;
            }
        }

        #endregion

        #region Check Current License Timer

        private System.Threading.Timer _verifyTimer;
        /// <summary>
        /// one Day Check License
        /// </summary>
        private const int TntervalDay = 1;
        /// <summary>
        /// Notify  Expiration Datetime event
        /// </summary>
        public event EventHandler<LicenseExpirationInfo> NotifyLicenseExpirationEvent;
        private void StartTimer()
        {
            _verifyTimer = new System.Threading.Timer(CheckLicenseTimeTick, null, 1000 * 60 * 60 * 6 * TntervalDay, 1000 * 60 * 60 * 6 * TntervalDay);
        }
        void CheckLicenseTimeTick(object o)
        {
            if (CurrentLicense == null) return;
            var localTime = CurrentLicense.ExpirationUtcDate.ToLocalTime();
            NotifyLicenseExpirationEvent?.Invoke(this, new LicenseExpirationInfo()
            {
                AvailableDays = GetCurrentExpirationDays(DateTime.UtcNow) + 1,
                LocalExpirationDate = localTime,
                HasExpired = (localTime - DateTime.Now).Minutes < 0,
            });
        }
        public void Dispose()
        {
            _verifyTimer?.Dispose();
        }

        #endregion

    }
}