public void Execute(EditUserDTO request)
{
if (Validate(request))
{
var user = context.Users.Find(request.UserId);
if (user.FirstName != null)
{
user.FirstName = request.FirstName;
}
if (user.LastName != null)
{
user.LastName = request.LastName;
}
if (user.Password != null)
{
user.Password = CreateSha256Hash(request.Password);
}
if (user.Role != null)
{
user.Role = request.Role;
}
user.ModifiedAt = DateTime.Now;
context.SaveChanges();
}
}
// GET: Actividades/Edit/5
public async Task <IActionResult> EditUser(string id)
{
if (id == null)
{
return(NotFound());
}
var user = await userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var userClaims = await userManager.GetClaimsAsync(user);
var userRoles = await userManager.GetRolesAsync(user);
var model = new EditUserDTO
{
Id = user.Id,
Claims = userClaims.Select(c => c.Value).ToList(),
Roles = userRoles
};
return(View(model));
}
public async Task <IActionResult> EditUser(EditUserDTO model)
{
var user = await userManager.FindByIdAsync(model.Id);
if (user == null)
{
ViewBag.ErrorMessage = $"Role with Id = {model.Id} cannot be found";
return(NotFound());
}
else
{
user.UserName = model.UserName;
var result = await userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("ListUsers"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public IDatabaseUser updatedUser(IDatabaseUser existing, EditUserDTO dto) => User.Builder .FromExisting(existing) .SetBeginningOfWeek(dto.BeginningOfWeek) .SetSyncStatus(SyncStatus.SyncNeeded) .SetAt(timeService.CurrentDateTime) .Build();
public void ChangeUser(User user, EditUserDTO newData)
{
if (newData.Username != null && newData.Username != user.UserName)
{
if (FindUser(newData.Username) != null)
{
throw new ArgumentException(ExceptionsTexts.RepeatingUsername);
}
user.UserName = newData.Username;
}
if (newData.FirstName != null && newData.FirstName != user.FirstName)
{
user.FirstName = newData.FirstName;
}
if (newData.MiddleName != null && newData.MiddleName != user.MiddleName)
{
user.MiddleName = newData.MiddleName;
}
if (newData.LastName != null && newData.LastName != user.LastName)
{
user.LastName = newData.LastName;
}
db.SaveChanges();
}
/// <summary>
/// Checks that EditUSer info seuccesfully edits a users info
/// </summary>
public void TestEditUserInfo()
{
//Arrange
ClaimsIdentity objClaim = new ClaimsIdentity(new List <Claim> {
new Claim(ClaimTypes.NameIdentifier, "3")
});
_userController.HttpContext.User = new ClaimsPrincipal(objClaim);
EditUserDTO editUser = new EditUserDTO();
editUser.FirstName = "Bryan_Test";
editUser.LastName = "Ang_Test";
editUser.DateOfBirth = new DateTime(1984, 02, 09);
editUser.PhoneNumber = "5555555555";
editUser.Email = "*****@*****.**";
editUser.MedicalInformation = "editing test";
editUser.BankAccount = "111-1111-1111111";
//Act
_ = _userController.EditUserInfo(editUser);
var response = _userController.GetUserInfo();
UserInfoDTO editedUser = response.Value;
//Assert
Assert.That(editedUser.FirstName == editUser.FirstName);
Assert.That(editedUser.LastName == editUser.LastName);
Assert.That(editedUser.DateOfBirth == editUser.DateOfBirth);
Assert.That(editedUser.PhoneNumber == editUser.PhoneNumber);
Assert.That(editedUser.Email == editUser.Email);
Assert.That(editedUser.MedicalInformation == editUser.MedicalInformation);
Assert.That(editedUser.BankAccount == editUser.BankAccount);
}
public ActionResult AddUser(EditUserDTO user, int inActive)
{
var validationIds = new List <string>();
var validationMessage = Validate(user, true, out validationIds);
if (!validationMessage.Any())
{
UserManagement.AddUser(user.ToUser());
}
var users = UserManagement.GetAllUserList();
if (inActive == 0)
{
users = users.Where(x => x.IsDeleted == false);
}
else if (inActive == 1)
{
users = users.Where(x => x.IsDeleted);
}
var totalUsersPage = (int)Math.Ceiling(((double)users.Count() / (double)pageSize));
return(Json(new
{
users = ApplyPaging(users, 1),
passed = !validationMessage.Any(),
validationIds,
totalUsersPage,
validationMessage = string.Join("</br>", validationMessage)
}));
}
public async Task <IActionResult> Edit(EditUserDTO editUserDTO)
{
try
{
if (ModelState.IsValid)
{
var response = await _userService.UpdateUser(editUserDTO);
if (!response.Succeeded)
{
foreach (var errorMessage in response.Errors)
{
ModelState.AddModelError(string.Empty, errorMessage.Description);
}
return(View(editUserDTO));
}
return(RedirectToAction("Profile", "Home", new { editUserDTO.Id }));
}
return(View(editUserDTO));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <UserInfoDTO> EditUser(EditUserDTO editUserDTO)
{
var user = await _context.Users.AsNoTracking().FirstOrDefaultAsync(x => x.Id == editUserDTO.Id);
try
{
if (user != null)
{
user.FirstName = editUserDTO.FirstName;
user.MiddleName = editUserDTO.MiddleName;
user.LastName = editUserDTO.LastName;
user.Address = editUserDTO.Address;
user.PhoneNumber = editUserDTO.PhoneNumber;
_context.Users.Update(user);
_context.SaveChanges();
return(_mapper.Map <UserInfoDTO>(user));
}
throw new NullReferenceException();
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
private bool InputIsValid(EditUserDTO user)
{
if (string.IsNullOrEmpty(user.PhoneNumber) ||
string.IsNullOrEmpty(user.HoTen) ||
string.IsNullOrEmpty(user.DiaChi) ||
string.IsNullOrEmpty(user.CurrentPassword) ||
string.IsNullOrEmpty(user.NewPassword) ||
string.IsNullOrEmpty(user.NewPasswordConfirm))
{
return(false);
}
var phoneregex = new Regex(@"^[0-9]+$");
var passregex = new Regex(@".{5,}");
if (!phoneregex.IsMatch(user.PhoneNumber))
{
return(false);
}
if (!passregex.IsMatch(user.CurrentPassword) || !passregex.IsMatch(user.NewPassword) || !passregex.IsMatch(user.NewPasswordConfirm))
{
return(false);
}
if (user.NewPassword != user.NewPasswordConfirm)
{
return(false);
}
return(true);
}
public bool Validate(EditUserDTO dto)
{
if (!context.Users.Any(m => m.Id == dto.UserId))
{
throw new EntityNotFoundException("Korisnik nije pronadjen");
}
return(true);
}
public UpdateUserInteractor(ITimeService timeService, ISingletonDataSource <IThreadSafeUser> dataSource, EditUserDTO dto)
{
Ensure.Argument.IsNotNull(dto, nameof(dto));
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
this.dto = dto;
this.dataSource = dataSource;
this.timeService = timeService;
}
public async Task <IdentityResult> UpdateUser(EditUserDTO editUserDTO)
{
var updateModel = _userRepository.GetUserById(editUserDTO.Id);
updateModel = await editUserDTO.UpdateToUser(updateModel);
var response = await _userManager.UpdateAsync(updateModel);
return(response);
}
public async Task <IActionResult> EditUser([FromBody] EditUserDTO editUser)
{
if (User.Identity.IsAuthenticated)
{
await _userServices.EditUserInfo(editUser, User.GetUserId());
return(JsonResponseStatus.Success(new { message = "اطلاعات کاربر با موفقیت ویرایش شد" }));
}
return(JsonResponseStatus.UnAuthorized());
}
public IActionResult EditUser(EditUserDTO editUserDto)
{
if (_repo.EditUser(editUserDto))
{
return(Ok());
}
else
{
return(BadRequest());
}
}
// edit user + token ?
public void UpdateUser(int Id, EditUserDTO editUserDTO)
{
var updateUser = _userRepository.FindById(Id);
if (updateUser != null && editUserDTO != null)
{
var hashedPassword = JsonWebToken.GenerateHash(editUserDTO.Password, "128");
editUserDTO.Password = hashedPassword;
_userRepository.Update(Id, _mapper.Map(editUserDTO, updateUser));
}
}
public static Parent EditUserDTOToParent(EditUserDTO dto)
{
logger.Info("Converting EditUserDTO to Parent.");
return(new Parent()
{
Email = dto.Email,
UserName = dto.UserName,
FirstName = dto.FirstName,
LastName = dto.LastName
});
}
public static Teacher EditUserDTOToTeacher(EditUserDTO dto)
{
logger.Info("Converting EditUserDTO to Teacher.");
return(new Teacher()
{
Email = dto.Email,
UserName = dto.UserName,
FirstName = dto.FirstName,
LastName = dto.LastName
});
}
public async Task <ActionResult <UserInfoDTO> > EditUser(EditUserDTO editUserDTO)
{
try
{
return(await _userService.EditUser(editUserDTO));
}
catch (Exception e)
{
return(NotFound($"We couldn't find the selected user: {e.Message}"));
}
}
public async Task <ActionResult> PutUser(EditUserDTO user)
{
if (user == null || string.IsNullOrEmpty(user.FamilyName) || string.IsNullOrEmpty(user.FirstName) || string.IsNullOrEmpty(user.Phone) || string.IsNullOrEmpty(user.Email) || user.Categories == null)
{
return(BadRequest());
}
if (!_categoryRepo.CategoriesExist(user.Categories))
{
return(BadRequest());
}
List <Category> categories = _categoryRepo.GetCategoriesById(user.Categories).ToList();
User u = _userRepo.GetById(user.UserId);
if (u == null)
{
return(BadRequest());
}
IdentityUser identityUser = await _userManager.FindByNameAsync(u.Email);
if (identityUser == null)
{
return(BadRequest());
}
identityUser.UserName = user.Email;
identityUser.Email = user.Email;
u.FirstName = user.FirstName;
u.FamilyName = user.FamilyName;
u.Email = user.Email;
u.Phone = user.Phone;
u.Contract = user.Contract;
u.Categories = categories.Select(c => Model.User.MapCategoryToCategoryUser(c, u)).ToList();
if (_userRepo.UserExists(u))
{
return(StatusCode(303));
}
try
{
await _userManager.UpdateAsync(identityUser);
_userRepo.UpdateUser(u);
_userRepo.SaveChanges();
}
catch (Exception)
{
return(StatusCode(500));
}
return(Ok());
}
public static Admin EditUserDTOToAdmin(EditUserDTO dto)
{
logger.Info("Converting EditUserDTO to Admin.");
return(new Admin()
{
Email = dto.Email,
UserName = dto.UserName,
FirstName = dto.FirstName,
LastName = dto.LastName
});
}
public void Create([FromBody] EditUserDTO editUserDTO)
{
try
{
_userService.CreateUser(editUserDTO);
}
catch (Exception)
{
// Implement logging MS
//throw StatusCode(500, "Internal server error");
}
}
public void Update(int userId, [FromBody] EditUserDTO userDTO)
{
try
{
_userService.UpdateUser(userId, userDTO);
}
catch (Exception)
{
// Implement logging MS
//throw StatusCode(500, "Internal server error");
}
}
/// <summary>
/// Edits the Users name
/// </summary>
/// <param name="editedUser">Object {FirstName: string, LastName: string, Id: GUID}</param>
/// <returns>True if no errors thrown</returns>
public bool EditUser(EditUserDTO editedUser)
{
using (var db = new SqlConnection(_connectionString))
{
var sql = @"UPDATE [User]
SET
[FirstName] = @firstName,
[LastName] = @lastName
WHERE [Id] = @id";
return(db.Execute(sql, editedUser) == 1);
}
}
public static async Task <User> UpdateToUser(this EditUserDTO editUserDTO, User user)
{
user.FirstName = editUserDTO.FirstName;
user.LastName = editUserDTO.LastName;
if (editUserDTO.ProfilePhoto != null)
{
user.ProfilePicture = await editUserDTO.ProfilePhoto.ConvertImageToByte();
}
return(user);
}
public void UpdateFromDTO(EditUserDTO dto)
{
Name = dto.Name ?? Name;
Surname = dto.Surname ?? Surname;
Position = dto.Position ?? Position;
PharmacyId = dto.PharmacyId ?? PharmacyId;
DismissalDate = dto.DismissalDate ?? DismissalDate;
if (dto.EmployeeStateId != null)
{
EmployeeStateId = (EmployeeStateId)dto.EmployeeStateId;
}
}
public async Task <IHttpActionResult> PutStudent(string id, [FromBody] EditUserDTO user)
{
if (!ModelState.IsValid)
{
logger.Warn("PutStudent returned BadRequest with invalid ModelState");
return(BadRequest(ModelState));
}
var result = await service.EditStudent(id, user);
logger.Info("PutStudent finished Ok. Student {0} was edited.", id);
return(Ok(result));
}
public async Task EditUserInfo(EditUserDTO user, long userId)
{
var mainUser = await GetUserById(userId);
if (mainUser != null)
{
mainUser.FirstName = user.FirstName;
mainUser.LastName = user.LastName;
mainUser.Address = user.Address;
_userRepository.UpdateEntity(mainUser);
await _userRepository.SaveChanges();
}
}
public void IsChangingUserName()
{
EditUserDTO editUserDTO = new EditUserDTO
{
Username = "******",
FirstName = "FirsteName",
MiddleName = "MidleName",
LastName = "LasteName"
};
userServices.ChangeUser(user, editUserDTO);
Assert.That(user.UserName, Is.EqualTo("sirMadam"));
}
public IActionResult EditCustomer(EditUserDTO editUserDTO)
{
try
{
var index = Users.FindIndex(u => u.Id == editUserDTO.Id);
Users[index].Gender = editUserDTO.Gender;
Users[index].DateOfBirth = editUserDTO.DateOfBirth;
Users[index].Mobile = editUserDTO.Mobile;
return(Ok(Users[index]));
}
catch (Exception e)
{
return(BadRequest("Bad Request - " + e.Message));
}
}
