public async Task <IActionResult> PutUser(long id, UserEditDTO userEditDTO)
{
var currentUserId = long.Parse(User.Identity.Name);
if (id != currentUserId)
{
return(Forbid());
}
if (id != userEditDTO.Id)
{
return(BadRequest());
}
var user = await _context.Users.FindAsync(id);
if (user == null)
{
return(NotFound());
}
_mapper.Map(userEditDTO, user);
if (!string.IsNullOrWhiteSpace(userEditDTO.Password))
{
_userService.CreateHashedPassword(user, userEditDTO.Password);
}
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <JsonResult> Edit(UserEditDTO editDTO)
{
try
{
if (!ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.KEY_IN_REQUIRED_FIELD);
}
Response.StatusCode = 200;
return(Json(await handler.Edit(editDTO), JsonRequestBehavior.AllowGet));
}
catch (HttpException ex)
{
//return Json(ConstantHelper.ERROR, JsonRequestBehavior.AllowGet);
if (ex.Message == ConstantHelper.LOGIN_NAME_EXIST || ex.Message == ConstantHelper.KEY_IN_REQUIRED_FIELD)
{
Response.StatusCode = 400;
}
else
{
Response.StatusCode = 500;
}
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
}
public User CreateUserEditEntity(UserEditDTO userDTO)
{
List <AvatarImage> avatars = new List <AvatarImage>();
if (userDTO.AvatarImage != null)
{
avatars.Add(CreateAvatarEntity(userDTO.AvatarImage));
return(new User()
{
Id = userDTO.Id,
EmailAddress = userDTO.EmailAddress,
Address = userDTO.Address,
AvatarImage = avatars
});
}
else
{
return(new User()
{
Id = userDTO.Id,
EmailAddress = userDTO.EmailAddress,
Address = userDTO.Address
});
}
}
public async Task <List <UserEditDTO> > GetUsers([FromBody] string[] userNames)
{
var users = await GetUsersAsync(userNames.ToList());
var lst = new List <UserEditDTO>();
foreach (var user in users)
{
UserEditDTO dto = new UserEditDTO();
dto.CreationDateUtc = user.CreationDateUtc;
dto.FirstName = user.FirstName;
dto.IsApproved = user.IsApproved;
dto.IsLockedOut = DateTime.UtcNow < user.LockoutEndDateUtc;
dto.LastLoginDateUtc = user.LastLoginDateUtc;
dto.LastName = user.LastName;
dto.LastPasswordResetDateUtc = user.LastPasswordResetDateUtc;
dto.Phone = user.PhoneNumber;
dto.ProviderUserKey = user.SecurityStamp;
dto.UserName = user.UserName;
dto.Email = user.Email;
dto.LockOutEndDateUtc = user.LockoutEndDateUtc;
//dto.CdtId = user.CdtId;
//dto.Department = user.Department;
lst.Add(dto);
}
return(lst);
}
public IActionResult UserEdit(int id)
{
_loggerManager.Info($"UserEdit:Get was requested");
if (id <= 0)
{
_loggerManager.Warn($"UserEdit:Get was bad request");
return(BadRequest());
}
var user = _userRepository.GetUserById(id);
var userEdit = new UserEditDTO
{
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Id = user.Id,
PositionId = user.Position?.Id,
Role = user.Role
};
return(PartialView("~/Views/Manage/Partials/_UserEdit.cshtml", userEdit));
}
public async Task <UserDTO> EditUserInfo(UserEditDTO userInfo)
{
using (_unitOfWork)
{
User user = await _unitOfWork.UserRepository.FindByID(userInfo.UserId);
user.Name = userInfo.Name;
user.LastName = userInfo.LastName;
if (!string.IsNullOrEmpty(userInfo.Picture))
{
user.Picture = PictureManagerService.SaveImageToFile(userInfo.Picture, user.GetType().Name, user.UserId);
}
_unitOfWork.UserRepository.Update(user);
await _unitOfWork.Save();
if (userInfo.Picture != null)
{
user.Picture = null;
}
UserDTO returnUser = _mapper.Map <User, UserDTO>(user);
if (userInfo.Picture != null)
{
returnUser.Picture = userInfo.Picture;
}
return(returnUser);
}
}
public async Task <string> Edit(UserEditDTO editDTO)
{
User user = await _eFUnitOfWork.UserManager.FindByIdAsync(Convert.ToString(editDTO.Id));
if (user != null)
{
user.Email = editDTO.Email;
user.UserName = editDTO.UserName;
var result = await _eFUnitOfWork.UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return("Данні користувача успішно змінені!");
}
else
{
string ErrorMessage = "";
foreach (var error in result.Errors)
{
ErrorMessage += error.Description + "\n";
}
return(ErrorMessage);
}
}
return("Користувача не існує!");
}
public HttpResponseMessage EditUser(UserEditDTO userDTO)
{
User userToEdit = mapper.CreateUserEditEntity(userDTO);
bool duplicateEmailAddress = userRepo.CheckEmailAddress(userToEdit.EmailAddress);
if (duplicateEmailAddress == false)
{
if (userToEdit.Id == 0)
{
return(Request.CreateResponse(HttpStatusCode.Conflict));
}
else
{
userRepo.EditUser(userToEdit);
return(Request.CreateResponse(HttpStatusCode.OK));
}
}
else if (userRepo.GetUserById(userDTO.Id).EmailAddress == userToEdit.EmailAddress)
{
userRepo.EditUser(userToEdit);
return(Request.CreateResponse(HttpStatusCode.OK));
}
else
{
return(Request.CreateResponse(HttpStatusCode.Conflict));
}
}
public async Task <UserEditDTO> SaveUser(UserEditDTO user)
{
if (string.IsNullOrEmpty(user.ProviderUserKey))
{
if (user.ProviderUserKey == null && this._userManager.Users.Where(u => u.UserName == user.UserName).Count() > 0)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(string.Format("The username {0} is already in use", user.UserName)), ReasonPhrase = "Business exception"
});
}
ClientPortalUser newUser = new ClientPortalUser();
newUser.UserName = user.UserName;
newUser.TwoFactorEnabled = false;
newUser.PhoneNumberConfirmed = false;
newUser.PhoneNumber = user.Phone;
newUser.LockoutEnabled = true;
newUser.LastName = user.LastName;
//newUser.Department = user.Department;
newUser.IsApproved = true;
newUser.FirstName = user.FirstName;
newUser.Email = user.Email;
newUser.CreationDateUtc = DateTime.UtcNow;
newUser.DefaultRole = "GUEST";
//newUser.CdtId = user.CdtId ?? 0;
await this._userManager.CreateAsync(newUser, "Welcome1"); //default password should be changed
newUser = await this._userManager.FindByNameAsync(user.UserName);
await this._userManager.AddToRoleAsync(newUser.Id, "GUEST");
}
else
{
ClientPortalUser userEdit = await this._userManager.FindByNameAsync(user.UserName);
userEdit.Email = user.Email;
userEdit.FirstName = user.FirstName;
userEdit.LastName = user.LastName;
userEdit.PhoneNumber = user.Phone;
userEdit.IsApproved = user.IsApproved;
//userEdit.Department = user.Department;
//userEdit.CdtId = user.CdtId ?? 0;
if (user.IsLockedOut)
{
userEdit.LockoutEndDateUtc = SqlDateTime.MaxValue.Value;
}
else
{
userEdit.LockoutEndDateUtc = null;
}
await this._userManager.UpdateAsync(userEdit);
}
UserEditDTO userDto = await this.GetUser(user.UserName);
return(userDto);
}
public async Task <ActionResult> EditUser(UserEditDTO model, HttpPostedFileBase picture)
{
ClaimsIdentity identity = (ClaimsIdentity)User.Identity;
if (!ModelState.IsValid)
{
TempData["ViewData"] = ViewData;
return(RedirectToAction("Detail", "User", new { id = int.Parse(identity.FindFirst(ClaimTypes.NameIdentifier).Value) }));
}
UserEditDTO userToEdit = new UserEditDTO();
userToEdit.Address = model.Address;
userToEdit.EmailAddress = model.EmailAddress;
userToEdit.Id = int.Parse(identity.FindFirst(ClaimTypes.NameIdentifier).Value);
if (picture != null)
{
if (picture.ContentType == "image/jpeg" || picture.ContentType == "image/jpg" || picture.ContentType == "image/png" || picture.ContentType == "image/gif")
{
byte[] image = new byte[picture.ContentLength];
picture.InputStream.Read(image, 0, image.Length);
userToEdit.AvatarImage = new AvatarImageDTO()
{
AvatarImageBytes = image,
User = new UserDTO()
{
Id = int.Parse(identity.FindFirst(ClaimTypes.NameIdentifier).Value)
}
};
}
}
string content = JsonConvert.SerializeObject(userToEdit);
Byte[] buffer = System.Text.Encoding.UTF8.GetBytes(content);
ByteArrayContent byteContent = new ByteArrayContent(buffer);
byteContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
HttpResponseMessage result = await client.PostAsync(apiUrl + "/EditUser", byteContent);
if (result.StatusCode == HttpStatusCode.Conflict)
{
TempData["EmailError"] = "true";
return(RedirectToAction("Detail", "User", new { id = int.Parse(identity.FindFirst(ClaimTypes.NameIdentifier).Value) }));
}
if (result.StatusCode == HttpStatusCode.OK)
{
return(RedirectToAction("Detail", "User", new { id = userToEdit.Id }));
}
else
{
return(View("Error"));
}
}
public static void MapForEdit(this User dbUser, UserEditDTO user)
{
dbUser.Id = user.Id;
dbUser.Name = user.Name;
dbUser.Family = user.Family;
dbUser.Email = user.Email;
dbUser.Password = user.Password;
dbUser.IsActive = user.IsActive;
}
public void UpdateUser(UserEditDTO user)
{
this._personRepository.Update(this._mapper.Map <UserDTO, Persons>(user.person));
Users userUpdate = this._mapper.Map <UserDTO, Users>(user.user);
userUpdate.PersonId = user.person.Id;
this._userRepository.Update(userUpdate);
this.log.WriteLog("Update User", userUpdate.UserName);
}
public void AddUser(UserEditDTO user)
{
Persons person = this._personRepository.Insert(this._mapper.Map <UserDTO, Persons>(user.person));
Users userToInsert = this._mapper.Map <UserDTO, Users>(user.user);
userToInsert.PersonId = person.Id;
userToInsert.IsActive = true;
this._userRepository.Insert(userToInsert);
this.log.WriteLog("Create user", userToInsert.UserName);
}
public JsonResult SaveUser(UserEditDTO token)
{
string error;
var result = _userAccountServices.UpdateUser(token, out error);
return(Json(new JsonResponseToken
{
success = result
, error = error
}, JsonRequestBehavior.AllowGet));
}
public static User FromUserEditDTO(UserEditDTO DTO)
{
return(new User()
{
Id = DTO.Id,
Name = DTO.Name,
Surname = DTO.Surname,
PhoneNumber = DTO.PhoneNumber,
Email = DTO.Email,
PasswordHash = DTO.PasswordHash
});
}
public Domain.User.User PopulateDomainObject(Domain.User.User entity, UserEditDTO dto)
{
entity.FirstName = dto.FirstName;
entity.LastName = dto.LastName;
entity.Address = new Address()
{
Country = dto.Country,
City = dto.City,
Street = dto.Street,
HouseNumber = dto.HouseNumber
};
return(entity);
}
public async Task <UserDTO> UpdateUserAsync(UserEditDTO userEditDTO)
{
var user = await _userRepository.GetByIdAsync(userEditDTO.Id);
user = _mapper.Map(userEditDTO, user);
if (userEditDTO.Password != null)
{
var newPassword = _userManager.PasswordHasher.HashPassword(user, userEditDTO.Password);
user.PasswordHash = newPassword;
}
await _userRepository.UpdateAsync(user);
return(_mapper.Map <UserDTO>(user));
}
//-> Edit
public async Task<UserViewDTO> Edit(UserEditDTO editDTO)
{
editDTO = StringHelper.TrimStringProperties(editDTO);
var checkRecord = await db.tblUsers.FirstOrDefaultAsync(x => x.deleted == null && x.userName == editDTO.userName && x.id != editDTO.id);
if (checkRecord != null)
throw new HttpException((int)HttpStatusCode.BadRequest, ConstantHelper.LOGIN_NAME_EXIST);
var record = await db.tblUsers.FirstOrDefaultAsync(x => x.deleted == null && x.id == editDTO.id);
if (record == null)
throw new HttpException((int)HttpStatusCode.NotFound, "NotFound");
record = (tblUser)MappingHelper.MapDTOToDBClass<UserEditDTO, tblUser>(editDTO, record);
//record.updatedDate = DateTime.Now;
await db.SaveChangesAsync();
return await SelectByID(record.id);
}
/*====================== Edit ======================*/
public async Task <bool> UpdateUser(UserEditDTO user)
{
string serializedUser = JsonConvert.SerializeObject(user);
var requestMessage = new HttpRequestMessage(HttpMethod.Put, "UpdateUser");
requestMessage.Content = new StringContent(serializedUser);
requestMessage.Content.Headers.ContentType
= new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var response = await httpClient.SendAsync(requestMessage);
var responseStatusCode = response.StatusCode;
var responseBody = await response.Content.ReadAsStringAsync();
var returnedUser = JsonConvert.DeserializeObject <UserRegisterDTO>(responseBody);
return(returnedUser.Email != null ? true : false);
}
public async Task <ActionResult> EditUserInfo([FromBody] UserEditDTO userInfo)
{
try
{
UserDTO result = await _userService.EditUserInfo(userInfo);
if (result == null)
{
return(BadRequest());
}
return(Ok(result));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> UpdateUser(int id, UserEditDTO userEditDTO)
{
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userFromRepo = await _datingRepo.GetUser(id);
_mapper.Map(userEditDTO, userFromRepo);
if (await _datingRepo.SaveAll())
{
return(NoContent()); // '204 No Content' means save was successful
}
throw new Exception($"Failed to update user {id}");
}
public ApplicationUser EditUser(UserEditDTO regUser)
{
regUser.PhoneNumber = "0" + Misc.NormalizePhoneNumber(regUser.PhoneNumber);
var user = dbContext.Users.Find(regUser.Id);
user.UserName = regUser.Email;
user.NormalizedUserName = regUser.Email.ToUpper();
user.FirstName = regUser.FirstName == "null" ? null : regUser.FirstName;
user.LastName = regUser.LastName == "null" ? null : regUser.LastName;
user.Email = regUser.Email == "null" ? null : regUser.Email;
user.NormalizedEmail = regUser.Email.ToUpper();
user.PhoneNumber = regUser.PhoneNumber == "null" ? null : regUser.PhoneNumber;
if (user.MomoDetails == null)
{
user.MomoDetails = new MobileMoneyDetails();
}
user.MomoDetails.Country = regUser.Country == "null" ? null : regUser.Country;
user.MomoDetails.Number = regUser.MobileMoneyNumber == "null" ? null : regUser.MobileMoneyNumber;
user.MomoDetails.Network = regUser.Network == "null" ? null : regUser.Network;
user.MomoDetails.Currency = regUser.Currency == "null" ? null : regUser.Currency;
if (user.BankDetails == null)
{
user.BankDetails = new BankDetails();
}
user.BankDetails.BankName = regUser.BankName == "null" ? null : regUser.BankName;
user.BankDetails.AccountNumber = regUser.AccountNumber == "null" ? null : regUser.AccountNumber;
user.BankDetails.SwiftCode = regUser.SwiftCode == "null" ? null : regUser.SwiftCode;
user.PreferedMoneyReceptionMethod = regUser.PreferredReceptionMethod == "null" ? null : regUser.PreferredReceptionMethod;
try
{
dbContext.Entry(user).State = EntityState.Modified;
dbContext.Entry(user.BankDetails).State = EntityState.Modified;
dbContext.Entry(user.MomoDetails).State = EntityState.Modified;
dbContext.SaveChanges();
return(user);
}
catch
{
return(null);
}
}
public async Task <int> UpdateUser(string user_id, UserEditDTO value)
{
if (ValidateUser(user_id, 1))
{
Users user;
user = GetUser(value.Id);
if (user_id != value.Id)
{
if (ValidateUser(user_id, 2) != true)
{
return(401);
}
}
if (user != null)
{
if (ValidateUser(user.Id, 3))
{
user.Role = value.Role;
user.Active = value.Active;
user.Email = value.Email;
user.FirstName = value.FirstName;
user.LastName = value.LastName;
user.Phone = value.Phone;
_context.Update(user);
await _context.SaveChangesAsync();
return(200);
}
else
{
return(404);
}
}
else
{
return(404);
}
}
else
{
return(401);
}
}
public async Task <ActionResult> UpdateUser([FromBody] UserEditDTO value)
{
string user_id = Request.Headers.FirstOrDefault(header => header.Key == "user_id").Value;
var resul = await _repository.UpdateUser(user_id, value);
if (resul == 200)
{
return(Ok());
}
else if (resul == 401)
{
return(Unauthorized("You have no permission to perform this action"));
}
else
{
return(NotFound("User not exist"));
}
}
public void PostInvalidTest()
{
var input = new UserEditDTO {
FirstName = null,
LastName = null,
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
};
var expected = new InsertUserResponse {
Result = false,
Exception = new ValidationException("name")
};
var mockService = new Mock <IUserService>();
mockService.Setup(x => x.InsertUser(It.IsAny <InsertUserRequest>())).Returns(expected);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new UserController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(It.IsAny <HttpRequestMessage>(), expected))
.Returns(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(expected.Exception.Message)
});
var response = controller.Post(input);
bool result;
response.TryGetContentValue(out result);
Assert.IsFalse(result);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
mockService.Verify(x => x.InsertUser(It.IsAny <InsertUserRequest>()), Times.Once);
}
public async Task <IActionResult> EditUser([FromHeader] int userId, [FromBody] UserEditDTO model)
{
var usr = _db.Users.FirstOrDefault(user => user.Id == userId);
if (usr == null)
{
return(BadRequest("Пользователь не найден"));
}
usr.Email = model.Email;
usr.Name = model.Name;
usr.Surname = model.Surname;
usr.Patronymic = model.Patronymic;
_db.Users.Update(usr);
await _db.SaveChangesAsync();
return(Ok(usr));
}
public HttpResponseMessage Post([FromBody] UserEditDTO user)
{
var request = new InsertUserRequest {
UserProperties = user
};
var response = new InsertUserResponse();
try
{
response = _userService.InsertUser(request);
}
catch (Exception ex)
{
response.Exception = ex;
}
return(_responseBuilder.BuildResponse(Request, response));
}
public async Task <IActionResult> EditUser([FromForm] UserEditDTO regDTO)
{
ApplicationUser result = null;
if (ModelState.IsValid)
{
result = _userService.EditUser(regDTO);
if (result != null)
{
return(Ok(result));
}
else
{
return(BadRequest(""));
}
}
return(NoContent());
}
public async Task <IActionResult> EditUser(UserEditDTO userDTO)
{
var user = await context.Users.SingleOrDefaultAsync(u => u.Id == userDTO.Id);
if (userDTO.FullName != null && userDTO.FullName != "")
{
user.FullName = userDTO.FullName;
}
if (userDTO.PhoneNumber != null && userDTO.PhoneNumber != "")
{
user.PhoneNumber = userDTO.PhoneNumber;
}
if (userDTO.NotificationDeviceId != null && userDTO.NotificationDeviceId != "")
{
user.NotificationDeviceId = userDTO.NotificationDeviceId;
}
await context.SaveChangesAsync();
return(Ok());
}
//[HttpGet]
//public UserEditDTO GetUserByCdtId([FromUri]
// int correlationId)
//{
// ClientPortalUser user = this._userManager.Users.SingleOrDefault(x => x.CdtId == correlationId);
// if (user == null)
// {
// throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound) { Content = new StringContent(string.Format("User with correlationId {0} not found", correlationId)), ReasonPhrase = "Business exception" });
// }
// var dto = BuildCdtUser(user);
// return dto;
//}
private UserEditDTO BuildCdtUser(ClientPortalUser user)
{
UserEditDTO dto = new UserEditDTO();
dto.CreationDateUtc = user.CreationDateUtc;
dto.FirstName = user.FirstName;
dto.IsApproved = user.IsApproved;
dto.IsLockedOut = DateTime.UtcNow < user.LockoutEndDateUtc;
dto.LastLoginDateUtc = user.LastLoginDateUtc;
dto.LastName = user.LastName;
dto.LastPasswordResetDateUtc = user.LastPasswordResetDateUtc;
dto.Phone = user.PhoneNumber;
dto.ProviderUserKey = user.SecurityStamp;
dto.UserName = user.UserName;
dto.Email = user.Email;
dto.LockOutEndDateUtc = user.LockoutEndDateUtc;
//dto.CdtId = user.CdtId;
//dto.Department = user.Department;
return(dto);
}
