/// <summary>
 ///     Inicializa un nuevo cliente con la clavede acceso, la clave secreta, el tipo de autenticación y la url base
 /// </summary>
 /// <param name="accessKey"></param>
 /// <param name="secretKey"></param>
 /// <param name="authenticationScheme"></param>
 /// <param name="baseUrl"></param>
 public EffiPeopleRestClient(string accessKey, string secretKey, AuthenticationType authenticationScheme, string baseUrl)
     : base(baseUrl)
 {
     _accessKey = accessKey;
     _secretKey = secretKey;
     _authenticationScheme = authenticationScheme;
 }

 protected CouchBase(string username, string password, AuthenticationType aT, DbType dbType)
 {
     this.username = username;
     this.password = password;
     this.authType = aT;
     this.dbType = dbType;
 }

   public SqlGetDatabaseFromProcedureWorker(string server, AuthenticationType authenticationType, string user, string password, string version,
 out ISqlGetDatabaseFromProcedureWorkerReturnedData data)
       : base(server, "", authenticationType, user, password)
   {
       data = this.data = new SqlGetDatabaseFromProcedureWorkerReturnedData();
         this.version = version;
   }

        protected bool InitializeClient(AuthenticationType authType, EventHandler<AuthorizationCodeRequiredEventArgs> codeRequiredHandler, Guid clientId = default(Guid), string clientSecret = null)
        {
            var s = GetSettings();

            if (!s.IsConfigured) return false;

            lock (_lck)
            { 
                if (_aaClient == null || _settings == null || _clientSecret != clientSecret || _clientId != clientId || _settings.LastChanged < s.LastChanged )
                {
                    if (authType == AuthenticationType.Code)
                    {
                        clientId = s.UserAppId;
                        if (clientId == default(Guid))
                            clientId = Parameters.CLIENT_ID;
                    }

                    _aaClient = new AAClient(s.TenantId, s.SubscriptionId, s.ResourceGroupName, s.AutomationAccountName, authType, clientId, clientSecret);

                    if (authType == AuthenticationType.Code)
                        _aaClient.AuthorizationCodeRequired += codeRequiredHandler;

                    _clientSecret = clientSecret;
                    _settings = s;
                    _isInitialized = true;
                }
            }
            return true;
        }

   public SqlDatabaseExistWorker(string server, string checkedDatabase, AuthenticationType authenticationType, string user, string password,
 out ISqlDatabaseExistWorkerReturnedData data)
       : base(server, "", authenticationType, user, password)
   {
       this.checkedDatabase = checkedDatabase;
         data = this.data = new ReturnedData();
   }

 public AppManager(string sharePointUrl, AuthenticationType authenticationType, string userName, SecureString password)
 {
     this.sharePointUrl = sharePointUrl;
     this.authenticationType = authenticationType;
     this.userName = userName;
     this.password = password;
 }

   public SqlProgressWorker(string server, string database, AuthenticationType authenticationType, string user, string password,
 EventHandler<SqlWorkerProgressEventArgs> progressEvent = null)
       : base(server, database, authenticationType, user, password)
   {
       this.progressEvent = progressEvent;
         initializedDataAreSent = false;
         prevCurrentCount = 0;
   }

 public RemoteOperation(string targetUrl, AuthenticationType authType, string user, string password, string domain = "")
 {
     this.TargetSiteUrl = targetUrl;
     this.AuthType = authType;
     this.User = user;
     this.Password = password;
     this.Domain = domain;
 }

 public static AuthenticationType ParseAuthType(string value, AuthenticationType defaultvalue) {
     if (value == "Password")
         return AuthenticationType.Password;
     else if (value == "PublicKey")
         return AuthenticationType.PublicKey;
     else
         return defaultvalue;
 }

   public SqlAttachDatabaseWorker(string server, string newDatabase, AuthenticationType authenticationType, string user, string password,
 string pathToMdf, string pathToLdf, out ISqlAttachDatabaseWorkerReturnedData data)
       : base(server, "", authenticationType, user, password)
   {
       data = this.data = new ReturnedData();
         this.newDatabase = newDatabase;
         this.pathToMdf = pathToMdf;
         this.pathToLdf = pathToLdf;
   }

 public RemoteOperation(string targetUrl, AuthenticationType authType, string user, SecureString password, string AppInstanceId, string domain = "")
 {
     TargetSiteUrl = targetUrl;
     AuthType = authType;
     User = user;
     Password = password;
     Domain = domain;
     this.AppInstanceId = AppInstanceId;
 }

 public SharepointServerSourceCallbackHandler(IEnvironmentRepository environmentRepository,string server,string userName,string password,AuthenticationType authenticationType)
     : base(environmentRepository)
 {
     VerifyArgument.AreNotNull(new Dictionary<string, object>{{"environmentRepository",environmentRepository}});
     _server = server;
     _userName = userName;
     _password = password;
     _authenticationType = authenticationType;
 }

        public Stream(Uri streamUrl, AuthenticationType authenticationType, string httpMethod = "GET", int timeout = -1)
        {
            tokenSource = new CancellationTokenSource();
            ct = tokenSource.Token;

            AuthenticationType = authenticationType;
            HttpMethod = httpMethod.ToUpper();
            _streamUrl = streamUrl;
            Timeout = timeout;
        }

        /// <summary>
        /// This static method activates a user and creates a new instance of SecureEnvironment.
        /// The authentication type determines the type of user identity that will be activated. 
        /// If Permanent Windows activation is requested then the default currently logged on 
        /// Windows Account identity will be activated. If Temporary Windows activation requested 
        /// then user will be prompted for Windows Domain credentials through a dialog, and the 
        /// user identified through those credentials will be activated. 
        /// In case of Passport authentication, a Passport authentication dialog will always
        /// appear regardless of temporary or permanent activation mode. The user that authenticatd 
        /// through that Passport Authentication dialog will be activated.
        /// Regardless of Windows or Passport Authentication, all Temporary created activation will be 
        /// destroyed when SecureEnvironment instance is Disposed or Finalized.  
        /// </summary>   
        public static SecureEnvironment Create(string applicationManifest, 
                                                                                        AuthenticationType authentication, 
                                                                                        UserActivationMode userActivationMode)
        {
            SecurityHelper.DemandRightsManagementPermission();

            return CriticalCreate(applicationManifest, 
                                            authentication,
                                            userActivationMode);
        }

 public ApiInitializePushCommand(IEnumerable<IntegrationPackageDto> packages, AuthenticationType authenticationType,
     AuditIntegrationCommand audit, ApiConfigurationIdentifier configuration, long configurationId)
 {
     Packages = packages;
     PackageTransactions = new List<PackageTransactionDto>();
     AuthenticationType = authenticationType;
     Audit = audit;
     Configuration = configuration;
     ConfigurationId = configurationId;
 }

 public AccountingRequest(string nasIpAddress, ServiceType serviceType, string userName,
     AuthenticationType authenticationType, StatusType statusType, uint delayTime, string clientIp, string sessionId, Client client)
     : base(PacketType.AccountingRequest, nasIpAddress, serviceType, userName)
 {
     Packet.Secret = client.Secret;
     Packet.Attributes.Add(new AuthenticationTypeAttribute(authenticationType));
     Packet.Attributes.Add(new StatusTypeAttribute(statusType));
     Packet.Attributes.Add(new IntegerAttribute(AttributeType.AcctDelayTime, delayTime));
     Packet.Attributes.Add(new IpAddressAttribute(AttributeType.FramedIpAddress, clientIp));
     Packet.Attributes.Add(new StringAttribute(AttributeType.AcctSessionId, sessionId));
 }

 /// <summary>
 /// Initializes a new instance of the ActivateSessionRequest class.
 /// </summary>
 /// <param name="sessionAuthenticationType">Session authentication type.</param>
 /// <param name="maximumPrivilegeLevel">Maximum privilege level for this session.</param>
 /// <param name="sessionChallengeString">Challenge string from Get Session Challenge message.</param>
 /// <param name="initialOutboundSequenceNumber">Initial outbound sequence number.</param>
 internal ActivateSessionRequest(
     AuthenticationType sessionAuthenticationType, 
     PrivilegeLevel maximumPrivilegeLevel,
     byte[] sessionChallengeString,
     uint initialOutboundSequenceNumber)
 {
     this.sessionAuthenticationType = sessionAuthenticationType;
     this.maximumPrivilegeLevel = maximumPrivilegeLevel;
     this.sessionChallengeString = sessionChallengeString;
     this.initialOutboundSequenceNumber = initialOutboundSequenceNumber;
 }

        internal SqlServerSettings(string server, AuthenticationType authentication, string adminUser, string adminPassword, string ibnUser, string ibnPassword)
        {
            Server = server;
            Authentication = authentication;
            AdminUser = adminUser;
            AdminPassword = adminPassword;
            PortalUser = ibnUser;
            PortalPassword = ibnPassword;

            AdminConnectionString = BuildConnectionString(authentication, server, "master", adminUser, adminPassword);
        }

        internal static string BuildConnectionString(AuthenticationType authentication, string server, string database, string user, string password)
        {
            string format;

            if (authentication == AuthenticationType.SqlServer)
                format = "Data source={0};Initial catalog={1};User Id={2};Password={3}";
            else
                format = "Data source={0};Initial catalog={1};Integrated Security=SSPI";

            return string.Format(CultureInfo.InvariantCulture, format,
                server, database, user, password);
        }

        /// <summary>
        /// Initializes a new instance of the GetSessionChallengeRequest class.
        /// </summary>
        /// <param name="authenticationType">Authentication type for challenge.</param>
        /// <param name="userid">Userid or null.</param>
        internal GetSessionChallengeRequest(AuthenticationType authenticationType, string userId)
        {
            this.challengeAuthenticationType = (byte)authenticationType;

            this.UserId = new byte[16];

            if (!string.IsNullOrEmpty(userId))
            {
                for (int i = 0; i < userId.Length; i++)
                {
                    this.UserId[i] = (byte)userId[i];
                }
            }
        }