protected virtual Task <Tenant> GetCurrentTenantAsync()
{
return(TenantManager.GetByIdAsync(AbpSession.GetTenantId()));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
ExternalLoginInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
throw new Exception("Can not external login!");
}
model.UserName = model.EmailAddress;
model.Password = Authorization.Users.User.CreateRandomPassword();
}
else
{
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(L("FormIsNotValidMessage"));
}
}
var user = await _userRegistrationManager.RegisterAsync(
model.Name,
model.Surname,
model.EmailAddress,
model.UserName,
model.Password,
true // Assumed email address is always confirmed. Change this if you want to implement email confirmation.
);
// Getting tenant-specific settings
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
if (model.IsExternalLogin)
{
Debug.Assert(externalLoginInfo != null);
if (string.Equals(externalLoginInfo.Principal.FindFirstValue(ClaimTypes.Email), model.EmailAddress, StringComparison.OrdinalIgnoreCase))
{
user.IsEmailConfirmed = true;
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.ProviderKey,
TenantId = user.TenantId
}
};
}
await _unitOfWorkManager.Current.SaveChangesAsync();
Debug.Assert(user.TenantId != null);
var tenant = await _tenantManager.GetByIdAsync(user.TenantId.Value);
// Directly login if possible
if (user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin))
{
AbpLoginResult <Tenant, User> loginResult;
if (externalLoginInfo != null)
{
loginResult = await _logInManager.LoginAsync(externalLoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await _signInManager.SignInAsync(loginResult.Identity, false);
return(Redirect(GetAppHomeUrl()));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
return(View("RegisterResult", new RegisterResultViewModel
{
TenancyName = tenant.TenancyName,
NameAndSurname = user.Name + " " + user.Surname,
UserName = user.UserName,
EmailAddress = user.EmailAddress,
IsEmailConfirmed = user.IsEmailConfirmed,
IsActive = user.IsActive,
IsEmailConfirmationRequiredForLogin = isEmailConfirmationRequiredForLogin
}));
}
catch (UserFriendlyException ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View("Register", model));
}
}
public async Task <RegisterTenantOutput> RegisterTenant(RegisterTenantInput input)
{
if (input.EditionId.HasValue)
{
await CheckEditionSubscriptionAsync(input.EditionId.Value, input.SubscriptionStartType, input.Gateway, input.PaymentId);
}
else
{
await CheckRegistrationWithoutEdition();
}
using (CurrentUnitOfWork.SetTenantId(null))
{
CheckTenantRegistrationIsEnabled();
if (UseCaptchaOnRegistration())
{
await _recaptchaValidator.ValidateAsync(input.CaptchaResponse);
}
//Getting host-specific settings
var isNewRegisteredTenantActiveByDefault = await SettingManager.GetSettingValueForApplicationAsync <bool>(AppSettings.TenantManagement.IsNewRegisteredTenantActiveByDefault);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueForApplicationAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
DateTime?subscriptionEndDate = null;
var isInTrialPeriod = false;
if (input.EditionId.HasValue)
{
isInTrialPeriod = input.SubscriptionStartType == ESubscriptionStartType.Trial;
if (isInTrialPeriod)
{
var edition = (SubscribableEdition)await _editionManager.GetByIdAsync(input.EditionId.Value);
subscriptionEndDate = Clock.Now.AddDays(edition.TrialDayCount ?? 0);
}
}
var tenantId = await _tenantManager.CreateWithAdminUserAsync(
input.TenancyName,
input.Name,
input.AdminPassword,
input.AdminEmailAddress,
null,
isNewRegisteredTenantActiveByDefault,
input.EditionId,
false,
true,
subscriptionEndDate,
isInTrialPeriod,
AppUrlService.CreateEmailActivationUrlFormat(input.TenancyName)
);
Tenant tenant;
if (input.SubscriptionStartType == ESubscriptionStartType.Paid)
{
if (!input.Gateway.HasValue)
{
throw new Exception("Gateway is missing!");
}
var payment = await _subscriptionPaymentRepository.GetByGatewayAndPaymentIdAsync(
input.Gateway.Value,
input.PaymentId
);
tenant = await _tenantManager.UpdateTenantAsync(
tenantId,
true,
false,
payment.PaymentPeriodType,
payment.EditionId,
EEditionPaymentType.NewRegistration);
await _subscriptionPaymentRepository.UpdateByGatewayAndPaymentIdAsync(input.Gateway.Value,
input.PaymentId, tenantId, SubscriptionPaymentStatus.Completed);
}
else
{
tenant = await TenantManager.GetByIdAsync(tenantId);
}
await _appNotifier.NewTenantRegisteredAsync(tenant);
if (input.EditionId.HasValue && input.Gateway.HasValue && !input.PaymentId.IsNullOrEmpty())
{
_paymentCache.RemoveCacheItem(input.Gateway.Value, input.PaymentId);
}
return(new RegisterTenantOutput
{
TenantId = tenant.Id,
TenancyName = input.TenancyName,
Name = input.Name,
UserName = AbpUserBase.AdminUserName,
EmailAddress = input.AdminEmailAddress,
IsActive = tenant.IsActive,
IsEmailConfirmationRequired = isEmailConfirmationRequiredForLogin,
IsTenantActive = tenant.IsActive
});
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
if (!model.IsExternalLogin && UseCaptchaOnRegistration())
{
await _recaptchaValidator.ValidateAsync(HttpContext.Request.Form[RecaptchaValidator.RecaptchaResponseKey]);
}
ExternalLoginInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
throw new Exception("Can not external login!");
}
model.UserName = model.EmailAddress.ToMd5();
model.Password = Authorization.Users.User.CreateRandomPassword();
}
else
{
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(L("FormIsNotValidMessage"));
}
}
var user = await _userRegistrationManager.RegisterAsync(
model.Name,
model.Surname,
model.EmailAddress,
model.UserName,
model.Password,
false,
_appUrlService.CreateEmailActivationUrlFormat(AbpSession.TenantId)
);
//Getting tenant-specific settings
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
if (model.IsExternalLogin)
{
Debug.Assert(externalLoginInfo != null);
if (string.Equals(externalLoginInfo.Principal.FindFirstValue(ClaimTypes.Email), model.EmailAddress, StringComparison.OrdinalIgnoreCase))
{
user.IsEmailConfirmed = true;
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.ProviderKey,
TenantId = user.TenantId
}
};
}
await _unitOfWorkManager.Current.SaveChangesAsync();
Debug.Assert(user.TenantId != null);
var tenant = await _tenantManager.GetByIdAsync(user.TenantId.Value);
//Directly login if possible
if (user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin))
{
AbpLoginResult <Tenant, User> loginResult;
if (externalLoginInfo != null)
{
loginResult = await _logInManager.LoginAsync(externalLoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await _signInManager.SignInAsync(loginResult.Identity, false);
if (!string.IsNullOrEmpty(model.SingleSignIn) && model.SingleSignIn.Equals("true", StringComparison.OrdinalIgnoreCase) && loginResult.Result == AbpLoginResultType.Success)
{
var returnUrl = NormalizeReturnUrl(model.ReturnUrl);
loginResult.User.SetSignInToken();
returnUrl = AddSingleSignInParametersToReturnUrl(returnUrl, loginResult.User.SignInToken, loginResult.User.Id, loginResult.User.TenantId);
return(Redirect(returnUrl));
}
return(Redirect(GetAppHomeUrl()));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
return(View("RegisterResult", new RegisterResultViewModel
{
TenancyName = tenant.TenancyName,
NameAndSurname = user.Name + " " + user.Surname,
UserName = user.UserName,
EmailAddress = user.EmailAddress,
IsActive = user.IsActive,
IsEmailConfirmationRequired = isEmailConfirmationRequiredForLogin
}));
}
catch (UserFriendlyException ex)
{
ViewBag.UseCaptcha = !model.IsExternalLogin && UseCaptchaOnRegistration();
ViewBag.ErrorMessage = ex.Message;
return(View("Register", model));
}
}
public virtual async Task <ActionResult> Register(TenantRegistrationViewModel model)
{
try
{
CheckTenantRegistrationIsEnabled();
if (UseCaptchaOnRegistration())
{
var recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (recaptchaHelper.Response.IsNullOrEmpty())
{
throw new UserFriendlyException(L("CaptchaCanNotBeEmpty"));
}
if (recaptchaHelper.VerifyRecaptchaResponse() != RecaptchaVerificationResult.Success)
{
throw new UserFriendlyException(L("IncorrectCaptchaAnswer"));
}
}
//Getting host-specific settings
var isNewRegisteredTenantActiveByDefault = await SettingManager.GetSettingValueForApplicationAsync <bool>(AppSettings.TenantManagement.IsNewRegisteredTenantActiveByDefault);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueForApplicationAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
var defaultEditionIdValue = await SettingManager.GetSettingValueForApplicationAsync(AppSettings.TenantManagement.DefaultEdition);
int?defaultEditionId = null;
if (!string.IsNullOrEmpty(defaultEditionIdValue) && (await _editionManager.FindByIdAsync(Convert.ToInt32(defaultEditionIdValue)) != null))
{
defaultEditionId = Convert.ToInt32(defaultEditionIdValue);
}
CurrentUnitOfWork.SetTenantId(null);
var tenantId = await _tenantManager.CreateWithAdminUserAsync(
model.TenancyName,
model.Name,
model.AdminPassword,
model.AdminEmailAddress,
null,
isNewRegisteredTenantActiveByDefault,
defaultEditionId,
false,
true);
ViewBag.UseCaptcha = UseCaptchaOnRegistration();
var tenant = await _tenantManager.GetByIdAsync(tenantId);
await _appNotifier.NewTenantRegisteredAsync(tenant);
CurrentUnitOfWork.SetTenantId(tenant.Id);
var user = await _userManager.FindByNameAsync(Authorization.Users.User.AdminUserName);
//Directly login if possible
if (tenant.IsActive && user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin))
{
var loginResult = await GetLoginResultAsync(user.UserName, model.AdminPassword, tenant.TenancyName);
if (loginResult.Result == AbpLoginResultType.Success)
{
await SignInAsync(loginResult.User, loginResult.Identity);
return(Redirect(Url.Action("Index", "Application")));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
return(View("RegisterResult", new TenantRegisterResultViewModel
{
TenancyName = model.TenancyName,
Name = model.Name,
UserName = Authorization.Users.User.AdminUserName,
EmailAddress = model.AdminEmailAddress,
IsActive = isNewRegisteredTenantActiveByDefault,
IsEmailConfirmationRequired = isEmailConfirmationRequiredForLogin
}));
}
catch (UserFriendlyException ex)
{
ViewBag.UseCaptcha = UseCaptchaOnRegistration();
ViewBag.ErrorMessage = ex.Message;
return(View("Index", model));
}
}
public async Task <IActionResult> Upgrade(int upgradeEditionId)
{
if (!AbpSession.TenantId.HasValue)
{
throw new ArgumentNullException();
}
SubscriptionPaymentType subscriptionPaymentType;
using (CurrentUnitOfWork.SetTenantId(null))
{
var tenant = await _tenantManager.GetByIdAsync(AbpSession.GetTenantId());
subscriptionPaymentType = tenant.SubscriptionPaymentType;
if (tenant.EditionId.HasValue)
{
var currentEdition = await _editionManager.GetByIdAsync(tenant.EditionId.Value);
if (((SubscribableEdition)currentEdition).IsFree)
{
var upgradeEdition = await _editionManager.GetByIdAsync(upgradeEditionId);
if (((SubscribableEdition)upgradeEdition).IsFree)
{
await _paymentAppService.SwitchBetweenFreeEditions(upgradeEditionId);
return(RedirectToAction("Index", "SubscriptionManagement", new { area = "App" }));
}
return(RedirectToAction("Buy", "Payment", new
{
tenantId = AbpSession.GetTenantId(),
editionId = upgradeEditionId,
editionPaymentType = (int)EditionPaymentType.BuyNow
}));
}
if (!await _paymentAppService.HasAnyPayment())
{
return(RedirectToAction("Buy", "Payment", new
{
tenantId = AbpSession.GetTenantId(),
editionId = upgradeEditionId,
editionPaymentType = (int)EditionPaymentType.BuyNow
}));
}
}
}
var paymentInfo = await _paymentAppService.GetPaymentInfo(new PaymentInfoInput { UpgradeEditionId = upgradeEditionId });
if (paymentInfo.IsLessThanMinimumUpgradePaymentAmount())
{
await _paymentAppService.UpgradeSubscriptionCostsLessThenMinAmount(upgradeEditionId);
return(RedirectToAction("Index", "SubscriptionManagement", new { area = "App" }));
}
var edition = await _tenantRegistrationAppService.GetEdition(upgradeEditionId);
var lastPayment = await _subscriptionPaymentRepository.GetLastCompletedPaymentOrDefaultAsync(
tenantId : AbpSession.GetTenantId(),
gateway : null,
isRecurring : null);
var model = new UpgradeEditionViewModel
{
Edition = edition,
AdditionalPrice = paymentInfo.AdditionalPrice,
SubscriptionPaymentType = subscriptionPaymentType,
PaymentPeriodType = lastPayment.GetPaymentPeriodType()
};
if (subscriptionPaymentType.IsRecurring())
{
model.PaymentGateways = new List <PaymentGatewayModel>
{
new PaymentGatewayModel
{
GatewayType = lastPayment.Gateway,
SupportsRecurringPayments = true
}
};
}
else
{
model.PaymentGateways = _paymentAppService.GetActiveGateways(new GetActiveGatewaysInput());
}
return(View("Upgrade", model));
}
public async Task <ActionResult> Index()
{
string settingValueAsync;
int value;
int? tenantId = null;
TenantSettingsEditDto allSettings = await this._tenantSettingsAppService.GetAllSettings(tenantId);
((dynamic)this.ViewBag).IsMultiTenancyEnabled = this._multiTenancyConfig.IsEnabled;
TenantManager tenantManager = this._tenantManager;
tenantId = this.AbpSession.TenantId;
Tenant byIdAsync = await tenantManager.GetByIdAsync(tenantId.Value);
((dynamic)this.ViewBag).TenantName = byIdAsync.Name.Trim();
List <SelectListItem> selectListItems = new List <SelectListItem>();
using (HttpClient httpClient = new HttpClient())
{
string str = this.Url.RouteUrl("DefaultApiWithAction", new { httproute = "", controller = "Generic", action = "GetCountriesAsSelectListItems", countryId = 0, selectedCountryId = allSettings.Details.CountryId }, this.Request.Url.Scheme);
using (HttpResponseMessage async = await httpClient.GetAsync(str))
{
if (async.IsSuccessStatusCode)
{
settingValueAsync = await async.Content.ReadAsStringAsync();
selectListItems = JsonConvert.DeserializeObject <List <SelectListItem> >(settingValueAsync);
}
}
}
List <SelectListItem> selectListItems1 = selectListItems;
SelectListItem selectListItem = new SelectListItem()
{
Text = "",
Value = "",
Disabled = false
};
selectListItems1.Insert(0, selectListItem);
this.ViewData["Countries"] = selectListItems.AsEnumerable <SelectListItem>();
settingValueAsync = await this.SettingManager.GetSettingValueAsync("App.General.Timezones");
List <TimeZoneInfo> timeZoneInfos = JsonConvert.DeserializeObject <List <TimeZoneInfo> >(settingValueAsync);
List <SelectListItem> selectListItems2 = new List <SelectListItem>();
foreach (TimeZoneInfo timeZoneInfo in timeZoneInfos)
{
SelectListItem selectListItem1 = new SelectListItem()
{
Text = timeZoneInfo.DisplayName,
Value = timeZoneInfo.Id,
Disabled = false,
Selected = false
};
selectListItems2.Add(selectListItem1);
}
this.ViewData["Timezones"] = selectListItems2.AsEnumerable <SelectListItem>();
List <SelectListItem> selectListItems3 = new List <SelectListItem>();
tenantId = this.AbpSession.TenantId;
LookupFill lookupFill = new LookupFill("PaymentTerms", tenantId.Value);
IRepository <PaymentSetting, long> repository = this._paymentSettingRepository;
List <PaymentSetting> allListAsync = await repository.GetAllListAsync((PaymentSetting x) => (int?)x.TenantId == this.AbpSession.TenantId);
List <PaymentSetting> paymentSettings = allListAsync;
if (paymentSettings.Any <PaymentSetting>())
{
foreach (PaymentSetting paymentSetting in paymentSettings)
{
ICollection <Lookup> lookupItems = lookupFill.LookupItems;
string str1 = paymentSetting.Setting.ToString();
tenantId = this.AbpSession.ImpersonatorTenantId;
if (tenantId.HasValue)
{
tenantId = this.AbpSession.ImpersonatorTenantId;
value = tenantId.Value;
}
else
{
tenantId = this.AbpSession.TenantId;
value = tenantId.Value;
}
lookupItems.Add(LookupFill.CreateLookupFromString(str1, value));
}
}
ICollection <Lookup> lookups = lookupFill.LookupItems;
foreach (Lookup lookup in
from x in lookups
orderby x.Text
select x)
{
List <SelectListItem> selectListItems4 = selectListItems3;
SelectListItem selectListItem2 = new SelectListItem()
{
Text = lookup.Text,
Value = lookup.Value,
Disabled = lookup.Disabled,
Selected = lookup.Selected
};
selectListItems4.Add(selectListItem2);
}
this.ViewData["PaymentTerms"] = selectListItems3;
return(this.View(allSettings));
}
public virtual async Task <ActionResult> NewTenantSignUp(TenantRegistrationView model)
{
try
{
if (!CheckActivationCode(model.OTP))
{
ViewBag.ErrorMessage = L("OTPMismatched");
CheckTenantRegistrationIsEnabled();
ViewBag.UseCaptcha = UseCaptchaOnRegistration();
ViewBag.PasswordComplexitySetting = SettingManager.GetSettingValue(AppSettings.Security.PasswordComplexity).Replace("\"", "");
return(View(new TenantRegistrationView()
{
PlanId = model.PlanId,
CurrentPlan = _tenantManager.GetCurrentTenantPlan(model.PlanId),
listCountries = _tenantManager.GetCountries(),
listCurrencies = _tenantManager.GetCurrencies()
}));
}
CheckTenantRegistrationIsEnabled();
if (UseCaptchaOnRegistration())
{
var recaptchaHelper = this.GetRecaptchaVerificationHelper();
if (recaptchaHelper.Response.IsNullOrEmpty())
{
throw new UserFriendlyException(L("CaptchaCanNotBeEmpty"));
}
if (recaptchaHelper.VerifyRecaptchaResponse() != RecaptchaVerificationResult.Success)
{
throw new UserFriendlyException(L("IncorrectCaptchaAnswer"));
}
}
//Getting host-specific settings
var isNewRegisteredTenantActiveByDefault = await SettingManager.GetSettingValueForApplicationAsync <bool>(AppSettings.TenantManagement.IsNewRegisteredTenantActiveByDefault);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueForApplicationAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
var defaultEditionIdValue = await SettingManager.GetSettingValueForApplicationAsync(AppSettings.TenantManagement.DefaultEdition);
int?defaultEditionId = null;
if (!string.IsNullOrEmpty(defaultEditionIdValue) && (await _editionManager.FindByIdAsync(Convert.ToInt32(defaultEditionIdValue)) != null))
{
defaultEditionId = Convert.ToInt32(defaultEditionIdValue);
}
// model.PlanId = Convert.ToInt32(ViewBag.PlanId);
CurrentUnitOfWork.SetTenantId(null);
var tenantId = await _tenantManager.CreateWithAdminUserAsync(
model.TenancyName,
model.LoginName,
model.AdminPassword,
model.AdminEmailAddress,
model.FullName,
model.CellNumber.Replace("(", "").Replace(")", "").Replace("-", "").Replace(" ", ""),
//model.PhoneNumber,
//model.CompanyRegistrationNo,
//model.CompanyVatNo,
//model.Address,
//model.City,
model.CountryCode,
model.CurrencyCode,
//model.InvoicingInstruction,
// model.BillingCountryCode,
// model.BillingCurrencyCode,
//model.Timezone,
model.CardHoldersName,
model.CardNumber,
model.CardExpiration,
model.CVV,
model.payment,
model.PlanId,
null,
true,
defaultEditionId,
false,
true);
ViewBag.UseCaptcha = UseCaptchaOnRegistration();
var tenant = await _tenantManager.GetByIdAsync(tenantId);
await _appNotifier.NewTenantRegisteredAsync(tenant);
CurrentUnitOfWork.SetTenantId(tenant.Id);
var user = await _userManager.FindByNameAsync(AbpUserBase.AdminUserName);
//Directly login if possible
if (tenant.IsActive && user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin))
{
var loginResult = await GetLoginResultAsync(user.UserName, model.AdminPassword, tenant.TenancyName);
if (loginResult.Result == AbpLoginResultType.Success)
{
await SignInAsync(loginResult.User, loginResult.Identity);
return(Redirect("~/Application#!/tenant/settings"));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
return(View("RegisterResult", new TenantRegisterResultViewModel
{
TenancyName = model.TenancyName,
Name = model.LoginName,
UserName = AbpUserBase.AdminUserName,
EmailAddress = model.AdminEmailAddress,
IsActive = isNewRegisteredTenantActiveByDefault,
IsEmailConfirmationRequired = isEmailConfirmationRequiredForLogin
}));
}
catch (UserFriendlyException ex)
{
ViewBag.UseCaptcha = UseCaptchaOnRegistration();
ViewBag.ErrorMessage = ex.Message;
return(View(new TenantRegistrationView()
{
PlanId = model.PlanId,
CurrentPlan = _tenantManager.GetCurrentTenantPlan(model.PlanId),
listCountries = _tenantManager.GetCountries(),
listCurrencies = _tenantManager.GetCurrencies()
}));
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
ExternalLoginInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
throw new Exception("Can not external login!");
}
model.UserName = model.EmailAddress;
model.Password = Authorization.Users.User.CreateRandomPassword();
}
else
{
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(L("FormIsNotValidMessage"));
}
}
var user = await _userRegistrationManager.RegisterAsync(
model.Name,
string.Empty,// model.Surname,
model.EmailAddress,
model.UserName,
model.Password,
false,
false,
model.MobileNumber,
model.ZoomId,
model.DOB,
model.Gender
);
// Getting tenant-specific settings
var isEmailConfirmationRequiredForLogin = true; // await SettingManager.GetSettingValueAsync<bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
if (model.IsExternalLogin)
{
Debug.Assert(externalLoginInfo != null);
if (string.Equals(externalLoginInfo.Principal.FindFirstValue(ClaimTypes.Email), model.EmailAddress, StringComparison.OrdinalIgnoreCase))
{
user.IsEmailConfirmed = true;
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.ProviderKey,
TenantId = user.TenantId
}
};
}
await _unitOfWorkManager.Current.SaveChangesAsync();
Debug.Assert(user.TenantId != null);
var tenant = await _tenantManager.GetByIdAsync(user.TenantId.Value);
// Directly login if possible
if (user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin))
{
AbpLoginResult <Tenant, User> loginResult;
if (externalLoginInfo != null)
{
loginResult = await _logInManager.LoginAsync(externalLoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await _signInManager.SignInAsync(loginResult.Identity, false);
return(Redirect(GetAppHomeUrl()));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
//Welcome Email
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrlMessage = Url.Action(nameof(ConfirmEmail), "Account", new { token = code, email = user.EmailAddress }, protocol: HttpContext.Request.Scheme);
try
{
var welcomeModel = new WelcomeNotificationUserDto()
{
FullName = user.FullName,
Email = user.EmailAddress,
UserName = user.UserName,
Message = callbackUrlMessage
};
await _notificationManager.SendWelcomeEmail(welcomeModel);
}
catch (Exception ex)
{
throw ex;
}
return(View("RegisterResult", new RegisterResultViewModel
{
TenancyName = tenant.TenancyName,
NameAndSurname = user.Name + " " + user.Surname,
UserName = user.UserName,
EmailAddress = user.EmailAddress,
IsEmailConfirmed = user.IsEmailConfirmed,
IsActive = user.IsActive,
IsEmailConfirmationRequiredForLogin = isEmailConfirmationRequiredForLogin
}));
}
catch (UserFriendlyException ex)
{
ViewBag.ErrorMessage = ex.Message;
model.GenderList = GetGenderSelectListItem();
return(View("Register", model));
}
}
