public async Task <IActionResult> Register([FromBody] RegisterModel model)
{
try
{
var validator = new RegisterModelValidator();
if (model == null || !validator.Validate(model))
{
return(BadRequest());
}
var userExists = await userService.ExistsWhere(new { Email = model.Email }) ?? true;
if (userExists)
{
return(Forbid());
}
model.Password = BCrypt.Net.BCrypt.HashPassword(model.Password);
var response = await userService.Add(new User(model));
if (response != HttpStatusCode.OK)
{
return(StatusCode((int)response));
}
return(Ok());
}
catch (Exception e)
{
logger.LogError(e, e.Message);
return(StatusCode(500));
}
}
public RegisterViewModel()
{
_validator = new RegisterModelValidator();
_userClient = new UserClient();
RegisterCommand = new RelayCommand <object>(DoRegister);
ReturnToLoginCommand = new RelayCommand(BackToLogin);
CustomFields = new ObservableRangeCollection <CustomUserFieldViewModel>();
Loaded += (sender, args) => { Task.Run(async() => { await LoadCustomFields(); }); };
}
public async Task <ActionResult <Models.WorkerWithToken> > SignUp([FromBody] Models.RegisterModel registerModel)
{
var registerModelValidator = new RegisterModelValidator();
var validationResult = registerModelValidator.Validate(registerModel);
if (!validationResult.IsValid)
{
return(UnprocessableEntity(validationResult.Errors.Select(x => new ValidatorException
{
Field = x.PropertyName,
Message = x.ErrorCode,
Description = x.ErrorMessage
}).ToList()));
}
var hashPassword = HashPassword.Hash(registerModel.Password);
var existUser = await _context.Workers.SingleOrDefaultAsync(x => x.Email == registerModel.Email && x.Password == hashPassword);
if (existUser == null)
{
var newWorker = new Models.Worker
{
FirstName = registerModel.FirstName,
LastName = registerModel.LastName,
Email = registerModel.Email,
Password = hashPassword,
SpecialityId = registerModel.SpecialityId
};
var token = JWTExtension.CreateToken(newWorker);
_context.Workers.Add(newWorker);
await _context.SaveChangesAsync();
var registeredWorker = await _context.Workers
.Include(x => x.Speciality)
.ThenInclude(x => x.Department)
.SingleOrDefaultAsync(x => x.Email == newWorker.Email && x.Password == newWorker.Password);
return(Ok(new Models.WorkerWithToken
{
Token = token,
Worker = ResponseWorkerList.FromApiWorker(registeredWorker, avatar: _getAvatar(registeredWorker.AvatarUrl)),
}));
}
else
{
return(Conflict(new ExceptionInfo
{
Message = AuthErrorsMessages.UserExist,
Description = "Сотрудник с таким Email и паролем уже существует"
}));
}
}
public AuthenticateController(IAuthenticateService authenticateService,
IMapper mapper,
IOptions <AppSettings> appSettings,
IOptions <RegisterModelValidator> registerValidations,
IOptions <AuthenticateModelValidator> authenticateValidator,
IHttpClientFactory httpClientFactory)
{
this.authenticateService = authenticateService;
this.appSettings = appSettings.Value;
this.registerValidations = registerValidations.Value;
this.authenticateValidator = authenticateValidator.Value;
this.mapper = mapper;
this.httpClientFactory = httpClientFactory;
}
public bool CheckRegister(RegisterModel registerModel)
{
if (registerModel == null)
{
return(false);
}
RegisterModelValidator validator = new RegisterModelValidator();
var result = validator.Validate(registerModel);
if (!result.IsValid)
{
InvalidRegisterMessage = ErrorMessageGenerator.ComposeErrorMessage(result);
return(false);
}
return(true);
}
public async Task <ServiceResponse <ProfileViewModel> > Register([FromBody] RegisterModel model)
{
var response = new ServiceResponse <ProfileViewModel>();
try
{
var validation = new RegisterModelValidator(model);
var results = validation.Validate(model);
response.ErrorMessages = results.Errors.ToList();
if (!response.Successful)
{
return(response);
}
var isUserExist = await this._userManager.FindByEmailAsync(model.Email);
if (isUserExist != null)
{
response.ErrorMessages.Add(
new ValidationFailure(string.Empty, "That email is taken. Try another."));
return(response);
}
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Disabled = false
};
var result = await this._userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
user.EmailConfirmed = false;
await this._userManager.UpdateAsync(user);
await this._userManager.AddToRoleAsync(user, RolesNames.User);
var code = await this._userManager.GenerateEmailConfirmationTokenAsync(user);
code = HttpUtility.UrlEncode(code);
var callbackUrl =
$"{new Uri(this._iconfiguration["Cors:AllowedOrigin"])}/register?userid={user.Id}&code={code}";
var registerText =
$"{this._env.WebRootPath}{Path.DirectorySeparatorChar}EmailTemplate{Path.DirectorySeparatorChar}Register.html";
var replaceEmailText = new
{
model.Email,
RegisterLink = callbackUrl,
Logo = Convert.ToString(
$"{new Uri(this._iconfiguration["Cors:AllowedOrigin"])}{Path.DirectorySeparatorChar}assets{Path.DirectorySeparatorChar}img{Path.DirectorySeparatorChar}logo.png"),
Url = Convert.ToString(
new Uri(this._iconfiguration["Cors:AllowedOrigin"]))
};
var registerBody = replaceEmailText.SetEmailTemplates(registerText.ReadFile());
await this._emailSender.SendEmailAsync(model.Email, "Confirm your Account", registerBody);
}
else
{
foreach (var error in result.Errors)
{
response.ErrorMessages.Add(new ValidationFailure(error.Code, error.Description));
}
}
}
catch (Exception ex)
{
response.ErrorMessages.Add(new ValidationFailure(model.Email, ex.Message));
}
return(response);
}
