public virtual async Task <ProfileDto> UpdateAsync(UpdateProfileDto input)
{
var user = await UserManager.GetByIdAsync(CurrentUser.GetId());
if (await SettingProvider.IsTrueAsync(IdentitySettingNames.User.IsUserNameUpdateEnabled))
{
(await UserManager.SetUserNameAsync(user, input.UserName)).CheckErrors();
}
if (await SettingProvider.IsTrueAsync(IdentitySettingNames.User.IsEmailUpdateEnabled))
{
(await UserManager.SetEmailAsync(user, input.Email)).CheckErrors();
}
(await UserManager.SetPhoneNumberAsync(user, input.PhoneNumber)).CheckErrors();
user.Name = input.Name;
user.Surname = input.Surname;
input.MapExtraPropertiesTo(user);
(await UserManager.UpdateAsync(user)).CheckErrors();
await CurrentUnitOfWork.SaveChangesAsync();
return(ObjectMapper.Map <IdentityUser, ProfileDto>(user));
}
public async Task GetProfile_WhenUserIsAuthenticated_ShouldReturnValidProfile()
{
// Arrange
await AuthenticateAsync();
var updatedProfileDto = new UpdateProfileDto
{
FirstName = "Test firstname",
LastName = "Test lastName",
Informations = "Test informations"
};
await UpdateUserProfileAsync(updatedProfileDto);
Guid userId = await GetUserIdAsync();
// Act
var response = await TestClient.GetAsync($"UserProfile/{userId}");
var responseString = await response.Content.ReadAsStringAsync();
var profile = JsonConvert.DeserializeObject <UserProfileBaseDto>(responseString);
// Assert
profile.FirstName
.Should()
.BeEquivalentTo(updatedProfileDto.FirstName);
profile.LastName
.Should()
.BeEquivalentTo(updatedProfileDto.LastName);
}
public async Task UpdateAsync()
{
//Arrange
_currentUser.Id.Returns(_testData.UserJohnId);
_currentUser.IsAuthenticated.Returns(true);
var input = new UpdateProfileDto
{
UserName = CreateRandomString(),
PhoneNumber = CreateRandomPhoneNumber(),
Email = CreateRandomEmail(),
Name = CreateRandomString(),
Surname = CreateRandomString()
};
//Act
var result = await _profileAppService.UpdateAsync(input);
//Assert
result.UserName.ShouldBe(input.UserName);
result.Email.ShouldBe(input.Email);
result.PhoneNumber.ShouldBe(input.PhoneNumber);
result.Surname.ShouldBe(input.Surname);
result.Name.ShouldBe(input.Name);
}
public async Task <ActionResult> UpdateProfile([FromBody] UpdateProfileDto model)
{
ApplicationUser result;
try
{
var currentUserId = _authRepo.GetCurrentUser();
var user = await _authRepo.GetUserById(currentUserId);
if (user == null)
{
return(NotFound(new { Error = "User not found" }));
}
user.UserName = model.Email ?? user.UserName;
user.Email = model.Email ?? user.Email;
user.PhoneNumber = model.phoneNumber ?? user.PhoneNumber;
result = await _authRepo.UpdateProfile(user);
}
catch (Exception e)
{
_logger.LogError(e.InnerException?.ToString() ?? e.Message);
return(StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error"));
}
return(Ok(result));
}
public async Task <IActionResult> UpdateInfo([FromBody] UpdateProfileDto update)
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var user = await _userManager.FindByIdAsync(userId);
user.Address = update.Address;
user.Birthday = DateTime.ParseExact(update.Birthday, "yyyy-MM-dd", CultureInfo.InvariantCulture);
user.FirstName = update.FirstName;
user.LastName = update.LastName;
user.PhoneNumber = update.PhoneNumber;
user.ImageUrl = update.ImageUrl;
user.CardNumber = update.CardNumber;
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest("Cannot update profile info"));
}
var profile = _mapper.Map <UserProfile>(user);
return(Ok(ResponseDto <UserProfile> .Ok(profile)));
}
public async Task <string> UpdateProfile(string userId, UpdateProfileDto updateProfileDto)
{
var user = await GetUserById(userId);
if (user == null)
{
throw new AuthenticationException();
}
// if (!user.Email.Equals(updateProfileDto.Email))
// {
// var result = await _userManager.SetEmailAsync(user, updateProfileDto.Email);
//
// if (!result.Succeeded)
// throw new ArgumentException("Failed to update");
// }
user.FirstName = updateProfileDto.FirstName;
user.LastName = updateProfileDto.LastName;
user.Email = updateProfileDto.Email;
user.About = updateProfileDto.About;
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
throw new ArgumentException("Failed to update");
}
return(await GenerateJwtToken(user));
}
public virtual async Task <ProfileDto> UpdateAsync(UpdateProfileDto input)
{
return(await RequestAsync <ProfileDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
{
{ typeof(UpdateProfileDto), input }
}));
}
/// <summary>
/// 更新基本信息
/// </summary>
/// <param name="parameters">请求参数</param>
/// <returns>Task<ProfileDto>.</returns>
public async Task <ProfileDto> Update(UpdateProfileDto parameters)
{
var result = await _appService.UpdateAsync(parameters);
_cacheProvider.RemoveAsync(string.Format("FindById_{0}", _currentUser.GetId()));
_cacheProvider.RemoveAsync(string.Format("FindByUserName_{0}", result.UserName));
return(result);
}
public UnifyResponseDto SetProfileInfo(UpdateProfileDto updateProfileDto)
{
_freeSql.Update <LinUser>(_currentUser.Id).Set(a => new LinUser()
{
Nickname = updateProfileDto.Nickname,
Introduction = updateProfileDto.Introduction
}).ExecuteAffrows();
return(UnifyResponseDto.Success("更新基本信息成功"));
}
private async Task <Result> UpdateProfile(UpdateProfileDto updateProfileDto, User user)
{
user.Modified = DateTime.UtcNow;
user.FirstName = updateProfileDto.FirstName;
user.LastName = updateProfileDto.LastName;
var identityResult = await _userManager.UpdateAsync(user);
return(identityResult.ToResult());
}
public void UpdateProfile(UpdateProfileDto updateProfileDto)
{
UpdateProfileValidate(updateProfileDto);
var profile = GetProfile(updateProfileDto.Id);
_mapper.Map(updateProfileDto, profile);
_dbContext.SaveChanges();
}
public async Task UpdateProfileAsync(UpdateProfileDto updateProfileDto)
{
UpdateProfileValidate(updateProfileDto);
var profile = await GetProfileAsync(updateProfileDto.Id);
_mapper.Map(updateProfileDto, profile);
await _dbContext.SaveChangesAsync();
}
protected virtual async Task <IActionResult> UpdateProfile(Profile profile, UpdateProfileDto model, bool updateAdminNotes)
{
var adminNotes = profile.AdminNotes;
var updatedProfile = _mapper.Map(model, profile);
if (!updateAdminNotes)
{
// restore from original
updatedProfile.AdminNotes = adminNotes;
// updating self - set as onboarded
updatedProfile.HasOnboarded = true;
}
if (!updatedProfile.IsDropOffPoint.GetValueOrDefault())
{
updatedProfile.Address = null;
updatedProfile.Address2 = null;
}
try
{
var googleAddress = await GeoCodeLocation(updatedProfile);
updatedProfile.Latitude = googleAddress?.Coordinates.Latitude ?? 0;
updatedProfile.Longitude = googleAddress?.Coordinates.Longitude ?? 0;
updatedProfile.Location = new Point(googleAddress?.Coordinates.Longitude ?? 0,
googleAddress?.Coordinates.Latitude ?? 0)
{
SRID = 4326
};
}
catch (Exception exc)
{
Logger.LogError(exc, $"Error encoding location via google api for {JsonConvert.SerializeObject(updatedProfile, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore })} - Exception: {JsonConvert.SerializeObject(exc, Formatting.Indented, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore })}");
}
if (updatedProfile.Id > 0)
{
_context.Entry(updatedProfile).State = EntityState.Modified;
}
else if (!string.IsNullOrWhiteSpace(User.Identity.Name))
{
updatedProfile.CreatedDate = DateTime.Now;
updatedProfile.Auth0Id = User.Identity.Name;
_context.Profiles.Add(updatedProfile);
}
else
{
throw new UnauthorizedAccessException();
}
await _context.SaveChangesAsync();
return(Ok(true));
}
public async Task <IActionResult> PostUser([FromBody] UpdateProfileDto request)
{
var update = request.ToUpdate();
var user = await userStore.UpsertAsync(App.Id, UserId, update, HttpContext.RequestAborted);
var response = ProfileDto.FromDomainObject(user !, App);
return(Ok(response));
}
public async Task <ProfileDto> UpdateProfile(UpdateProfileDto input)
{
var user = await UserManager.GetUserByIdAsync(AbpSession.UserId.Value);
await Validate(user, input);
ObjectMapper.Map(input, user);
CheckErrors(await UserManager.UpdateAsync(user));
return(ObjectMapper.Map <ProfileDto>(user));
}
public IActionResult UpdateProfile(UpdateProfileDto profile)
{
var result = _memberService.UpdateProfile(profile);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result.Message));
}
public async Task UpdateProfileAsync(Guid userId, UpdateProfileDto profileDto)
{
var user = await _userRepository.GetAsync(userId);
CheckIfUserExists(user);
user.Profile.FirstName = profileDto.FirstName;
user.Profile.LastName = profileDto.LastName;
user.Profile.Informations = profileDto.Informations;
await _userRepository.UpdateAsync(user);
}
public void UpdateProfile(UpdateProfileDto updateProfile, int userId)
{
var checkForUser = _stationeryContext.Users.FindAsync(userId);
if (checkForUser == null)
{
throw new AppException("User not found");
}
// _stationeryContext.Users.Update(checkForUser);
}
public async Task <IActionResult> PutProfileById(int id, UpdateProfileDto model)
{
if (model.Id != id)
{
return(BadRequest("Profile doesn't match."));
}
var profile = await _context.Profiles.FirstOrDefaultAsync(p => p.Id == id);
return(await UpdateProfile(profile, model, true));
}
public async Task <IActionResult> ChangeProfileInformation([FromBody] UpdateProfileDto updateProfileDto)
{
var result = await _profileService.UpdateProfile(updateProfileDto, UserId);
if (!result.Succedeed)
{
return(BadRequest());
}
return(NoContent());
}
private void UpdateProfileValidate(UpdateProfileDto updateProfileDto)
{
if (updateProfileDto == null)
{
throw new ArgumentNullException(nameof(updateProfileDto));
}
if (!updateProfileDto.Validate())
{
throw new InvalidOperationException();
}
}
public string Execute(UpdateProfileDto dto)
{
string result = Messages.ErenOK;
User user = unit.User.Get(dto.Id);
user.Name = dto.Name;
user.FamilyName = dto.FamilyName;
user.CityId = dto.CityId;
unit.Complete();
return(result);
}
public async Task <ActionResult <GetProfileDto> > Update([FromRoute] int id, [FromBody] UpdateProfileDto profile)
{
var command = new UpdateProfileCommand(id, profile);
var result = await Mediator.Send(command);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task <IActionResult> Edit(UpdateProfileDto model)
{
if (ModelState.IsValid)
{
updateProfile.Execute(model);
return(RedirectToAction("Index"));
}
else
{
return(View(model));
}
}
//[Authorize]
//[HttpPost]
//public async Task<IActionResult> Create(CreateUserModel model)
//{
// User user = new Core.Domains.User {AccessFailedCount=0,Address="",ConcurrencyStamp="",Email="*****@*****.**" ,EmailConfirmed=true,FamilyName=model.FamilyName,LockoutEnabled=false,Name=model.Name,NormalizedEmail="*****@*****.**",NormalizedUserName=model.Mobile,PasswordHash = Api.EncryptPassword(model.Password),PhoneNumber=model.Mobile,PhoneNumberConfirmed=true,RegisterDate=Utility.UnixTimeNow(),StationId=model.StationId,TwoFactorEnabled=false,UserName=model.Mobile,SecurityStamp =""};
// unit.User.Add(user);
// unit.Complete();
// var roleCheck1 = await roleManager.RoleExistsAsync("کاربر پنل");
// if (!roleCheck1)
// {
// var roleResult = await roleManager.CreateAsync(new Role("کاربر پنل"));
// }
//[Authorize]
public IActionResult Edit(Guid UserId)
{
var user = unit.User.GetByUserId(UserId);
UpdateProfileDto up = new UpdateProfileDto
{
Name = user.Name,
FamilyName = user.FamilyName,
CityId = user.CityId,
Id = UserId
};
return(View(up));
}
public async Task <ActionResult> UpdateProfile(UpdateProfileDto updateProfileDto)
{
try
{
await _profileService.UpdateProfileAsync(updateProfileDto);
}
catch
{
return(BadRequest());
}
return(NoContent());
}
public async Task <IActionResult> PutProfile(UpdateProfileDto model)
{
var profile = await GetLoggedInProfile();
if (model.Id == 0)
{
model.Id = profile.Id;
}
else if (model.Id != profile.Id)
{
throw new UnauthorizedAccessException();
}
return(await UpdateProfile(profile, model, false));
}
public async Task <IActionResult> PersonalData()
{
var user = await _userManager.GetUserAsync(User);
var updateProfile = new UpdateProfileDto
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PhoneNumber = user.PhoneNumber
};
return(View(updateProfile));
}
public async Task <IActionResult> PersonalData(UpdateProfileDto updateProfile)
{
AppUser user = await _userManager.GetUserAsync(User);
user.FirstName = updateProfile.FirstName;
user.LastName = updateProfile.LastName;
user.PhoneNumber = updateProfile.PhoneNumber;
user.Email = updateProfile.Email;
user.UserName = updateProfile.Email;
await _userManager.UpdateAsync(user);
return(View());
}
public BaseApiResult Execute(UpdateProfileDto dto)
{
User user = unit.User.Get(dto.Id);
user.Name = dto.Name;
user.FamilyName = dto.FamilyName;
user.CityId = dto.CityId;
unit.Complete();
return(new BaseApiResult
{
Message = Messages.OK,
Status = true
});
}
