public async Task <IdentityUserResult> AddUserToRole(string id, bool isUserSelected, string roleName)
{
var user = await unitOfWork.UserManager.FindByIdAsync(id);
if (user == null)
{
return new IdentityUserResult()
{
NotFound = true, Errors = new List <string>()
{
$"User with {id} not found"
}
}
}
;
if (isUserSelected && !(await unitOfWork.UserManager.IsInRoleAsync(user, roleName)))
{
var result = await unitOfWork.UserManager.AddToRoleAsync(user, roleName);
return(result.Succeeded ? IdentityUserResult.SUCCESS : IdentityUserResult.GenerateErrorResponce(result));
}
else if (!isUserSelected && (await unitOfWork.UserManager.IsInRoleAsync(user, roleName)))
{
var result = await unitOfWork.UserManager.RemoveFromRoleAsync(user, roleName);
return(result.Succeeded
? IdentityUserResult.SUCCESS
: IdentityUserResult.GenerateErrorResponce(result));
}
return(null);
}
public async Task <IdentityUserResult> UpdateRole(RoleDTO role)
{
var identityRole = await unitOfWork.RoleManager.FindByIdAsync(role.Id);
if (identityRole == null)
{
return(new IdentityUserResult()
{
NotFound = true, Errors = new List <string>()
{
$"Role with {role.Id} not found"
}
});
}
identityRole.Name = role.Name;
var result = await unitOfWork.RoleManager.UpdateAsync(identityRole);
if (result.Succeeded)
{
return(IdentityUserResult.SUCCESS);
}
else
{
return(IdentityUserResult.GenerateErrorResponce(result));
}
}
private void AddModelErrors(IdentityUserResult result)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error);
}
}
public async Task <IdentityUserResult> RegisterPerson(PersonDTO person)
{
using (unitOfWork.BeginTransaction())
{
try
{
ApplicationUser user = await unitOfWork.UserManager.FindByEmailAsync(person.Email);
if (user == null)
{
user = new ApplicationUser {
Email = person.Email, UserName = person.UserName, PhoneNumber = person.PhoneNumber
};
var result = await unitOfWork.UserManager.CreateAsync(user, person.Password);
await unitOfWork.Save();
if (result.Succeeded)
{
var token = await unitOfWork.UserManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationLink = UrlHelper.Action("ConfirmEmail", "Account", new { token, email = user.Email }, httpContextAccessor.HttpContext.Request.Scheme);
var message = new CustomMessage(new List <string>()
{
user.Email
}, "Confirmation email link", confirmationLink, null);
var personMapped = PersonEntityToDtoMapper.Instance.MapBack(person);
personMapped.ApplicationUserFkId = user.Id;
unitOfWork.PersonRepository.Add(personMapped);
await unitOfWork.Save();
await emailSender.SendEmailAsync(message);
await unitOfWork.UserManager.AddToRoleAsync(user, "User");
unitOfWork.CommitTransaction();
return(IdentityUserResult.SUCCESS);
}
return(IdentityUserResult.GenerateErrorResponce(result));
}
else
{
return(new IdentityUserResult()
{
NotFound = true, Errors = new List <string>()
{
"Current user already registered"
}
});
}
}
catch (Exception e)
{
unitOfWork.RollbackTransaction();
logger.LogError(e.Message);
throw e;
}
}
}
public async Task <IdentityUserResult> AddRole(RoleDTO role)
{
var identityRole = new IdentityRole
{
Name = role.Name
};
var result = await unitOfWork.RoleManager.CreateAsync(identityRole);
return(result.Succeeded ? IdentityUserResult.SUCCESS : IdentityUserResult.GenerateErrorResponce(result));
}
public async Task <IdentityUserResult> ResetPasswordForPerson(PersonDTO person)
{
var user = await unitOfWork.UserManager.FindByEmailAsync(person.Email);
if (user == null)
{
return(new IdentityUserResult()
{
NotFound = true, Errors = new List <string>()
{
$"User {person.Email} not found"
}
});
}
var result = await unitOfWork.UserManager.ResetPasswordAsync(user, person.Token, person.Password);
return(result.Succeeded ? IdentityUserResult.SUCCESS : IdentityUserResult.GenerateErrorResponce(result));
}
public async Task <IdentityUserResult> DeleteRole(string id)
{
var roleReturned = await unitOfWork.RoleManager.FindByIdAsync(id);
if (roleReturned == null)
{
return new IdentityUserResult()
{
NotFound = true, Errors = new List <string>()
{
$"Role with {id} not found"
}
}
}
;
var result = await unitOfWork.RoleManager.DeleteAsync(roleReturned);
return(result.Succeeded ? IdentityUserResult.SUCCESS : IdentityUserResult.GenerateErrorResponce(result));
}
public async Task <IdentityUserResult> ConfirmUserEmailAsync(string email, string code)
{
var user = await unitOfWork.UserManager.FindByEmailAsync(email);
if (user == null)
{
return new IdentityUserResult()
{
Errors = new List <string>()
{
$"User wit email {email} not found"
}, NotFound = true
}
}
;
var result = await unitOfWork.UserManager.ConfirmEmailAsync(user, code);
return(result.Succeeded ? IdentityUserResult.SUCCESS : IdentityUserResult.GenerateErrorResponce(result));
}
