/// <summary>
/// Returns <see cref="ApplicationUser"/> instance after successful registration
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <OperationResult <ApplicationUserProfileViewModel> > RegisterAsync(RegisterViewModel model)
{
var operation = OperationResult.CreateResult <ApplicationUserProfileViewModel>();
var user = _mapper.Map <ApplicationUser>(model);
using (var transaction = await _unitOfWork.BeginTransactionAsync())
{
var userManager = _unitOfWork.GetUserManager();
var result = await userManager.CreateAsync(user, model.Password);
var role = AppData.CompanyRoleName;
if (result.Succeeded)
{
var roleManager = _unitOfWork.GetRoleManager();
if (await roleManager.FindByNameAsync(role) == null)
{
operation.Error = new MicroserviceUserNotFoundException();
operation.AddError(AppData.Exceptions.UserNotFoundException);
return(await Task.FromResult(operation));
}
await userManager.AddToRoleAsync(user, role);
await AddClaimsToUser(userManager, user, role);
var profile = _mapper.Map <ApplicationUserProfile>(model);
var profileRepository = _unitOfWork.GetRepository <ApplicationUserProfile>();
profile.ApplicationUserId = user.Id;
await profileRepository.InsertAsync(profile);
await _unitOfWork.SaveChangesAsync();
if (_unitOfWork.LastSaveChangesResult.IsOk)
{
var principal = await _claimsFactory.CreateAsync(user);
operation.Result = _mapper.Map <ApplicationUserProfileViewModel>(principal.Identity);
operation.AddSuccess(AppData.Messages.UserSuccessfullyRegistered);
_logger.LogInformation(operation.GetMetadataMessages());
transaction.Commit();
return(await Task.FromResult(operation));
}
}
var errors = result.Errors.Select(x => $"{x.Code}: {x.Description}");
if (result.Errors.Select(x => x.Code).Contains("DuplicateEmail"))
{
operation.AddError(result.Errors.SingleOrDefault(x => x.Code == "DuplicateEmail"));
operation.Error = _unitOfWork.LastSaveChangesResult.Exception;
}
else
{
operation.AddError(string.Join(", ", errors));
operation.Error = _unitOfWork.LastSaveChangesResult.Exception;
}
transaction.Rollback();
return(await Task.FromResult(operation));
}
}
/// <summary>
/// Returns <see cref="ApplicationUser"/> instance after successful registration
/// </summary>
/// <param name="model"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <OperationResult <UserProfileViewModel> > RegisterAsync(RegisterViewModel model, CancellationToken cancellationToken)
{
var operation = OperationResult.CreateResult <UserProfileViewModel>();
var user = _mapper.Map <ApplicationUser>(model);
await using var transaction = await _unitOfWork.BeginTransactionAsync();
var result = await _userManager.CreateAsync(user, model.Password);
const string role = AppData.ManagerRoleName;
if (result.Succeeded)
{
if (await _roleManager.FindByNameAsync(role) == null)
{
operation.Exception = new MicroserviceUserNotFoundException();
operation.AddError(AppData.Exceptions.UserNotFoundException);
return(await Task.FromResult(operation));
}
await _userManager.AddToRoleAsync(user, role);
await AddClaimsToUser(_userManager, user, role);
var profile = _mapper.Map <ApplicationUserProfile>(model);
var profileRepository = _unitOfWork.GetRepository <ApplicationUserProfile>();
await profileRepository.InsertAsync(profile, cancellationToken);
await _unitOfWork.SaveChangesAsync();
if (_unitOfWork.LastSaveChangesResult.IsOk)
{
var principal = await _claimsFactory.CreateAsync(user);
operation.Result = _mapper.Map <UserProfileViewModel>(principal.Identity);
operation.AddSuccess(AppData.Messages.UserSuccessfullyRegistered);
_logger.LogInformation(operation.GetMetadataMessages());
await transaction.CommitAsync(cancellationToken);
_logger.MicroserviceUserRegistration(model.Email);
return(await Task.FromResult(operation));
}
}
var errors = result.Errors.Select(x => $"{x.Code}: {x.Description}");
operation.AddError(string.Join(", ", errors));
operation.Exception = _unitOfWork.LastSaveChangesResult.Exception;
await transaction.RollbackAsync(cancellationToken);
_logger.MicroserviceUserRegistration(model.Email, operation.Exception);
return(await Task.FromResult(operation));
}
public async Task <ClaimsPrincipal> Handle(GetUserClaimsByIdRequest request, CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(request.UserId))
{
throw new MicroserviceException();
}
var user = await _userManager.FindByIdAsync(request.UserId);
if (user == null)
{
throw new MicroserviceUserNotFoundException();
}
var defaultClaims = await _claimsFactory.CreateAsync(user);
return(defaultClaims);
}