public async Task <IResponseEntity> UpdateAsync(UserEditRequest req)
{
if (req == null || req?.Id == "")
{
return(ResponseEntity.Error("更新的实体主键丢失"));
}
var entity = await _sysUserRepository.GetAsync(req.Id);
if (entity == null || entity.Id == "")
{
return(ResponseEntity.Error("用户不存在!"));
}
if (entity.PermissionId != req.PermissionId)
{
//清除权限模板的资源缓存
await _cache.RemoveByPatternAsync(CacheKeyTemplate.PermissionResourceList);
//清除权限模板的API缓存
await _cache.RemoveByPatternAsync(CacheKeyTemplate.PermissionApiList);
}
_mapper.Map(req, entity);
//var entity = _mapper.Map<SysUserEntity>(req);
await _sysUserRepository.UpdateAsync(entity);
return(ResponseEntity.Ok("更新成功"));
}
public void HandleUserEditRequest()
{
// Arrange
var request = new UserEditRequest {
Id = 111
};
var user = new User {
Id = 111, Username = "******", UserRole = UserRole.ProductOwner, PasswordHash = "blablabla"
};
var expectedResult = new UserQueryResult
{
Id = user.Id,
Username = user.Username,
UserRole = user.UserRole
};
_userRepo.Setup(p => p.LoadUser(request.Id)).Returns((new Success(), user));
// Act
var(status, actualResult) = _sut.HandleUserEditRequest(request);
// Assert
_userRepo.Verify(p => p.LoadUser(request.Id));
status.Should().BeOfType <Success>();
actualResult.Should().BeEquivalentTo(expectedResult);
}
/// <summary>
/// 更新当前用户基本信息
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public async Task <IResponseEntity> UpdateUserInfo(UserEditRequest req)
{
if (req == null)
{
return(ResponseEntity.Error("更新的实体丢失"));
}
//req.Id = _authUser.Id;
var entity = await _sysUserRepository.GetAsync(_authUser.Id);
if (entity == null || entity.Id == "")
{
return(ResponseEntity.Error("用户不存在!"));
}
entity.DisplayName = req.DisplayName;
entity.Mobile = req.Mobile;
entity.Mail = req.Mail;
entity.Description = req.Description;
await _sysUserRepository.UpdateAsync(entity);
return(ResponseEntity.Ok(entity));
}
public async Task <IActionResult> EditUser(int id, [FromForm] UserEditRequest model)
{
DataResponse response = new DataResponse();
try
{
if (!ModelState.IsValid)
{
response.Message = string.Join("", ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage));
return(BadRequest(response));
}
var user = await _userService.GetById(id);
if (user == null)
{
response.Message = "The user is not found.";
return(NotFound(response));
}
await _userService.Edit(user, model);
response.Success = 1;
response.Message = "The user has been edited.";
return(Ok(response));
}
catch (Exception ex)
{
response.Message = ex.Message;
return(StatusCode(500, response));
}
}
public async Task <ValidationProblemDetails> CurrentUserUpdate(String token, UserEditRequest userEditRequest)
{
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
UsersControllerClient _client = new UsersControllerClient(httpClient);
return(await _client.UpdateCurrentUserAsync(userEditRequest));
}
public async Task <object> EditUser(UserEditRequest user)
{
if (!ModelState.IsValid)
{
return(JsonResults.Error(400, ModelState.Values.FirstOrDefault().Errors.FirstOrDefault().ErrorMessage.ToString()));
}
try
{
var users = await _userService.GetUser(user.Id);
if (users == null)
{
return(JsonResults.Error(404, "It`s user not found"));
}
users.FirstName = user.FirstName;
users.LastName = user.LastName;
users.Country = user.Country;
users.City = user.City;
users.Address = user.Address;
users.Phone = user.Phone;
users.Email = user.Email;
users.Birsday = user.Birsday;
await _userService.UpdateUser(users);
return(JsonResults.Success());
}
catch (Exception ex)
{
return(JsonResults.Error(400, ex.Message));
}
}
public async Task <IActionResult> Update([FromBody] UserEditRequest userEditRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(userEditRequest));
}
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
Console.WriteLine(
userEditRequest.AvatarUrl,
userEditRequest.CurrentPassword,
userEditRequest.NewPassword,
userEditRequest.VerifyNewPassword,
userEditRequest.UserName,
userEditRequest.FullName,
userEditRequest.Email
);
var errors = await accountService.UpdateAsync(userId, userEditRequest);
if (errors.Count == 0)
{
return(Ok("Userdata updated successfully."));
}
return(BadRequest(errors));
}
public void HandleUserEditRequest()
{
// Arrange
var request = new UserEditRequest {
Id = 111
};
var user = new User {
Id = 111, Username = "******", UserRole = UserRole.ProductOwner, PasswordHash = "blablabla"
};
Action <string> dummyFailureAction = s => { };
var actualResult = new UserQueryResult();
var expectedResult = new UserQueryResult
{
Id = user.Id,
Username = user.Username,
UserRole = user.UserRole
};
_userRepo.Setup(p => p.LoadUser(request.Id, It.IsAny <Action <User> >(), dummyFailureAction))
.Callback((int id, Action <User> onSuccess, Action <string> onFailure) => onSuccess(user));
// Act
_sut.HandleUserEditRequest(request, result => actualResult = result, dummyFailureAction);
// Assert
_userRepo.Verify(p => p.LoadUser(request.Id, It.IsAny <Action <User> >(), dummyFailureAction));
actualResult.Should().BeEquivalentTo(expectedResult);
}
public async Task <IActionResult> Edit(long id, UserEditRequest dto)
{
if (await CheckRoles(id))
{
return(NotFound());
}
if (!ModelState.IsValid)
{
var user = await _userService.Get(id);
return(View("Edit", new UserEditRequest
{
Email = dto.Email,
Name = dto.Name,
Phone = dto.Phone,
Role = dto.Role,
Id = dto.Id,
IsActive = !user.IsBlocked
}));
}
await _userService.UpdateUser(dto.Id, dto.Name, dto.Password, dto.Email, dto.Phone, dto.Role);
return(RedirectToAction("Edit", "User", new { id }));
}
public async Task <List <string> > UpdateAsync(string userId, UserEditRequest userEditRequest)
{
var errorList = new List <string>();
var user = await userManager.FindByIdAsync(userId);
user.Email = userEditRequest.Email;
user.UserName = userEditRequest.UserName;
user.FullName = userEditRequest.FullName;
var passwordChangeResult = IdentityResult.Success;
if (userEditRequest.NewPassword.Length != 0 && userEditRequest.NewPassword == userEditRequest.VerifyNewPassword)
{
passwordChangeResult = await userManager.ChangePasswordAsync(user, userEditRequest.CurrentPassword, userEditRequest.NewPassword);
if (!passwordChangeResult.Succeeded)
{
errorList.AddRange(passwordChangeResult.Errors
.Select(e => e.Description)
.ToList());
}
}
var userUpdateResult = await userManager.UpdateAsync(user);
if (!userUpdateResult.Succeeded)
{
errorList.AddRange(userUpdateResult.Errors
.Select(e => e.Description)
.ToList());
}
return(errorList);
}
public void HandleUserEditRequest(UserEditRequest request, Action <UserQueryResult> OnSuccess,
Action <string> OnFailure)
{
_userRepo.LoadUser(
request.Id,
user => OnSuccess(new UserQueryResult(user)),
OnFailure);
}
public async Task <IdentityResult> UpdateUser(string userId, UserEditRequest userToEdit)
{
var user = await _userManager.FindByIdAsync(userId);
_mapper.Map(userToEdit, user);
var result = await _userManager.UpdateAsync(user);
return(result);
}
public (Status, UserQueryResult) HandleUserEditRequest(UserEditRequest request)
{
var(status, user) = _userRepo.LoadUser(request.Id);
if (status is Failure)
{
return(status, null);
}
return(new Success(), new UserQueryResult(user));
}
public async Task <IActionResult> UpdateUser(string userId, UserEditRequest userToEdit)
{
var userResponse = await _userService.UpdateUser(userId, userToEdit);
if (userResponse.Succeeded)
{
return(Ok(userToEdit));
}
return(BadRequest(userResponse.Errors));
}
public IActionResult UpdateUser(long id, [FromBody] UserEditRequest request)
{
var user = UsersService.UpdateUser(id, request);
if (user == null)
{
return(NotFound());
}
return(Ok(user));
}
public async Task Edit(User user, UserEditRequest model)
{
user.Username = model.Username;
user.Email = model.Email;
user.Role = model.Role;
if (model.Picture != null)
{
user.Picture = await UploadPicture(model.Picture);
}
_context.Entry(user).State = EntityState.Modified;
await _context.SaveChangesAsync();
}
public async Task <UserEditResponse> EditUser(UserEditRequest request)
{
var response = new UserEditResponse();
var currentUser = _cacheManager.GetCachedCurrentUser(request.CurrentUserId);
if (!currentUser.IsAdmin)
{
response.SetInvalid();
return(response);
}
if (await _organizationRepository.Any(x => x.Id == currentUser.OrganizationId && !x.IsActive))
{
response.SetInvalid();
response.ErrorMessages.Add("organization_not_found");
return(response);
}
var entity = _cacheManager.GetCachedUser(request.UserUid);
if (entity.OrganizationId != currentUser.OrganizationId)
{
response.SetInvalid();
return(response);
}
var language = await _languageRepository.Select(x => x.Uid == request.LanguageUid);
if (language.IsNotExist())
{
response.SetInvalid();
response.ErrorMessages.Add("language_not_found");
return(response);
}
var updatedEntity = _userFactory.CreateEntityFromRequest(request, entity, language);
var result = await _userRepository.Update(request.CurrentUserId, updatedEntity);
if (result)
{
_cacheManager.UpsertUserCache(entity, _userFactory.MapCurrentUser(entity));
response.Item = _userFactory.CreateDtoFromEntity(entity);
response.Status = ResponseStatus.Success;
return(response);
}
response.SetFailed();
return(response);
}
/// <summary>
/// 修改
/// </summary>
/// <param name="editRequest"></param>
/// <returns></returns>
public async Task <ResponseMessage <bool> > UserUpdateAsync(UserEditRequest editRequest)
{
var response = new ResponseMessage <bool>()
{
Extension = false
};
var user = _mapper.Map <User>(editRequest);
user.UpdateTime = DateTime.Now;
if (await _userStore.PutEntityAsync(user.Id, user))
{
response.Extension = true;
}
return(response);
}
public User CreateEntityFromRequest(UserEditRequest request, User entity, Language language)
{
entity.UpdatedBy = request.CurrentUserId;
entity.FirstName = request.FirstName;
entity.LastName = request.LastName;
entity.Name = MapName(request.FirstName, request.LastName);
entity.LanguageId = language.Id;
entity.LanguageUid = language.Uid;
entity.LanguageName = language.Name;
entity.LanguageIconUrl = language.IconUrl;
return(entity);
}
public async Task <ResponseMessage <bool> > UserEdit([FromBody] UserEditRequest request)
{
var response = new ResponseMessage <bool>()
{
Extension = false
};
if (!(await _userManager.IsExists(request.Id)) || string.IsNullOrWhiteSpace(request.Id))
{
response = await _userManager.UserAddAsync(request);
}
else
{
response = await _userManager.UserUpdateAsync(request);
}
return(response);
}
/// <summary>
/// Validate the Edit USer details
/// </summary>
/// <param name="request"></param>
public static void ValidateEditUserRequest(string userId, UserEditRequest request, List <string> ChangedProps)
{
User user = dbContext.Users.FirstOrDefault(i => i.Id == userId);
if (user == null)
{
var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, ErrorCodes.USER_DOES_NOT_EXISTS);
throw new HttpResponseException(response);
}
if (string.IsNullOrEmpty(request.FirstName) && ChangedProps.Contains("FirstName"))
{
var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, ErrorCodes.USER_FIRSTNAME_REQ);
throw new HttpResponseException(response);
}
if (string.IsNullOrEmpty(request.LastName) && ChangedProps.Contains("LastName"))
{
var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, ErrorCodes.USER_LASTNAME_REQ);
throw new HttpResponseException(response);
}
//check for inprogress assignments.
if (request.IsActiveUser == false)
{
//Abhijeet 06-11-2018
//Remove PropertyUserMap in Query
//var assignmentCount = (from pum in user.PropertyUserMaps.Where(i => i.Deleted == false).ToList()
// join pus in user.PropertyUserStatus.Where(i => i.Deleted == false).ToList()
// on pum.Id equals pus.PropertyUserMapsId into temp
// from lj in temp.DefaultIfEmpty()
// where (lj == null || lj.StatusId == null) && pum.Property.Incident.Status == 0
// select new { pum.PropertyId, pum.UserId }).Distinct().Count();
var assignmentCount = (from pus in user.PropertyUserStatus.Where(i => i.Deleted == false && i.StatusId == null).ToList()
where pus.Property.Incident.Status == 0
select new { pus.PropertyId, pus.UserId }).Distinct().Count();
if (assignmentCount > 0)
{
var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, ErrorCodes.UNASSIGN_MPRNs_BEFORE_DEACTIVATE);
throw new HttpResponseException(response);
}
}
}
/// <summary>
/// 获取单挑数据
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public UserEditResponse UserEdit(UserEditRequest request)
{
UserEditResponse response = new UserEditResponse();
if (request.Uid < 0)
{
response.Status = false;
response.Message = "网络错误请重试";
return(response);
}
var res = UserDal.Instance.EditUser(request.Uid);
if (res != null)
{
response.Status = true;
response.Message = "请求成功";
response.UserEdit = res;
}
return(response);
}
public async Task <IActionResult> Edit(UserEditModel model)
{
if (model.IsNotValid())
{
model.SetInputModelValues();
return(View(model));
}
var request = new UserEditRequest(CurrentUser.Id, model.UserUid, model.FirstName, model.LastName, model.LanguageUid);
var response = await OrganizationService.EditUser(request);
if (response.Status.IsNotSuccess)
{
model.MapMessages(response);
model.SetInputModelValues();
return(View(model));
}
CurrentUser.IsActionSucceed = true;
return(Redirect("/User/Detail/" + model.UserUid));
}
/// <summary>
/// 新增
/// </summary>
/// <param name="editRequest"></param>
/// <returns></returns>
public async Task <ResponseMessage <bool> > UserAddAsync(UserEditRequest editRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var response = new ResponseMessage <bool>()
{
Extension = false
};
if (editRequest == null)
{
throw new ArgumentNullException();
}
if (await _userStore.IQueryableListAsync().Where(y => y.UserName == editRequest.UserName).AnyAsync(cancellationToken))
{
throw new ZCustomizeException(ResponseCodeEnum.ObjectAlreadyExists, "该用户名已存在请重试");
}
var user = _mapper.Map <User>(editRequest);
user.CreateTime = DateTime.Now;
user.Id = Guid.NewGuid().ToString();
user.Password = "******";
response.Extension = await _userStore.AddEntityAsync(user);
return(response);
}
public async Task <IActionResult> EditUser(long ID, UserEditRequest userEditRequest)
{
await _userFacade.UpdateUserAsync(HttpContext.User.FindFirst(ClaimTypes.Hash).Value, ID, userEditRequest);
return(RedirectToAction("AdminDetail", new { ID = ID }));
}
public async Task <IActionResult> EditCurrentUser(UserEditRequest userEditRequest)
{
await _userFacade.CurrentUserUpdate(HttpContext.User.FindFirst(ClaimTypes.Hash).Value, userEditRequest);
return(Redirect("/"));
}
/// <summary>
/// 获取用户单条数据
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public UserEditResponse UserEdit(UserEditRequest request)
{
return(ApiRequestHelper.Post <UserEditRequest, UserEditResponse>(request));
}
public User UpdateUser(long id, UserEditRequest request)
{
var user = Repository.UpdateUser(id, request.Email, request.Username);
return(Mapper.Map <User>(user));
}
/// <summary>
/// 获取单条数据
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public JsonResult UserEdit(UserEditRequest request)
{
return(Json(UserBll.Instance.UserEdit(request)));
}
public IActionResult UpdateCurrentUser([FromBody] UserEditRequest request)
{
var currentUserID = HttpContext.User.GetUserID();
return(Ok(UsersService.UpdateUser(currentUserID, request)));
}
