public async Task Should_Update_Email()
{
string path = "/api/users/updateEmail";
var request = new UpdateEmailRequest
{
CurrentEmail = "*****@*****.**",
NewEmail = "*****@*****.**"
};
MockRestClient.Setup(m => m.PostAsync <UpdateUserResponse>(It.Is <string>(a => a == path), It.IsAny <UpdateEmailRequest>())).ReturnsAsync(new ApiResponse <UpdateUserResponse>
{
UrlPath = path,
HttpStatusCode = HttpStatusCode.OK,
Model = new UpdateUserResponse
{
Code = "Success"
}
});
ApiResponse <UpdateUserResponse> response = await _userClient.UpdateEmailAsync(request).ConfigureAwait(false);
Assert.NotNull(response);
Assert.NotNull(response.Model);
Assert.Equal("Success", response.Model.Code);
Assert.Equal(HttpStatusCode.OK, response.HttpStatusCode);
Assert.Equal(path, response.UrlPath);
MockRestClient.Verify(m => m.PostAsync <UpdateUserResponse>(It.Is <string>(a => a == path), It.IsAny <UpdateEmailRequest>()), Times.Once);
}
public async Task <ActionResult> UpdateEmail([FromRoute] Guid userId, [FromBody] UpdateEmailRequest updateEmailRequest, CancellationToken cancellationToken)
{
await _userService.UpdateUserEmailAsync(userId, updateEmailRequest.Email, cancellationToken).ConfigureAwait(false);
_logger.LogInformation("Successfully updated email for {userId}", userId);
return(Ok());
}
public override async Task <Empty> UpdateEmail(UpdateEmailRequest request, ServerCallContext context)
{
var updateEmailCommand = _mapper.Map <UpdateEmailCommand>(request);
var response = await _mediator.Send(updateEmailCommand);
return(new Empty());
}
public async Task <IActionResult> ChangeEmail([FromBody] UpdateEmailRequest request,
CancellationToken cancellationToken)
{
var command = UpdateEmailCommand.FromRequest(_currentUserId, request);
var result = await _mediator.Send(command, cancellationToken);
return(result.IsSuccess
? Ok()
: result.ReturnErrorResponse());
}
public async Task <IActionResult> UpdateEmail([FromRoute] long userId, [FromBody] UpdateEmailRequest emailRequest)
{
try
{
await _userService.UpdateEmail(userId, emailRequest.Email);
} catch (EmailAlreadyExistsException e) {
return(BadRequest(e));
}
return(Ok(true));
}
public async Task <IActionResult> UpdateEmail([FromBody] UpdateEmailRequest emailRequest)
{
var successful = await _userService.UpdateEmail(User.GetId(), emailRequest.Email);
if (successful)
{
return(Ok(true));
}
return(Ok(false));
}
/*
* Method to get open sections
*/
public UpdateEmailResponse UpdateEmail(UpdateEmailRequest updateEmailRequest)
{
var login = _ucOnlinePortalContext.LoginInfos.Where(x => x.StudId == updateEmailRequest.id_number).FirstOrDefault();
if (login == null)
{
return(new UpdateEmailResponse {
success = 0
});
}
else
{
var loginTemp = _ucOnlinePortalContext.LoginInfos.Where(x => x.Email == updateEmailRequest.email).FirstOrDefault();
if (loginTemp != null)
{
var checkIfEmailIsOwner = _ucOnlinePortalContext.LoginInfos.Where(x => x.Email == updateEmailRequest.email && x.StudId == updateEmailRequest.id_number).FirstOrDefault();
if (checkIfEmailIsOwner == null)
{
return(new UpdateEmailResponse {
success = 0
});
}
}
//Generate random number for Token
Random generator = new Random();
String token = generator.Next(0, 1000000).ToString("D6");
var Tk = Task.Run(() =>
{
var emailDetails = new EmailDetails
{
To = new EmailAddress {
Address = updateEmailRequest.email, Name = login.FirstName + " " + login.Mi + " " + login.LastName
}
};
emailDetails.SpecificInfo.Add("{{code}}", token);
_emailHandler.SendEmail(emailDetails, (int)RequestResponse.Enums.EmailType.VERIFICATIONCODE);
});
Tk.Wait();
login.Email = updateEmailRequest.email;
login.Token = token;
_ucOnlinePortalContext.LoginInfos.Update(login);
_ucOnlinePortalContext.SaveChanges();
}
return(new UpdateEmailResponse {
success = 1
});
}
public async Task <ActionResult <string> > UpdateEmail([FromBody] UpdateEmailRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(new JsonResult(
Mapper.Map <UserViewModel>(
await UserService.UpdateEmailAsync(request))));
}
public async Task <IActionResult> UpdateEmailAsync([FromBody] UpdateEmailRequest model, CancellationToken token)
{
try
{
var command = new UpdateEmailCommand(model.UserId, model.Email);
await _commandBus.DispatchAsync(command, token);
return(Ok());
}
catch (ArgumentException)
{
return(BadRequest());
}
}
public async Task <bool> UpdateEmailAsync(UpdateEmailRequest request)
{
var user = await UserRepository.GetByIdAsync(request.Id);
if (user == null)
{
throw new NotFoundException("Пользователь не найден");
}
var result = await ChangeEmailAsync(user, request.NewEmail, request.Token);
if (!result.Succeeded)
{
throw new IdentityUserException(result);
}
return(result.Succeeded);
}
public ActionResult <Client> Update(string clientNumber, UpdateEmailRequest updateEmailRequest)
{
if (string.IsNullOrWhiteSpace(updateEmailRequest.Email))
{
return(BadRequest("Email address cannot be empty."));
}
try
{
using (MySqlConnection connection = new MySqlConnection(_connectionString))
{
connection.Open();
using (MySqlCommand command = connection.CreateCommand())
{
command.CommandText = "UPDATE contactme.clients SET Email = @email, Alert = @alert WHERE ClientNumber = @clientNumber";
command.Parameters.Add(new MySqlParameter("@email", MySqlDbType.VarChar, 255)
{
Value = updateEmailRequest.Email
});
command.Parameters.Add(new MySqlParameter("@alert", MySqlDbType.Int32)
{
Value = Convert.ToInt32(updateEmailRequest.Alert)
});
command.Parameters.Add(new MySqlParameter("@clientNumber", MySqlDbType.VarChar, 255)
{
Value = clientNumber
});
command.Prepare();
if (command.ExecuteNonQuery() == 0)
{
return(NotFound(clientNumber));
}
else
{
return(Ok());
}
}
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public IEnumerator UpdateEmail(UpdateEmailRequest updateEmailRequest, ResultCallback callback)
{
Report.GetFunctionLog(this.GetType().Name);
Assert.IsNotNull(updateEmailRequest, "Update failed. updateEmailRequest is null!");
var request = HttpRequestBuilder.CreatePut(this.baseUrl + "/v4/public/namespaces/{namespace}/users/me/email")
.WithPathParam("namespace", this.@namespace)
.WithBearerAuth(this.session.AuthorizationToken)
.WithContentType(MediaType.ApplicationJson)
.WithBody(updateEmailRequest.ToUtf8Json())
.Accepts(MediaType.ApplicationJson)
.GetResult();
IHttpResponse response = null;
yield return(this.httpClient.SendRequest(request, rsp => response = rsp));
var result = response.TryParse();
callback.Try(result);
}
public async Task <IActionResult> UpdateEmail([FromBody] UpdateEmailRequest request)
{
//Check if required fields are present
if (!ModelState.IsValid)
{
return(Ok(new UpdateEmailResponse {
success = 0
}));
}
//Convert response object to DTO Objects
var serialized_req = Newtonsoft.Json.JsonConvert.SerializeObject(request);
var converted_req = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.Request.UpdateEmailRequest>(serialized_req);
//await result from function ChangePassword
var result = await Task.FromResult(_loginManagement.UpdateEmail(converted_req));
return(Ok(new UpdateEmailResponse {
success = result.success
}));
}
public async Task <LoginResponse> SendUpdateEmailForUser([FromBody] UpdateEmailRequest data)
{
var user = await _userService.GetByIdAsync(UserId);
if (!HashUtils.CheckHash(user.PasswordHash, data.Password))
{
throw new AppErrorException(ErrorCode.IncorrectValidation);
}
var token = _mailTokenService.EncryptToken(user.Email);
var model = new ChangeEmailEmailModel {
OldEmail = user.Email, NewEmail = data.NewEmail, Token = token
};
await _queueProvider.SendMessageAsync(model.ToJson());
return(new LoginResponse
{
AccessToken = _authService.GenerateAccessToken(user),
RefreshToken = _authService.GenerateRefreshToken(user)
});
}
/// <summary>
/// Update an individual account holder's email address
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public async Task UpdateEmailAsync(UpdateEmailRequest body)
{
//validating required parameters
if (null == body)
{
throw new ArgumentNullException(nameof(body), "The parameter \"body\" is a required parameter and cannot be null.");
}
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/account-holder/individual/email");
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetContentRequestHeaders();
//append body params
var serializedBody = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
var request = ClientInstance.PutBody(queryUrl, headers, serializedBody);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
}
/// <summary>
/// Update an individual account holder's email address
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public void UpdateEmail(UpdateEmailRequest body)
{
var t = UpdateEmailAsync(body);
APIHelper.RunTaskSynchronously(t);
}
public ServiceResult EditEmail(UpdateEmailRequest request)
{
return(_userService.UpdateEmail(request.Id, request.Email));
}
/// <summary>
/// Update user email address
/// </summary>
/// <param name="updateEmailRequest">Set verify code and user new email on the body</param>
/// <param name="callback">Returns a Result that contains UserData via callback when completed</param>
public void UpdateEmail(UpdateEmailRequest updateEmailRequest, ResultCallback callback)
{
Report.GetFunctionLog(this.GetType().Name);
this.coroutineRunner.Run(this.userAccount.UpdateEmail(updateEmailRequest, callback));
}
public async Task <ApiResponse <UpdateUserResponse> > UpdateEmailAsync(UpdateEmailRequest model)
{
Ensure.ArgumentNotNull(model, nameof(model));
return(await _client.PostAsync <UpdateUserResponse>("/api/users/updateEmail", model).ConfigureAwait(false));
}
