public async Task <IActionResult> UpdateUserProfile([FromBody] UpdateUserProfileRequest userProfileRequest) { var loggedUser = User.GetUserIdFromToken(); await _accountService.UpdateProfileAsync(loggedUser, userProfileRequest); return(Ok()); }
public async Task <IEnumerable <Claim> > UpdateUserProfile(string userId, UpdateUserProfileRequest request) { var existedUser = await _userManager.FindByEmailAsync(userId); if (existedUser == null) { throw new Exception($"User with email: {userId} was not found"); } var claims = await _userManager.GetClaimsAsync(existedUser); if (request.FirstName != claims.Single(p => p.Type == "FirstName").Value) { await _userManager.ReplaceClaimAsync(existedUser, claims.Single(p => p.Type == "FirstName"), new Claim("FirstName", request.FirstName)); } if (request.FirstName != claims.Single(p => p.Type == "LastName").Value) { await _userManager.ReplaceClaimAsync(existedUser, claims.Single(p => p.Type == "LastName"), new Claim("LastName", request.LastName)); } if (request.FirstName != claims.Single(p => p.Type == "Phone").Value) { await _userManager.ReplaceClaimAsync(existedUser, claims.Single(p => p.Type == "Phone"), new Claim("Phone", request.Phone)); } if (request.FirstName != claims.Single(p => p.Type == "City").Value) { await _userManager.ReplaceClaimAsync(existedUser, claims.Single(p => p.Type == "City"), new Claim("City", request.City)); } var updatedClaims = await _userManager.GetClaimsAsync(existedUser); return(updatedClaims); }
public object Put(UpdateUserProfileRequest request) { if (request.Id == default(int)) { request.Id = SessionUserId; } if (SessionUserId != request.Id) // Only admins may change other users profile { EnsureIsAdmin(); } var userAuth = Db.SingleById <UserAuth>(request.Id); var userAuthUpdated = Db.SingleById <UserAuth>(request.Id).PopulateWith(request); userAuthUpdated.SetDivision(UserAuthMetaKeys.DivisionLuzern, request.DivisionLuzern); userAuthUpdated.SetDivision(UserAuthMetaKeys.DivisionStGallen, request.DivisionStGallen); userAuthUpdated.SetDivision(UserAuthMetaKeys.DivisionZürich, request.DivisionZuerich); userAuthUpdated.SetDivision(UserAuthMetaKeys.DivisionWinti, request.DivisionWinti); if (string.IsNullOrWhiteSpace(request.Password)) { userAuthRepository.UpdateUserAuth(userAuth, userAuthUpdated); } else { userAuthRepository.UpdateUserAuth(userAuth, userAuthUpdated, request.Password); } return(Db.SingleById <UserAuth>(request.Id).ToUserProfileResponse()); }
internal UpdateUserProfileResponse UpdateUserProfile(UpdateUserProfileRequest request) { var marshaller = new UpdateUserProfileRequestMarshaller(); var unmarshaller = UpdateUserProfileResponseUnmarshaller.Instance; return(Invoke <UpdateUserProfileRequest, UpdateUserProfileResponse>(request, marshaller, unmarshaller)); }
public async Task <CreateUserProfileResponse> UpdateProfile(UpdateUserProfileRequest user) { IsBusy = true; try { var res = await userProfileAPI.UpdateUserProfile(user); if (res != null) { if (res.Code == 0) { return(res); } else { return(null); } } return(null); } catch (Exception ex) { throw; } finally { IsBusy = false; } }
public IEnumerator UpdateUserProfile(string @namespace, string userAccessToken, UpdateUserProfileRequest updateRequest, ResultCallback <UserProfile> callback) { Report.GetFunctionLog(this.GetType().Name); Assert.IsNotNull(@namespace, "Can't update user profile! Namespace parameter is null!"); Assert.IsNotNull(userAccessToken, "Can't update user profile! UserAccessToken parameter is null!"); Assert.IsNotNull(updateRequest, "Can't update user profile! ProfileRequest parameter is null!"); var request = HttpRequestBuilder .CreatePut(this.baseUrl + "/v1/public/namespaces/{namespace}/users/me/profiles") .WithPathParam("namespace", @namespace) .WithBearerAuth(userAccessToken) .WithContentType(MediaType.ApplicationJson) .Accepts(MediaType.ApplicationJson) .WithBody(updateRequest.ToUtf8Json()) .GetResult(); IHttpResponse response = null; yield return(this.httpClient.SendRequest(request, rsp => response = rsp)); var result = response.TryParseJson <UserProfile>(); callback.Try(result); }
public async Task UpdateUser_ResponseStatus_204(UpdateUserProfileRequest request) { // Arrange var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, "anuviswan"), }, "mock")); var userProfileEntity = Mapper.Map <UserProfileEntity>(request); var mockUserProfileService = new Mock <IUserProfileService>(); mockUserProfileService.Setup(x => x.UpdateUserAsync(It.IsAny <UserProfileEntity>())) .Returns(Task.FromResult(true)); var userController = new UserController(Mapper, mockUserProfileService.Object, null, null); userController.ControllerContext.HttpContext = new DefaultHttpContext { User = user }; MockModelState(request, userController); // Act var response = await userController.UpdateUser(request); // Assert Assert.IsType <NoContentResult>(response); }
public override async Task <Empty> UpdateUserProfile(UpdateUserProfileRequest request, ServerCallContext context) { var updateUserProfileCommand = _mapper.Map <UpdateUserProfileCommand>(request); var response = await _mediator.Send(updateUserProfileCommand); return(new Empty()); }
public async Task <IActionResult> UpdateProfile(int profileId, [FromBody] UpdateUserProfileRequest request) { var updateUserProfileCommand = new UpdateUserProfileCommand(profileId, request); var result = await mediator.Send(updateUserProfileCommand); return(StatusCode((int)result.Code, result.Value)); }
public async Task <CreateUserProfileResponse> UpdateUserProfile(UpdateUserProfileRequest user) { string url = $"/users/update"; var requestBody = await Task.Run(() => JsonConvert.SerializeObject(user)); using (HttpClient httpClient = new HttpClient()) { CreateUserProfileResponse data = new CreateUserProfileResponse(); try { var authHeader = new AuthenticationHeaderValue("Bearer", await SecureStorage.GetAsync("auth_token")); httpClient.DefaultRequestHeaders.Authorization = authHeader; httpClient.BaseAddress = new Uri(Constants.BaseUrl); StringContent content = new StringContent(requestBody, Encoding.UTF8, "application/json"); HttpResponseMessage result = await httpClient.PostAsync(url, content); string response = await result.Content.ReadAsStringAsync(); data = JsonConvert.DeserializeObject <CreateUserProfileResponse>(response); if (result.IsSuccessStatusCode && result.StatusCode == HttpStatusCode.OK) { return(data); } return(null); } catch (Exception exp) { return(null); } } }
public async Task UpdateUserProfile(UpdateUserProfileRequest request) { CurrentUser currentUser = MemoryCache.Default["currentUser"] as CurrentUser; User user = await _unitOfWork.Users.All() .FirstOrDefaultAsync(x => x.Id == currentUser.Id); if (user == null) { throw new NotFoundException(); } bool userEmailExists = _unitOfWork.Users.All() .Any(x => x.Email == request.Email && x.Id != user.Id); if (userEmailExists) { throw new BadRequestException(); } user.Name = request.Name; user.Email = request.Email; user.City = request.City; user.Phone = request.Phone; _unitOfWork.Users.Update(user); await _unitOfWork.SaveAsync(); }
/// <summary> /// Initiates the asynchronous execution of the UpdateUserProfile operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UpdateUserProfile operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/codestar-2017-04-19/UpdateUserProfile">REST API Reference for UpdateUserProfile Operation</seealso> public Task <UpdateUserProfileResponse> UpdateUserProfileAsync(UpdateUserProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new UpdateUserProfileRequestMarshaller(); var unmarshaller = UpdateUserProfileResponseUnmarshaller.Instance; return(InvokeAsync <UpdateUserProfileRequest, UpdateUserProfileResponse>(request, marshaller, unmarshaller, cancellationToken)); }
/// <summary> /// Initiates the asynchronous execution of the UpdateUserProfile operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the UpdateUserProfile operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/codestar-2017-04-19/UpdateUserProfile">REST API Reference for UpdateUserProfile Operation</seealso> public virtual Task <UpdateUserProfileResponse> UpdateUserProfileAsync(UpdateUserProfileRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUserProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUserProfileResponseUnmarshaller.Instance; return(InvokeAsync <UpdateUserProfileResponse>(request, options, cancellationToken)); }
internal virtual UpdateUserProfileResponse UpdateUserProfile(UpdateUserProfileRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = UpdateUserProfileRequestMarshaller.Instance; options.ResponseUnmarshaller = UpdateUserProfileResponseUnmarshaller.Instance; return(Invoke <UpdateUserProfileResponse>(request, options)); }
public Domain.Result Update(Guid id, UpdateUserProfileRequest request) { var userProfile = _repository.Load(id); var result = userProfile.UpdateDisplayName(request.DisplayName); _meetupReadModelUpdater.OnUserDisplayNameUpdated(userProfile); _repository.Commit(); return(result); }
public async Task <IActionResult> UpdateUserInfo(UpdateUserProfileRequest profileRequest) { var userId = HttpContext.User.Claims.FirstOrDefault(r => r.Type == ClaimTypes.NameIdentifier)?.Value; var user = await _userManager.GetById(userId); var toInsert = profileRequest.MergeToModel(user); await _userManager.UpdateProfileAsync(toInsert); return(Ok(UserProfileRequest.Create(toInsert))); }
public IActionResult Update(Guid id, UpdateUserProfileRequest request) { var result = _applicationService.Update(id, request); if (result.Success) { return(Ok()); } else { return(BadRequest(new { Error = result.ErrorMessage })); } }
public void UpdateUserProfileWithPassword() { var client = ClientHelper.GetClient(); var request = new UpdateUserProfileRequest { Id = 1336, Email = "*****@*****.**", FirstName = "Oliver2", LastName = "Zürcher2", Password = "******" }; var response = client.Put(request); Assert.AreEqual(request.Email, response.Email); Assert.AreEqual(request.FirstName, response.FirstName); Assert.AreEqual(request.LastName, response.LastName); }
public void UpdateProfileFirstNameTest() { // Arrange UpdateUserProfileRequest req = new UpdateUserProfileRequest(); req.Properties.Add("firstName", newFirstName); // Act BaseResponse res = secAuthSvc.User.UpdateUserProfile(goodUsername, req); // Assert Assert.AreEqual(Constants.ResponseStatus.Success, res.Status); }
public void UpdateProfileKBTest() { // Arrange UpdateUserProfileRequest req = new UpdateUserProfileRequest(); req.KnowledgeBase.Add("kbq1", new KbProperty("Which Voltron lion is your favorite?", "The black one")); // Act BaseResponse res = secAuthSvc.User.UpdateUserProfile(goodUsername, req); // Assert Assert.AreEqual(Constants.ResponseStatus.Success, res.Status); }
public async Task <ActionResult <string> > UpdateUserProfile([FromBody] UpdateUserProfileRequest request) { var userId = Request.Headers.GetEmailFromDecodedToken(); var updatedClaims = await _authService.UpdateUserProfile(userId, request); var token = GenerateJwt(updatedClaims); var response = new { access_token = token }; var result = JsonConvert.SerializeObject(response); return(Ok(result)); }
/// <summary> /// Update some fields of user profile for current logged in user. /// </summary> /// <param name="updateRequest">User profile details to update user profile</param> /// <param name="callback">Returns a Result that contains UserProfile via callback when completed</param> public void UpdateUserProfile(UpdateUserProfileRequest updateRequest, ResultCallback <UserProfile> callback) { Report.GetFunctionLog(this.GetType().Name); if (!this.session.IsValid()) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.coroutineRunner.Run( this.api.UpdateUserProfile(this.@namespace, this.session.AuthorizationToken, updateRequest, callback)); }
/// <summary> /// Obtain user profile information from the user interface. /// </summary> /// <returns> User profile request from user interfaces.</returns> UpdateUserProfileRequest GetUserProfileRequestFromUI() { UpdateUserProfileRequest request = new UpdateUserProfileRequest { firstName = _inputFields.firstName.text, lastName = _inputFields.lastName.text, dateOfBirth = _inputFields.dateOfBirth.text, timeZone = _inputFields.timeZone.text, language = _inputFields.language.text, avatarUrl = _inputFields.avatarUrl.text }; return(request); }
/// <summary> /// Update some fields of user profile for current logged in user. /// </summary> /// <param name="updateRequest">User profile details to update user profile</param> /// <param name="callback">Returns a Result that contains UserProfile via callback when completed</param> public void UpdateUserProfile(UpdateUserProfileRequest updateRequest, ResultCallback <UserProfile> callback) { if (!this.user.IsLoggedIn) { callback.TryError(ErrorCode.IsNotLoggedIn); return; } this.taskDispatcher.Start( Task.Retry( cb => this.api.UpdateUserProfile(this.@namespace, this.user.AccessToken, updateRequest, result => cb(result)), result => this.coroutineRunner.Run(() => callback((Result <UserProfile>)result)), null)); }
public UpdateUserProfileResponse EditUserProfile(UpdateUserProfileRequest updateUserProfileRequest) { UpdateUserProfileResponse updateUserProfileResponse = null; if (updateUserProfileRequest.Id == updateUserProfileRequest.UserProfile.Id) { var userprofile = _messageMapper.MapToUserProfile(updateUserProfileRequest.UserProfile); _userprofileRepository.UpdateUserProfile(userprofile); var userprofileDto = _messageMapper.MapToUserProfileDto(userprofile); updateUserProfileResponse = new UpdateUserProfileResponse { }; } return(updateUserProfileResponse); }
public async Task <IActionResult> UpdateUser(UpdateUserProfileRequest user) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userName = User.Identity.Name; var userProfileEntity = Mapper.Map <UserProfileEntity>(user) with { UserName = userName }; var _ = await _userProfileService.UpdateUserAsync(userProfileEntity); return(NoContent()); }
public async Task <IActionResult> Update([FromRoute] string userId, [FromBody] UpdateUserProfileRequest updateUserProfile) { if (userId != User.FindFirst("Id").Value) { return(Unauthorized()); } var userFromRepo = await _repo.GetUser(userId); _mapper.Map(updateUserProfile, userFromRepo); if (await _repo.SaveAll()) { return(NoContent()); } return(NotFound()); }
/// <summary> /// Updates the user. /// </summary> /// <param name="details">The details.</param> /// <param name="request">The request.</param> /// <returns></returns> public async Task <APIResponse> UpdateUserProfile(ProfileIdDetails details, UpdateUserProfileRequest request) { try { string filename = ""; var folderName = Path.Combine("UserProfiles"); var pathToSave = Path.Combine("D:", "HappyWedding", folderName); if (request.ProfilePhoto.Length > 0) { string format = System.IO.Path.GetExtension(request.ProfilePhoto.FileName); filename = request.UserId + "_UserProfiles_" + DateTime.Now + format; string filenme = filename.Replace(":", "."); var filePath = Path.Combine(pathToSave, filenme); using var fileStream = new FileStream(filePath, FileMode.Create); request.ProfilePhoto.CopyTo(fileStream); request.Photo = filePath; request.ProfilePhoto = null; } var client = httpClientFactory.CreateClient(IdentityServiceOperation.serviceName); var param = JsonConvert.SerializeObject(request); HttpContent contentPost = new StringContent(param, Encoding.UTF8, "application/json"); var response = await client.PutAsync(servicesConfig.Identity + IdentityServiceOperation.UpdateUser(details.ProfileId), contentPost); if (response.StatusCode == HttpStatusCode.NoContent) { var user = new User { Id = details.ProfileId, FirstName = request.FirstName, LastName = request.LastName }; usernameUpdateSender.SendUserName(user); } return(JsonConvert.DeserializeObject <APIResponse>(await response.Content.ReadAsStringAsync())); } catch (Exception ex) { logger.Error(ex, "Exception in method 'UpdateUser()'"); var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message; return(new APIResponse(exMessage, HttpStatusCode.InternalServerError)); } }
public async Task UpdateUser_ResponseStatus_400(UpdateUserProfileRequest request) { // Arrange var userProfileEntity = Mapper.Map <UserProfileEntity>(request); var mockUserProfileService = new Mock <IUserProfileService>(); mockUserProfileService.Setup(x => x.UpdateUserAsync(It.IsAny <UserProfileEntity>())) .Returns(Task.FromResult(true)); var userController = new UserController(Mapper, mockUserProfileService.Object, null, null); MockModelState(request, userController); // Act var response = await userController.UpdateUser(request); // Assert var badObjectResult = Assert.IsType <BadRequestObjectResult>(response); }
public async Task UpdateProfileAsync(int loggedUser, UpdateUserProfileRequest userProfileRequest) { var user = await _uow.UserRepository.GetAsync(loggedUser); if (user == null) { throw new NotFoundException(ExceptionConstants.NOT_FOUND, "User"); } var existUsername = await _uow.UserRepository.FindAsync(u => u.Username == userProfileRequest.Username && u.Id != loggedUser); if (existUsername != null) { throw new AlreadyExistsException("Username is already in use."); } user.Username = userProfileRequest.Username; user.FullName = userProfileRequest.FullName; user.Phone = userProfileRequest.Phone; _uow.UserRepository.Update(user); await _uow.CommitAsync(); }