//api/applicationusers/register
public async Task <IActionResult> PostApplicationUser(ApplicationUserResource userResource)
{
var user = _mapper.Map <ApplicationUserResource, ApplicationUser> (userResource);
try {
var result = await _userManager.CreateAsync(user, userResource.Password);
if (result.Succeeded)
{
var currentUser = await _userManager.FindByNameAsync(user.UserName);
var roleResult = await _userManager.AddToRoleAsync(currentUser, Roles.User);
return(Ok());
}
else
{
return(BadRequest(new { message = result.Errors }));
}
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
//POST : /api/AuthController/Register
public async Task <IActionResult> UserRegister([FromBody] ApplicationUserResource model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var applicationUser = new ApplicationUser()
{
UserName = model.UserName,
Email = model.Email,
FullName = model.FullName
};
await InitialRoles();
var result = await _userManager.CreateAsync(applicationUser, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(applicationUser, model.IsAdmin? "Admin" : "Moderator");
return(Ok(result));
}
return(BadRequest(result.Errors));
}
//POST : /api/AuthController/Login
public async Task <IActionResult> UserLogin([FromBody] ApplicationUserResource model)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
{
var claims = new []
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration.GetSection("signingKey").ToString()));
var token = new JwtSecurityToken(
issuer: configuration.GetSection("issuer").ToString(),
audience: configuration.GetSection("audience").ToString(),
expires: DateTime.UtcNow.AddHours(1),
claims: claims,
signingCredentials: new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256)
);
var data = new TokenResultResource {
Token = new JwtSecurityTokenHandler().WriteToken(token),
Expiration = token.ValidTo,
isAdmin = _userManager.IsInRoleAsync(user, "Admin").Result,
FullName = user.FullName
};
return(Ok(data));
}
return(Unauthorized());
}
public async Task <IActionResult> PutClass(string id, ApplicationUserResource inputUser)
{
var requestUserId = HttpContext.User.Claims.First(c => c.Type == "sub").Value;
if (id != requestUserId)
{
return(BadRequest());
}
var storageUser = await _context.Users.FindAsync(id);
var validationError = storageUser.ModifyChangeIfItsValid(inputUser);
if (!string.IsNullOrWhiteSpace(validationError))
{
return(BadRequest(validationError));
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException ex)
{
if (ex.InnerException is SqlException innerException &&
(innerException.Number == 2627 || innerException.Number == 2601))
{
return(StatusCode(403, "Already taken."));
}
return(StatusCode(500, "Something went wrong."));
}
return(Ok(Guid.NewGuid()));
}
public ActionResult ResetPassword(ApplicationUserResource applicationUserResource)
{
string result = _applicationUserService.ResetPassword(applicationUserResource.UserName);
if (result == "Changed")
{
return(RedirectToAction("Index"));
}
else
{
return(View(applicationUserResource));
}
}
public JsonResult AddUserPost(ApplicationUserResource applicationUserResource)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = applicationUserResource.Email,
Email = applicationUserResource.Email,
Name = applicationUserResource.Name,
Role = applicationUserResource.Role,
PhoneNumber = applicationUserResource.PhoneNumber
};
return(Json(_applicationUserService.AddUser(user)));
}
return(Json("error"));
}
public async Task <Object> PostApplicationUser(ApplicationUserResource user)
{
var applicationUser = new ApplicationUser()
{
UserName = user.UserName,
Email = user.Email,
FullName = user.FullName
};
try {
var result = await _userManager.CreateAsync(applicationUser, user.Password);
await _userManager.AddToRoleAsync(applicationUser, user.Role);
return(Ok(result));
}
catch (Exception ex) {
throw ex;
}
}
public async Task <IActionResult> UpdateUser(ApplicationUserResource resource)
{
var user = await _userManager.FindByIdAsync(resource.Id);
if (user == null)
{
return(BadRequest());
}
user.FullName = resource.FullName;
user.UserName = resource.UserName;
user.Email = resource.UserName;
var userRole = _userManager.GetRolesAsync(user).Result;
await _userManager.RemoveFromRolesAsync(user, userRole);
await _userManager.AddToRoleAsync(user, resource.Role);
return(Ok());
}
public ActionResult Edit(ApplicationUserResource applicationUserResource)
{
if (ModelState.IsValid)
{
var exstuser = _applicationUserService.GetById(applicationUserResource.UserName);
exstuser.Name = applicationUserResource.Name;
exstuser.Email = applicationUserResource.Email;
exstuser.PhoneNumber = applicationUserResource.PhoneNumber;
exstuser.UserName = applicationUserResource.UserName;
string result = _applicationUserService.Update(exstuser);
if (result == "Success")
{
return(RedirectToAction("Index"));
}
else
{
return(View(applicationUserResource));
}
}
return(View());
}
public ActionResult Disable(ApplicationUserResource applicationUserResource)
{
var exstuser = _applicationUserService.GetById(applicationUserResource.UserName);
if (exstuser.Status == true)
{
exstuser.Status = false;
}
else
{
exstuser.Status = true;
}
string result = _applicationUserService.UpdateStatus(exstuser);
if (result == "Success")
{
return(RedirectToAction("Index"));
}
else
{
return(View(applicationUserResource));
}
}
public static string ModifyChangeIfItsValid(this ApplicationUser storageUser, ApplicationUserResource inputUser)
{
if (inputUser.Email != null)
{
try
{
var possibleEmail = new MailAddress(inputUser.Email);
storageUser.Email = inputUser.Email;
storageUser.EmailConfirmed = false;
}
catch
{
return("Email format is not valid.");
}
}
else if (inputUser.NameAndFamily != null)
{
var regex = new Regex("[آ-ی, ]{1,31}");
if (regex.IsMatch(inputUser.NameAndFamily))
{
storageUser.NameAndFamily = inputUser.NameAndFamily;
}
else
{
return("NameAndFamily format is not valid.");
}
}
else if (inputUser.StudentNumber != null)
{
var regex = new Regex("[0-9]{10}");
if (regex.IsMatch(inputUser.StudentNumber))
{
storageUser.StudentNumber = inputUser.StudentNumber;
storageUser.StudentNumberConfirmed = false;
}
else
{
return("StudentNumber format is not valid.");
}
}
else if (inputUser.PhoneNumber != null)
{
var regex = new Regex("^09[0-9]{9}");
if (regex.IsMatch(inputUser.PhoneNumber))
{
storageUser.PhoneNumber = inputUser.PhoneNumber;
storageUser.PhoneNumberConfirmed = false;
}
else
{
return("PhoneNumber format is not valid.");
}
}
return(null);
}
