public async Task <AuthResponse> ConfirmChangeEmail(ConfirmChangeEmailRequestModel model, string currentEmail)
{
AuthUser user = await this.userManager.FindByEmailAsync(currentEmail);
if (user == null)
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("User not found", AuthErrorCodes.UserDoesNotExist));
}
else
{
IdentityResult result = await this.userManager.ChangeEmailAsync(user, user.NewEmail, System.Net.WebUtility.UrlDecode(model.Token));
if (result.Succeeded)
{
user.NewEmail = string.Empty;
var updateResult = await this.userManager.UpdateAsync(user);
if (updateResult.Succeeded)
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponse());
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse(updateResult, AuthErrorCodes.UnableToUpdateUser));
}
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse(result, AuthErrorCodes.UnableToChangeEmail));
}
}
}
public async Task <AuthResponse> ResetPassword(ResetPasswordRequestModel model)
{
AuthUser user = await this.userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("User not found", AuthErrorCodes.UserDoesNotExist));
}
else
{
string confirmationToken = await this.userManager.GeneratePasswordResetTokenAsync(user);
string confirmationLink = $"{this.apiSettings.ExternalBaseUrl}/confirmpasswordreset/{user.Id}/{UrlEncoder.Default.Encode(confirmationToken)}";
string command = "Click this link to reset your password";
if (this.apiSettings.DebugSendAuthEmailsToClient)
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponseWithLink(command, confirmationLink));
}
else
{
string email = this.FormatLink(command, confirmationLink);
await this.emailService.SendEmailAsync(model.Email, "Password Reset", email);
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponse("Click the link sent to the provided email to reset your password"));
}
}
}
public async Task <AuthResponse> Register(RegisterRequestModel model)
{
IdentityUser existingUser = await this.userManager.FindByEmailAsync(model.Email);
if (existingUser == null)
{
AuthUser user = new AuthUser
{
Email = model.Email,
UserName = model.Email,
Id = this.guidService.NewGuid().ToString()
};
IdentityResult result = await this.userManager.CreateAsync(user);
if (result.Succeeded)
{
IdentityResult addPasswordResult = await this.userManager.AddPasswordAsync(user, model.Password);
if (addPasswordResult.Succeeded)
{
string confirmationToken = await this.userManager.GenerateEmailConfirmationTokenAsync(user);
string confirmationLink = $"{this.apiSettings.ExternalBaseUrl}/confirmregistration/{user.Id}/{UrlEncoder.Default.Encode(confirmationToken)}";
string command = "Click this link to complete registration";
string email = this.FormatLink(command, confirmationLink);
await this.emailService.SendEmailAsync(model.Email, "Registration", email);
if (this.apiSettings.DebugSendAuthEmailsToClient)
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponseWithLink(command, confirmationLink));
}
else
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponse("Click the link sent to the provided email to complete registration"));
}
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse(addPasswordResult, AuthErrorCodes.UnableToRegister));
}
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse(result, AuthErrorCodes.UnableToRegister));
}
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("User already exists", AuthErrorCodes.UserAlreadyExists));
}
}
public virtual async Task <ActionResponse> Delete(
int id)
{
ActionResponse response = ValidationResponseFactory <object> .ActionResponse(await this.CountryRequirementModelValidator.ValidateDeleteAsync(id));
if (response.Success)
{
await this.CountryRequirementRepository.Delete(id);
await this.mediator.Publish(new CountryRequirementDeletedNotification(id));
}
return(response);
}
public virtual async Task <ActionResponse> Delete(
int id)
{
ActionResponse response = ValidationResponseFactory <object> .ActionResponse(await this.PipelineStepDestinationModelValidator.ValidateDeleteAsync(id));
if (response.Success)
{
await this.PipelineStepDestinationRepository.Delete(id);
await this.mediator.Publish(new PipelineStepDestinationDeletedNotification(id));
}
return(response);
}
public async Task <AuthResponse> ChangeEmail(ChangeEmailRequestModel model, string currentEmail)
{
AuthUser user = await this.userManager.FindByEmailAsync(currentEmail);
if (user == null)
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("User not found", AuthErrorCodes.UserDoesNotExist));
}
else
{
if (this.userManager.PasswordHasher.VerifyHashedPassword(user, user.PasswordHash, model.Password) == PasswordVerificationResult.Success)
{
user.NewEmail = model.NewEmail;
IdentityResult updateResult = await this.userManager.UpdateAsync(user);
if (updateResult.Succeeded)
{
string confirmationToken = await this.userManager.GenerateChangeEmailTokenAsync(user, model.NewEmail);
string confirmationLink = $"{this.apiSettings.ExternalBaseUrl}/confirmchangeemail/{user.Id}/{UrlEncoder.Default.Encode(confirmationToken)}";
string command = "Click the link to change your email";
string email = this.FormatLink(command, confirmationLink);
await this.emailService.SendEmailAsync(model.NewEmail, "Change Email", email);
if (this.apiSettings.DebugSendAuthEmailsToClient)
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponseWithLink(command, confirmationLink));
}
else
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponse("Click the link sent to the provided email to complete changing your account email"));
}
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("Unable to update user", AuthErrorCodes.UnableToUpdateUser));
}
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("Invalid email or password", AuthErrorCodes.InvalidUsernameOrPassword));
}
}
}
public virtual async Task <CreateResponse <ApiCountryRequirementServerResponseModel> > Create(
ApiCountryRequirementServerRequestModel model)
{
CreateResponse <ApiCountryRequirementServerResponseModel> response = ValidationResponseFactory <ApiCountryRequirementServerResponseModel> .CreateResponse(await this.CountryRequirementModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
CountryRequirement record = this.DalCountryRequirementMapper.MapModelToEntity(default(int), model);
record = await this.CountryRequirementRepository.Create(record);
response.SetRecord(this.DalCountryRequirementMapper.MapEntityToModel(record));
await this.mediator.Publish(new CountryRequirementCreatedNotification(response.Record));
}
return(response);
}
public virtual async Task <CreateResponse <ApiHandlerPipelineStepServerResponseModel> > Create(
ApiHandlerPipelineStepServerRequestModel model)
{
CreateResponse <ApiHandlerPipelineStepServerResponseModel> response = ValidationResponseFactory <ApiHandlerPipelineStepServerResponseModel> .CreateResponse(await this.HandlerPipelineStepModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
HandlerPipelineStep record = this.DalHandlerPipelineStepMapper.MapModelToEntity(default(int), model);
record = await this.HandlerPipelineStepRepository.Create(record);
response.SetRecord(this.DalHandlerPipelineStepMapper.MapEntityToModel(record));
await this.mediator.Publish(new HandlerPipelineStepCreatedNotification(response.Record));
}
return(response);
}
public async Task <AuthResponse> ConfirmPasswordReset(ConfirmPasswordResetRequestModel model)
{
AuthUser user = await this.userManager.FindByIdAsync(model.Id);
if (user == null)
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("User not found", AuthErrorCodes.UserDoesNotExist));
}
else
{
IdentityResult result = await this.userManager.ResetPasswordAsync(user, System.Net.WebUtility.UrlDecode(model.Token), model.NewPassword);
if (result.Succeeded)
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponse());
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse(result, AuthErrorCodes.UnableToConfirmPasssordReset));
}
}
}
public async Task <AuthResponse> ChangePassword(ChangePasswordRequestModel model, string email)
{
AuthUser user = await this.userManager.FindByEmailAsync(email);
if (user == null)
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("User not found", AuthErrorCodes.UserDoesNotExist));
}
else
{
IdentityResult result = await this.userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword);
if (result.Succeeded)
{
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponse());
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse(result, AuthErrorCodes.UnableToChangePassword));
}
}
}
public virtual async Task <UpdateResponse <ApiCountryRequirementServerResponseModel> > Update(
int id,
ApiCountryRequirementServerRequestModel model)
{
var validationResult = await this.CountryRequirementModelValidator.ValidateUpdateAsync(id, model);
if (validationResult.IsValid)
{
CountryRequirement record = this.DalCountryRequirementMapper.MapModelToEntity(id, model);
await this.CountryRequirementRepository.Update(record);
record = await this.CountryRequirementRepository.Get(id);
ApiCountryRequirementServerResponseModel apiModel = this.DalCountryRequirementMapper.MapEntityToModel(record);
await this.mediator.Publish(new CountryRequirementUpdatedNotification(apiModel));
return(ValidationResponseFactory <ApiCountryRequirementServerResponseModel> .UpdateResponse(apiModel));
}
else
{
return(ValidationResponseFactory <ApiCountryRequirementServerResponseModel> .UpdateResponse(validationResult));
}
}
public virtual async Task <UpdateResponse <ApiPipelineStepDestinationServerResponseModel> > Update(
int id,
ApiPipelineStepDestinationServerRequestModel model)
{
var validationResult = await this.PipelineStepDestinationModelValidator.ValidateUpdateAsync(id, model);
if (validationResult.IsValid)
{
PipelineStepDestination record = this.DalPipelineStepDestinationMapper.MapModelToEntity(id, model);
await this.PipelineStepDestinationRepository.Update(record);
record = await this.PipelineStepDestinationRepository.Get(id);
ApiPipelineStepDestinationServerResponseModel apiModel = this.DalPipelineStepDestinationMapper.MapEntityToModel(record);
await this.mediator.Publish(new PipelineStepDestinationUpdatedNotification(apiModel));
return(ValidationResponseFactory <ApiPipelineStepDestinationServerResponseModel> .UpdateResponse(apiModel));
}
else
{
return(ValidationResponseFactory <ApiPipelineStepDestinationServerResponseModel> .UpdateResponse(validationResult));
}
}
public async Task <AuthResponse> Login(LoginRequestModel model)
{
AuthUser user = await this.userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("Invalid email or password", AuthErrorCodes.InvalidUsernameOrPassword));
}
else
{
if (this.userManager.PasswordHasher.VerifyHashedPassword(user, user.PasswordHash, model.Password) == PasswordVerificationResult.Success)
{
IList <Claim> claims = await this.userManager.GetClaimsAsync(user);
IList <string> roles = await this.userManager.GetRolesAsync(user);
foreach (string role in roles)
{
claims.Add(new Claim(ClaimTypes.Role, role));
}
string token = this.jwtService.GenerateBearerToken(
this.apiSettings.JwtSettings.SigningKey,
this.apiSettings.JwtSettings.Audience,
this.apiSettings.JwtSettings.Issuer,
user.Id,
user.Email,
claims);
return(ValidationResponseFactory <AuthResponse> .SuccessAuthResponseWithToken(token));
}
else
{
return(ValidationResponseFactory <AuthResponse> .FailureAuthResponse("Invalid email or password", AuthErrorCodes.InvalidUsernameOrPassword));
}
}
}