/// <summary>
 /// Extracts the storage account requested key
 /// </summary>
 private string ExtractStorageAccountKey(string storageName, BaseAuditingPolicyModel model, string storageAccountResourceGroup, StorageKeyKind keyType)
 {
     if (IgnoreStorage)
     {
         return null;
     }
     if (model.StorageKeyType == keyType)
     {
         return AzureCommunicator.GetStorageKeys(storageAccountResourceGroup, storageName)[keyType];
     }
     return null;
 }
        /// <summary>
        /// Extracts the event types from the given model
        /// </summary>
        private string ExtractEventTypes(BaseAuditingPolicyModel model)
        {
            if (model.EventType == null)
            {
                return null;
            }

            StringBuilder events = new StringBuilder();
            if (IsEventTypeOn(AuditEventType.PlainSQL_Success, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.PlainSQL_Success).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.PlainSQL_Failure, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.PlainSQL_Failure).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.ParameterizedSQL_Success, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.ParameterizedSQL_Success).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.ParameterizedSQL_Failure, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.ParameterizedSQL_Failure).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.StoredProcedure_Success, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.StoredProcedure_Success).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.StoredProcedure_Failure, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.StoredProcedure_Failure).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.Login_Success, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.Login_Success).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.Login_Failure, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.Login_Failure).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.TransactionManagement_Success, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.TransactionManagement_Success).Append(",");
            }
            if (IsEventTypeOn(AuditEventType.TransactionManagement_Failure, model.EventType))
            {
                events.Append(SecurityConstants.AuditingEndpoint.TransactionManagement_Failure).Append(",");
            }
            if(events.Length != 0) 
            {
                events.Remove(events.Length - 1, 1); // remove trailing comma
            }
            return events.ToString();
        }
        /// <summary>
        /// Extracts the storage account name from the given model
        /// </summary>
        private string ExtractStorageAccountName(BaseAuditingPolicyModel model)
        {
            string storageAccountName = null;

            if (model.StorageAccountName == FetchedStorageAccountName) // the user provided the same storage account that was given before
            {
                storageAccountName = FetchedStorageAccountName;
            }
            else if (model.StorageAccountName == null) // the user did not provided storage account for a policy for which such account is already defined
            {
                storageAccountName = FetchedStorageAccountName;
            }
            else // the user updates the name of the storage account
            {
                storageAccountName = model.StorageAccountName;
            }
            if (string.IsNullOrEmpty(storageAccountName) && (!IgnoreStorage)) // can happen if the user didn't provide account name for a policy that lacked it 
            {
                throw new Exception(string.Format(Resources.NoStorageAccountWhenConfiguringAuditingPolicy));
            }
            return storageAccountName;
        }
 /// <summary>
 /// Updates the content of the model object with all the retention information
 /// </summary>
 private void ModelizeRetentionInfo(BaseAuditingPolicyModel model, string retentionDays, string auditLogsTableName)
 {
     model.TableIdentifier = auditLogsTableName;
     uint retentionDaysForModel;
     if (!(UInt32.TryParse(retentionDays, out retentionDaysForModel)))
     {
         retentionDaysForModel = 0;
     }
     model.RetentionInDays = retentionDaysForModel;
 }
 /// <summary>
 /// Updates the given model with all the event types information
 /// </summary>
 private void ModelizeEventTypesInfo(BaseAuditingPolicyModel model, string eventTypesToAudit)
 { 
     HashSet<AuditEventType> events = new HashSet<AuditEventType>();
     if (eventTypesToAudit.IndexOf(SecurityConstants.PlainSQL_Success) != -1) events.Add(AuditEventType.PlainSQL_Success);
     if (eventTypesToAudit.IndexOf(SecurityConstants.PlainSQL_Failure) != -1) events.Add(AuditEventType.PlainSQL_Failure);
     if (eventTypesToAudit.IndexOf(SecurityConstants.ParameterizedSQL_Success) != -1) events.Add(AuditEventType.ParameterizedSQL_Success);
     if (eventTypesToAudit.IndexOf(SecurityConstants.ParameterizedSQL_Failure) != -1) events.Add(AuditEventType.ParameterizedSQL_Failure);
     if (eventTypesToAudit.IndexOf(SecurityConstants.StoredProcedure_Success) != -1) events.Add(AuditEventType.StoredProcedure_Success);
     if (eventTypesToAudit.IndexOf(SecurityConstants.StoredProcedure_Failure) != -1) events.Add(AuditEventType.StoredProcedure_Failure);
     if (eventTypesToAudit.IndexOf(SecurityConstants.Login_Success) != -1) events.Add(AuditEventType.Login_Success);
     if (eventTypesToAudit.IndexOf(SecurityConstants.Login_Failure) != -1) events.Add(AuditEventType.Login_Failure);
     if (eventTypesToAudit.IndexOf(SecurityConstants.TransactionManagement_Success) != -1) events.Add(AuditEventType.TransactionManagement_Success);
     if (eventTypesToAudit.IndexOf(SecurityConstants.TransactionManagement_Failure) != -1) events.Add(AuditEventType.TransactionManagement_Failure);
     model.EventType = events.ToArray();
 }
 /// <summary>
 /// Updates the content of the model object with all the storage related information
 /// </summary>
 private void ModelizeStorageInfo(BaseAuditingPolicyModel model, string accountName, string primary, string secondary)
 {
     model.StorageAccountName = accountName;
     if (!String.IsNullOrEmpty(secondary))
     {
         model.StorageKeyType = StorageKeyKind.Secondary;
     }
     else
     {
         model.StorageKeyType = StorageKeyKind.Primary;
     }
 }