public async Task <ActionResult <UserDto> > EditUser(EditUserDto dto)
{
var user = await _context.Set <User>().FindAsync(dto.Id);
if (user == null)
{
return(BadRequest());
}
user.FirstName = dto.FirstName;
user.LastName = dto.LastName;
user.Email = dto.Email;
user.Username = dto.Username;
user.Password = dto.Password;
_context.Set <User>().Update(user);
await _context.SaveChangesAsync();
var newEntity = await _context.Set <User>().FindAsync(dto.Id);
if (newEntity == null)
{
return(BadRequest());
}
var userDto = new UserDto
{
FirstName = newEntity.FirstName,
LastName = newEntity.LastName,
Email = newEntity.Email
};
return(Ok(userDto));
}
public IHttpActionResult EditUser([FromBody] EditUserDto user)
{
//Checks if what was given is a valid model.
if (!ModelState.IsValid)
{
return(BadRequest(GeneralErrorMessages.MODEL_STATE_ERROR));
}
try
{
if (user.NewDisplayName == "" && user.NewUsername == "" || user.NewDisplayName == null && user.NewUsername == null)
{
return(BadRequest(UserManagementErrorMessages.EMPTY_USERNAME_OR_DISPLAYNAME));
}
var manager = new UserManager();
var response = manager.Edituser(user);
if (response.Error != null)
{
return(BadRequest(response.Error));
}
return(Ok("User has been edited: " + user.Username));
}
catch (Exception)
{
return(InternalServerError());
}
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var owner = await _dataContext.Owners
.Include(o => o.User)
.FirstOrDefaultAsync(o => o.Id == id.Value);
if (owner == null)
{
return(NotFound());
}
var view = new EditUserDto
{
Address = owner.User.Address,
Document = owner.User.Document,
FirstName = owner.User.FirstName,
Id = owner.Id,
LastName = owner.User.LastName,
PhoneNumber = owner.User.PhoneNumber
};
return(View(view));
}
public static User MappingUserByEditUserDto(User user, EditUserDto editUserDto)
{
user.Email = editUserDto.Email;
user.BirthDay = editUserDto.BirthDay;
return(user);
}
public async Task <IActionResult> Put(int id, [FromBody] EditUserDto value)
{
// метод для редактирования пользователя(смена имени, смена прав)
var privMessage = await CheckPriv(value);
if (!string.IsNullOrEmpty(privMessage))
{
return(BadRequest(privMessage));
}
var user = await _ctx.Users
.FirstOrDefaultAsync(u => u.UserId == id);
if (user == null)
{
return(BadRequest("Пользователь не найден"));
}
user.UserName = value.EditedUserName;
user.Privs = value.EditedUserPrivs;
var result = await _ctx.SaveChangesAsync();
if (result > 0)
{
return(Ok());
}
return(BadRequest($"Не удалось отредактировать пользователя {user.UserName}"));
}
public async Task <UserDto> UpdateUser(EditUserDto input)
{
CheckUpdatePermission();
if (string.IsNullOrEmpty(input.EmailAddress))
{
input.EmailAddress = RandomStringGeneratorUtil.GenerateFakeEmail();
}
var user = await _userManager.GetUserByIdAsync(input.Id);
//MapEditUserDtoToEntity(input, user);
user.EmailAddress = input.EmailAddress;
user.Name = input.Name;
user.Surname = input.Surname;
user.UserName = input.UserName;
user.PhoneNumber = input.PhoneNumber;
user.IsActive = input.IsActive;
//Logger.Info("email for user: " + user.EmailAddress);
CheckErrors(await _userManager.UpdateAsync(user));
if (input.RoleNames != null)
{
CheckErrors(await _userManager.SetRoles(user, input.RoleNames));
}
return(await Get(input));
}
public async Task EditConflictTest()
{
using (var scope = _fixture.Server.Host.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <DatabaseFixture>().Context;
var appUserService = scope.ServiceProvider.GetRequiredService <IAppUsersService>();
var createdUser = await appUserService.Create(new AppUser
{
Email = "*****@*****.**",
UserName = "******"
});
// Test email conflict
var editRequest = new EditUserDto
{
Email = createdUser.Email,
};
using (var response = await SendEditUserRequest(createdUser.Id, editRequest))
{
Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
}
// Test username conflict
editRequest = new EditUserDto
{
UserName = createdUser.UserName
};
using (var response = await SendEditUserRequest(createdUser.Id, editRequest))
{
Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
}
}
}
public async Task <ActionResult> Edit(Guid id, [FromBody] EditUserDto editUserDto)
{
if (id == Guid.Empty || editUserDto == null)
{
return(BadRequest(_config["Errors:Base:ModelInValid"]));
}
//Validation model dto
var validatorDto = new EditUserDtoValidator();
var resultValidateDto = validatorDto.Validate(editUserDto);
if (!resultValidateDto.IsValid)
{
return(BadRequest(ValidationDto.GetMessagesByErrors(resultValidateDto.Errors)));
}
//Set Config
SetConfig();
//Edit user
var isOk = await _userService.Edit(id, editUserDto);
return(Ok(isOk));
}
public async Task <IActionResult> Update(int id, [FromBody] EditUserDto userDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userRepository.GetById(id);
if (user == null)
{
return(NotFound());
}
user = _mapper.Map(userDto, user);
_userRepository.Update(user);
if (await _unitOfWork.CompleteAsync() == false)
{
throw new Exception(message: "Update user failed in save");
}
user = await _userRepository.GetById(user.Id);
var result = _mapper.Map <User, ViewUserDto>(user);
return(Ok(result));
}
/// <summary>
/// EditUser edits the user when given a.
/// <para>
/// @author: Angelica Salas Tovar
/// @update: 03/20/2018
/// </para>
/// </summary>
/// <param name="username">The user that will be deactivated.</param>
/// <returns>Response Dto</returns>
public ResponseDto <bool> Edituser(EditUserDto editUserDto)
{
// Validation Strategy will validate if the user meets the requirements
var editUserValidation = new EditUserValidationStrategy(editUserDto);
// Validate data transfer object
var result = editUserValidation.ExecuteStrategy();
if (result.Error != null)
{
return(new ResponseDto <bool>
{
Data = false,
Error = result.Error
});
}
using (var gateway = new UserGateway())
{
var gatewayresult = gateway.EditUser(editUserDto);
if (gatewayresult.Data == false)
{
return(new ResponseDto <bool>()
{
Data = false,
Error = gatewayresult.Error
});
}
return(new ResponseDto <bool>
{
Data = true
});
}
}
public async Task <IActionResult> Edit(EditUserDto dto)
{
if (!ModelState.IsValid)
{
return(View(dto));
}
User user = await _manager.FindByIdAsync(dto.ID);
if (user == null)
{
return(View(dto));
}
user.Email = dto.Email;
user.Name = dto.Name;
var result = await _manager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Account"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(dto));
}
public async Task <IActionResult> UpdateUser(string username, [FromBody] EditUserDto model)
{
if (!await _unitOfWork.UserRepository.UserExists(username))
{
return(NotFound());
}
var user = await _unitOfWork.UserRepository.GetByUsername(username);
if (user == null)
{
return(NotFound());
}
var subjectId = User.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
if (subjectId != null && user.SubjectId != subjectId)
{
return(Forbid());
}
Mapper.Map(model, user);
if (!await _unitOfWork.Commit())
{
throw new Exception("Updating a user failed on save.");
}
return(Ok(Mapper.Map <UserDto>(user)));
}
public async Task <IActionResult> Edit(int id, [FromBody] EditUserDto user)
{
if (ModelState.IsValid)
{
var existing = await uow.User.Get(id);
if (existing == null)
{
return(NotFound(new { respose = "error", message = $"user id = {id} does not exist" }));
}
existing.Name = user.Name;
existing.Surname = user.Surname;
existing.BirthDate = user.BirthDate;
existing.CompanyId = user.CompanyId;
existing.Email = user.Email;
var updated = uow.User.Update(existing);
await uow.CommitAsync();
var userPic = await uow.Media.GetUserPic(id);
var userDto = mapper.Map <GetUserDto>(updated);
userDto.PicUrl = userPic == null ? null : Url.ActionUserPic(userPic.BlobPath);
return(Ok(userDto));
}
return(BadRequest(ModelState));
}
private static void UpdateUserDto(ADUser entity, EditUserDto dto)
{
if (entity == null)
{
throw new EntityNotFoundException();
}
entity.ADUserOrganizationName = dto.OrganizationName;
entity.ADUserAcronymName = dto.AcronymName;
entity.ADUserTaxNumber = dto.TaxNumber;
entity.ADUserPhone = dto.Phone;
entity.ADUserFax = dto.Fax;
entity.ADUserWebsite = dto.Website;
entity.ADUserRepresentative = dto.Representative;
entity.ADUserHouseNumber = dto.HouseNumber;
entity.ADUserAddress = dto.Address;
entity.ADUserIdentityCard = dto.IdentityCard;
entity.ADUserType = dto.Type;
entity.FK_GEStateProvinceID = dto.StateProvinceID;
entity.FK_GEDistrictID = dto.DistrictID;
entity.FK_GECommuneID = dto.CommuneID;
entity.ADUserEmail = dto.Email;
entity.ADUserStatus = dto.Status;
entity.ADUserEvaluate = dto.Evaluate;
entity.ADUserAvatarFileName = dto.Avatar.IsNullOrEmpty() ? string.Empty : dto.Avatar + CommonConstants.DefaultImageExtension;
}
public async Task EditUser(EditUserDto editUser)
{
var user = await _userRepository.GetAsync(editUser.Id);
user.Name = editUser.Name;
user.Lastname = editUser.Lastname;
await _userRepository.UpdateAsync(user.Id, user);
}
public async Task <ActionResult <UserDto> > EditUser([FromBody] EditUserDto editUser)
{
if (!UserRoles.isUserRole(editUser.Role))
{
return(BadRequest(new ErrorMessage("Wrong user role")));
}
var result = await _usersService.EditUserRole(editUser.UserId, editUser.Role);
return(result != null?Ok(result) : (ActionResult)BadRequest("User not found"));
}
public async Task <IActionResult> Edit(EditUserDto model)
{
var user = await _unitOfWork.UserRepo.GetUser(model.Id);
var vm = new EditUserVM {
Cities = await _unitOfWork.UserRepo.GetCities(), User = user
};
return(View(vm));
}
public async Task <IActionResult> UpdateUser([FromForm] EditUserDto userDto)
{
var addUser = await mediator.Send(new UpdateUserCommand(userDto.Id, userDto.Username, userDto.Name, userDto.Family, userDto.Email, userDto.Photo));
if (addUser.Success)
{
return(Ok());
}
return(BadRequest(addUser.ErrorMessage));
}
public UserDto UpdateUserProfile([FromBody] EditUserDto userDto)
{
var user = _usersRepository.UpdateUser(_sessionDto.UserId, userDto);
if (user == null)
{
throw new UnauthorizedAccessException();
}
return(_mapper.Map <UserDto>(user));
}
public async Task UpdateAsync(EditUserDto dto)
{
var user = await _repository.GetByIdAsync(dto.Id);
user.FirstName = dto.FirstName;
user.SecondName = dto.SecondName;
user.Email = dto.Email;
user.Password = !string.IsNullOrWhiteSpace(dto.Password) ? _securityService.Encrypt(dto.Password, dto.Email) : user.Password;
await _repository.UpdateAsync(user);
}
public void Update(Guid id, EditUserDto dto)
{
var user = base.GetById(id);
user.FirstName = dto.FirstName;
user.SecondName = dto.SecondName;
user.Email = dto.Email;
user.Password = !string.IsNullOrWhiteSpace(dto.Password) ? _securityService.Encrypt(dto.Password, dto.Email) : user.Password;
base.Update(user);
}
public async Task <IActionResult> EditUser([FromRoute] string userId, [FromBody] EditUserDto editUserDto)
{
if (!ModelState.IsValid || string.IsNullOrWhiteSpace(editUserDto.UserName) && string.IsNullOrWhiteSpace(editUserDto.Email))
{
return(BadRequest(ModelState));
}
// Check if the user exists
var exists = await _context.AppUsers.AnyAsync(usr => usr.Id == userId);
if (!exists)
{
return(NotFound());
}
// Check if the username conflicts with existing ones
var foundUser = await _context.AppUsers.AsNoTracking().SingleAsync(user => user.Id == userId);
if (!string.IsNullOrWhiteSpace(editUserDto.UserName))
{
var usernameExists = await _context.AppUsers.AnyAsync(usr => usr.UserName == editUserDto.UserName);
if (usernameExists)
{
return(Conflict("Username exists"));
}
foundUser.UserName = editUserDto.UserName;
}
// Check if the email conflicts with existing ones
if (!string.IsNullOrWhiteSpace(editUserDto.Email))
{
var emailExists = await _context.AppUsers.AnyAsync(usr => usr.Email == editUserDto.Email);
if (emailExists)
{
return(Conflict("Email exists"));
}
foundUser.Email = editUserDto.Email;
}
// Save the changes
await _appUsersService.Edit(foundUser);
// Form the HAL response
var response = new GetUserResponse(
foundUser,
LinkGenerator.Users.Edit(foundUser.Id, "self")
);
return(Ok(response));
}
public async Task <bool> EditUserAsync(string id, EditUserDto editUserDto)
{
var userEntity = await _userManager.FindByIdAsync(id);
userEntity.FirstName = editUserDto.FirstName;
userEntity.LastName = editUserDto.LastName;
userEntity.Email = editUserDto.Email;
userEntity.UserName = editUserDto.Username;
var result = await _userManager.UpdateAsync(userEntity);
return(result.Succeeded);
}
public async Task <ActionResult> EditUserModal(int Id)
{
var user = _userAppService.Get(Id);
var roles = (await _userAppService.GetRoles()).Items;
var model = new EditUserDto
{
User = user,
Roles = roles
};
return(View("_EditUserModal", model));
}
public IActionResult EditUser(EditUserDto editUserDto)
{
var editedUser = editUserDto;
if(_repo.EditUser(editedUser))
{
return Ok();
}
else
{
return BadRequest();
}
}
public void EditTeamLeader(EditUserDto teamLeaderDto)
{
var teamLeader = GetTeamLeader(teamLeaderDto.Id);
teamLeader.FirstName = teamLeaderDto.FirstName;
teamLeader.LastName = teamLeaderDto.LastName;
teamLeader.Age = teamLeaderDto.Age;
teamLeader.Email = teamLeaderDto.Email;
context.TeamLeaders.Update(teamLeader);
context.SaveChanges();
}
public IActionResult ApplayEdit(EditUserDto projectManagerDto)
{
if (ModelState.IsValid)
{
projectManagerRepository.EditProjectManager(projectManagerDto);
return(RedirectToAction("ShowProjectManagers"));
}
else
{
return(View("Edit"));
}
}
public IActionResult ApplayEdit(EditUserDto teamLeaderDto)
{
if (ModelState.IsValid)
{
teamLeaderRepository.EditTeamLeader(teamLeaderDto);
return(RedirectToAction("ShowTeamLeaders"));
}
else
{
return(View("Edit"));
}
}
public IActionResult UpdateUser(Guid userId, [FromBody] EditUserDto userDto)
{
if (userDto == null || userId != userDto.Id || !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userExists = _db.Users.Any(x => x.Id == userId);
if (!userExists)
{
return(NotFound("کاربر یافت نشد."));
}
var emailExists = _db.Users.Any(x => x.Id != userDto.Id && x.Email == userDto.Email);
if (emailExists)
{
ModelState.AddModelError("Email", "ایمیل قبلا استفاده شده است.");
return(StatusCode(409, ModelState));
}
var usernameExists = _db.Users.Any(x => x.Id != userDto.Id && x.Username == userDto.Username);
if (usernameExists)
{
ModelState.AddModelError("Email", "نام کاربری قبلا استفاده شده است.");
return(StatusCode(409, ModelState));
}
var userTitleExists = _db.Users.Any(x => x.Id != userDto.Id && x.UserTitle == userDto.UserTitle);
if (userTitleExists)
{
ModelState.AddModelError("Email", "عنوان کاربری قبلا استفاده شده است.");
return(StatusCode(409, ModelState));
}
var user = _mapper.Map <User>(userDto);
try
{
_db.Users.Update(user);
_db.SaveChanges();
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(StatusCode(500, ModelState));
}
return(NoContent());
}
public void EditProjectManager(EditUserDto projectManagerDto)
{
var projectManager = GetProjectManager(projectManagerDto.Id);
projectManager.FirstName = projectManagerDto.FirstName;
projectManager.LastName = projectManagerDto.LastName;
projectManager.Age = projectManagerDto.Age;
projectManager.Email = projectManagerDto.Email;
context.ProjectManagers.Update(projectManager);
context.SaveChanges();
}
