MARKUS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Data;

using System.Data.Common;

namespace KCOM

{

    public class ColInfo

    {

        public string Name { get; set; }

        public string DataType { get; set; }

    }

    /// <summary>

    /// Abstract base class for encapsulating provider independant database interactin logic.

    /// </summary>

    /// <remarks>Version 2.0</remarks>

    /// <typeparam name="CONNECTION_TYPE"><see cref="DbConnection"/> derived Connection type.</typeparam>

    /// <typeparam name="COMMAND_TYPE"><see cref="DbCommand"/> derived Command type.</typeparam>

    /// <typeparam name="ADAPTER_TYPE"><see cref="DbDataAdapater"/> derived Data Adapter type.</typeparam>

    public abstract class AbstractDatabase<CONNECTION_TYPE, COMMAND_TYPE, ADAPTER_TYPE> : IDisposable, IAbstractDatabase

        where CONNECTION_TYPE : DbConnection, new()

        where COMMAND_TYPE : DbCommand

        where ADAPTER_TYPE : DbDataAdapter, new()

    {

        #region : Connection :

        /// <summary>Gets the Connection object associated with the current instance.</summary>

        public DbConnection Connection

        {

            get

            {

                if (internal_currentConnection == null)

                {

                    internal_currentConnection = new CONNECTION_TYPE() { ConnectionString = GetConnectionString() };

                }

                return internal_currentConnection;

            }

        }

        private DbConnection internal_currentConnection = null;

        /// <summary>When overridden in derived classes returns the connection string for the database.</summary>

        /// <returns>The connection string for the database.</returns>

        protected abstract string GetConnectionString();

        #endregion

        #region : Commands :

        /// <summary>Gets a DbCommand object with the specified <see cref="DbCommand.CommandText"/>.</summary>

        /// <param name="sqlString">The SQL string.</param>

        /// <returns>A DbCommand object with the specified <see cref="DbCommand.CommandText"/>.</returns>

        public DbCommand GetSqlStringCommand(string sqlString)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            DbCommand cmd = this.Connection.CreateCommand();

            cmd.CommandType = CommandType.Text;

            cmd.CommandText = sqlString;

            cmd.CommandTimeout = 600; // 15.11.04 added by soohyun - Extend Time out of query

            return cmd;

        }

        /// <summary>Gets a DbCommand object with the specified <see cref="DbCommand.CommandText"/>.</summary>

        /// <param name="sqlStringFormat">The SQL string format.</param>

        /// <param name="args">The format arguments.</param>

        /// <returns>A DbCommand object with the specified <see cref="DbCommand.CommandText"/>.</returns>

        public DbCommand GetSqlStringCommand(string sqlStringFormat, params object[] args)

        {

            return GetSqlStringCommand(string.Format(sqlStringFormat, args));

        }

        /// <summary>Gets a DbCommand object for the specified Stored Procedure.</summary>

        /// <param name="storedProcName">The name of the stored procedure.</param>

        /// <returns>A DbCommand object for the specified Stored Procedure.</returns>

        public DbCommand GetStoredProcedureCommand(string storedProcName)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            DbCommand cmd = this.Connection.CreateCommand();

            cmd.CommandType = CommandType.StoredProcedure;

            cmd.CommandText = storedProcName;

            return cmd;

        }

        #region : Parameters :

        /// <summary>Adds an input parameter to the given <see cref="DbCommand"/>.</summary>

        /// <param name="cmd">The command object the parameter should be added to.</param>

        /// <param name="paramName">The identifier of the parameter.</param>

        /// <param name="paramType">The type of the parameter.</param>

        /// <param name="value">The value of the parameter.</param>

        /// <returns>The <see cref="DbParameter"/> that was created.</returns>

        public DbParameter AddInParameter(DbCommand cmd, string paramName, DbType paramType, object value)

        {

            return AddParameter(cmd, paramName, paramType, ParameterDirection.Input, value);

        }

        /// <summary>Adds an input parameter to the given <see cref="DbCommand"/>.</summary>

        /// <param name="cmd">The command object the parameter should be added to.</param>

        /// <param name="paramName">The identifier of the parameter.</param>

        /// <param name="paramType">The type of the parameter.</param>

        /// <param name="size">The maximum size in bytes, of the data table column to be affected.</param>

        /// <param name="value">The value of the parameter.</param>

        /// <returns>The <see cref="DbParameter"/> that was created.</returns>

        public DbParameter AddInParameter(DbCommand cmd, string paramName, DbType paramType, int size, object value)

        {

            DbParameter param = AddInParameter(cmd, paramName, paramType, value);

            param.Size = size;

            cmd.Parameters.Add(param);

            return param;

        }

        /// <summary>Adds the out parameter to the given <see cref="DbCommand"/></summary>

        /// <param name="cmd">The command object the parameter should be added to.</param>

        /// <param name="paramName">The identifier of the parameter.</param>

        /// <param name="paramType">The type of the parameter.</param>

        /// <param name="value">The value of the parameter.</param>

        /// <returns>The <see cref="DbParameter"/> that was created.</returns>

        public DbParameter AddOutParameter(DbCommand cmd, string paramName, DbType paramType, object value)

        {

            return AddParameter(cmd, paramName, paramType, ParameterDirection.Output, value);

        }

        /// <summary>Adds a parameter to the given <see cref="DbCommand"/>.</summary>

        /// <param name="cmd">The command object the parameter should be added to.</param>

        /// <param name="paramName">The identifier of the parameter.</param>

        /// <param name="paramType">The type of the parameter.</param>

        /// <param name="direction"><see cref="ParameterDirection"/> of the parameter.</param>

        /// <param name="value">The value of the parameter.</param>

        /// <returns>The <see cref="DbParameter"/> that was created.</returns>

        public DbParameter AddParameter(DbCommand cmd, string paramName,

                                            DbType paramType,

                                            ParameterDirection direction,

                                            object value)

        {

            DbParameter param = cmd.CreateParameter();

            param.DbType = paramType;

            param.ParameterName = paramName;

            param.Value = value;

            param.Direction = direction;

            cmd.Parameters.Add(param);

            return param;

        }

        /// <summary>Adds a parameter to the given <see cref="DbCommand"/>.</summary>

        /// <param name="cmd">The command object the parameter should be added to.</param>

        /// <param name="paramName">The identifier of the parameter.</param>

        /// <param name="paramType">The type of the parameter.</param>

        /// <param name="direction"><see cref="ParameterDirection"/> of the parameter.</param>

        /// <param name="size">The maximum size in bytes, of the data table column to be affected.</param>

        /// <param name="value">The value of the parameter.</param>

        /// <returns>The <see cref="DbParameter"/> that was created.</returns>

        public DbParameter AddParameter(DbCommand cmd, string paramName,

                                            DbType paramType,

                                            ParameterDirection direction,

                                            int size,

                                            object value)

        {

            DbParameter param = AddParameter(cmd, paramName, paramType, direction, value);

            param.Size = size;

            return param;

        }

        #endregion

        #region : Executes :

        /// <summary>Executes the specified command against the current connection.</summary>

        /// <param name="cmd">The command to be executed.</param>

        /// <returns>Result returned by the database engine.</returns>

        public int ExecuteNonQuery(DbCommand cmd)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            return cmd.ExecuteNonQuery();

        }

        public int ExecuteNonQuery(string sSql)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            return GetSqlStringCommand(sSql).ExecuteNonQuery();

        }

        /// <summary>Executes the specified command against the current connection.</summary>

        /// <param name="cmd">The command to be executed.</param>

        /// <param name="txn">The database transaction inside which the command should be executed.</param>

        /// <returns>Result returned by the database engine.</returns>

        public int ExecuteNonQuery(DbCommand cmd, DbTransaction txn)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            cmd.Transaction = txn;

            return cmd.ExecuteNonQuery();

        }

        /// <summary>Executes the specified command against the current connection.</summary>

        /// <param name="cmd">The command to be executed.</param>

        /// <returns>Result returned by the database engine.</returns>

        public DbDataReader ExecuteReader(DbCommand cmd)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            return cmd.ExecuteReader();

        }

        /// <summary>Executes the specified command against the current connection.</summary>

        /// <param name="cmd">The command to be executed.</param>

        /// <param name="behavior">One of the <see cref="System.Data.CommandBehavior"/> values.</param>

        /// <returns>Result returned by the database engine.</returns>

        public DbDataReader ExecuteReader(DbCommand cmd, CommandBehavior behavior)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            return cmd.ExecuteReader(behavior);

        }

        /// <summary>Executes the specified command against the current connection.</summary>

        /// <param name="cmd">The command to be executed.</param>

        /// <returns>Result returned by the database engine.</returns>

        public T ExecuteScalar<T>(DbCommand cmd, T defaultValue)

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            object retVal = cmd.ExecuteScalar();

            if (null == retVal || DBNull.Value == retVal)

                return defaultValue;

            else

                return (T)retVal;

        }

        /// <summary>Executes the specified command against the current connection.</summary>

        /// <param name="cmd">The command to be executed.</param>

        /// <returns>Result returned by the database engine.</returns>

        public DataSet ExecuteDataSet(DbCommand cmd, DbTransaction txn = null)

        {

            ADAPTER_TYPE adapter = new ADAPTER_TYPE();

            if (null != txn) cmd.Transaction = txn;

            adapter.SelectCommand = (COMMAND_TYPE)cmd;

            DataSet retVal = new DataSet()

            {

                Locale = System.Globalization.CultureInfo.InvariantCulture

            };

            adapter.Fill(retVal);

            return retVal;

        }

        #endregion

        #endregion

        /// <summary>Begins a transaction.</summary>

        /// <returns>Created transaction.</returns>

        public DbTransaction BeginTransaction()

        {

            if (this.Connection.State != ConnectionState.Open)

                this.Connection.Open();

            return Connection.BeginTransaction();

        }

        #region : Consturction / Destruction :

        /// <summary>Disposes the resources associated with the current database connection.</summary>

        ~AbstractDatabase()

        {

            Dispose();

        }

        #region IDisposable Members

        /// <summary>Disposes the resources associated with the current database connection.</summary>

        public void Dispose()

        {

            if (null != internal_currentConnection)

            {

                internal_currentConnection.Dispose();

                internal_currentConnection = null;

            }

        }

        #endregion

        #endregion

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

using System.Data.Common;

using System.Data.SQLite;

using System.Globalization;

namespace KCOM

{

	class AppSQLiteDatabase : AbstractDatabase<SQLiteConnection , SQLiteCommand , SQLiteDataAdapter>

	{

		public string FilePath{get;set;}

        /// <summary>

        /// sqlite connection string

        /// </summary>

        /// <author>humkyung</author>

        /// <date>2019.02.10</date>

        /// <returns></returns>

        protected override string  GetConnectionString()

		{

            return string.Format(CultureInfo.CurrentCulture, "Data Source = {0}", this.FilePath);

		}

    }

}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Text;

using System.Data;

using System.Data.Common;

namespace KCOM

{

    public interface IAbstractDatabase : IDisposable

    {

        DbConnection Connection { get; }

        DbCommand GetSqlStringCommand(string sqlString);

        DbCommand GetSqlStringCommand(string sqlStringFormat, params object[] args);

        DbCommand GetStoredProcedureCommand(string storedProcName);

        DbParameter AddInParameter(DbCommand cmd, string paramName, DbType paramType, object value);

        DbParameter AddInParameter(DbCommand cmd, string paramName, DbType paramType, int size, object value);

        DbParameter AddOutParameter(DbCommand cmd, string paramName, DbType paramType, object value);

        DbParameter AddParameter(DbCommand cmd, string paramName,

                                            DbType paramType,

                                            ParameterDirection direction,

                                            object value);

        DbParameter AddParameter(DbCommand cmd, string paramName,

                                            DbType paramType,

                                            ParameterDirection direction,

                                            int size,

                                            object value);

        int ExecuteNonQuery(DbCommand cmd);

        int ExecuteNonQuery(string sSql);

        int ExecuteNonQuery(DbCommand cmd, DbTransaction txn);

        DbDataReader ExecuteReader(DbCommand cmd);

        DbDataReader ExecuteReader(DbCommand cmd, CommandBehavior behavior);

        DataSet ExecuteDataSet(DbCommand cmd, DbTransaction txn = null);

        DbTransaction BeginTransaction();

    }

}

                if (item as ArrowTextControl != null)

                    (item as ArrowTextControl).Base_TextBox.IsHitTestVisible = false;

                else if (item as TextControl != null)

                    (item as TextControl).Base_TextBox.IsHitTestVisible = false;

                var text_item_ = ViewerDataModel.Instance.MarkupControls_USER.Where(data => (data as TextControl) != null && (data as TextControl).IsEditingMode == true).FirstOrDefault();

                var Arrowtext_item_ = ViewerDataModel.Instance.MarkupControls_USER.Where(data => (data as ArrowTextControl) != null && (data as ArrowTextControl).IsEditingMode == true).FirstOrDefault();

            if (e.OriginalSource is System.Windows.Controls.Image)

                (e.OriginalSource as System.Windows.Controls.Image).Focus();

                var control = ViewerDataModel.Instance.MarkupControls_USER.Where(data => data.IsMouseEnter).FirstOrDefault();

                if (init_user && gridViewMarkup.SelectedItems.Where(d => (d as MarkupInfoItem).UserID == App.ViewInfo.UserID).FirstOrDefault() == null && e.LeftButton == MouseButtonState.Pressed)

                                if (currentControl is CoordinateControl)

                                    if (IsGetoutpoint((currentControl as CoordinateControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                     && d.Data_Type == Convert.ToInt32(MarkupToPDF.Controls.Common.ControlType.Coordinate)).Count() > 0)

                                        currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                if (currentControl is InsideWhiteControl)

                                    if (IsGetoutpoint((currentControl as InsideWhiteControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                if (currentControl is RectangleControl)

                                    if (IsGetoutpoint((currentControl as RectangleControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                if (currentControl is RectCloudControl)

                                    if (IsGetoutpoint((currentControl as RectCloudControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                if (currentControl is CircleControl)

                                    if (IsGetoutpoint((currentControl as CircleControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                if (currentControl is TriControl)

                                    var content = currentControl as TriControl;

                                    if (content.MidPoint == new Point(0, 0))

                                        content.MidPoint = new Point(CanvasDrawingMouseDownPoint.X, CanvasDrawingMouseDownPoint.Y);

                                        if (IsGetoutpoint((currentControl as TriControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                if (currentControl is LineControl)

                                    if (IsGetoutpoint((currentControl as LineControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                            if (currentControl is PolygonControl)

                                var control = currentControl as PolygonControl;

                                    control.IsCompleted = true;

                                if (!control.IsCompleted)

                                    control.PointSet.Add(control.EndPoint);

                                    if (IsGetoutpoint((currentControl as PolygonControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                    var firstPoint = control.PointSet.First();

                                    control.DashSize = ViewerDataModel.Instance.DashSize;

                                    control.LineSize = ViewerDataModel.Instance.LineSize;

                                    control.PointSet.Add(firstPoint);

                                    control.ApplyOverViewData();

                                    control.UpdateControl();

                                if (currentControl is ArcControl)

                                    if (IsGetoutpoint((currentControl as ArcControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                if (currentControl is ArrowArcControl)

                                    if (IsGetoutpoint((currentControl as ArrowArcControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                    if (IsGetoutpoint((currentControl as CloudControl).PointSet.Where(data => IsRotationDrawingEnable(data) == true).FirstOrDefault()))

                                    //if (IsDrawingEnable(canvasZoomPanningMouseDownPoint))

                                    //{

                                    //}

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

                                    currentControl.SetValue(Canvas.ZIndexProperty, 3);

        public int ZIndex { get; set; } = 0;

        public int ZIndex { get; set; };

using System;

using System.Collections.Generic;

using System.Globalization;

using System.Net.NetworkInformation;

using System.Security.Cryptography;

using System.Security.Cryptography.Xml;

using System.ServiceModel;

using System.Threading;

using System.Xml;

//using log4net;

using Rhino.Licensing.Discovery;

namespace Rhino.Licensing

{

    /// <summary>

    /// Base license validator.

    /// </summary>

    public abstract class AbstractLicenseValidator

    {

        /// <summary>

        /// License validator logger

        /// </summary>

        //protected static readonly ILog Log = LogManager.GetLogger(typeof(LicenseValidator));

        /// <summary>

        /// Standard Time servers

        /// </summary>

        protected static readonly string[] TimeServers =

        {

            "time.nist.gov",

            "time-nw.nist.gov",

            "time-a.nist.gov",

            "time-b.nist.gov",

            "time-a.timefreq.bldrdoc.gov",

            "time-b.timefreq.bldrdoc.gov",

            "time-c.timefreq.bldrdoc.gov",

            "utcnist.colorado.edu",

            "nist1.datum.com",

            "nist1.dc.certifiedtime.com",

            "nist1.nyc.certifiedtime.com",

            "nist1.sjc.certifiedtime.com"

        };

        private readonly string licenseServerUrl;

        private readonly Guid clientId;

        private readonly string publicKey;

        private readonly Timer nextLeaseTimer;

        private bool disableFutureChecks;

        private bool currentlyValidatingSubscriptionLicense;

        private readonly DiscoveryHost discoveryHost;

        private DiscoveryClient discoveryClient;

        private Guid senderId;

        /// <summary>

        /// Fired when license data is invalidated

        /// </summary>

        public event Action<InvalidationType> LicenseInvalidated;

        /// <summary>

        /// Fired when license is expired

        /// </summary>

        public event Action<DateTime> LicenseExpired;

        /// <summary>

        /// Event that's raised when duplicate licenses are found

        /// </summary>

        public event EventHandler<DiscoveryHost.ClientDiscoveredEventArgs> MultipleLicensesWereDiscovered;

        /// <summary>

        /// Disable the <see cref="ExpirationDate"/> validation with the time servers

        /// </summary>

        public bool DisableTimeServersCheck

        {

            get; set;

        }

        /// <summary>

        /// Gets the expiration date of the license

        /// </summary>

        public DateTime ExpirationDate

        {

            get; private set;

        }

        /// <summary>

        /// Lease timeout

        /// </summary>

        public TimeSpan LeaseTimeout { get; set; }

        /// <summary>

        /// How to behave when using the same license multiple times

        /// </summary>

        public MultipleLicenseUsage MultipleLicenseUsageBehavior { get; set; }

        /// <summary>

        /// Gets or Sets the endpoint address of the subscription service

        /// </summary>

        public string SubscriptionEndpoint

        {

            get; set;

        }

        /// <summary>

        /// Gets the Type of the license

        /// </summary>

        public LicenseType LicenseType

        {

            get; private set;

        }

        /// <summary>

        /// Gets the Id of the license holder

        /// </summary>

        public Guid UserId

        {

            get; private set;

        }

        /// <summary>

        /// Gets the name of the license holder

        /// </summary>

        public string Name

        {

            get; private set;

        }

        /// <summary>

        /// Gets or Sets Floating license support

        /// </summary>

        public bool DisableFloatingLicenses

        {

            get; set;

        }

        /// <summary>

        /// Whether the client discovery server is enabled. This detects duplicate licenses used on the same network.

        /// </summary>

        public bool DiscoveryEnabled { get; private set; }

        /// <summary>

        /// Gets extra license information

        /// </summary>

        public IDictionary<string, string> LicenseAttributes

        {

            get; private set;

        }

        /// <summary>

        /// Gets or Sets the license content

        /// </summary>

        protected abstract string License

        {

            get; set;

        }

        /// <summary>

        /// Creates a license validator with specfied public key.

        /// </summary>

        /// <param name="publicKey">public key</param>

        /// <param name="enableDiscovery">Whether to enable the client discovery server to detect duplicate licenses used on the same network.</param>

        protected AbstractLicenseValidator(string publicKey, bool enableDiscovery = false)

        {

            LeaseTimeout = TimeSpan.FromMinutes(5);

            LicenseAttributes = new Dictionary<string, string>();

            nextLeaseTimer = new Timer(LeaseLicenseAgain);

            this.publicKey = publicKey;

            DiscoveryEnabled = enableDiscovery;

            if (DiscoveryEnabled)

            {

                senderId = Guid.NewGuid();

                discoveryHost = new DiscoveryHost();

                discoveryHost.ClientDiscovered += DiscoveryHostOnClientDiscovered;

                discoveryHost.Start();

            }

        }

        /// <summary>

        /// Creates a license validator using the client information

        /// and a service endpoint address to validate the license.

        /// </summary>

        protected AbstractLicenseValidator(string publicKey, string licenseServerUrl, Guid clientId)

            : this(publicKey)

        {

            this.licenseServerUrl = licenseServerUrl;

            this.clientId = clientId;

        }

        private void LeaseLicenseAgain(object state)

        {

            var client = discoveryClient;

            if (client != null)

                client.PublishMyPresence();

            if (HasExistingLicense())

                return;

            RaiseLicenseInvalidated();

        }

        private void RaiseLicenseInvalidated()

        {

            var licenseInvalidated = LicenseInvalidated;

            if (licenseInvalidated == null)

                throw new InvalidOperationException("License was invalidated, but there is no one subscribe to the LicenseInvalidated event");

            licenseInvalidated(LicenseType == LicenseType.Floating ? InvalidationType.CannotGetNewLicense :

                                                                     InvalidationType.TimeExpired);

        }

        private void RaiseMultipleLicenseDiscovered(DiscoveryHost.ClientDiscoveredEventArgs args)

        {

            var onMultipleLicensesWereDiscovered = MultipleLicensesWereDiscovered;

            if (onMultipleLicensesWereDiscovered != null)

            {

                onMultipleLicensesWereDiscovered(this, args);

            }

        }

        private void DiscoveryHostOnClientDiscovered(object sender, DiscoveryHost.ClientDiscoveredEventArgs clientDiscoveredEventArgs)

        {

            if (senderId == clientDiscoveredEventArgs.SenderId) // we got our own notification, ignore it

                return;

            if (UserId != clientDiscoveredEventArgs.UserId) // another license, we don't care

                return;

            // same user id, different senders

            switch (MultipleLicenseUsageBehavior)

            {

                case MultipleLicenseUsage.AllowForSameUser:

                    if (Environment.UserName == clientDiscoveredEventArgs.UserName)

                        return;

                    break;

            }

            RaiseLicenseInvalidated();

            RaiseMultipleLicenseDiscovered(clientDiscoveredEventArgs);

        }

        /// <summary>

        /// Validates loaded license

        /// </summary>

        public virtual void AssertValidLicense()

        {

            LicenseAttributes.Clear();

            if (HasExistingLicense())

            {

                if (DiscoveryEnabled)

                {

                    discoveryClient = new DiscoveryClient(senderId, UserId, Environment.MachineName, Environment.UserName);

                    discoveryClient.PublishMyPresence();

                }

                return;

            }

            //Log.WarnFormat("Could not validate existing license\r\n{0}", License);

            throw new LicenseNotFoundException();

        }

        private bool HasExistingLicense()

        {

            try

            {

                if (TryLoadingLicenseValuesFromValidatedXml() == false)

                {

                    //Log.WarnFormat("Failed validating license:\r\n{0}", License);

                    return false;

                }

                //Log.InfoFormat("License expiration date is {0}", ExpirationDate);

                bool result;

                if (LicenseType == LicenseType.Subscription)

                {

                    result = ValidateSubscription();

                }

                else

                {

                    result = DateTime.UtcNow < ExpirationDate;

                }

                if (result &&

                    !DisableTimeServersCheck)

                {

                    ValidateUsingNetworkTime();

                }

                if (!result)

                {

                    if (LicenseExpired == null)

                        throw new LicenseExpiredException("Expiration Date : " + ExpirationDate);

                    DisableFutureChecks();

                    LicenseExpired(ExpirationDate);

                }

                return true;

            }

            catch (RhinoLicensingException)

            {

                throw;

            }

            catch (Exception)

            {

                return false;

            }

        }

        private bool ValidateSubscription()

        {

            if ((ExpirationDate - DateTime.UtcNow).TotalDays > 4)

                return true;

            if (currentlyValidatingSubscriptionLicense)

                return DateTime.UtcNow < ExpirationDate;

            if (SubscriptionEndpoint == null)

                throw new InvalidOperationException("Subscription endpoints are not supported for this license validator");

            try

            {

                TryGettingNewLeaseSubscription();

            }

            catch (Exception e)

            {

                //Log.Error("Could not re-lease subscription license", e);

                throw new Exception("Could not re-lease subscription license", e);

            }

            return ValidateWithoutUsingSubscriptionLeasing();

        }

        private bool ValidateWithoutUsingSubscriptionLeasing()

        {

            currentlyValidatingSubscriptionLicense = true;

            try

            {

                return HasExistingLicense();

            }

            finally

            {

                currentlyValidatingSubscriptionLicense = false;

            }

        }

        private void TryGettingNewLeaseSubscription()

        {

            var service = ChannelFactory<ISubscriptionLicensingService>.CreateChannel(new BasicHttpBinding(), new EndpointAddress(SubscriptionEndpoint));

            try

            {

                var newLicense = service.LeaseLicense(License);

                TryOverwritingWithNewLicense(newLicense);

            }

            finally

            {

                var communicationObject = service as ICommunicationObject;

                if (communicationObject != null)

                {

                    try

                    {

                        communicationObject.Close(TimeSpan.FromMilliseconds(200));

                    }

                    catch

                    {

                        communicationObject.Abort();

                    }

                }

            }

        }

        /// <summary>

        /// Loads the license file.

        /// </summary>

        /// <param name="newLicense"></param>

        /// <returns></returns>

        protected bool TryOverwritingWithNewLicense(string newLicense)

        {

            if (string.IsNullOrEmpty(newLicense))

                return false;

            try

            {

                var xmlDocument = new XmlDocument();

                xmlDocument.LoadXml(newLicense);

            }

            catch (Exception e)

            {

                // Log.Error("New license is not valid XML\r\n" + newLicense, e);

                System.Diagnostics.Debug.WriteLine("New license is not valid XML\r\n" + newLicense, e);

                //throw new Exception("New license is not valid XML\r\n" + newLicense, e);

                return false;

            }

            License = newLicense;

            return true;

        }

        private void ValidateUsingNetworkTime()

        {

            if (!NetworkInterface.GetIsNetworkAvailable())

                return;

            var sntp = new SntpClient(GetTimeServers());

            sntp.BeginGetDate(time =>

            {

                if (time > ExpirationDate)

                    RaiseLicenseInvalidated();

            }

            , () =>

            {

                /* ignored */

            });

        }

        /// <summary>

        /// Extension point to return different time servers

        /// </summary>

        /// <returns></returns>

        protected virtual string[] GetTimeServers()

        {

            return TimeServers;

        }

        /// <summary>

        /// Removes existing license from the machine.

        /// </summary>

        public virtual void RemoveExistingLicense()

        {

        }

        /// <summary>

        /// Loads license data from validated license file.

        /// </summary>

        /// <returns></returns>

        public bool TryLoadingLicenseValuesFromValidatedXml()

        {

            try

            {

                var doc = new XmlDocument();

                doc.LoadXml(License);

                if (TryGetValidDocument(publicKey, doc) == false)

                {

                    //Log.WarnFormat("Could not validate xml signature of:\r\n{0}", License);

                    return false;

                }

                if (doc.FirstChild == null)

                {

                    //Log.WarnFormat("Could not find first child of:\r\n{0}", License);

                    return false;

                }

                if (doc.SelectSingleNode("/floating-license") != null)

                {

                    var node = doc.SelectSingleNode("/floating-license/license-server-public-key/text()");

                    if (node == null)

                    {

                        //Log.WarnFormat("Invalid license, floating license without license server public key:\r\n{0}", License);

                        throw new InvalidOperationException(

                            "Invalid license file format, floating license without license server public key");

                    }

                    return ValidateFloatingLicense(node.InnerText);

                }

                var result = ValidateXmlDocumentLicense(doc);

                if (result && disableFutureChecks == false)

                {

                    nextLeaseTimer.Change(LeaseTimeout, LeaseTimeout);

                }

                return result;

            }

            catch (RhinoLicensingException)

            {

                throw;

            }

            catch (Exception e)

            {

                //Log.Error("Could not validate license", e);

                System.Diagnostics.Debug.WriteLine("Could not validate license", e);

                return false;

            }

        }

        private bool ValidateFloatingLicense(string publicKeyOfFloatingLicense)

        {

            if (DisableFloatingLicenses)

            {

               // Log.Warn("Floating licenses have been disabled");

                System.Diagnostics.Debug.WriteLine("Floating licenses have been disabled");

                return false;

            }

            if (licenseServerUrl == null)

            {

                //Log.Warn("Could not find license server url");

                throw new InvalidOperationException("Floating license encountered, but licenseServerUrl was not set");

            }

            var success = false;

            var licensingService = ChannelFactory<ILicensingService>.CreateChannel(new WSHttpBinding(), new EndpointAddress(licenseServerUrl));

            try

            {

                   var leasedLicense = licensingService.LeaseLicense(

                    Environment.MachineName,

                    Environment.UserName,

                    clientId);

                ((ICommunicationObject)licensingService).Close();

                success = true;

                if (leasedLicense == null)

                {

                    //Log.WarnFormat("Null response from license server: {0}", licenseServerUrl);

                    throw new FloatingLicenseNotAvailableException();

                }

                var doc = new XmlDocument();

                doc.LoadXml(leasedLicense);

                if (TryGetValidDocument(publicKeyOfFloatingLicense, doc) == false)

                {

                    //Log.WarnFormat("Could not get valid license from floating license server {0}", licenseServerUrl);

                    throw new FloatingLicenseNotAvailableException();

                }

                var validLicense = ValidateXmlDocumentLicense(doc);

                if (validLicense)

                {

                    //setup next lease

                    var time = (ExpirationDate.AddMinutes(-5) - DateTime.UtcNow);

                    System.Diagnostics.Debug.WriteLine("Will lease license again at {0}", time);

                    //Log.DebugFormat("Will lease license again at {0}", time);

                    if (disableFutureChecks == false)

                        nextLeaseTimer.Change(time, time);

                }

                return validLicense;

            }

            finally

            {

                if (success == false)

                    ((ICommunicationObject)licensingService).Abort();

            }

        }

        internal bool ValidateXmlDocumentLicense(XmlDocument doc)

        {

            var id = doc.SelectSingleNode("/license/@id");

            if (id == null)

            {

                //Log.WarnFormat("Could not find id attribute in license:\r\n{0}", License);

                return false;

            }

            UserId = new Guid(id.Value);

            var date = doc.SelectSingleNode("/license/@expiration");