public async Task <ActionResult> Create(UserCreationViewModel userCreation)
{
if (ModelState.IsValid)
{
var user = userCreation.User;
user.UserName = user.Email;
//password is set to user.email+ A1 on creation and should be changed by the user
var res = await UserManager.CreateAsync(user, user.Email + "A1");
//we do not expect more than 2 roles, so addition is hardcoded
if (String.Equals("Teacher", userCreation.SelectedRole) || String.Equals("Student", userCreation.SelectedRole))
{
var resR = await UserManager.AddToRoleAsync(user.Id, userCreation.SelectedRole);
if (resR.Succeeded)
{
user.Role = userCreation.SelectedRole;
}
}
return(RedirectToAction("Index"));
}
return(View(userCreation));
}
public IActionResult Register([FromBody] UserCreationViewModel candidateUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values));
}
var validationErrors = new List <ValidationError>();
if (_userService.CheckEmailExits(candidateUser.Email))
{
validationErrors.Add(new ValidationError {
Field = "Email", Message = "Podany email jest już zajęty"
});
}
if (_userService.CheckPhoneNumberTaken(candidateUser.PhoneNumber))
{
validationErrors.Add(new ValidationError {
Field = "PhoneNumber", Message = "Podany numer telefonu jest już zajęty"
});
}
if (validationErrors.Count != 0)
{
return(Ok(validationErrors));
}
var user = _mapper.Map <User>(candidateUser);
var result = _userService.CreateUser(user);
return(Ok(result));
}
public async Task <ResultResponse> CreateAsync(UserCreationViewModel userCreationViewModel)
{
var user = _mapper.Map <User>(userCreationViewModel);
var businessResult = await _userService.CreateAsync(user);
return(new ResultResponse(businessResult, Operation.CREATE));
}
// GET: UsersManagement/Create
public ActionResult Create()
{
var model = new UserCreationViewModel();
model.UserRoles = UserRoles;
model.User = new UniUser();
return(View("Create", model));
}
public IActionResult Cadastro([FromBody] UserCreationViewModel userViewModel)
{
if (Service.IsEmailTaken(userViewModel.Email))
{
return(CreateError("E-mail já existente", 400));
}
return(CreateResult(Service.CreateUser(userViewModel)));
}
public void Create_OnGet_PassesEmptyViewModelToView()
{
var result = _subject.Create() as ViewResult;
var emptyViewModel = new UserCreationViewModel();
var returnedViewModel = result.Model as UserCreationViewModel;
Assert.Equal(emptyViewModel.EmailAddress, returnedViewModel.EmailAddress);
Assert.Equal(emptyViewModel.UnencryptedPassword, returnedViewModel.UnencryptedPassword);
}
public async Task <IActionResult> CreateAsync([FromBody] UserCreationViewModel user)
{
var resultUserCreated = await _userAppService.CreateAsync(user);
if (resultUserCreated.StatusCode == Application.Core.StatusCode.BAD_REQUEST)
{
return(BadRequest(resultUserCreated.Errors));
}
return(CreatedAtRoute("", user));
}
public void Create_OnPost_ChecksUserExists()
{
var vm = new UserCreationViewModel()
{
UnencryptedPassword = "******", EmailAddress = "*****@*****.**"
};
_subject.Create(vm);
_userExistsQuery.Verify(c => c.Execute(It.IsAny <string>()), Times.Once);
}
public void Create_OnPost_WhenModelStateHasError_ReturnsToView()
{
_subject.ModelState.AddModelError("error", "this is an error");
var vm = new UserCreationViewModel()
{
UnencryptedPassword = "******", EmailAddress = "*****@*****.**"
};
var result = _subject.Create(vm) as ViewResult;
Assert.Null(result.ViewName);
Assert.Equal(vm, result.Model as UserCreationViewModel);
}
public void Create_OnPost_RedirectsToHomePageWithMessage()
{
var vm = new UserCreationViewModel()
{
UnencryptedPassword = "******", EmailAddress = "*****@*****.**"
};
var result = _subject.Create(vm) as RedirectToActionResult;
Assert.Equal("Home", result.ControllerName);
Assert.Equal("Index", result.ActionName);
Assert.NotNull(result.RouteValues["message"]);
}
public async Task <ActionResult> Put([FromBody] UserCreationViewModel model)
{
if (ModelState.IsValid)
{
//some validation if user with given name exists if it is important.
var user = new User();
user.Name = model.Name;
user.Initials = model.Initials; //Could be created from Name.
await _userRepository.InsertAsync(user);
return(Ok("User has been added to database."));
}
return(BadRequest("Data validation failed"));
}
public UserViewModel CreateUser(UserCreationViewModel userViewModel)
{
var user = new User
{
Email = userViewModel.Email,
Name = userViewModel.Email,
PasswordHash = GenerateHash(userViewModel.Password),
Phones = userViewModel.Phones,
Token = GenerateToken()
};
Repository.CreateUser(user);
return(ToViewModel(user));
}
public void Create_OnPost_WhenUserAlreadyExists_ReturnsToViewWithModalError()
{
_userExistsQuery.Setup(c => c.Execute(It.IsAny <string>())).Returns(true);
var vm = new UserCreationViewModel()
{
UnencryptedPassword = "******", EmailAddress = "*****@*****.**"
};
var result = _subject.Create(vm) as ViewResult;
var errorMessage = _subject.ModelState["EmailAddress"].Errors[0].ErrorMessage;
Assert.Single(_subject.ModelState);
Assert.Equal("Email address is already in use", errorMessage);
}
private static UserCreationViewModel GetValidUserCreationViewModel()
{
const string validEmail = "*****@*****.**";
const string validPassword = "******";
const string validName = "ValidName";
const string validSurname = "ValidSurname";
var validuserCreationViewModel = new UserCreationViewModel
{
Email = validEmail,
Password = validPassword,
ConfirmPassword = validPassword,
Name = validName,
Surname = validSurname,
TermsAndConditions = true
};
return(validuserCreationViewModel);
}
public IActionResult Create(UserCreationViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var doesUserAlreadyExist = _userExistsQuery.Execute(vm.EmailAddress);
if (doesUserAlreadyExist)
{
ModelState.AddModelError(nameof(vm.EmailAddress), "Email address is already in use");
return(View(vm));
}
_createUserCommand.Execute(vm.EmailAddress, vm.UnencryptedPassword);
return(RedirectToAction("Index", "Home", new { message = $"User '{vm.EmailAddress}' successfully created!" }));
}
public async Task <ActionResult> Edit(UserCreationViewModel userCreation)
{
var isadmin = await userIsAdmin(userCreation.User.Id);
if (isadmin)
{
return(View("Index"));
}
if (ModelState.IsValid)
{
userCreation.User.Role = await GetUserRole(userCreation.User.Id);
userCreation.User.UserName = userCreation.User.Email;
await UpdateUserAndUserRole(userCreation.User, userCreation.SelectedRole);
return(RedirectToAction("Index"));
}
return(View(userCreation.User));
}
public async Task <IActionResult> CreateUserAsync(
UserCreationViewModel userCreationViewModel)
{
var user = _mapper.Map <User>(userCreationViewModel);
_unitOfWork.UserRepository.Add(user);
_logger.LogInformation(
LoggingEvents.PostItem,
"Update record of a user with ID of: {ID}",
user.Id);
await _unitOfWork.SaveChangesAsync();
//query again in case you want to include other details from the context,
//this is just for future use.
await _unitOfWork.UserRepository.GetAsync(user.Id);
return(CreatedAtRoute("GetUser", new { id = user.Id }, user));
}
// GET: UsersManagement/Edit/5
public async Task <ActionResult> Edit(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UniUser uniUser = db.Users.Find(id);
uniUser.Role = await GetUserRole(uniUser.Id);
if (uniUser == null)
{
return(HttpNotFound());
}
var model = new UserCreationViewModel();
model.UserRoles = UserRoles;
model.User = uniUser;
model.SelectedRole = uniUser.Role;
return(View(model));
}
public async Task <ActionResult> UserCreation(UserCreationViewModel model)
{
if (ModelState.IsValid)
{
using (var client = apiClient())
{
var userCreationData = new ExternalUserCreationData
{
Email = model.Email,
FirstName = model.Name,
Surname = model.Surname,
Password = model.Password,
ConfirmPassword = model.ConfirmPassword,
ActivationBaseUrl = externalRouteService.ActivateExternalUserAccountUrl,
};
try
{
var response = await oauthClientCredential().GetClientCredentialsAsync();
await client.User.CreateExternalUserAsync(userCreationData, response.AccessToken);
var signInResponse = await oauthClient().GetAccessTokenAsync(model.Email, model.Password);
authenticationManager.SignIn(signInResponse.GenerateUserIdentity());
return(RedirectToAction("UserAccountActivationRequired", "Account"));
}
catch (ApiBadRequestException ex)
{
this.HandleBadRequest(ex);
if (ModelState.IsValid)
{
throw;
}
foreach (var modelState in ViewData.ModelState.Values.ToList())
{
List <int> errorsToRemoveIndex = new List <int>();
List <String> errorsToAdd = new List <string>();
for (var i = modelState.Errors.Count - 1; i >= 0; i--)
{
if (modelState.Errors[i].ErrorMessage.Contains("Passwords") && modelState.Value == null)
{
errorsToRemoveIndex.Add(i);
}
else if (modelState.Errors[i].ErrorMessage.Contains("is already taken"))
{
errorsToRemoveIndex.Add(i);
errorsToAdd.Add("An account already exists with this email address. Sign in or reset your password.");
}
}
foreach (int index in errorsToRemoveIndex)
{
modelState.Errors.RemoveAt(index);
}
foreach (string error in errorsToAdd)
{
modelState.Errors.Add(error);
}
}
}
return(View(model));
}
}
return(View(model));
}
