private async void btnAddUser_Click(object sender, EventArgs e)
{
try
{
string username = textUsername.Text;
if (string.IsNullOrEmpty(username))
{
MessageBox.Show("Invalid Username");
return;
}
if (username.Length > 100)
{
MessageBox.Show("Invalid Username");
return;
}
ApplicationUserInputModel inputModel = new ApplicationUserInputModel
{
UserName = username,
};
string inputModelJson = JsonConvert.SerializeObject(inputModel);
await applicationUserService.InsertApplicationUserAsync(inputModelJson);
MessageBox.Show("Successfully added new user");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public async Task <IActionResult> Put([FromBody] ApplicationUserInputModel model)
{
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user != null)
{
user.FirstName = model.FirstName;
user.MiddleName = model.MiddleName;
user.LastName = model.LastName;
user.UserName = model.UserName;
user.Gender = model.Gender;
user.PhoneNumber = model.PhoneNumber;
user.Email = model.Email;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(Ok(user));
}
else
{
return(BadRequest(result.Errors));
}
}
else
{
return(NotFound());
}
}
public void Models_ApplicationUserInputModel_Get_Set_Should_Pass()
{
// Arange
var Student = DataSourceBackend.Instance.StudentBackend.GetDefault();
var userInfo = DataSourceBackend.Instance.IdentityBackend.FindUserByUserName(Student.Name);
// Act
var result = new ApplicationUserInputModel(userInfo)
{
Id = "123",
Role = UserRoleEnum.StudentUser,
Student = Student,
State = true
};
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.IsNotNull(result, TestContext.TestName);
Assert.AreEqual(result.Id, result.Id, TestContext.TestName);
Assert.AreEqual(result.Role, result.Role, TestContext.TestName);
Assert.AreEqual(result.Student, result.Student, TestContext.TestName);
Assert.AreEqual(result.State, result.State, TestContext.TestName);
}
public async Task InsertApplicationUserAsync(string inputModelJson)
{
ApplicationUserInputModel inputModel = JsonConvert.DeserializeObject <ApplicationUserInputModel>(inputModelJson);
string currentDate = DateTime.Now.ToString("dd.MM.yyyy");
string insertStatement = $"insert into application_user(is_del, username, created_on)values(0,'{inputModel.UserName}', '{currentDate}')";
await CommandExecuter.ExecuteNonQuaryAsync(insertStatement);
}
public async Task <IActionResult> Edit(string id, [Bind("Id,FirstName,LastName,Email,Password,ConfirmPassword,IsApproved")] ApplicationUserInputModel input)
{
if (id != input.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(input.Id);
if (user.FirstName != input.FirstName)
{
user.FirstName = input.FirstName;
}
if (user.LastName != input.LastName)
{
user.LastName = input.LastName;
}
var approvedChanged = false;
if (user.IsApproved != input.IsApproved)
{
user.IsApproved = input.IsApproved;
approvedChanged = true;
}
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
_logger.LogInformation("User updated.");
if (approvedChanged)
{
if (input.IsApproved)
{
await _emailSender.SendEmailAsync(input.Email, "Account Activated",
$"Your account has been activated.");
}
else
{
await _emailSender.SendEmailAsync(input.Email, "Account Deactivated",
$"Your account has been deactivated, please contact Administrator.");
}
}
return(RedirectToAction(nameof(Index)));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(input));
}
public void Models_ApplicationUserInput_Instantiate_Should_Pass()
{
// Arange
// Act
var result = new ApplicationUserInputModel();
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.IsNotNull(result, TestContext.TestName);
}
public void Models_ApplicationUserInput_Invalid_User_Should_Fail()
{
// Arange
var userInfo = DataSourceBackend.Instance.IdentityBackend.FindUserByUserName("bogus");
// Act
var result = new ApplicationUserInputModel(userInfo);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.IsNull(result.Student, TestContext.TestName);
}
public async Task <ActionResult <ApplicationUserViewModel> > PostUser([FromBody] ApplicationUserInputModel userInputModel)
{
ApplicationUser user = _mapper.Map <ApplicationUser>(userInputModel);
IdentityResult result = await _userManager.CreateAsync(user, userInputModel.Password);
if (!result.Succeeded)
{
SetIdentityResultErrors(result);
return(BadRequest(new ValidationProblemDetails(ModelState)
{
Status = StatusCodes.Status400BadRequest
}));
}
return(GenerateAuthenticateUser(user));
}
public void Models_ApplicationUserInputModel_Instantiate_Should_Pass()
{
// Arange
//DataSourceBackend.Instance.StudentBackend.Index();
var Student = DataSourceBackend.Instance.StudentBackend.GetDefault();
var userInfo = DataSourceBackend.Instance.IdentityBackend.FindUserByID(Student.Id);
// Act
var result = new ApplicationUserInputModel(userInfo);
// Reset
DataSourceBackend.Instance.Reset();
// Assert
Assert.IsNotNull(Student, TestContext.TestName);
Assert.IsNotNull(userInfo, TestContext.TestName);
Assert.IsNotNull(result, TestContext.TestName);
}
public ActionResult ToggleUser([Bind(Include =
"Id," +
"State," +
"Role," +
"")] ApplicationUserInputModel data)
{
if (!ModelState.IsValid)
{
// Send back for edit
return(View(data));
}
if (data == null)
{
return(RedirectToAction("Error", "Home"));
}
if (string.IsNullOrEmpty(data.Id))
{
return(RedirectToAction("Error", "Home"));
}
if (data.Role == UserRoleEnum.Unknown)
{
return(RedirectToAction("Error", "Home"));
}
if (DataSourceBackend.Instance.IdentityBackend.UserHasClaimOfType(data.Id, data.Role))
{
DataSourceBackend.Instance.IdentityBackend.RemoveClaimFromUser(data.Id, data.Role.ToString());
}
else
{
DataSourceBackend.Instance.IdentityBackend.AddClaimToUser(data.Id, data.Role.ToString(), "True");
}
return(RedirectToAction("UserList", "Support"));
}
//GET support/togglestudent/userID
public ActionResult ToggleUser(string id = null, string item = null)
{
var CurrentId = DataSourceBackend.Instance.IdentityBackend.GetCurrentStudentID(HttpContext);
if (DataSourceBackend.Instance.IdentityBackend.BlockExecptForRole(CurrentId, UserRoleEnum.SupportUser))
{
return(RedirectToAction("Login", "Support"));
}
if (string.IsNullOrEmpty(id))
{
return(RedirectToAction("Index", "Home"));
}
if (string.IsNullOrEmpty(item))
{
return(RedirectToAction("Index", "Home"));
}
var myUserInfo = DataSourceBackend.Instance.IdentityBackend.FindUserByID(id);
if (myUserInfo == null)
{
return(RedirectToAction("Index", "Home"));
}
var RoleEnum = (UserRoleEnum)Enum.Parse(typeof(UserRoleEnum), item, true);
var myReturn = new ApplicationUserInputModel(myUserInfo)
{
Id = myUserInfo.Id,
Role = RoleEnum,
State = DataSourceBackend.Instance.IdentityBackend.UserHasClaimOfType(myUserInfo.Id, RoleEnum)
};
return(View(myReturn));
}
public async Task <IActionResult> Create([Bind("FirstName,LastName,Email,Password,ConfirmPassword")] ApplicationUserInputModel input)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
FirstName = input.FirstName, LastName = input.LastName, UserName = input.Email, Email = input.Email, IsApproved = false, CreatedOn = DateTime.Now
};
var result = await _userManager.CreateAsync(user, input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _userManager.AddToRoleAsync(user, "Admin");
ModelState.AddModelError("AccountInactive", "Your Account is not activated yet. Please wait until administrator approves your account.");
return(RedirectToAction(nameof(Index)));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(input));
}
public async Task <ActionResult <ApplicationUserViewModel> > PostApplicationUser([FromBody] ApplicationUserInputModel applicationUser)
{
var user = new ApplicationUser
{
UserName = applicationUser.UserName,
Email = applicationUser.Email,
Rol = applicationUser.Rol
};
var result = await _userManager.CreateAsync(user, applicationUser.Password);
if (!result.Succeeded)
{
ModelState.AddModelError("UsuarioYaTomado", "El usuario ya esta tomado po otra persona");
return(Conflict(ModelState));
}
return(new ApplicationUserViewModel
{
UserName = user.UserName,
Email = user.Email,
Token = _tokenGenerator.GenerateToken(user.UserName, user.Rol),
Rol = user.Rol
});
}
