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)); }