private IHttpActionResult GetErrorResult(RegisterResultViewModel result)
{
if (result == null)
{
return(InternalServerError());
}
if (!result.Succeeded)
{
if (result.Errors != null)
{
foreach (string error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
if (ModelState.IsValid)
{
// No ModelState errors are available to send, so just return an empty BadRequest.
return(BadRequest());
}
return(BadRequest(ModelState));
}
return(null);
}
public async Task <RegisterResultViewModel> CreateAsync(string userName, string password, string fullName)
{
var result = new RegisterResultViewModel();
var serialNumber = SerialNumberGenerator.Generate();
var user = _context.Users.Add(new User
{
CreateDate = DateTime.Now,
Email = userName,
FullName = fullName,
IsActive = true,
IsAdmin = false,
Password = PasswordHasher.Hash(password),
UserName = userName,
SerialNumber = serialNumber
});
if (await _context.SaveChangesAsync() > 0)
{
result.IsSuccess = true;
result.SerialNumber = serialNumber;
result.UserId = user.Entity.Id;
}
else
{
result.IsSuccess = false;
}
return(result);
}
/// <summary>
/// 注册- 注册成功,重新发送邮件页面
/// </summary>
/// <param name="u"></param>
/// <param name="e"></param>
/// <returns></returns>
public async Task <ActionResult> RegisterByLink(string u, string e)
{
await Task.Yield();
var viewModel = new RegisterResultViewModel {
UserName = u, EmailAddress = e
};
return(View(viewModel));
}
public async Task <IActionResult> Create(RegisterViewModel registerModel)
{
if (ModelState.IsValid)
{
try
{
var birthdate = DateTime.Parse(registerModel.Birthdate);
if (birthdate.Age() < 18)
{
throw new Exception("You have to be at least 18 years old to register");
}
RegisterResultViewModel registerResult = await _userLogic.Create(registerModel);
if (registerResult != null)
{
if (registerResult.Result.Succeeded)
{
if ((await _singInManager.PasswordSignInAsync(registerResult.User,
registerModel.Password, false, false)).Succeeded)
{
return(Redirect(registerModel?.ReturnUrl ?? "/"));
}
}
else
{
AddErrorsFromResult(registerResult.Result);
}
}
}
catch (ConnectionException ex)
{
_logger.Log(LogLevel.Error,
$"The following connection error occurred: {ex.Message} @ {GetType().Name}");
ModelState.AddModelError("", ex.Message);
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, $"A general exception occurred: {ex.Message} @ {GetType().Name}");
ModelState.AddModelError("", ex.Message);
}
}
ViewBag.Countries = new SelectList(_citiesLogic.ListCountries());
return(View(registerModel));
}
public async Task <IHttpActionResult> Register(RegisterUserViewModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
RegisterResultViewModel result = await worker.RegisterUser(userModel);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok());
}
/// <summary>
/// 测试用的模拟地址
/// </summary>
/// <returns></returns>
public IActionResult RegisterResultabc()
{
if (!DebugHelper.IsDebug)
{
return(RedirectToAppHome());
}
else
{
RegisterResultViewModel model = new RegisterResultViewModel
{
EmailAddress = "*****@*****.**",
NameAndSurname = "NameAndSurname",
TenancyName = "NameAndSurname",
UserName = "******"
};
return(View("~/Views/Account/RegisterResult.cshtml", model));
}
}
public virtual async Task <ActionResult> Register(RegisterViewModel model)
{
ActionResult actionResult;
AbpUserManager <Tenant, Role, FuelWerx.Authorization.Users.User> .AbpLoginResult loginResultAsync;
Guid guid;
Guid guid1;
bool flag;
AbpUserManager <Tenant, Role, FuelWerx.Authorization.Users.User> .AbpLoginResult abpLoginResult;
TenantLogosEditDto tenantLogosEditDto = Abp.Threading.AsyncHelper.RunSync <TenantLogosEditDto>(() => this.GetCurrentTenantLogos());
dynamic viewBag = this.ViewBag;
guid = (tenantLogosEditDto.HeaderImageId.HasValue ? tenantLogosEditDto.HeaderImageId.Value : Guid.Empty);
viewBag.TenantCompanyHeaderImageId = guid;
dynamic obj = this.ViewBag;
guid1 = (tenantLogosEditDto.HeaderMobileImageId.HasValue ? tenantLogosEditDto.HeaderMobileImageId.Value : Guid.Empty);
obj.TenantCompanyHeaderMobileImageId = guid1;
try
{
this.CheckSelfRegistrationIsEnabled();
this.CheckModelState();
if (!model.IsExternalLogin && this.UseCaptchaOnRegistration())
{
RecaptchaVerificationHelper recaptchaVerificationHelper = this.GetRecaptchaVerificationHelper();
if (recaptchaVerificationHelper.Response.IsNullOrEmpty())
{
throw new UserFriendlyException(this.L("CaptchaCanNotBeEmpty"));
}
if (recaptchaVerificationHelper.VerifyRecaptchaResponse() != RecaptchaVerificationResult.Success)
{
throw new UserFriendlyException(this.L("IncorrectCaptchaAnswer"));
}
}
if (!this._multiTenancyConfig.IsEnabled)
{
model.TenancyName = "Default";
}
else if (model.TenancyName.IsNullOrEmpty())
{
throw new UserFriendlyException(this.L("TenantNameCanNotBeEmpty"));
}
Tenant activeTenantAsync = await this.GetActiveTenantAsync(model.TenancyName);
bool settingValueForTenantAsync = await SettingManagerExtensions.GetSettingValueForTenantAsync <bool>(this.SettingManager, "App.UserManagement.AllowSelfRegistration", activeTenantAsync.Id);
if (!settingValueForTenantAsync)
{
throw new UserFriendlyException(this.L("SelfUserRegistrationIsDisabledMessage_Detail"));
}
settingValueForTenantAsync = await SettingManagerExtensions.GetSettingValueForTenantAsync <bool>(this.SettingManager, "App.UserManagement.IsNewRegisteredUserActiveByDefault", activeTenantAsync.Id);
bool flag1 = settingValueForTenantAsync;
settingValueForTenantAsync = await SettingManagerExtensions.GetSettingValueForTenantAsync <bool>(this.SettingManager, "Abp.Zero.UserManagement.IsEmailConfirmationRequiredForLogin", activeTenantAsync.Id);
bool flag2 = settingValueForTenantAsync;
FuelWerx.Authorization.Users.User user = new FuelWerx.Authorization.Users.User()
{
TenantId = new int?(activeTenantAsync.Id),
Name = model.Name,
Surname = model.Surname,
EmailAddress = model.EmailAddress,
IsActive = flag1
};
FuelWerx.Authorization.Users.User userName = user;
ExternalLoginInfo externalLoginInfoAsync = null;
if (model.IsExternalLogin)
{
externalLoginInfoAsync = await AuthenticationManagerExtensions.GetExternalLoginInfoAsync(this.AuthenticationManager);
if (externalLoginInfoAsync == null)
{
throw new ApplicationException("Can not external login!");
}
FuelWerx.Authorization.Users.User user1 = userName;
List <UserLogin> userLogins = new List <UserLogin>();
UserLogin userLogin = new UserLogin()
{
LoginProvider = externalLoginInfoAsync.Login.LoginProvider,
ProviderKey = externalLoginInfoAsync.Login.ProviderKey
};
userLogins.Add(userLogin);
user1.Logins = userLogins;
model.UserName = model.EmailAddress;
model.Password = FuelWerx.Authorization.Users.User.CreateRandomPassword();
if (string.Equals(externalLoginInfoAsync.Email, model.EmailAddress, StringComparison.InvariantCultureIgnoreCase))
{
userName.IsEmailConfirmed = true;
}
}
else if (model.UserName.IsNullOrEmpty() || model.Password.IsNullOrEmpty())
{
throw new UserFriendlyException(this.L("FormIsNotValidMessage"));
}
userName.UserName = model.UserName;
userName.Password = (new PasswordHasher()).HashPassword(model.Password);
IActiveUnitOfWork current = this._unitOfWorkManager.Current;
current.EnableFilter(new string[] { "MayHaveTenant" });
this._unitOfWorkManager.Current.SetFilterParameter("MayHaveTenant", "tenantId", activeTenantAsync.Id);
userName.Roles = new List <UserRole>();
IQueryable <Role> roles = this._roleManager.Roles;
List <Role> listAsync = await(
from r in roles
where r.IsDefault
select r).ToListAsync <Role>();
foreach (Role role in listAsync)
{
ICollection <UserRole> userRoles = userName.Roles;
userRoles.Add(new UserRole()
{
RoleId = role.Id
});
}
this.CheckErrors(await this._userManager.CreateAsync(userName));
await this._unitOfWorkManager.Current.SaveChangesAsync();
if (!userName.IsEmailConfirmed)
{
userName.SetNewEmailConfirmationCode();
await this._userEmailer.SendEmailActivationLinkAsync(userName, null);
}
if (userName.IsActive && (userName.IsEmailConfirmed || !flag2))
{
if (externalLoginInfoAsync == null)
{
loginResultAsync = await this.GetLoginResultAsync(userName.UserName, model.Password, activeTenantAsync.TenancyName);
abpLoginResult = loginResultAsync;
}
else
{
loginResultAsync = await this._userManager.LoginAsync(externalLoginInfoAsync.Login, activeTenantAsync.TenancyName);
abpLoginResult = loginResultAsync;
}
if (abpLoginResult.Result != AbpLoginResultType.Success)
{
this.Logger.Warn(string.Concat("New registered user could not be login. This should not be normally. login result: ", abpLoginResult.Result));
abpLoginResult = null;
}
else
{
await this.SignInAsync(abpLoginResult.User, abpLoginResult.Identity, false);
actionResult = this.Redirect(this.Url.Action("Index", "Application"));
return(actionResult);
}
}
AccountController accountController = this;
RegisterResultViewModel registerResultViewModel = new RegisterResultViewModel()
{
TenancyName = activeTenantAsync.TenancyName,
NameAndSurname = string.Concat(userName.Name, " ", userName.Surname),
UserName = userName.UserName,
EmailAddress = userName.EmailAddress,
IsActive = userName.IsActive,
IsEmailConfirmationRequired = flag2
};
actionResult = accountController.View("RegisterResult", registerResultViewModel);
}
catch (UserFriendlyException userFriendlyException1)
{
UserFriendlyException userFriendlyException = userFriendlyException1;
((dynamic)this.ViewBag).IsMultiTenancyEnabled = this._multiTenancyConfig.IsEnabled;
dynamic viewBag1 = this.ViewBag;
flag = (model.IsExternalLogin ? false : this.UseCaptchaOnRegistration());
viewBag1.UseCaptcha = flag;
((dynamic)this.ViewBag).ErrorMessage = userFriendlyException.Message;
actionResult = this.View("Register", model);
}
return(actionResult);
}
