///////////////////////////////////////////////////////////
//  Global.cs
//  Implementation of Class GlobalEx
//  CSLA type: Editable Root 
//  Created on: 09-Jun-2005 
//  Object design: John    
//	Coded: John 09-Jun-2005
///////////////////////////////////////////////////////////

//case 3378
//#define FIPS_MODE  


using System;
using System.Data;
using CSLA.Data;
using CSLA;
using System.Threading;
using CSLA.Security;
using System.ComponentModel;
using System.Text;
using System.IO;
using System.Xml;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.Xml;
using GZTW.Data;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

//JSON KEY
using Newtonsoft.Json;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.OpenSsl;



namespace GZTW.AyaNova.BLL
{
    /// <summary>
    /// Global settings ex
    /// </summary>
    [Serializable, EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
    internal class GlobalEx : BusinessBase
    {// Create a logger for use in this class
        //private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);


        #region Attributes


        private byte[] mbGlobalData;

        //Keydata
        private bool _Valid;
        private string _RegisteredTo;
        private int _ScheduleableUsers;
        //case 3187
        private string _Source;

        //case 2094, now a plugin
        //private bool _FeatureWebInterface;

        private object _Expires;


        //case 2094 now a plugin
        ////Case 762
        //private bool _FeatureMBIInterface;

        //Case 999
        private bool _RequestedTrial;

        private bool _BootKeyIsRequestedTrial;

        //Case 508
        private string _DigestValue;

        private string _LicenseValidationStatus;
        private DateTime _Generated;
        private DateTime _InstallableUntil;
        private bool _Installable;
        private double _SchemaVersion;
        private bool _TrialKey;

        //Housekeeping info
        private int mDBSchema = 0;
        //trial expiry date and evaluation date advance reference date
        AGlobalExData _AGlobalExData = null;


        //case 1053
        private DataTable dtPlugins;

        //case 1172
        private bool _Lite;

        //case 2094
        private bool _SubscriptionLicense;
        private bool _Lockout;
        private DateTime _LockoutDate;

#if(FIPS_MODE)
        //case 3378 FIPS
        private bool _FIPS_READY = false;
#endif
        #endregion

        #region Constructor

        /// <summary>
        /// Private constructor to prevent direct instantiation
        /// </summary>
        private GlobalEx()
        {
            InValidate();
            //_AGlobalExData=new AGlobalExData();

        }
        #endregion

        #region Business properties

        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal AGlobalExData TData
        {
            //trial version first boot data and expiry date for trial

            get
            {
                return _AGlobalExData;
            }

            set
            {
                //if(!User.IsAdmin) return;

                _AGlobalExData = value;

                MarkDirty();

            }
        }
        /// <summary>
        /// Get Database schema version
        ///
        /// 
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        public int DBSchemaVersion
        {
            get
            {
                return mDBSchema;
            }
        }

        /// <summary>
        /// Get/Set global data
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal string GlobalData
        {

            set
            {
                if (!User.IsAdmin && !AyaBizUtils.Lite) return;

                UTF8Encoding utf8 = new UTF8Encoding();
                mbGlobalData = utf8.GetBytes(value);

                Validate(true);
                BrokenRules.Assert("GlobalDataValid", "Global data not valid", "GlobalData", !_Valid);

                MarkDirty();

            }
        }

        /// <summary>
        /// View global data in human readable format
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal string ViewGlobalData
        {

            get
            {


                if (this._Valid == false)
                    return "Invalid data";

                //_Expires can be null!!!!
                DateTime dt_Expires = DateTime.MinValue;
                if (_Expires != null)
                {
                    dt_Expires = (DateTime)_Expires;
                }


                System.Text.StringBuilder sb = new StringBuilder();
                sb.Append("Key issued: " + this._Generated.ToString() + "\r\n");
                if (_SubscriptionLicense && !_TrialKey)
                {
                    sb.Append("Support and updates until: " + dt_Expires.ToLongDateString() + "\r\n");
                }
                else
                {
                    if (_Expires != null)
                    {
                        //check if downloaded trial
                        if (dt_Expires.Year == 1968)
                        {
                            sb.Append("Trial key Expires: " + _AGlobalExData.EvalExpire.ToLongDateString() + "\r\n");

                        }
                        else
                        {
                            sb.Append("Key Expires: " + dt_Expires.ToLongDateString() + "\r\n");
                        }
                    }
                }

                //Lockout key?
                if (_Lockout)
                {
                    if (_LockoutDate < DateTime.Now)
                        sb.AppendLine("\r\n** TEMPORARY KEY EXPIRED: " + _LockoutDate.ToLongDateString() + " **\r\n");
                    else
                        sb.AppendLine("Temporary key, will expire: " + _LockoutDate.ToLongDateString() + "\r\n");

                }

                sb.Append("Registered to: " + _RegisteredTo + "\r\n");

                //case 3187
                sb.Append("Source: " + _Source + "\r\n");

                sb.Append("Version: " + _SchemaVersion + ".X\r\n");

                if (!_SubscriptionLicense)
                    sb.Append("Scheduleable resources: " + this._ScheduleableUsers.ToString() + "\r\n");
                else
                {
                    sb.AppendLine(string.Format("Scheduleable resources: Up to {0}", this._ScheduleableUsers));

                    //case 3551
                    //switch (this._ScheduleableUsers)
                    //{
                    //    case 1:
                    //        sb.AppendLine("1");
                    //        break;
                    //    case 5:
                    //        sb.AppendLine("Up to 5");
                    //        break;
                    //    case 10:
                    //        sb.AppendLine("Up to 10");
                    //        break;
                    //    case 20:
                    //        sb.AppendLine("Up to 20");
                    //        break;
                    //    case 50:
                    //        sb.AppendLine("Up to 50");
                    //        break;
                    //    case 999:
                    //        sb.AppendLine("Up to 999");
                    //        break;
                    //}
                }

                //case 1172
                sb.Append("Lite: " + _Lite.ToString() + "\r\n");

                //case 999
                sb.Append("Requested trial: " + this._RequestedTrial.ToString() + "\r\n");

                //case 2094 These are now plugins:
                //Case 762
                //sb.Append("Option - Mobile browser interface: " + this._FeatureMBIInterface.ToString() + "\r\n");
                //sb.Append("Option - Web browser interface: " + this._FeatureWebInterface.ToString() + "\r\n");

                if (dtPlugins.Rows.Count > 0)
                {
                    sb.Append("\r\n");
                    sb.Append("Plugins:\r\n");
                    foreach (DataRow dr in dtPlugins.Rows)
                    {
                        sb.Append("\t");
                        sb.Append(dr["Plugin"].ToString());
                        sb.Append(" ");
                        //case 2094
                        if (_SubscriptionLicense)
                        {
                            //check if downloaded trial
                            if (dt_Expires.Year == 1968)
                            {
                                sb.Append("Trial subscription expires: ");
                                sb.Append(_AGlobalExData.EvalExpire.ToLongDateString());
                            }
                            else
                            {
                                sb.Append("Support and updates until: ");
                                //case 3113
                                DateTime dtx = (DateTime)dr["SubscriptionExpires"];
                                // DateTime dtx = DateTime.Parse(dr["SubscriptionExpires"].ToString());
                                sb.Append(dtx.ToLongDateString());
                            }
                        }
                        else
                        {
                            sb.Append(dr["Version"].ToString());
                        }
                        sb.Append("\r\n");
                    }
                }

                return sb.ToString();
            }

        }

        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal string RegisteredTo
        {
            get
            {
                return _RegisteredTo;
            }

        }


        //[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        //internal string Status
        //{
        //    get
        //    {
        //        return _LicenseValidationStatus;
        //    }

        //}


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal int ScheduleableUsers
        {
            get
            {
                return _ScheduleableUsers;
            }

        }


        //case 2094 - now a  plugin in license code
        //[EditorBrowsable(EditorBrowsableState.Never),Browsable(false)]
        //internal bool FeatureWebInterface
        //{
        //    get
        //    {
        //        return _FeatureWebInterface;
        //    }

        //}


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool TrialExpired
        {
            get
            {
                //Is the license for an older version of AyaNova?

                //SET VALID LICENSE VERSION HERE
                //case 2094
                //if (_SchemaVersion < 7)//case 999
                //    return true;

                //TRIAL KEY
                if (_TrialKey)
                {
                    if (System.DateTime.Now > _AGlobalExData.EvalExpire)
                        return true;
                }


                //if it's not a trial key then it can never be true right?
                return false;


                ////NON TRIAL KEY PATH
                ////null expiry never expires
                //if(_Expires==null) return false;
                //if(System.DateTime.Now>(System.DateTime)_Expires)
                //    return true;

                //return false;
            }

        }


        //case 2094
        //If the license contains a lockout date and it's passed then this returns true
        //used for web requested trial and licensed trial to differentiate
        //subscription expiry date
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool LockedOut
        {
            get
            {
                if (_Lockout && System.DateTime.Now > _LockoutDate)
                    return true;


                return false;
            }

        }



        /// <summary>
        /// case 2094
        /// Returns true only if it's a subscription license and it has expired
        /// In all other cases returns true (such as it's an expired trial)
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool SubscriptionExpired
        {
            get
            {
                //If it's a trial then it's not an active subscription so it can't have expired
                if (_TrialKey)
                    return false;

                //null expiry always expires, it's a bug or something weird
                if (_Expires == null) return true;

                if (System.DateTime.Now > (System.DateTime)_Expires)
                    return true;

                return false;
            }

        }

        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool WillExpire
        {
            get
            {
                if (_TrialKey || _Lockout) return true;
                //null expiry never expires
                if (_Expires == null) return false;

                return true;
            }

        }


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal DateTime ExpiryDate
        {
            get
            {
                if (_TrialKey) return _AGlobalExData.EvalExpire;

                if (_Expires == null) return System.DateTime.MaxValue;
                else return (DateTime)_Expires;
            }

        }


        //case 2094 now a plugin in license code
        ////Case 762
        //[EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        //internal bool FeatureMBIInterface
        //{
        //    get
        //    {
        //        return _FeatureMBIInterface;
        //    }

        //}


        //Case 999
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool RequestedTrial
        {
            get
            {
                return _RequestedTrial;
            }

        }

        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool Valid
        {
            get
            {


                return _Valid;
            }

        }


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal DateTime Generated
        {
            get
            {
                return _Generated;
            }

        }


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal DateTime InstallableUntil
        {
            get
            {
                return _InstallableUntil;
            }

        }


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool Installable
        {
            get
            {
                return _Installable;
            }

        }


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal double SchemaVersion
        {
            get
            {
                return _SchemaVersion;
            }
        }


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool TrialKey
        {
            get
            {
                return _TrialKey;
            }

        }


        //Case 508
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal string DigestValue
        {
            get
            {
                return _DigestValue;
            }

        }


        /// <summary>
        /// Get plugins
        ///
        /// 
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal DataTable Plugins
        {
            get
            {
                if (dtPlugins == null)
                {
                    dtPlugins = new DataTable();
                    dtPlugins.Columns.Add("Plugin");
                    dtPlugins.Columns.Add("Version");
                    //case 2094
                    dtPlugins.Columns.Add("SubscriptionExpires", typeof(DateTime));
                }
                return dtPlugins;
            }
        }


        //case 1172
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool Lite
        {
            get
            {
                return _Lite;
            }

        }

        //case 2094
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool SubscriptionLicense
        {
            get
            {
                return _SubscriptionLicense;
            }

        }

        //case 2094
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal bool Lockout
        {
            get
            {
                return _Lockout;
            }

        }

        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal DateTime LockoutDate
        {
            get
            {
                return _LockoutDate;
            }

        }


        #endregion

        #region System.Object overrides
        public override string ToString()
        {
            return "GlobalEx";
        }

        /// 
        /// <param name="obj"></param>
        public override bool Equals(Object obj)
        {
            return true;
        }
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        public override int GetHashCode()
        {
            return ("GlobalEx").GetHashCode();
        }
        #endregion

        #region Static methods


        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        public static GlobalEx GetItem()
        {

            GlobalEx a = (GlobalEx)DataPortal.Fetch(new Criteria());
            return a;
            //return (GlobalEx)DataPortal.Fetch(new Criteria());

        }





        #endregion

        #region DAL Data access
        /// 
        /// <param name="Criteria"></param>
        protected override void DataPortal_Fetch(object Criteria)
        {
            this._LicenseValidationStatus = "";
            //Fetching license key
            //sets all settings to safe mode before fetch and validate
            InValidate();

            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 2";


            Criteria crit = (Criteria)Criteria;
#if(FIPS_MODE)
            //case 3378
            bool bMustUpdate = false;//if it has to decrypt the key and ex data then it should save it back immediately here
#endif
            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 3";
            using (SafeDataReader dataReader = DBUtil.GetReaderFromSQLString("SELECT * FROM aGlobalEx"))
            {
                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 4";
                if (dataReader.Read())
                {
                    //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 5";
                    try
                    {
                        //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 6";
                        //schema version
                        mDBSchema = dataReader.GetInt32("aDBSchema");

                        //Global data
                        int nTempsize = dataReader.GetInt32("aGlobalDataSize");

                        //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 7";
                        if (nTempsize > 0)
                        {
                            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 8";
                            byte[] temp = new Byte[nTempsize];

                            dataReader.GetBytes("aGlobalData", 0, temp, 0, nTempsize);

#if(FIPS_MODE)
                            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 9";
                            //case 3378
                            string sKey = new UTF8Encoding().GetString(temp);
                            if (sKey.Contains("LicenseKey"))
                            { //already stored decrypted
                                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 9-PathA";
                                _FIPS_READY = true;//flag for the globalEx block below which is not as easily identifiable as decrypted
                                mbGlobalData = temp;
                            }
                            else
                            {
                                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 9-PathB";
                                //trigger a save after all is decrypted
                                bMustUpdate = true;
                                /*shaM.ComputeHash(enc.GetBytes("Who is John Galt?"))*/
                                byte[] bkey = new byte[32] { 0xAE, 0x6E, 0x53, 0x24, 0xC6, 0x53, 0x1D, 0x88, 0x90, 0x12, 0x80, 0xCC, 0x19, 0x88, 0x71, 0x38, 0xA3, 0xBF, 0x63, 0x64, 0xCB, 0x0C, 0xED, 0x50, 0x47, 0xCA, 0x96, 0x8C, 0x27, 0xCD, 0xD2, 0x64 };
                                /*shaM.ComputeHash(enc.GetBytes("License IV"))*/
                                byte[] biv = new byte[32] { 0xB7, 0xF8, 0x10, 0xED, 0x51, 0x28, 0x44, 0x2C, 0x77, 0x3D, 0xBB, 0x6B, 0x0D, 0x89, 0x3A, 0x1E, 0xA1, 0xA3, 0x4E, 0xAA, 0x0A, 0x74, 0xD7, 0x35, 0xE0, 0x52, 0xC2, 0xFF, 0x38, 0x72, 0xB3, 0xF2 };
                                CipherWrapper c = new CipherWrapper(bkey);
                                mbGlobalData = c.DecryptMessage(temp, biv);

                                
                            }

#else
                             //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 9-PathC";
                            /*shaM.ComputeHash(enc.GetBytes("Who is John Galt?"))*/
                            byte[] bkey = new byte[32] { 0xAE, 0x6E, 0x53, 0x24, 0xC6, 0x53, 0x1D, 0x88, 0x90, 0x12, 0x80, 0xCC, 0x19, 0x88, 0x71, 0x38, 0xA3, 0xBF, 0x63, 0x64, 0xCB, 0x0C, 0xED, 0x50, 0x47, 0xCA, 0x96, 0x8C, 0x27, 0xCD, 0xD2, 0x64 };
                            /*shaM.ComputeHash(enc.GetBytes("License IV"))*/
                            byte[] biv = new byte[32] { 0xB7, 0xF8, 0x10, 0xED, 0x51, 0x28, 0x44, 0x2C, 0x77, 0x3D, 0xBB, 0x6B, 0x0D, 0x89, 0x3A, 0x1E, 0xA1, 0xA3, 0x4E, 0xAA, 0x0A, 0x74, 0xD7, 0x35, 0xE0, 0x52, 0xC2, 0xFF, 0x38, 0x72, 0xB3, 0xF2 };
                            CipherWrapper c = new CipherWrapper(bkey);
                            mbGlobalData = c.DecryptMessage(temp, biv);
#endif


                        }
                        else
                            throw new InvalidOperationException();

                        //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 10";

                        //Global data EX
                        nTempsize = dataReader.GetInt32("aGlobalDataExSize");

                        if (nTempsize > 0)
                        {

                            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 11";
                            //Get the data...
                            byte[] temp = new Byte[nTempsize];
                            dataReader.GetBytes("aGlobalDataEx", 0, temp, 0, nTempsize);

                            //Into a memory stream...
                            MemoryStream mstream = null;
                            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 12";
#if(FIPS_MODE)
                            if (!_FIPS_READY)
                            {
                                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 12-A";
                                //Decrypt the data...	
                                UTF8Encoding enc = new UTF8Encoding();
                                //SHA256 shaM = new SHA256Managed();
                                //enc.GetBytes("The dog barks at midnight.")
                                byte[] bkey = new byte[32] { 0xC2, 0x18, 0x47, 0x78, 0xF8, 0x4B, 0x1A, 0x56, 0xE9, 0x9A, 0x87, 0x82, 0x82, 0x8E, 0x5F, 0x6B, 0x7F, 0x94, 0x5E, 0xB1, 0x1E, 0xA0, 0x57, 0x1A, 0x23, 0xFE, 0x13, 0x91, 0xCD, 0xE8, 0xC5, 0x90 };
                                //enc.GetBytes("EX IV")
                                byte[] biv = new byte[32] { 0x9F, 0xDF, 0x65, 0x02, 0xA8, 0x48, 0x79, 0x2D, 0xC2, 0xD9, 0xCB, 0xCB, 0x9F, 0x0C, 0x8B, 0x55, 0x3F, 0x2E, 0x92, 0x3C, 0x48, 0xAD, 0xDC, 0xF4, 0x53, 0x03, 0x82, 0x29, 0x80, 0x28, 0x45, 0x1D };

                                CipherWrapper c = new CipherWrapper(bkey);
                                mstream = new MemoryStream(c.DecryptMessage(temp, biv));
                            }
                            else
                            {
                                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 12-B";
                                //already fips ready (decrypted in db) so just process it
                                mstream = new MemoryStream(temp);
                            }
                            
#else
                             //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 12-C";
                            //Decrypt the data...	
                            UTF8Encoding enc = new UTF8Encoding();
                            //SHA256 shaM = new SHA256Managed();
                            //enc.GetBytes("The dog barks at midnight.")
                            byte[] bkey = new byte[32] { 0xC2, 0x18, 0x47, 0x78, 0xF8, 0x4B, 0x1A, 0x56, 0xE9, 0x9A, 0x87, 0x82, 0x82, 0x8E, 0x5F, 0x6B, 0x7F, 0x94, 0x5E, 0xB1, 0x1E, 0xA0, 0x57, 0x1A, 0x23, 0xFE, 0x13, 0x91, 0xCD, 0xE8, 0xC5, 0x90 };
                            //enc.GetBytes("EX IV")
                            byte[] biv = new byte[32] { 0x9F, 0xDF, 0x65, 0x02, 0xA8, 0x48, 0x79, 0x2D, 0xC2, 0xD9, 0xCB, 0xCB, 0x9F, 0x0C, 0x8B, 0x55, 0x3F, 0x2E, 0x92, 0x3C, 0x48, 0xAD, 0xDC, 0xF4, 0x53, 0x03, 0x82, 0x29, 0x80, 0x28, 0x45, 0x1D };

                            CipherWrapper c = new CipherWrapper(bkey);
                            mstream = new MemoryStream(c.DecryptMessage(temp, biv));
#endif
                            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 13";
                            //De-serialize it into the AGlobalExData object...
                            BinaryFormatter bformatter = new BinaryFormatter();
                            bformatter.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
                            try
                            {
                                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 13-A";
                                _AGlobalExData = (AGlobalExData)bformatter.Deserialize(mstream);
                            }
                            catch
                            {
                                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 13-B";
                                _AGlobalExData = new AGlobalExData();
                                _AGlobalExData.EvalExpire = System.DateTime.Now;
                                _AGlobalExData.EvalAdvanceReference = System.DateTime.Now;
                            }

                        }
                        else
                            throw new InvalidOperationException();

                        //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 14";

                    }
                    catch (Exception ex)
                    {
                        //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 15";
                        //this will be caught if the fields requested above don't exist
                        //or there is *any* problem dealing with them
                        //which generally will be that the database is a pre-release one they
                        //are trying to use or they have screwed with the data somehow
#if(DEBUG)
                        //string s=ex.Message;

#else
                        throw new System.ApplicationException(
                            "\r\n************************************************\r\n" +
                            "Database is missing startup information.\r\n " +
                            "It is either damaged, tamped with or not a valid AyaNova database.\r\n" +
                            "(Note that a pre-release database can not be used with AyaNova)\r\n" +
                            "\r\n************************************************\r\n", ex
                            );
#endif
                    }
                    finally
                    {
                        //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 16";
                        dataReader.Close();
                    }



                }
            }
            //END new database code

            MarkOld();

            try
            {
                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 17";//this is the last logged line before 18 and then finally 18a
                Validate(false);//this must be throwing an exception
                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 17-A";//this doesn't log
                if (_Valid == false)
                {
                    //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 17-B";
                    throw new InvalidOperationException();
                }
            }
            catch(Exception ex)
            {
                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 18";
                _Valid = false;
#if(FIPS_MODE)

                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 18-A";

                _LicenseValidationStatus += "\r\nValidate Exception:\r\n" + ex.Message;
                _LicenseValidationStatus += "\r\nValidate Exception stack:\r\n" + ex.StackTrace;

                 throw new InvalidOperationException(
                    "**** A VALID AYANOVA LICENSE WAS NOT FOUND ***\r\n\r\n " +
                    "Diagnostic info:\r\n\r\n"+_LicenseValidationStatus);

#else
                 //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 18-B";
                //_LicenseValidationStatus
                throw new InvalidOperationException(
                    "**** A VALID AYANOVA LICENSE WAS NOT FOUND ***\r\n\r\n " +
                    "The license key has been tampered with or damaged.\r\n\r\n" +
                    "** License violations are logged for the protection of the licensee and licensor **\r\n\r\n" +
                    "Restore the database from a backup or contact AyaNova technical\r\n" +
                    "support for assistance.");
#endif

            }

#if(FIPS_MODE)
            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 19";
            //case 3378
            if (bMustUpdate)
            {
                //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 20";
                DataPortal_Update();
            }
#endif
            //_LicenseValidationStatus += "\r\nDataPortal_Fetch: 21-FIN";
        }


        /// <summary>
        /// Called by DataPortal to delete/add/update data into the database
        /// </summary>
        protected override void DataPortal_Update()
        {
            if (!_Valid) throw new InvalidOperationException("DataPortal_Update, not validated can't update, see log for details ");

#if(FIPS_MODE)
            
            //license key
            byte[] bencrypted = mbGlobalData;

            //globalEx (trial) data
            //Serialize to a memory stream:
            MemoryStream ms = new MemoryStream();
            BinaryFormatter b = new BinaryFormatter();
            b.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
            b.Serialize(ms, _AGlobalExData);           
            byte[] beencrypted = ms.GetBuffer();
#else
            //this is merely for obfuscation while the license is resident in the database
            //it's assumed that this assembly will always be obfuscated and all strings
            //encrypted.  Even if the license was plain text it still
            //contains a signature that disallows editing, this is just 
            //to prevent casual users from bothering to try messing with it in the first place
            //by seeing it when opening the db in a db admin tool

            /*shaM.ComputeHash(enc.GetBytes("Who is John Galt?"))*/
            byte[] bkey = new byte[32] { 0xAE, 0x6E, 0x53, 0x24, 0xC6, 0x53, 0x1D, 0x88, 0x90, 0x12, 0x80, 0xCC, 0x19, 0x88, 0x71, 0x38, 0xA3, 0xBF, 0x63, 0x64, 0xCB, 0x0C, 0xED, 0x50, 0x47, 0xCA, 0x96, 0x8C, 0x27, 0xCD, 0xD2, 0x64 };
            /*shaM.ComputeHash(enc.GetBytes("License IV"))*/
            byte[] biv = new byte[32] { 0xB7, 0xF8, 0x10, 0xED, 0x51, 0x28, 0x44, 0x2C, 0x77, 0x3D, 0xBB, 0x6B, 0x0D, 0x89, 0x3A, 0x1E, 0xA1, 0xA3, 0x4E, 0xAA, 0x0A, 0x74, 0xD7, 0x35, 0xE0, 0x52, 0xC2, 0xFF, 0x38, 0x72, 0xB3, 0xF2 };

            CipherWrapper c = new CipherWrapper(bkey);
            byte[] bencrypted = c.EncryptMessage(mbGlobalData, biv);


            //Serialize to a memory stream:
            MemoryStream ms = new MemoryStream();
            BinaryFormatter b = new BinaryFormatter();
            b.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
            b.Serialize(ms, _AGlobalExData);


            //Encrypt
            //enc.GetBytes("The dog barks at midnight.")
            byte[] bekey = new byte[32] { 0xC2, 0x18, 0x47, 0x78, 0xF8, 0x4B, 0x1A, 0x56, 0xE9, 0x9A, 0x87, 0x82, 0x82, 0x8E, 0x5F, 0x6B, 0x7F, 0x94, 0x5E, 0xB1, 0x1E, 0xA0, 0x57, 0x1A, 0x23, 0xFE, 0x13, 0x91, 0xCD, 0xE8, 0xC5, 0x90 };
            //enc.GetBytes("EX IV")
            byte[] beiv = new byte[32] { 0x9F, 0xDF, 0x65, 0x02, 0xA8, 0x48, 0x79, 0x2D, 0xC2, 0xD9, 0xCB, 0xCB, 0x9F, 0x0C, 0x8B, 0x55, 0x3F, 0x2E, 0x92, 0x3C, 0x48, 0xAD, 0xDC, 0xF4, 0x53, 0x03, 0x82, 0x29, 0x80, 0x28, 0x45, 0x1D };

            CipherWrapper ce = new CipherWrapper(bekey);
            byte[] beencrypted = ce.EncryptMessage(ms.GetBuffer(), beiv);
#endif


            DBCommandWrapper cm = DBUtil.GetCommandFromSQL(
                "UPDATE aGlobalEx " +
                "SET aGlobalData=@GlobalData, " +
                "aGlobalDataSize=@GlobalDataSize, " +
                "aGlobalDataEx=@GlobalDataEx, " +
                "aGlobalDataExSize=@GlobalDataExSize");
            //globaldata
            cm.AddInParameter("@GlobalData", DbType.Object, bencrypted);
            cm.AddInParameter("@GlobalDataSize", DbType.Int32, bencrypted.Length);
            //globaldata ex
            cm.AddInParameter("@GlobalDataEx", DbType.Object, beencrypted);
            cm.AddInParameter("@GlobalDataExSize", DbType.Int32, beencrypted.Length);


            using (IDbConnection connection = DBUtil.DB.GetConnection())
            {
                connection.Open();
                IDbTransaction transaction = connection.BeginTransaction();

                try
                {

                    DBUtil.DB.ExecuteNonQuery(cm, transaction);

                    // Commit the transaction
                    transaction.Commit();
                    MarkOld();//db is now synched with object
                }
                catch
                {
                    // Rollback transaction 
                    transaction.Rollback();
                    throw;
                }
                connection.Close();
            }

        }



        #endregion

        #region Override IsValid / IsDirty etc etc
        //Override base class version if there are child objects 
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        public override bool IsValid
        {
            get
            {
                return base.IsValid;
            }
        }
        [EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        public override bool IsDirty
        {
            get
            {
                return base.IsDirty;
            }
        }



        #endregion

        #region criteria
        /// <summary>
        /// Criteria for identifying existing object
        /// </summary>
        [Serializable]
        private class Criteria
        {
            //public Guid ID;
            public Criteria()
            {

            }

        }
        #endregion

        #region validation

        //clear settings set back to invalid state
        //in preparation for validation
        private void InValidate()
        {
            _Valid = false;
            this._TrialKey = true;
            this._RegisteredTo = "";

            //Hex encoded string "UNKNOWN"
            this._Source = "554E4B4E4F574E";

            this._ScheduleableUsers = 0;
            this._SchemaVersion = 0;
            
            this._Expires = System.DateTime.Now;

            //case 999
            _RequestedTrial = false;

            //case 2094 now a plugin
            //_FeatureWebInterface=false;

            //case 2094
            this._SubscriptionLicense = false;//default for old license processing
            _Lockout = false;
            _LockoutDate = DateTime.MaxValue;

            Plugins.Rows.Clear();
            _Installable = false;

            this._InstallableUntil = System.DateTime.Today.AddDays(-10);
            this._Generated = System.DateTime.Today.AddDays(-10);
        }

        private void Validate(bool CheckInstallableUntilDate)
        {

            //_LicenseValidationStatus += "\r\nValidate: 1";

            InValidate();
            UTF8Encoding utf8 = new UTF8Encoding();

            string Key = utf8.GetString(mbGlobalData);

           // throw new System.NotSupportedException("TEST");

            //case 1172
            string sKeyType = "AyaNovaLiteLicenseKey";
            _Lite = true;
            if (Key.Contains("AyaNovaLicenseKey"))
            {
                sKeyType = "AyaNovaLicenseKey";
                _Lite = false;
            }


            bool containsXML = Key.Contains("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?>");
            bool containsJSON = Key.Contains("[KEY");

            //_LicenseValidationStatus += "\r\nValidate: 2";

            if (!containsXML && !containsJSON)
            {
                _Valid = false;
                _LicenseValidationStatus = "Error: could not find license key in text provided";
                return;
            }

            //_LicenseValidationStatus += "\r\nValidate: 3";

            if (containsXML)
            {
                #region PARSE XML KEY
                //Ensure we have a key and strip out any unnecessary text
                int nStart = Key.IndexOf("<?xml version=\"1.0\" encoding=\"utf-16\" standalone=\"yes\"?>");
                int nEnd = Key.IndexOf("</" + sKeyType + ">");
                if (nEnd == -1 || nStart == -1 || nEnd < nStart)
                {
                    _Valid = false;
                    //	log.Error("Internal error # 1000");//Error: could not find license XML in text.";

                    return;

                }
                Key = Key.Substring(nStart, (nEnd + (("</" + sKeyType + ">").Length)) - nStart);


                //validate key signature then get settings within key
                // Get the XML content from the embedded XML public key.
                Stream s = null;
                string xmlkey = string.Empty;
                try
                {

                    //								System.Reflection.Assembly ass=System.Reflection.Assembly.GetExecutingAssembly();
                    //								string [] items=ass.GetManifestResourceNames();
                    //								foreach(string ss in items)
                    //								{
                    //									string xy=ss;
                    //									string ab=xy;
                    //				
                    //								}



                    s = typeof(GlobalEx).Assembly.GetManifestResourceStream(
                        "GZTW.AyaNova.BLL.p.xml");

                    // Read-in the XML content.
                    StreamReader reader = new StreamReader(s);
                    xmlkey = reader.ReadToEnd();
                    reader.Close();
                }
                catch
                {
                    _Valid = false;
                    //log.Error("Internal error # 1001");
                    //log.Error("Error: could not import public key. " + ex.Message + "\r\n" + ex.InnerException;

                    return;
                }

                // Create an RSA crypto service provider from the embedded
                // XML document resource (the public key).
                RSACryptoServiceProvider csp = new RSACryptoServiceProvider();
                csp.FromXmlString(xmlkey);

                // Load the signed XML license file.
                XmlDocument xmldoc = new XmlDocument();
                try
                {
                    xmldoc.LoadXml(Key);
                }
                catch
                {
                    _Valid = false;
                    //log.Error("Internal error # 1002");
                    //_LicenseValidationStatus="Error: exception in LoadXml:\r\n." + ex.Message + "\r\n" + ex.InnerException;
                    return;

                }

                // Create the signed XML object.
                SignedXml sxml = new SignedXml(xmldoc);

                try
                {
                    // Get the XML Signature node and load it into the signed XML object.
                    XmlNode dsig = xmldoc.GetElementsByTagName("Signature",
                        SignedXml.XmlDsigNamespaceUrl)[0];
                    sxml.LoadXml((XmlElement)dsig);
                }
                catch
                {
                    _Valid = false;
                    //log.Error("Internal error # 1003");
                    //_LicenseValidationStatus="Error: no signature found." + ex.Message + "\r\n" + ex.InnerException;
                    return;


                }

                // Verify the signature.
                if (!sxml.CheckSignature(csp))
                {
                    _Valid = false;
                    //log.Error("Internal error # 1004");
                    //_LicenseValidationStatus="Error: Signature not valid, key has been tampered with.";
                    return;

                }

                _Valid = true;



                try
                {

                    _SchemaVersion = XmlConvert.ToDouble(xmldoc.SelectSingleNode("/" + sKeyType + "/SchemaVersion").InnerText);
                    _RegisteredTo = xmldoc.SelectSingleNode("/" + sKeyType + "/RegisteredTo").InnerText;
                    _ScheduleableUsers = XmlConvert.ToInt32(xmldoc.SelectSingleNode("/" + sKeyType + "/TotalScheduleableUsers").InnerText);
                    _Generated = XmlConvert.ToDateTime(xmldoc.SelectSingleNode("/" + sKeyType + "/Created").InnerText, XmlDateTimeSerializationMode.Local);
                    _InstallableUntil = XmlConvert.ToDateTime(xmldoc.SelectSingleNode("/" + sKeyType + "/InstallableUntil").InnerText, XmlDateTimeSerializationMode.Local);

                    //Case 508
                    _DigestValue = xmldoc.GetElementsByTagName("DigestValue")[0].InnerText;


                    if (xmldoc.SelectSingleNode("/" + sKeyType + "/Expires") != null)
                        _Expires = XmlConvert.ToDateTime(xmldoc.SelectSingleNode("/" + sKeyType + "/Expires").InnerText, XmlDateTimeSerializationMode.Local);
                    else
                        _Expires = null;

                    //case 2094, now just standard plugin
                    //_FeatureWebInterface = XmlConvert.ToBoolean(xmldoc.SelectSingleNode("/" + sKeyType + "/FeatureWebBrowserInterface").InnerText);

                    //case 3187
                    if (xmldoc.SelectSingleNode("/" + sKeyType + "/Source") != null)
                        _Source = xmldoc.SelectSingleNode("/" + sKeyType + "/Source").InnerText;
                    else
                        _Source = "554E4B4E4F574E";//Hex encoded string "UNKNOWN"


                    if (CheckInstallableUntilDate && System.DateTime.Now > _InstallableUntil)
                    {
                        _Installable = false;
                        _Valid = false;
                        //log.Error("Internal error # 1005");
                        //_LicenseValidationStatus="Error: Installation key has expired.";
                        //return;

                    }
                    else
                        _Installable = true;

                    if (_RegisteredTo != "Unregistered trial")
                        _TrialKey = false;




                    //case 2094 MBI now plugin license like pti
                    ////Case 726
                    //if (xmldoc.SelectSingleNode("/" + sKeyType + "/FeatureMBIInterface") != null)
                    //    _FeatureMBIInterface = XmlConvert.ToBoolean(xmldoc.SelectSingleNode("/" + sKeyType + "/FeatureMBIInterface").InnerText);
                    //else
                    //    _FeatureMBIInterface = false;


                    //Case 999
                    if (xmldoc.SelectSingleNode("/" + sKeyType + "/RequestedTrial") != null)
                        _RequestedTrial = XmlConvert.ToBoolean(xmldoc.SelectSingleNode("/" + sKeyType + "/RequestedTrial").InnerText);
                    else
                        _RequestedTrial = false;


                    //Case 2094
                    if (xmldoc.SelectSingleNode("/" + sKeyType + "/Sub") != null)
                        _SubscriptionLicense = XmlConvert.ToBoolean(xmldoc.SelectSingleNode("/" + sKeyType + "/Sub").InnerText);
                    else
                        _SubscriptionLicense = false;

                    //case 2094
                    if (xmldoc.SelectSingleNode("/" + sKeyType + "/LockDate") != null)
                    {
                        _Lockout = true;
                        _LockoutDate = XmlConvert.ToDateTime(xmldoc.SelectSingleNode("/" + sKeyType + "/LockDate").InnerText, XmlDateTimeSerializationMode.Local);
                    }
                    else
                    {
                        _Lockout = false;
                        _LockoutDate = DateTime.MaxValue;
                    }

                    //case 1053 plugins
                    XmlNodeList plugs = xmldoc.SelectNodes("//Plugin");
                    if (plugs != null && plugs.Count > 0)
                    {
                        foreach (XmlNode n in plugs)
                        {
                            DataRow dr = Plugins.NewRow();
                            dr["Plugin"] = n.SelectSingleNode("Item").InnerText;

                            //case 2094 SubscriptionExpires key
                            if (_SubscriptionLicense)
                            {
                                if (n.SelectSingleNode("SubscriptionExpires") != null)
                                    dr["SubscriptionExpires"] = XmlConvert.ToDateTime(n.SelectSingleNode("SubscriptionExpires").InnerText, XmlDateTimeSerializationMode.Local);
                            }
                            else
                            {
                                dr["Version"] = n.SelectSingleNode("Version").InnerText;
                            }


                            Plugins.Rows.Add(dr);
                        }

                    }


                    if (!CheckInstallableUntilDate)//case 999, this is only false if just reading from db at start
                        _BootKeyIsRequestedTrial = _RequestedTrial;
                    else//we're here because a new key has just been entered
                    {
                        if (_RequestedTrial && _BootKeyIsRequestedTrial)//was boot key a requested trial and new key a requested trial?
                        {
                            //Nope, can't install a requested trial on top of a requested trial
                            //otherwise people will keep requesting and take advantage
                            _Installable = false;
                            _Valid = false;
                        }
                    }


                }
                catch
                {
                    _Valid = false;
                    //log.Error("Internal error # 1006");
                    //_LicenseValidationStatus="Error: Signature not valid - exception Processing fields:\r\n." + ex.Message + "\r\n" + ex.InnerException;
                    return;

                }
                #endregion read XML format key
            }
            else
            {
                //_LicenseValidationStatus += "\r\nValidate: 4";
                #region PARSE JSON KEY
                string licenseFileData = Key;
                //extract between [KEY and KEY]
                if (!licenseFileData.Contains("[KEY") ||
                    !licenseFileData.Contains("KEY]") ||
                    !licenseFileData.Contains("[SIGNATURE") ||
                    !licenseFileData.Contains("SIGNATURE]"))
                {
                    _Valid = false;
                    //_LicenseValidationStatus = "KEY IS NOT VALID!  Missing one or more required delimiters";
                    return;
                }

                //_LicenseValidationStatus += "\r\nValidate: 5";

                string keyNoWS = System.Text.RegularExpressions.Regex.Replace(AyaBizUtils.ExtractString(licenseFileData, "[KEY", "KEY]").Trim(), "(\"(?:[^\"\\\\]|\\\\.)*\")|\\s+", "$1");
                string keySig = AyaBizUtils.ExtractString(licenseFileData, "[SIGNATURE", "SIGNATURE]").Trim();

                #region Check Signature
                //***** NOTE: this is our real 2016 public key
                var publicPem = @"-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz7wrvLDcKVMZ31HFGBnL
WL08IodYIV5VJkKy1Z0n2snprhSiu3izxTyz+SLpftvKHJpky027ii7l/pL9Bo3J
cjU5rKrxXavnE7TuYPjXn16dNLd0K/ERSU+pXLmUaVN0nUWuGuUMoGJMEXoulS6p
JiG11yu3BM9fL2Nbj0C6a+UwzEHFmns3J/daZOb4gAzMUdJfh9OJ0+wRGzR8ZxyC
99Na2gDmqYglUkSMjwLTL/HbgwF4OwmoQYJBcET0Wa6Gfb17SaF8XRBV5ZtpCsbS
tkthGeoXZkFriB9c1eFQLKpBYQo2DW3H1MPG2nAlQZLbkJj5cSh7/t1bRF08m6P+
EQIDAQAB
-----END PUBLIC KEY-----";



                PemReader pr = new PemReader(new StringReader(publicPem));
                var KeyParameter = (Org.BouncyCastle.Crypto.AsymmetricKeyParameter)pr.ReadObject();
                var signer = SignerUtilities.GetSigner("SHA256WITHRSA");
                signer.Init(false, KeyParameter);
                var expectedSig = Convert.FromBase64String(keySig);
                var msgBytes = Encoding.UTF8.GetBytes(keyNoWS);
                signer.BlockUpdate(msgBytes, 0, msgBytes.Length);
                if (!signer.VerifySignature(expectedSig))
                {
                    _Valid = false;
                    _LicenseValidationStatus = "Error: Signature not valid, key has been tampered with.";
                    return;
                }

                #endregion check signature
                //_LicenseValidationStatus += "\r\nValidate: 6";
                //valid key (has valid signature)
                _Valid = true;
                try
                {
                    #region Get Values
                    Newtonsoft.Json.Linq.JToken token = Newtonsoft.Json.Linq.JObject.Parse(keyNoWS);
                    _SchemaVersion = (double)token.SelectToken(sKeyType + ".SchemaVersion");

                    //for json keys use the Id unique index number as the digestvalue for revocation purposes
                    //(this is a unix timestamp of moment key generated)
                    _DigestValue = (string)token.SelectToken(sKeyType + ".Id");

                    _RegisteredTo = (string)token.SelectToken(sKeyType + ".RegisteredTo");

                    //case 3187
                    if (token.SelectToken(sKeyType + ".Source") != null)
                    {
                        _Source = (string)token.SelectToken(sKeyType + ".Source");
                    }
                    else
                    {
                        _Source = "554E4B4E4F574E";//Hex encoded string "UNKNOWN"
                    }

                    _ScheduleableUsers = (int)token.SelectToken(sKeyType + ".TotalScheduleableUsers");
                    _Generated = (DateTime)token.SelectToken(sKeyType + ".Created");
                    _InstallableUntil = (DateTime)token.SelectToken(sKeyType + ".InstallableUntil");

                    if (token.SelectToken(sKeyType + ".Expires") != null)
                    {
                        _Expires = (DateTime)token.SelectToken(sKeyType + ".Expires");
                    }
                    else
                    {
                        _Expires = null;
                    }


                    if (CheckInstallableUntilDate && System.DateTime.Now > _InstallableUntil)
                    {
                        _Installable = false;
                        _Valid = false;
                    }
                    else
                        _Installable = true;


                    if (_RegisteredTo != "Unregistered trial")
                        _TrialKey = false;


                    if (token.SelectToken(sKeyType + ".RequestedTrial") != null)
                    {
                        _RequestedTrial = (bool)token.SelectToken(sKeyType + ".RequestedTrial");
                    }
                    else
                    {
                        _RequestedTrial = false;
                    }


                    if (token.SelectToken(sKeyType + ".Sub") != null)
                    {
                        _SubscriptionLicense = (bool)token.SelectToken(sKeyType + ".Sub");
                    }
                    else
                    {
                        _SubscriptionLicense = false;
                        //default expiry to yesterday on v7 keys forcing new date to be selected in UI
                        _Expires = DateTime.Now.AddDays(-1);
                    }

                    if (token.SelectToken(sKeyType + ".LockDate") != null)
                    {
                        _Lockout = true;
                        _LockoutDate = (DateTime)token.SelectToken(sKeyType + ".LockDate");
                    }
                    else
                    {
                        _LockoutDate = DateTime.MaxValue;
                        _Lockout = false;
                    }

                    //PLUGINS
                    //case 3222 
                    Newtonsoft.Json.Linq.JArray p = (Newtonsoft.Json.Linq.JArray)token.SelectToken(sKeyType + ".Plugins.Plugin");
                    for (int x = 0; x < p.Count; x++)
                    {
                        DataRow dr = dtPlugins.NewRow();

                        dr["Plugin"] = (string)p[x].SelectToken("Item");
                        dr["SubscriptionExpires"] = (DateTime)p[x].SelectToken("SubscriptionExpires");
                        dtPlugins.Rows.Add(dr);
                    }

                    if (!CheckInstallableUntilDate)//case 999, this is only false if just reading from db at start
                        _BootKeyIsRequestedTrial = _RequestedTrial;
                    else//we're here because a new key has just been entered
                    {
                        if (_RequestedTrial && _BootKeyIsRequestedTrial)//was boot key a requested trial and new key a requested trial?
                        {
                            //Nope, can't install a requested trial on top of a requested trial
                            //otherwise people will keep requesting and take advantage
                            _Installable = false;
                            _Valid = false;
                        }
                    }

                    //_LicenseValidationStatus += "\r\nValidate: 7";
                    #endregion get values

                }
                catch (Exception ex)
                {
                    //_LicenseValidationStatus += "\r\nValidate: 8";
                    _Valid = false;
                    //_LicenseValidationStatus += "Error: Signature not valid - exception processing fields:\r\n." + ex.Message;
                    if (ex.InnerException != null)
                        //_LicenseValidationStatus += "\r\n" + ex.InnerException.Message;
                    return;

                }
                #endregion parse json key
            }

        }
        #endregion



        #region crypt
        //case 3378 
        //this class is not actually doing anything useful and blocking FIPS
        //deprecated
        internal class CipherWrapper
        {

            RijndaelManaged _cipher = null;
            public CipherWrapper()
            {
                _cipher = InitCipher();
            }
            public CipherWrapper(byte[] key)
            {
                _cipher = InitCipher(key);
            }
            public byte[] Key
            {
                get { return _cipher.Key; }
                set { _cipher.Key = value; }
            }
            //			public byte[] EncryptMessage(byte[] plainText, out byte[] iv)
            //			{
            //				_cipher.GenerateIV();
            //				iv = _cipher.IV;
            //				ICryptoTransform transform = _cipher.CreateEncryptor();
            //				byte[] cipherText = transform.TransformFinalBlock(plainText, 0, plainText.Length);
            //				return cipherText;
            //			}

            public byte[] EncryptMessage(byte[] plainText, byte[] iv)
            {
                _cipher.IV = iv;
                ICryptoTransform transform = _cipher.CreateEncryptor();
                byte[] cipherText = transform.TransformFinalBlock(plainText, 0, plainText.Length);
                return cipherText;
            }

            public byte[] DecryptMessage(byte[] cipherText, byte[] iv)
            {
                _cipher.IV = iv;
                ICryptoTransform transform = _cipher.CreateDecryptor();
                byte[] plainText = transform.TransformFinalBlock(cipherText, 0, cipherText.Length);
                return plainText;
            }
            private RijndaelManaged InitCipher()
            {
                RijndaelManaged cipher = CreateCipher();
                cipher.GenerateKey();
                return cipher;
            }

            private RijndaelManaged InitCipher(byte[] key)
            {
                RijndaelManaged cipher = CreateCipher();
                cipher.Key = key;
                return cipher;
            }
            private RijndaelManaged CreateCipher()
            {
                RijndaelManaged cipher = new RijndaelManaged();
                cipher.KeySize = 256;
                cipher.BlockSize = 256;
                cipher.Mode = CipherMode.CBC;
                cipher.Padding = PaddingMode.PKCS7;
                return cipher;
            }
        }
        #endregion crypt

        #region trial data ex

        [Serializable, EditorBrowsable(EditorBrowsableState.Never), Browsable(false)]
        internal class AGlobalExData
        {
            //


            private System.DateTime mEvalExpire;
            public System.DateTime EvalExpire
            {
                get
                {
                    return mEvalExpire;
                }
                set
                {
                    mEvalExpire = value;
                }
            }

            private System.DateTime mEvalAdvanceReference;
            public System.DateTime EvalAdvanceReference
            {
                get
                {
                    return mEvalAdvanceReference;
                }
                set
                {
                    mEvalAdvanceReference = value;
                }
            }


        }
        #endregion trial data ex

    }//end Global

}//end namespace GZTW.AyaNova.BLL