private string DecryptPassword(string password)
{
return(InstanceCrypto.Decrypt(password));
}
private static Token DecryptToken(string token)
{
return(string.IsNullOrEmpty(token) ? null : FromJson(InstanceCrypto.Decrypt(token)));
}
public EncryptionSettingsHelper(CoreConfiguration coreConfiguration, AscCacheNotify ascCacheNotify, InstanceCrypto instanceCrypto)
{
CoreConfiguration = coreConfiguration;
AscCacheNotify = ascCacheNotify;
InstanceCrypto = instanceCrypto;
}
private static string DecryptPassword(string password)
{
return(string.IsNullOrEmpty(password) ? string.Empty : InstanceCrypto.Decrypt(password));
}
private static string EncryptToken(Token token)
{
var t = token.ToJson();
return(string.IsNullOrEmpty(t) ? string.Empty : InstanceCrypto.Encrypt(t));
}
public MailboxWithAddressDto CreateMailbox(IAccount teamlabAccount, string name,
string fullAddress, string password, string addressName,
DateTime addressCreatedDate,
int domainId, string domainName, bool isVerified, DbManager db)
{
if (teamlabAccount == null)
{
throw new ArgumentNullException("teamlabAccount");
}
if (string.IsNullOrEmpty(fullAddress))
{
throw new ArgumentNullException("fullAddress");
}
if (string.IsNullOrEmpty(password))
{
throw new ArgumentNullException("password");
}
if (string.IsNullOrEmpty(addressName))
{
throw new ArgumentNullException("addressName");
}
if (domainId < 0)
{
throw new ArgumentException("Argument domain_id less then zero.", "domainId");
}
if (string.IsNullOrEmpty(domainName))
{
throw new ArgumentNullException("domainName");
}
if (db == null)
{
throw new ArgumentNullException("db");
}
const string mailbox_alias = "mb";
const string address_alias = "a";
var userTeamlabMailboxCountQuery = new SqlQuery(MailboxTable.Name.Alias(mailbox_alias))
.InnerJoin(AddressTable.Name.Alias(address_alias),
Exp.EqColumns(MailboxTable.Columns.Id.Prefix(mailbox_alias),
AddressTable.Columns.MailboxId.Prefix(address_alias)))
.SelectCount()
.Where(MailboxTable.Columns.IsTeamlabMailbox.Prefix(mailbox_alias), true)
.Where(MailboxTable.Columns.IsRemoved.Prefix(mailbox_alias), false)
.Where(MailboxTable.Columns.Tenant.Prefix(mailbox_alias), tenant)
.Where(MailboxTable.Columns.User.Prefix(mailbox_alias), teamlabAccount.ID.ToString())
.Where(AddressTable.Columns.DomainId.Prefix(address_alias), domainId)
.Where(AddressTable.Columns.IsAlias.Prefix(address_alias), false);
var userMailboxesCount = db.ExecuteScalar <int>(userTeamlabMailboxCountQuery);
if (userMailboxesCount >= _mailboxCountLimit)
{
throw new ArgumentOutOfRangeException("addressName", string.Format("Count of user's mailboxes must be less or equal {0}.", _mailboxCountLimit));
}
var serverInformation = GetTenantServer(db);
var dateCreated = DateTime.UtcNow;
var insertQuery = new SqlInsert(MailboxTable.Name)
.InColumnValue(MailboxTable.Columns.Id, 0)
.InColumnValue(MailboxTable.Columns.Tenant, tenant)
.InColumnValue(MailboxTable.Columns.User, teamlabAccount.ID.ToString())
.InColumnValue(MailboxTable.Columns.Address, fullAddress)
.InColumnValue(MailboxTable.Columns.AddressName, name)
.InColumnValue(MailboxTable.Columns.Password, InstanceCrypto.Encrypt(password))
.InColumnValue(MailboxTable.Columns.MsgCountLast, 0)
.InColumnValue(MailboxTable.Columns.SmtpPassword, InstanceCrypto.Encrypt(password))
.InColumnValue(MailboxTable.Columns.SizeLast, 0)
.InColumnValue(MailboxTable.Columns.LoginDelay, Config.LoginDelayInSeconds)
.InColumnValue(MailboxTable.Columns.Enabled, true)
.InColumnValue(MailboxTable.Columns.Imap, true)
.InColumnValue(MailboxTable.Columns.OAuthType, AuthorizationServiceType.None)
.InColumnValue(MailboxTable.Columns.OAuthToken, null)
.InColumnValue(MailboxTable.Columns.DateCreated, dateCreated)
.InColumnValue(MailboxTable.Columns.SmtpServerId, serverInformation.smtp_settings_id)
.InColumnValue(MailboxTable.Columns.ServerId, serverInformation.imap_settings_id)
.InColumnValue(MailboxTable.Columns.IsTeamlabMailbox, true)
.Identity(0, 0, true);
var result = db.ExecuteScalar <int>(insertQuery);
var createdMailbox = new MailboxDto(result, teamlabAccount.ID.ToString(), tenant,
fullAddress, name);
var addressDal = new MailAddressDal(tenant);
var mailboxAddress = addressDal.AddMailboxAddress(createdMailbox.id, addressName, addressCreatedDate,
domainId, domainName, isVerified, db);
var resultDto = new MailboxWithAddressDto(createdMailbox, mailboxAddress);
return(resultDto);
}
private void PrepareSettings(LDAPSupportSettings settings)
{
if (settings == null)
{
_log.Error("Wrong LDAP settings were received from client.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
if (!settings.EnableLdapAuthentication)
{
settings.Password = string.Empty;
return;
}
if (!string.IsNullOrWhiteSpace(settings.Server))
{
settings.Server = settings.Server.Trim();
}
else
{
_log.Error("settings.Server is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
if (!settings.Server.StartsWith("LDAP://"))
{
settings.Server = "LDAP://" + settings.Server;
}
if (!string.IsNullOrWhiteSpace(settings.UserDN))
{
settings.UserDN = settings.UserDN.Trim();
}
else
{
_log.Error("settings.UserDN is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
if (!string.IsNullOrWhiteSpace(settings.LoginAttribute))
{
settings.LoginAttribute = settings.LoginAttribute.Trim();
}
else
{
_log.Error("settings.LoginAttribute is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
if (!string.IsNullOrWhiteSpace(settings.UserFilter))
{
settings.UserFilter = settings.UserFilter.Trim();
}
if (!string.IsNullOrWhiteSpace(settings.FirstNameAttribute))
{
settings.FirstNameAttribute = settings.FirstNameAttribute.Trim();
}
if (!string.IsNullOrWhiteSpace(settings.SecondNameAttribute))
{
settings.SecondNameAttribute = settings.SecondNameAttribute.Trim();
}
if (!string.IsNullOrWhiteSpace(settings.MailAttribute))
{
settings.MailAttribute = settings.MailAttribute.Trim();
}
if (!string.IsNullOrWhiteSpace(settings.TitleAttribute))
{
settings.TitleAttribute = settings.TitleAttribute.Trim();
}
if (!string.IsNullOrWhiteSpace(settings.MobilePhoneAttribute))
{
settings.MobilePhoneAttribute = settings.MobilePhoneAttribute.Trim();
}
if (settings.GroupMembership)
{
if (!string.IsNullOrWhiteSpace(settings.GroupDN))
{
settings.GroupDN = settings.GroupDN.Trim();
}
else
{
_log.Error("settings.GroupDN is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
if (!string.IsNullOrWhiteSpace(settings.GroupFilter))
{
settings.GroupFilter = settings.GroupFilter.Trim();
}
if (!string.IsNullOrWhiteSpace(settings.GroupAttribute))
{
settings.GroupAttribute = settings.GroupAttribute.Trim();
}
else
{
_log.Error("settings.GroupAttribute is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
if (!string.IsNullOrWhiteSpace(settings.UserAttribute))
{
settings.UserAttribute = settings.UserAttribute.Trim();
}
else
{
_log.Error("settings.UserAttribute is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
}
if (WorkContext.IsMono)
{
settings.Authentication = true;
}
if (!settings.Authentication)
{
settings.Password = string.Empty;
return;
}
if (!string.IsNullOrWhiteSpace(settings.Login))
{
settings.Login = settings.Login.Trim();
}
else
{
_log.Error("settings.Login is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR, Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
if (settings.PasswordBytes == null || !settings.PasswordBytes.Any())
{
if (!string.IsNullOrEmpty(settings.Password))
{
settings.PasswordBytes =
InstanceCrypto.Encrypt(new UnicodeEncoding().GetBytes(settings.Password));
}
else
{
_log.Error("settings.Password is null or empty.");
SetProggressInfo(Constants.LDAP_SETTING_TASK_ERROR,
Resource.LdapSettingsErrorCantGetLdapSettings);
SetProggressInfo(Constants.LDAP_SETTING_TASK_IS_COMPLETED, true);
return;
}
}
settings.Password = string.Empty;
}
internal string Transport()
{
return(HttpServerUtility.UrlTokenEncode(InstanceCrypto.Encrypt(Encoding.UTF8.GetBytes(ToSerializedString()))));
}
internal void FromTransport(string transportstring)
{
var serialized = Encoding.UTF8.GetString(InstanceCrypto.Decrypt(HttpServerUtility.UrlTokenDecode(transportstring)));
FromSerializedString(serialized);
}
public AuthenticationController(
UserManager userManager,
TenantManager tenantManager,
SecurityContext securityContext,
TenantCookieSettingsHelper tenantCookieSettingsHelper,
CookiesManager cookiesManager,
PasswordHasher passwordHasher,
EmailValidationKeyModelHelper emailValidationKeyModelHelper,
ICache cache,
SetupInfo setupInfo,
MessageService messageService,
ProviderManager providerManager,
IOptionsSnapshot <AccountLinker> accountLinker,
CoreBaseSettings coreBaseSettings,
PersonalSettingsHelper personalSettingsHelper,
StudioNotifyService studioNotifyService,
UserManagerWrapper userManagerWrapper,
UserHelpTourHelper userHelpTourHelper,
Signature signature,
InstanceCrypto instanceCrypto,
DisplayUserSettingsHelper displayUserSettingsHelper,
MessageTarget messageTarget,
StudioSmsNotificationSettingsHelper studioSmsNotificationSettingsHelper,
SettingsManager settingsManager,
SmsManager smsManager,
TfaManager tfaManager,
TimeZoneConverter timeZoneConverter,
SmsKeyStorage smsKeyStorage,
CommonLinkUtility commonLinkUtility,
ApiContext apiContext,
AuthContext authContext)
{
UserManager = userManager;
TenantManager = tenantManager;
SecurityContext = securityContext;
TenantCookieSettingsHelper = tenantCookieSettingsHelper;
CookiesManager = cookiesManager;
PasswordHasher = passwordHasher;
EmailValidationKeyModelHelper = emailValidationKeyModelHelper;
Cache = cache;
SetupInfo = setupInfo;
MessageService = messageService;
ProviderManager = providerManager;
AccountLinker = accountLinker;
CoreBaseSettings = coreBaseSettings;
PersonalSettingsHelper = personalSettingsHelper;
StudioNotifyService = studioNotifyService;
UserHelpTourHelper = userHelpTourHelper;
Signature = signature;
InstanceCrypto = instanceCrypto;
DisplayUserSettingsHelper = displayUserSettingsHelper;
MessageTarget = messageTarget;
StudioSmsNotificationSettingsHelper = studioSmsNotificationSettingsHelper;
SettingsManager = settingsManager;
SmsManager = smsManager;
TfaManager = tfaManager;
TimeZoneConverter = timeZoneConverter;
SmsKeyStorage = smsKeyStorage;
CommonLinkUtility = commonLinkUtility;
ApiContext = apiContext;
AuthContext = authContext;
UserManagerWrapper = userManagerWrapper;
}
public ProviderManager(Signature signature, InstanceCrypto instanceCrypto, ConsumerFactory consumerFactory)
{
Signature = signature;
InstanceCrypto = instanceCrypto;
ConsumerFactory = consumerFactory;
}
public static string DecryptPassword(string password)
{
return(InstanceCrypto.Decrypt(password));
}
public Helpers(InstanceCrypto instanceCrypto)
{
this.instanceCrypto = instanceCrypto;
}
public OpenIdLoginProvider(Signature signature, InstanceCrypto instanceCrypto, ConsumerFactory consumerFactory)
{
Signature = signature;
InstanceCrypto = instanceCrypto;
ConsumerFactory = consumerFactory;
}
