public async Task <IActionResult> EditAsync([FromRoute] int profileId, [FromBody] UpdateProfileRequest model) { if (CurrentUser == null) { return(BadRequest(new { ErrorMessage = "Unauthorized" })); } var profile = await _profileService.GetProfile(profileId); if (!profile.Profile.UserId.Equals(CurrentUser.Id)) { return(BadRequest(new { ErrorMessage = "You are not allowed to edit profile." })); } profile.Profile.User.Email = model.Email; profile.Profile.User.FirstName = model.FirstName; profile.Profile.User.LastName = model.LastName; profile.Profile.User.PhoneNumber = model.PhoneNumber; profile.Profile.About = model.About; _profileService.Update(profile.Profile); var editedProfile = await _profileService.GetProfile(profileId); return(Ok(_mapper.Map <ApplicationUserResponse>(editedProfile))); }
public ProfileViewModel(UserItem user) { User = user; Profile = new UpdateProfileRequest(); image = new ImageItem(); byteimage = new byte[4]; }
public async Task <Response <UpdateProfileResponse> > updateuser(UpdateProfileRequest request) { string userlogin = string.Empty; string token = Request.Headers["Authorization"]; // Get user login from token var info = this._authService.checkToken(token); Response <UpdateProfileResponse> response = new Response <UpdateProfileResponse>(); UploadStatus statusUpload = new UploadStatus(); if (!string.IsNullOrEmpty(info.Username)) { if (request.File != null && request.File.Length > 0) { statusUpload = await this.uploadFile(request.File, request.UserName + ".png"); if (statusUpload.Status) { return(await this._authService.updateUser(request, statusUpload.FileName)); } response.message_type = 2; response.message = statusUpload.FileName;// Error upload file profile } return(await this._authService.updateUser(request, statusUpload.FileName)); } else { response.message_type = 2; response.message = "Unauthorize"; } return(response); }
public HttpResponseMessage Update([FromBody] UpdateProfileRequest request) { UserProfileManager profileMan = new UserProfileManager(); var response = profileMan.UpdateUserProfile(request); return(response); }
public async Task <ActionResult <UserResponse> > UpdateProfile([FromBody] UpdateProfileRequest request) { var login = User.Identity.Name; var users = await db.Users.AsNoTracking().ToListAsync(); var user = users.Find(x => x.Login == login); if (user == null) { return(StatusCode(400, "There is not the user")); } var updatedUser = new User { Id = user.Id, Login = !string.IsNullOrEmpty(request.Login) ? request.Login : user.Login, Password = !string.IsNullOrEmpty(request.Password) ? request.Password : user.Password, Name = request.Name, Surname = request.Surname }; db.Update(updatedUser); await db.SaveChangesAsync(); return(new UserResponse { Name = updatedUser.Name, Surname = updatedUser.Surname }); }
public async Task <UpdateProfileResponse> UpdateProfile(UpdateProfileRequest request) { var response = new UpdateProfileResponse(); var user = await _sessionManager.GetUser(); var dbRequest = new Repositories.DatabaseRepos.UserRepo.Models.UpdateUserRequest() { Id = user.Id, Username = request.Username, Email_Address = request.EmailAddress, First_Name = request.FirstName, Last_Name = request.LastName, Mobile_Number = request.MobileNumber, Updated_By = user.Id }; using (var uow = _uowFactory.GetUnitOfWork()) { await uow.UserRepo.UpdateUser(dbRequest); uow.Commit(); } await _sessionManager.DehydrateSession(); // user has changed await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest() { EventKey = SessionEventKeys.UserUpdatedProfile, }); response.Notifications.Add("Profile updated successfully", NotificationTypeEnum.Success); return(response); }
public UpdateProfileResponse UpdateProfile(UpdateProfileRequest request) { request.mobile_number = Common.GetStandardMobileNumber(request.mobile_number); UpdateProfileResponse response = new UpdateProfileResponse(); try { if (!CheckAuthDriver(request.user_id, request.auth_token)) { MakeNoDriverResponse(response); return(response); } using (DriverDao dao = new DriverDao()) { Driver driver = dao.FindById(request.user_id); driver.DriverName = request.driver_name; //driver.MobileNumber = request.mobile_number; //driver.ProfileImage = request.profile_image; //Commented bcz image is uploading as multipart dao.Update(driver); response.code = 0; response.has_resource = 0; response.message = MessagesSource.GetMessage("profile.changed"); return(response); } } catch (Exception ex) { response.MakeExceptionResponse(ex); return(response); } }
public void Put(string id, UpdateProfileRequest body) { var areArgumentsValid = !string.IsNullOrEmpty(id) && body != null && !string.IsNullOrEmpty(body.Name); if (!areArgumentsValid) { return; } // HACK: Uncomment it when we done the authentication //var currentUserId = User.Identity.Name; //if (currentUserId != id) return; var userProfile = _userProfileRepo.GetUserProfileById(id); var isUserProfileValid = userProfile != null && !userProfile.DeletedDate.HasValue; if (!isUserProfileValid) { return; } userProfile.Name = body.Name; userProfile.SchoolName = body.SchoolName; userProfile.IsPrivateAccount = body.IsPrivate; userProfile.CourseReminder = body.IsReminderOnceTime ? UserProfile.ReminderFrequency.Once: UserProfile.ReminderFrequency.Twice; _userProfileRepo.UpsertUserProfile(userProfile); }
public async Task <Response <UpdateProfileResponse> > updateProfile(UpdateProfileRequest request, string fileProfile) { Response <UpdateProfileResponse> response = new Response <UpdateProfileResponse>(); try { if (!string.IsNullOrWhiteSpace(request.UserName)) { UserProfile user = await this._userManager.FindByNameAsync(request.UserName); //if (string.IsNullOrWhiteSpace(user.ProfilePicture)) //{ if (!string.IsNullOrWhiteSpace(fileProfile)) { user.ProfilePicture = fileProfile; } //} user.FullName = request.Namalengkap; user.Email = request.Email; user.PhoneNumber = request.NoTelp; this.Db.Users.Update(user); this.Db.SaveChanges(); } } catch (Exception exc) { response.message = exc.Message; response.message_type = 2; } return(response); }
public async Task Edit(string currentPassword = "", string username = null, string email = null, string password = null, Stream avatar = null, ImageType avatarType = ImageType.Png) { if (currentPassword == null) throw new ArgumentNullException(nameof(currentPassword)); var request = new UpdateProfileRequest() { CurrentPassword = currentPassword, Email = email ?? Email, Password = password, Username = username ?? Client.PrivateUser.Name, AvatarBase64 = avatar.Base64(avatarType, Client.PrivateUser.AvatarId) }; await Client.ClientAPI.Send(request).ConfigureAwait(false); if (password != null) { var loginRequest = new LoginRequest() { Email = Email, Password = password }; var loginResponse = await Client.ClientAPI.Send(loginRequest).ConfigureAwait(false); Client.ClientAPI.Token = loginResponse.Token; Client.GatewaySocket.Token = loginResponse.Token; Client.GatewaySocket.SessionId = null; } }
public ActionResult Edit(EditProfileViewModel model) { if (ModelState.IsValid) { var userService = new UserService(); var user = userService.GetUserByAccountId(new GetUserByAccountIdRequest() { AccountId = User.Identity.GetUserId() }).User; if (user != null) { var request = new UpdateProfileRequest { Id = user.Id, Description = model.Description, Phone = model.Phone, FullName = model.FullName, ShowData = model.ShowData }; var response = userService.UpdateProfile(request); return(RedirectToAction("Index", "Manage")); } } return(View(model)); }
public async Task UpdateProfileAsync2() { Mock <ProfileService.ProfileServiceClient> mockGrpcClient = new Mock <ProfileService.ProfileServiceClient>(MockBehavior.Strict); UpdateProfileRequest request = new UpdateProfileRequest { Profile = new Profile(), }; Profile expectedResponse = new Profile { ProfileName = new ProfileName("[PROJECT]", "[TENANT]", "[PROFILE]"), ExternalId = "externalId-1153075697", Source = "source-896505829", Uri = "uri116076", GroupId = "groupId506361563", Processed = true, KeywordSnippet = "keywordSnippet1325317319", }; mockGrpcClient.Setup(x => x.UpdateProfileAsync(request, It.IsAny <CallOptions>())) .Returns(new Grpc.Core.AsyncUnaryCall <Profile>(Task.FromResult(expectedResponse), null, null, null, null)); ProfileServiceClient client = new ProfileServiceClientImpl(mockGrpcClient.Object, null); Profile response = await client.UpdateProfileAsync(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public UpdateProfileResponse UpdateProfile(UpdateProfileRequest request) { UpdateProfileResponse response = new UpdateProfileResponse(); User user = _userRepository.Get(request.Id); if (user == null) { response.HasError = true; return(response); } user.Email = request.UsersUpdateModel.Email; user.FirstName = request.UsersUpdateModel.FirstName; user.LastName = request.UsersUpdateModel.LastName; // Security Questions foreach (var question in request.UsersUpdateModel.SecurityQuestions.Where(q => q.Answer.IsNotNullOrEmpty())) { user.UpdateQuestion(question.Id, question.Question, question.Answer); } _roleRepository.Query().Where(r => r.CustomerId == request.CustomerId).ToList().Map( request.UsersUpdateModel.SelectedRoles, r => r.AddUser(user), r => r.RemoveUser(user) ); _unitOfWork.Commit(); return(response); }
public override async Task <UpdateProfileResponse> UpdateProfile(UpdateProfileRequest request, ServerCallContext context) { var updateProfileModel = new UpdateProfileModel { ProfileId = Guid.Parse(request.ProfileId), FirstName = request.FirstName, LastName = request.LastName, PhotoThumbUrl = request.PhotoThumbUrl }; var updateProfileCommand = new UpdateProfileCommand(updateProfileModel); var result = await _commandBus.TransactionSendAsync(updateProfileCommand); if (result.IsOk) { var response = result.Value as dynamic; return(new UpdateProfileResponse { ProfileId = response.ProfileId, FirstName = response.FirstName, LastName = response.LastName, PhotoThumbUrl = response.PhotoThumbUrl, }); } var statusCode = (StatusCode)result.StatusCode; throw new RpcException(new Status(statusCode, result.Value?.ToString())); }
public async Task <IActionResult> UpdateProfile(int profileId, UpdateProfileRequest request) { var cancellation = HttpContext.RequestAborted; var profile = await _dbContext.Profiles .AsTracking() .FirstOrDefaultAsync(p => p.Id == profileId, cancellation); if (profile == null) { return(Problem( statusCode: 404, title: "Not Found", detail: $"Profile '{profileId}' not found" )); } if (User.TryGetProfileId() != profileId) { return(Problem( statusCode: 403, title: "Forbidden", detail: $"Profile '{profileId}' does not belong to the authenticated user" )); } profile.IsPublic = request.IsPublic; profile.Location = request.Location; profile.Bio = request.Bio; profile.ExternalLinks = request.ExternalLinks?.ToArray() ?? Array.Empty <string>(); await _dbContext.SaveChangesAsync(cancellation); return(Ok()); }
public async void ChangeExpression(string face, string name) { face = face.ToLower(); UpdateProfileRequest req = new UpdateProfileRequest(); req.Username = name; //Give this your bots username if you leave it blank the name will be None switch (face) { case "trump": req.AvatarBase64 = Faces.TrumpFace; break; case "hillary": req.AvatarBase64 = Faces.HillaryFace; break; case "resting": req.AvatarBase64 = Faces.RestingFace; break; } try { await _client.ClientAPI.Send(req); } catch(Exception e) { Console.WriteLine("[DISCORD API ERROR] "+e.Message); }; }
public void UpdateProfileRequestObject() { moq::Mock <ProfilerService.ProfilerServiceClient> mockGrpcClient = new moq::Mock <ProfilerService.ProfilerServiceClient>(moq::MockBehavior.Strict); UpdateProfileRequest request = new UpdateProfileRequest { Profile = new Profile(), UpdateMask = new wkt::FieldMask(), }; Profile expectedResponse = new Profile { Name = "name1c9368b0", ProfileType = ProfileType.Contention, Deployment = new Deployment(), Duration = new wkt::Duration(), ProfileBytes = proto::ByteString.CopyFromUtf8("profile_bytes12d9894a"), Labels = { { "key8a0b6e3c", "value60c16320" }, }, }; mockGrpcClient.Setup(x => x.UpdateProfile(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); ProfilerServiceClient client = new ProfilerServiceClientImpl(mockGrpcClient.Object, null); Profile response = client.UpdateProfile(request); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async stt::Task UpdateProfileRequestObjectAsync() { moq::Mock <ProfilerService.ProfilerServiceClient> mockGrpcClient = new moq::Mock <ProfilerService.ProfilerServiceClient>(moq::MockBehavior.Strict); UpdateProfileRequest request = new UpdateProfileRequest { Profile = new Profile(), UpdateMask = new wkt::FieldMask(), }; Profile expectedResponse = new Profile { Name = "name1c9368b0", ProfileType = ProfileType.Contention, Deployment = new Deployment(), Duration = new wkt::Duration(), ProfileBytes = proto::ByteString.CopyFromUtf8("profile_bytes12d9894a"), Labels = { { "key8a0b6e3c", "value60c16320" }, }, }; mockGrpcClient.Setup(x => x.UpdateProfileAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Profile>(stt::Task.FromResult(expectedResponse), null, null, null, null)); ProfilerServiceClient client = new ProfilerServiceClientImpl(mockGrpcClient.Object, null); Profile responseCallSettings = await client.UpdateProfileAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); xunit::Assert.Same(expectedResponse, responseCallSettings); Profile responseCancellationToken = await client.UpdateProfileAsync(request, st::CancellationToken.None); xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); }
public void UpdateProfile(UpdateProfileRequest request, Action <GuestControllerResult <ProfileResponse> > callback) { QueueItem item = CreateQueueItem("/client/{client-id}/guest/{swid}", HttpMethod.POST, request, GuestControllerAuthenticationType.AccessToken, callback); queue.Add(item); ExecuteNextCall(); }
public async Task Edit(string currentPassword = "", string username = null, string email = null, string password = null, Stream avatar = null, ImageType avatarType = ImageType.Png) { if (currentPassword == null) { throw new ArgumentNullException(nameof(currentPassword)); } var request = new UpdateProfileRequest() { CurrentPassword = currentPassword, Email = email ?? Email, Password = password, Username = username ?? Client.PrivateUser.Name, AvatarBase64 = avatar.Base64(avatarType, Client.PrivateUser.AvatarId) }; await Client.ClientAPI.Send(request).ConfigureAwait(false); if (password != null) { var loginRequest = new LoginRequest() { Email = Email, Password = password }; var loginResponse = await Client.ClientAPI.Send(loginRequest).ConfigureAwait(false); Client.ClientAPI.Token = loginResponse.Token; } }
/* * Updates the profile of a staff */ public ResponseErrorEnum?UpdateProfile(UpdateProfileRequest request) { try { var isEmailAlreadyUsed = _userRepository.Exists(s => s.Id != request.UserId && s.Email == request.Email); if (isEmailAlreadyUsed) { return(ResponseErrorEnum.EmailAlreadyUsed); } var user = _userRepository.GetById(request.UserId); user.FirstName = request.FirstName; user.LastName = request.LastName; user.Email = request.Email; user.PhoneNumber = request.PhoneNumber; user.Address = request.Address; _userRepository.Update(user); _userRepository.Save(); } catch { // TODO: Log the exception. return(ResponseErrorEnum.RepositoryError); } return(null); }
public void UpdateProfile2() { Mock <ProfileService.ProfileServiceClient> mockGrpcClient = new Mock <ProfileService.ProfileServiceClient>(MockBehavior.Strict); UpdateProfileRequest request = new UpdateProfileRequest { Profile = new Profile(), }; Profile expectedResponse = new Profile { ProfileName = new ProfileName("[PROJECT]", "[TENANT]", "[PROFILE]"), ExternalId = "externalId-1153075697", Source = "source-896505829", Uri = "uri116076", GroupId = "groupId506361563", ResumeHrxml = "resumeHrxml1834730555", Processed = true, KeywordSnippet = "keywordSnippet1325317319", }; mockGrpcClient.Setup(x => x.UpdateProfile(request, It.IsAny <CallOptions>())) .Returns(expectedResponse); ProfileServiceClient client = new ProfileServiceClientImpl(mockGrpcClient.Object, null); Profile response = client.UpdateProfile(request); Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public UpdateProfileResponse UpdateProfile(UpdateProfileRequest request) { UpdateProfileResponse response = new UpdateProfileResponse(); response.Errors = new List <BusinessRule>(); User user = _repository .FindBy(request.UserId); if (user != null) { try { user.FirstName = request.Firstname; user.LastName = request.Lastname; user.PhoneNumber = request.PhoneNumber; user.BirthDay = request.BirthDay; _repository.Save(user); _uow.Commit(); response.Result = true; } catch (Exception ex) { response.Errors.Add(new BusinessRule("Error", ex.Message)); response.Result = false; } } else { response.Result = false; } return(response); }
public async Task <IActionResult> UpdateProfile(UpdateProfileRequest request) { var response = await mediator.Send(request); logger.LogResponse($"User #{HttpContext.GetCurrentUserId()} updated profile", response.Error); return(response.IsSucceeded ? (IActionResult)Ok(response) : BadRequest(response)); }
public async Task <IActionResult> UpdateProfile([FromBody] UpdateProfileRequest updateProfile) { var loggedUser = User.GetUserIdFromToken(); var result = await _accountService.UpdateProfileAsync(updateProfile, loggedUser); var user = _mapper.Map <UserResponse>(result); return(Ok(new ApiOkResponse(user))); }
public async Task <IActionResult> UpdateProfile([FromBody] UpdateProfileRequest updateProfile) { var claimsIdentity = this.User.Identity as ClaimsIdentity; var userId = claimsIdentity.FindFirst(ClaimTypes.UserData)?.Value; var result = await _accountService.UpdateProfileAsync(updateProfile, int.Parse(userId)); var user = _mapper.Map <UserResponse>(result); return(Ok(new ApiOkResponse(user))); }
public async Task <IActionResult> UpdateUser([FromBody] UpdateProfileRequest request, CancellationToken cancellationToken) { var command = UpdateProfileCommand.FromRequest(_currentUserId, request); var result = await _mediator.Send(command, cancellationToken); return(result.IsSuccess ? Ok() : result.ReturnErrorResponse()); }
public void UpdateProfile(Identifier userId, UserProfileType profile) { UpdateProfileRequest request = new UpdateProfileRequest() { UserId = userId, UserProfile = profile }; CallWebService <IUserManagementServicev1_6, UpdateProfileRequest, UpdateProfileResponse>( m_service1_6, request, (s, q) => s.UpdateProfile(q)); }
public async Task <IActionResult> Update([FromBody] UpdateProfileRequest updateProfileRequest) { if (ModelState.IsValid) { var response = await _profileService.UpdateProfileAsync(updateProfileRequest.DisplayName, updateProfileRequest.Email, updateProfileRequest.Description, updateProfileRequest.GoogleId); return(response.Success ? new OkObjectResult(response.Data) : StatusCode(500)); } return(StatusCode(500)); }
public async Task <ActionResult> UpdateProfile([FromBody] UpdateProfileRequest request) { var resp = await(await factory.GetAccountClientAsync()) .UpdateProfileAsync(new AcademyCloud.Identity.Protos.Account.UpdateProfileRequest() { Email = request.Email, Name = request.Name, }); return(NoContent()); }
public async Task Profile_UpdateSuccessful() { _output.WriteLine("Update profile of user: "******"api/profile", UriKind.Relative); StringContent content = new UpdateProfileRequest { DisplayName = "abc", Street = "Abc", City = "Abc", PostalCode = "3032" }.ToStringContent(); HttpResponseMessage response = await _context.NewTestUserHttpClient.PatchAsync(url, content); response.EnsureSuccessStatusCode(); }