public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
try
{
if (ModelState.IsValid)
{
var user = new AppUser {
UserName = model.Email, Email = model.Email
};
var result = await _accountService.Register(user, model.Password);
if (result.Succeeded)
{
return(RedirectToLocal(returnUrl));
}
ModelState.AddIdentityErrors(result);
}
}
catch (Exception ex)
{
var exceptionMessage = await Helpers.GetErrors(ex, _emailService);
ModelState.AddModelError(new ValidationResult(exceptionMessage));
}
ModelState.AddModelError(string.Empty, "Invalid register attempt.");
return(View(model));
}
public async Task <IActionResult> Register([FromBody] RegistrationDto register)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var appUser = new AppUser
{
Email = register.Email,
DisplayName = register.DisplayName,
InvitationCode = register.InvitationCode,
UserName = register.Email,
};
var result = await _userManager.CreateAsync(appUser, register.Password);
if (!result.Succeeded)
{
return(BadRequest(ModelState.AddIdentityErrors(result)));
}
return(CreatedAtAction("LoginEmail",
new LoginDto()
{
Email = register.Email
}));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel registerViewModel)
{
try
{
if (ModelState.IsValid)
{
var user = new AppUser
{
UserName = registerViewModel.Username,
Email = registerViewModel.Email,
FirstName = registerViewModel.FirstName,
LastName = registerViewModel.LastName
};
var result = await _accountService.Register(user, registerViewModel.Password);
if (result.Succeeded)
{
return(Ok("Registered successfully!"));
}
ModelState.AddIdentityErrors(result);
}
}
catch (Exception ex)
{
var exceptionMessage = await Helpers.GetErrors(ex);
ModelState.AddModelError(new ValidationResult(exceptionMessage));
}
ModelState.AddModelError(new ValidationResult("Invalid register attempt."));
return(BadRequest(ModelState.GetErrors()));
}
public async Task <IActionResult> Register([FromBody] Registration registration)
{
if (registration.Password != registration.RepeatPassword)
{
return(BadRequest("Passwords do not match."));
}
if (ModelState.IsValid)
{
AppUser newUser = new AppUser
{
UserName = registration.Username
};
IdentityResult createResult = await _userManager.CreateAsync(newUser, registration.Password);
if (createResult.Succeeded)
{
await _signInManager.SignInAsync(newUser, isPersistent : true);
return(NoContent());
}
ModelState.AddIdentityErrors(createResult);
}
return(BadRequest(ModelState));
}
public async Task <ActionResult> RegisterUser(RegisterUserViewModel model)
{
if (ModelState.IsValid)
{
if (User.Identity.IsAuthenticated)
{
return(Json(new ServiceResponse(true, User.Identity.GetUserId())));
}
var buyer = Mapper.Map <Buyer>(model);
var result = await UserManager.CreateAsync(buyer, model.Password);
if (result.Succeeded)
{
buyer = await UserManager.FindByNameAsync(buyer.UserName) as Buyer;
await UserManager.AddToRolesAsync(buyer.Id, UserRoles.Buyer);
await SignInManager.SignInAsync(buyer, isPersistent : false, rememberBrowser : false);
return(Json(new ServiceResponse(true, buyer.Id.ToString())));
}
ModelState.AddIdentityErrors(result);
}
return(Json(new ServiceResponse(false, ModelState.GetErrors())));
}
public async Task <IActionResult> Register(Registration registration)
{
if (ModelState.IsValid)
{
AppUser newUser = new AppUser
{
UserName = registration.Username
};
IdentityResult createResult = await _userManager.CreateAsync(newUser, registration.Password);
if (createResult.Succeeded)
{
await _userImageService.StoreImageForUserId(newUser.Id);
await _signInManager.SignInAsync(newUser, isPersistent : true);
return(Ok());
}
ModelState.AddIdentityErrors(createResult);
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> SignUp(UserCredentials userCredentials, string returnUrl)
{
if (ModelState.IsValid)
{
AppUser newUser = new AppUser
{
UserName = userCredentials.Username,
Email = userCredentials.Email,
PhoneNumber = userCredentials.PhoneNumber
};
IdentityResult createResult = await _userManager.CreateAsync(newUser, userCredentials.Password);
if (createResult.Succeeded)
{
IdentityResult addToRoleResult = await _userManager.AddToRoleAsync(newUser, "User");
if (addToRoleResult.Succeeded)
{
await _signInManager.SignInAsync(newUser, false);
return(Redirect(returnUrl));
}
ModelState.AddIdentityErrors(addToRoleResult);
}
ModelState.AddIdentityErrors(createResult);
}
ViewBag.ReturnUrl = returnUrl;
return(View());
}
public async Task <IActionResult> Edit(UserCredentials userCredentials)
{
AppUser targetUser = await _userManager.GetUserAsync(User);
userCredentials.Username = targetUser.UserName;
if (ModelState.IsValid)
{
IFormFile image = userCredentials.Image;
if (image != null)
{
string userImagesPath = Path.Combine(_hostingEnvironment.WebRootPath, "images", "user");
string newExtension = Path.GetExtension(image.FileName);
string newExtensionPure = newExtension.TrimStart('.');
if (newExtensionPure != targetUser.ImageExtension)
{
Directory.CreateDirectory(userImagesPath);
string filePath = Path.Combine(userImagesPath, string.Concat(targetUser.Id, ".", targetUser.ImageExtension));
if (IOFile.Exists(filePath))
{
IOFile.Delete(filePath);
}
targetUser.ImageExtension = newExtensionPure;
}
string newImagePath = Path.Combine(userImagesPath, string.Concat(targetUser.Id, newExtension));
using (FileStream fileStream = IOFile.Create(newImagePath))
{
await image.CopyToAsync(fileStream);
}
}
targetUser.Email = userCredentials.Email;
targetUser.PhoneNumber = userCredentials.PhoneNumber;
IdentityResult updateResult = await _userManager.UpdateAsync(targetUser);
if (updateResult.Succeeded)
{
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
ModelState.AddIdentityErrors(updateResult);
}
return(View(userCredentials));
}
public async Task <IActionResult> CheckPassword([FromBody] LoginDto request)
{
var result = await _userManager.PasswordValidators
.First(x => x.GetType() == typeof(CustomPasswordValidator <AppUser>))
.ValidateAsync(_userManager,
new AppUser
{
UserName = request.Email,
Email = request.Email
},
request.Password);
return(Ok(ModelState.AddIdentityErrors(result)));
}
public async Task <RedirectToActionResult> Delete()
{
AppUser targetUser = await _userManager.GetUserAsync(User);
IdentityResult deleteResult = await _userManager.DeleteAsync(targetUser);
if (!deleteResult.Succeeded)
{
// TODO: Redirect to error page?
ModelState.AddIdentityErrors(deleteResult);
}
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
public async Task <ActionResult> Post([FromBody] UserDto userDto)
{
_userValidator.ValidateEmail(ModelState, userDto.Email);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.BadRequest()));
}
var newUserResult = await _userService.CreateNewUser(userDto);
if (!newUserResult.Succeeded)
{
ModelState.AddIdentityErrors(newUserResult);
return(BadRequest(ModelState.BadRequest()));
}
return(Ok());
}
public async Task <ActionResult> Register(RegisterUserViewModel model)
{
if (ModelState.IsValid)
{
var buyer = Mapper.Map <Buyer>(model);
var result = await UserManager.CreateAsync(buyer, model.Password);
if (result.Succeeded)
{
buyer = await UserManager.FindByNameAsync(buyer.UserName) as Buyer;
await UserManager.AddToRolesAsync(buyer.Id, UserRoles.Buyer);
await SignInManager.SignInAsync(buyer, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Schedule"));
}
ModelState.AddIdentityErrors(result);
}
return(View(model));
}
public async Task <IActionResult> Register(RegisterViewModel registerViewModel, string returnUrl = null)
{
// Set the return url
ViewData["ReturnUrl"] = returnUrl;
try
{
if (ModelState.IsValid)
{
var user = new AppUser
{
UserName = registerViewModel.Email,
Email = registerViewModel.Email,
FirstName = registerViewModel.FirstName,
LastName = registerViewModel.LastName
};
var result = await _accountService.Register(user, registerViewModel.Password);
if (result.Succeeded)
{
// if successful, this will automatically logged in the user.
// Redirect to the return url
return(RedirectToLocal(returnUrl));
}
ModelState.AddIdentityErrors(result);
}
}
catch (Exception ex)
{
var exceptionMessage = await Helpers.GetErrors(ex, _emailService);
ModelState.AddModelError(new ValidationResult(exceptionMessage));
}
ModelState.AddModelError(string.Empty, "Invalid register attempt.");
return(View(registerViewModel));
}
public async Task <IActionResult> RegisterNode([FromBody] ServerNodeViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var username = Guid.NewGuid().ToString();
var password = StringGenerator.GetRandomString(24);
var user = new VanguardUser
{
UserName = username
};
var userResult = await _userManager.CreateAsync(user, password);
if (!userResult.Succeeded)
{
ModelState.AddIdentityErrors(userResult.Errors);
return(BadRequest(ModelState));
}
await _userManager.AddToRoleAsync(user, RoleConstants.NodeAgent);
var createResult = await _service.CreateAsync(model, user);
if (!createResult.Succeeded)
{
ModelState.AddEntityTransactionErrors(createResult.Errors);
await _userManager.DeleteAsync(user);
return(BadRequest(ModelState));
}
return(CreatedAtRoute("GetServerNode", new { id = createResult.Value.Id }, new UsernamePasswordCredentialsViewModel
{
Username = username,
Password = password
}));
}
