public ActionResult CreateUser()
{
var viewModel = new CreateUserFormViewModel
{
UserRoles = _context.Roles.ToList()
};
return(View(viewModel));
}
private CreateUserFormViewModel ReturnUserFormViewModelWithErrors(CreateUserFormViewModel model)
=> new CreateUserFormViewModel
{
Roles = this.GetRoles(),
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
UserName = model.UserName,
WithoutRole = model.WithoutRole
};
public async Task <ActionResult> Create()
{
var viewModel = new CreateUserFormViewModel();
viewModel.AllRolesList = new SelectList(
items: await RoleManager.Roles.ToListAsync(),
dataValueField: "Name",
dataTextField: "Name");
viewModel.AllClaimsList = new SelectList(
items: ClaimsStore.AllClaims,
dataValueField: "value",
dataTextField: "type");
return(View("CreateUserForm", viewModel));
}
public async Task <IActionResult> Create(CreateUserFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
else
{
try
{
var user = new User()
{
Email = viewModel.Email,
PasswordHash = viewModel.PasswordHash,
UserName = viewModel.UserName,
QuantidadeMembroFamilia = viewModel.QuantidadeMembroFamilia,
DespesasExcluidas = false
};
var result = await _userManager.CreateAsync(user, user.PasswordHash);
if (result.Succeeded)
{
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var LinkConfirmacao = Url.Action("ConfirmEmail", "Users",
new { UserId = user.Id, Token = token }, Request.Scheme);
await SendConfirmationEmailAsync(token, user.Email, LinkConfirmacao, 1);
return(RedirectToAction(nameof(SuccessfullyAdded)));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description.ToString());
}
}
}
catch (Exception e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
return(View(viewModel));
}
public async Task <IActionResult> Create(CreateUserFormViewModel model)
{
if (!ModelState.IsValid)
{
return(View(this.ReturnUserFormViewModelWithErrors(model)));
}
var user = new User
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var password = this.GenerateRandomPassword();
var result = await userManager.CreateAsync(user, password);
if (!result.Succeeded)
{
TempData[TempDataErrorMessageKey] = $"User with username {model.UserName} or email {model.Email} already exists.";
return(View(this.ReturnUserFormViewModelWithErrors(model)));
}
if (!model.WithoutRole)
{
var existingRole = await this.roleManager.RoleExistsAsync(model.Role);
if (!existingRole)
{
ModelState.AddModelError(string.Empty, "Invalid role.");
}
await this.userManager.AddToRoleAsync(user, model.Role);
}
TempData[TempDataSuccessMessageKey] = $"Successfully created with password: {password}";
return(RedirectToAction(nameof(Index)));
}
public async Task <ActionResult> Create(CreateUserFormViewModel viewModel, string[] selectedRoles, string[] selectedClaims)
{
// selectedRole is the name of the checkbox list on the html form
// HERE WE ARE USING SAME FORM & VIEWMODEL FOR ADD & EDIT
// BUT BOTH SCENARIOS ARE DIFFERENT,
// ADD NEED PASSWORD & CONFIRM PASSWORD IN VIEW & VIEWMODEL & THEY ARE MANDATORY
// WITH THEM MODEL WILL BE NOT VALIDATED
// EDIT DO NOT NEED PASSWORD & CONFIRM PASSWORD IN VIEW & VIEWMODEL
// MODEL VALIDATION WILL STOP US FROM EDITING USER AND WILL ASK FOR PASSWORKD & CONFIRM PASSWORD
// SPLIT VIEWS & VIEWMODELS FOR ADD & EDIT
IdentityResult result = null;
ApplicationUser user = null;
if (!ModelState.IsValid)
{
// Invalid Model, all Model Errors will be auto shown, no need to add yourself
// Model has those Error Messages in it & Shown Automatically.
ModelState.AddModelError("", "Something failed.");
viewModel.AllRolesList = new SelectList(
items: await RoleManager.Roles.ToListAsync(),
dataValueField: "Name",
dataTextField: "Name");
viewModel.AllClaimsList = new SelectList(
items: ClaimsStore.AllClaims,
dataValueField: "value",
dataTextField: "type");
return(View("CreateUserForm", viewModel));
}
// New User
user = new ApplicationUser
{
UserName = viewModel.Email,
Email = viewModel.Email,
DrivingLicense = viewModel.DrivingLicense,
Phone = viewModel.Phone,
};
result = await UserManager.CreateAsync(user, viewModel.Password);
if (!result.Succeeded)
{
// Error occures while Adding New User
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
viewModel.AllRolesList = new SelectList(
items: await RoleManager.Roles.ToListAsync(),
dataValueField: "Name",
dataTextField: "Name");
viewModel.AllClaimsList = new SelectList(
items: ClaimsStore.AllClaims,
dataValueField: "value",
dataTextField: "type");
return(View("CreateUserForm", viewModel));
}
// New User Added Successfully now add it roles
if (selectedRoles == null)
{
ViewBag.Message = "Record(s) addded successfully.";
return(List());
}
// If some roles are selected for New User, Add those roles
result = await UserManager.AddToRolesAsync(user.Id, selectedRoles);
// Errors occurs while adding Roles to New user
if (!result.Succeeded)
{
// Error occurs while adding roles
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
viewModel.AllRolesList = new SelectList(
items: await RoleManager.Roles.ToListAsync(),
dataValueField: "Name",
dataTextField: "Name");
viewModel.AllClaimsList = new SelectList(
items: ClaimsStore.AllClaims,
dataValueField: "value",
dataTextField: "type");
return(View("CreateUserForm", viewModel));
}
List <Claim> selectedClaimsOnForm = ClaimsStore.AllClaims.Where(c => selectedClaims.Contains(c.Value)).ToList();
// Adding Claim Array
foreach (var claim in selectedClaimsOnForm)
{
result = await UserManager.AddClaimAsync(user.Id, claim);
}
if (!result.Succeeded)
{
// Error occurs while adding roles
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
viewModel.AllRolesList = new SelectList(
items: await RoleManager.Roles.ToListAsync(),
dataValueField: "Name",
dataTextField: "Name");
viewModel.AllClaimsList = new SelectList(
items: ClaimsStore.AllClaims,
dataValueField: "value",
dataTextField: "type");
return(View("CreateUserForm", viewModel));
}
ViewBag.Message = "Record(s) addded successfully.";
return(List());
}
public async Task <ActionResult> CreateUser(CreateUserFormViewModel viewModel)
{
if (ModelState.IsValid)
{
switch (viewModel.RoleId)
{
case "1":
var adminUser = new ApplicationUser()
{
UserName = viewModel.Email,
Email = viewModel.Email,
EmailConfirmed = true,
Admin = new Admin()
{
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
Email = viewModel.Email,
Active = viewModel.Active
}
};
var adminRole = new IdentityUserRole()
{
RoleId = viewModel.RoleId,
UserId = adminUser.Id
};
var adminResult = await UserManager.CreateAsync(adminUser); // Create without password.
if (adminResult.Succeeded)
{
_context.Set <IdentityUserRole>().AddOrUpdate(adminRole);
_context.SaveChanges();
await SendActivationMail(adminUser);
TempData["AlertMessage"] = "User has been added";
return(RedirectToAction("CreateUser"));
}
foreach (var error in adminResult.Errors)
{
ModelState.AddModelError("", error);
}
break;
case "2":
var instructorUser = new ApplicationUser()
{
UserName = viewModel.Email,
Email = viewModel.Email,
EmailConfirmed = true,
Instructor = new Instructor()
{
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
Email = viewModel.Email,
Active = viewModel.Active
}
};
var instructorRole = new IdentityUserRole()
{
RoleId = viewModel.RoleId,
UserId = instructorUser.Id
};
var instructorResult = await UserManager.CreateAsync(instructorUser); // Create without password.
if (instructorResult.Succeeded)
{
_context.Set <IdentityUserRole>().AddOrUpdate(instructorRole);
_context.SaveChanges();
await SendActivationMail(instructorUser);
TempData["AlertMessage"] = "User has been added";
return(RedirectToAction("CreateUser"));
}
foreach (var error in instructorResult.Errors)
{
ModelState.AddModelError("", error);
}
break;
case "3":
var studentUser = new ApplicationUser()
{
UserName = viewModel.Email,
Email = viewModel.Email,
EmailConfirmed = true,
Student = new Student()
{
FirstName = viewModel.FirstName,
LastName = viewModel.LastName,
Email = viewModel.Email,
Active = viewModel.Active
}
};
var studentRole = new IdentityUserRole()
{
RoleId = viewModel.RoleId,
UserId = studentUser.Id
};
var studentResult = await UserManager.CreateAsync(studentUser); // Create without password.
if (studentResult.Succeeded)
{
_context.Set <IdentityUserRole>().AddOrUpdate(studentRole);
_context.SaveChanges();
await SendActivationMail(studentUser);
TempData["AlertMessage"] = "User has been added";
return(RedirectToAction("CreateUser"));
}
foreach (var error in studentResult.Errors)
{
ModelState.AddModelError("", error);
}
break;
}
}
return(View(viewModel));
}
