private async Task <User> RegisterExternalUserAsync(ExternalLoginUserInfo externalUser)
{
var user = await _userRegistrationManager.RegisterAsync(
externalUser.Name,
externalUser.Surname,
externalUser.EmailAddress,
externalUser.EmailAddress,
Authorization.Users.User.CreateRandomPassword(),
true
);
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalUser.LoginInfo.LoginProvider,
ProviderKey = externalUser.LoginInfo.ProviderKey,
TenantId = user.TenantId
}
};
await CurrentUnitOfWork.SaveChangesAsync();
return(user);
}
private static void NormalizeExternalLoginUserInfo(
ExternalLoginUserInfo externalUser,
string userName
)
{
if (externalUser.ProviderKey.IsNullOrWhiteSpace())
{
externalUser.ProviderKey = userName;
}
}
private async Task <ActionResult> RegisterForExternalLogin(ExternalLoginUserInfo userInfo)
{
var viewModel = new RegisterViewModel
{
EmailAddress = userInfo.EmailAddress,
Name = userInfo.Name,
Surname = userInfo.Surname,
IsExternalLogin = true,
ExternalLoginAuthSchema = userInfo.LoginInfo.LoginProvider
};
if (userInfo.HasAllNonEmpty())
{
return(await Register(viewModel));
}
return(RegisterView(viewModel));
}
private async Task <ActionResult> RegisterViewForExternalLogin(ExternalLoginUserInfo userInfo, string tenancyName = null)
{
var viewModel = new RegisterViewModel
{
TenancyName = tenancyName,
EmailAddress = userInfo.EmailAddress,
Name = userInfo.Name,
Surname = userInfo.Surname,
IsExternalLogin = true,
ExternalLoginAuthSchema = userInfo.LoginInfo.LoginProvider
};
if (!tenancyName.IsNullOrEmpty() && userInfo.HasAllNonEmpty())
{
return(await Register(viewModel));
}
return(RegisterView(viewModel));
}
protected virtual async Task <IdentityUser> CreateUserAsync(ExternalLoginUserInfo externalUser, string userName, string providerName)
{
NormalizeExternalLoginUserInfo(externalUser, userName);
var user = new IdentityUser(
GuidGenerator.Create(),
userName,
externalUser.Email,
tenantId: CurrentTenant.Id
);
user.Name = externalUser.Name;
user.Surname = externalUser.Surname;
user.IsExternal = true;
user.SetEmailConfirmed(externalUser.EmailConfirmed ?? false);
user.SetPhoneNumber(externalUser.PhoneNumber, externalUser.PhoneNumberConfirmed ?? false);
(await UserManager.CreateAsync(user)).CheckErrors();
if (externalUser.TwoFactorEnabled != null)
{
(await UserManager.SetTwoFactorEnabledAsync(user, externalUser.TwoFactorEnabled.Value)).CheckErrors();
}
(await UserManager.AddDefaultRolesAsync(user)).CheckErrors();
(await UserManager.AddLoginAsync(
user,
new UserLoginInfo(
providerName,
externalUser.ProviderKey,
providerName
)
)
).CheckErrors();
return(user);
}
public virtual async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
//Get tenancy name and tenant
if (!_multiTenancyConfig.IsEnabled)
{
model.TenancyName = Tenant.DefaultTenantName;
}
else if (model.TenancyName.IsNullOrEmpty())
{
throw new UserFriendlyException(L("TenantNameCanNotBeEmpty"));
}
CurrentUnitOfWork.SetTenantId(null);
var tenant = await GetActiveTenantAsync(model.TenancyName);
CurrentUnitOfWork.SetTenantId(tenant.Id);
//Create user
var user = new User
{
TenantId = tenant.Id,
Name = model.Name,
Surname = model.Surname,
EmailAddress = model.EmailAddress,
IsActive = true
};
//Get external login info if possible
ExternalLoginUserInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await HttpContext.Authentication.GetExternalLoginUserInfo(model.ExternalLoginAuthSchema);
if (externalLoginInfo == null)
{
throw new ApplicationException("Can not external login!");
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.LoginInfo.ProviderKey,
TenantId = tenant.Id
}
};
model.UserName = model.UserName;
model.Password = Users.User.CreateRandomPassword();
if (string.Equals(externalLoginInfo.EmailAddress, model.EmailAddress, StringComparison.InvariantCultureIgnoreCase))
{
user.IsEmailConfirmed = true;
}
}
else
{
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(L("FormIsNotValidMessage"));
}
}
user.UserName = model.UserName;
user.Password = new PasswordHasher().HashPassword(model.Password);
//Add default roles
user.Roles = new List <UserRole>();
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
user.Roles.Add(new UserRole {
RoleId = defaultRole.Id
});
}
//Save user
CheckErrors(await _userManager.CreateAsync(user));
await _unitOfWorkManager.Current.SaveChangesAsync();
//Directly login if possible
if (user.IsActive)
{
AbpLoginResult <Tenant, User> loginResult;
if (externalLoginInfo != null)
{
loginResult = await _logInManager.LoginAsync(externalLoginInfo.LoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await SignInAsync(loginResult.User, loginResult.Identity);
return(Redirect(Url.Action("Index", "Home")));
}
Logger.Warn("New registered user could not be login. This should not be normally. login result: " + loginResult.Result);
}
//If can not login, show a register result page
return(View("RegisterResult", new RegisterResultViewModel
{
TenancyName = tenant.TenancyName,
NameAndSurname = user.Name + " " + user.Surname,
UserName = user.UserName,
EmailAddress = user.EmailAddress,
IsActive = user.IsActive
}));
}
catch (UserFriendlyException ex)
{
ViewBag.IsMultiTenancyEnabled = _multiTenancyConfig.IsEnabled;
ViewBag.ErrorMessage = ex.Message;
return(View("Register", model));
}
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
ExternalLoginUserInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await _signInManager.GetExternalLoginUserInfo(model.ExternalLoginAuthSchema);
if (externalLoginInfo == null)
{
throw new ApplicationException("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
);
//Getting tenant-specific settings
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin);
if (model.IsExternalLogin)
{
Debug.Assert(externalLoginInfo != null);
if (string.Equals(externalLoginInfo.EmailAddress, model.EmailAddress, StringComparison.InvariantCultureIgnoreCase))
{
user.IsEmailConfirmed = true;
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.LoginInfo.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.LoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await SignInAsync(loginResult.User, loginResult.Identity);
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
}));
}
catch (UserFriendlyException ex)
{
ViewBag.ErrorMessage = ex.Message;
return(View("Register", model));
}
}
public virtual async Task <ActionResult> Register(RegisterViewModel model)
{
try
{
CheckSelfRegistrationIsEnabled();
if (!model.IsExternalLogin && UseCaptchaOnRegistration())
{
await CheckCaptchaResponseAsync(_recaptchaValidationService);
}
if (!_multiTenancyConfig.IsEnabled)
{
model.TenancyName = Tenant.DefaultTenantName;
}
else if (model.TenancyName.IsNullOrEmpty())
{
throw new UserFriendlyException(L("TenantNameCanNotBeEmpty"));
}
CurrentUnitOfWork.SetTenantId(null);
var tenant = await GetActiveTenantAsync(model.TenancyName);
CurrentUnitOfWork.SetTenantId(tenant.Id);
if (!await SettingManager.GetSettingValueForTenantAsync <bool>(AppSettings.UserManagement.AllowSelfRegistration, tenant.Id))
{
throw new UserFriendlyException(L("SelfUserRegistrationIsDisabledMessage_Detail"));
}
//Getting tenant-specific settings
var isNewRegisteredUserActiveByDefault = await SettingManager.GetSettingValueForTenantAsync <bool>(AppSettings.UserManagement.IsNewRegisteredUserActiveByDefault, tenant.Id);
var isEmailConfirmationRequiredForLogin = await SettingManager.GetSettingValueForTenantAsync <bool>(AbpZeroSettingNames.UserManagement.IsEmailConfirmationRequiredForLogin, tenant.Id);
var user = new User
{
TenantId = tenant.Id,
Name = model.Name,
Surname = model.Surname,
EmailAddress = model.EmailAddress,
IsActive = isNewRegisteredUserActiveByDefault
};
ExternalLoginUserInfo externalLoginInfo = null;
if (model.IsExternalLogin)
{
externalLoginInfo = await _signInManager.GetExternalLoginUserInfo(model.ExternalLoginAuthSchema);
if (externalLoginInfo == null)
{
throw new ApplicationException("Can not external login!");
}
user.Logins = new List <UserLogin>
{
new UserLogin
{
LoginProvider = externalLoginInfo.LoginInfo.LoginProvider,
ProviderKey = externalLoginInfo.LoginInfo.ProviderKey,
TenantId = tenant.Id
}
};
model.UserName = model.EmailAddress;
model.Password = Authorization.Users.User.CreateRandomPassword();
if (string.Equals(externalLoginInfo.EmailAddress, model.EmailAddress, StringComparison.InvariantCultureIgnoreCase))
{
user.IsEmailConfirmed = true;
}
}
else
{
if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(L("FormIsNotValidMessage"));
}
}
user.UserName = model.UserName;
user.Password = new PasswordHasher().HashPassword(model.Password);
user.Roles = new List <UserRole>();
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
user.Roles.Add(new UserRole(tenant.Id, user.Id, defaultRole.Id));
}
CheckErrors(await _userManager.CreateAsync(user));
await _unitOfWorkManager.Current.SaveChangesAsync();
if (!user.IsEmailConfirmed)
{
user.SetNewEmailConfirmationCode();
await _userEmailer.SendEmailActivationLinkAsync(user);
}
//Notifications
await _notificationSubscriptionManager.SubscribeToAllAvailableNotificationsAsync(user.ToUserIdentifier());
await _appNotifier.WelcomeToTheApplicationAsync(user);
await _appNotifier.NewUserRegisteredAsync(user);
//Directly login if possible
if (user.IsActive && (user.IsEmailConfirmed || !isEmailConfirmationRequiredForLogin))
{
AbpLoginResult <Tenant, User> loginResult;
if (externalLoginInfo != null)
{
loginResult = await _logInManager.LoginAsync(externalLoginInfo.LoginInfo, tenant.TenancyName);
}
else
{
loginResult = await GetLoginResultAsync(user.UserName, model.Password, tenant.TenancyName);
}
if (loginResult.Result == AbpLoginResultType.Success)
{
await SignInAsync(loginResult.User, loginResult.Identity);
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.IsMultiTenancyEnabled = _multiTenancyConfig.IsEnabled;
ViewBag.UseCaptcha = !model.IsExternalLogin && UseCaptchaOnRegistration();
ViewBag.ErrorMessage = ex.Message;
return(View("Register", model));
}
}
protected virtual async Task UpdateUserAsync(IdentityUser user, ExternalLoginUserInfo externalUser, string providerName)
{
NormalizeExternalLoginUserInfo(externalUser, user.UserName);
if (!externalUser.Name.IsNullOrWhiteSpace())
{
user.Name = externalUser.Name;
}
if (!externalUser.Surname.IsNullOrWhiteSpace())
{
user.Surname = externalUser.Surname;
}
if (user.PhoneNumber != externalUser.PhoneNumber)
{
if (!externalUser.PhoneNumber.IsNullOrWhiteSpace())
{
await UserManager.SetPhoneNumberAsync(user, externalUser.PhoneNumber);
user.SetPhoneNumberConfirmed(externalUser.PhoneNumberConfirmed == true);
}
}
else
{
if (!user.PhoneNumber.IsNullOrWhiteSpace() &&
user.PhoneNumberConfirmed == false &&
externalUser.PhoneNumberConfirmed == true)
{
user.SetPhoneNumberConfirmed(true);
}
}
if (!string.Equals(user.Email, externalUser.Email, StringComparison.OrdinalIgnoreCase))
{
(await UserManager.SetEmailAsync(user, externalUser.Email)).CheckErrors();
user.SetEmailConfirmed(externalUser.EmailConfirmed ?? false);
}
if (externalUser.TwoFactorEnabled != null)
{
(await UserManager.SetTwoFactorEnabledAsync(user, externalUser.TwoFactorEnabled.Value)).CheckErrors();
}
await IdentityUserRepository.EnsureCollectionLoadedAsync(user, u => u.Logins);
var userLogin = user.Logins.FirstOrDefault(l => l.LoginProvider == providerName);
if (userLogin != null)
{
if (userLogin.ProviderKey != externalUser.ProviderKey)
{
(await UserManager.RemoveLoginAsync(user, providerName, userLogin.ProviderKey)).CheckErrors();
(await UserManager.AddLoginAsync(user, new UserLoginInfo(providerName, externalUser.ProviderKey, providerName))).CheckErrors();
}
}
else
{
(await UserManager.AddLoginAsync(user, new UserLoginInfo(providerName, externalUser.ProviderKey, providerName))).CheckErrors();
}
user.IsExternal = true;
(await UserManager.UpdateAsync(user)).CheckErrors();
}
