public async Task <UserProfileResponseModel> UpdateUser(UserUpdateRequestModel model)
{
var dbUser = await _userRepository.GetExists(u => u.Email == model.Email);
if (dbUser == false)
{
return(null);
}
var existUser = await _userRepository.GetUserByEmail(model.Email);
existUser.FullName = model.FullName;
existUser.Password = model.Password;
var updatedUser = await _userRepository.Update(existUser);
UserProfileResponseModel response = new UserProfileResponseModel
{
Id = updatedUser.Id,
Email = updatedUser.Email,
FullName = updatedUser.FullName,
JoinedOn = updatedUser.JoinedOn,
};
return(response);
}
public async Task <ResponseModel> UpdateProfileAsync(UserUpdateRequestModel model)
{
var user = await _userManager.Users
.Include(x => x.UserRoles)
.ThenInclude(x => x.Role)
.FirstOrDefaultAsync(x => x.PhoneNumber == model.PhoneNumber);
if (user == null)
{
return(new ResponseModel()
{
StatusCode = System.Net.HttpStatusCode.NotFound,
Message = "Tài khoản này đã bị ban hoặc không tìm thấy"
});
}
user.Name = model.Name ?? user.Name;
user.Email = model.Email ?? user.Email;
user.Address = model.Address ?? user.Address;
user.DeviceToken = model.DeviceToken ?? user.DeviceToken;
await _userManager.UpdateAsync(user);
return(new ResponseModel()
{
StatusCode = System.Net.HttpStatusCode.OK,
Data = new UserBaseViewModel(user)
});
}
public async Task <IActionResult> UpdateProfile([FromBody] UserUpdateRequestModel model)
{
var phoneNumber = User.FindFirst(ClaimTypes.NameIdentifier).Value;
model.PhoneNumber = phoneNumber;
var responseModel = await _identityService.UpdateProfileAsync(model);
return(new CustomActionResult(responseModel));
}
public async Task <IActionResult> UpdateUser([FromBody] UserUpdateRequestModel model)
{
var user = await _userService.UpdateUser(model);
if (user == null)
{
return(NotFound("User email does not exist"));
}
return(Ok(user));
}
public UserDto PutUser(Guid key, UserUpdateRequestModel requestModel) {
var user = _membershipService.GetUser(key);
if (user == null) {
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var userWithRoles = _membershipService.UpdateUser(
user.User, requestModel.Name, requestModel.Email);
return userWithRoles.ToUserDto();
}
public async Task <User> UpdateUser(UserUpdateRequestModel userRequestModel)
{
var user = await _userRepository.GetById(userRequestModel.Id);
user.Email = userRequestModel.Email;
user.FullName = userRequestModel.FullName;
user.MobileNo = userRequestModel.MobileNo;
if (userRequestModel.Password != null)
{
user.Password = userRequestModel.Password;
}
return(await _userRepository.Update(user));
}
// take in model to create user entity to send to repository
public async Task <bool> UpdateUser(UserUpdateRequestModel model)
{
var updatedUser = new User
{
Id = model.Id,
Email = model.Email,
Password = model.Password,
Fullname = model.Fullname,
JoinedOn = model.JoinedOn
};
await _userRepository.UpdateAsync(updatedUser);
return(true);
}
public UserDto PutUser(Guid key, UserUpdateRequestModel requestModel)
{
var user = _membershipService.GetUser(key);
if (user == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
var userWithRoles = _membershipService.UpdateUser(
user.User, requestModel.Name, requestModel.Email);
return(userWithRoles.ToUserDto());
}
public void UpdateUser(UserUpdateRequestModel um)
{
//List<string> q = new List<string>();
//int i = 0;
//um.Columns.ForEach(x =>
//{
// q.Add(x + " = " + "@" + i);
// i++;
//});
//var sql = "update tblusers set " + string.Join(", ", q.ToArray()) + " where userid = @" + i;
//um.Values.Add(Convert.ToString(um.UserId));
//Da.Update<UserModel>(sql, um.Values.ToArray());
}
public ActionResult <CommonResponeModel> Update(UserUpdateRequestModel model)
{
var user = userRepository.GetById(model.Id);
if (user != null)
{
if (userRepository.IsExistUsername(model.Username) && user.Username != model.Username)
{
string message = UserMessageGlobal.ExistUsername;
Result = new ErrorResult(ActionType.Login, message);
return(GetCommonRespone());
}
else
{
if (model.Password == user.Password) //Not change password
{
user.Password = user.Password; //update to old password
}
else //change password
{
user.MapFrom(model);
user.InitBeforeSave(RequestUsername, InitType.Update);
user.InitDefault();
user.SetPassword();
}
int result = userRepository.Update(user);
if (result > 0)
{
Result = new SuccessResult(ActionType.Edit, AppGlobal.EditSuccess);
Data = user;
}
else
{
Result = new ErrorResult(ActionType.Edit, AppGlobal.EditError);
Data = user;
}
}
}
else
{
string message = UserMessageGlobal.NotExistUser;
Result = new ErrorResult(ActionType.Login, message);
}
return(GetCommonRespone());
}
public async Task <string> UpdateUser(UserUpdateRequestModel userUpdateRequestModel)
{
//try
//{
var user = _mapper.Map <User>(userUpdateRequestModel);
var userMobile = _mapper.Map <List <UserMobileNumber> >(userUpdateRequestModel.UserMobileNumbers);
await _userRepository.UpdateAsync(user);
await _userMobileRepository.UpdateRangeAsync(userMobile);
return(ResultStatus.SUCCESS);
//}
//catch (Exception)
//{
//return "FAILED";
//}
}
Returns_400_If_Request_Authorized_But_Invalid()
{
// Arrange
Guid[] keys = new[] {
Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()
};
var config = IntegrationTestHelper
.GetInitialIntegrationTestConfig(
GetInitialServices(GetMembershipService(keys)));
// This is a not valid user request to update one
var userRequestModel = new UserUpdateRequestModel {
Name = "ANameWhichIsMoreThan50CharsANameWhichIsMoreThan50Chars",
Email = "FooBarexample.com",
};
var request = HttpRequestMessageHelper
.ConstructRequest(
httpMethod: HttpMethod.Put,
uri: string.Format(
"https://localhost/{0}/{1}",
"api/users",
keys[1]),
mediaType: "application/json",
username: Constants.ValidAdminUserName,
password: Constants.ValidAdminPassword);
request.Content = new ObjectContent <UserUpdateRequestModel>(
userRequestModel, new JsonMediaTypeFormatter());
// Act
var httpError = await IntegrationTestHelper
.GetResponseMessageBodyAsync <HttpError>(
config, request, HttpStatusCode.BadRequest);
var modelState = (HttpError)httpError["ModelState"];
var nameError = modelState["requestModel.Name"] as string[];
var emailError = modelState["requestModel.Email"] as string[];
// Assert
Assert.NotNull(nameError);
Assert.NotNull(emailError);
}
public async Task <IActionResult> UpdateUser(UserUpdateRequestModel userModel)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values));
}
await _userService.UpdateUser(userModel);
return(Ok());
}
catch (Exception e)
{
Console.WriteLine(e);
return(StatusCode(500, e.Message));
}
}
public async Task <IActionResult> UpdateUser([FromBody] UserUpdateRequestModel userUpdateRequestModel)
{
try
{
var userId = HttpContext.User.GetUserIdClaim();
if (userId != userUpdateRequestModel.UserId)
{
return(BadRequest(new ApiResponseBadRequestResult()
{
ErrorMessage = $"Data posted is not for logged-in User."
}));
}
var user = await _userManager.FindByIdAsync(userId.ToString());
if (null == user)
{
return(BadRequest(new ApiResponseBadRequestResult()
{
ErrorMessage = $"User with Id {userId} does not exists"
}));
}
_mapper.Map(userUpdateRequestModel, user);
var result = await _userManager.UpdateAsync(user);
return(Ok(new ApiResponseOKResult()
{
StatusCode = StatusCodes.Status200OK, Data = result.Succeeded
}));
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to update user details");
return(StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponseFailure()
{
ErrorMessage = "Failed to update user details"
}));
}
}
Returns_404_If_Request_Authorized_But_User_Does_Not_Exist()
{
// Arrange
Guid[] keys = new[] {
Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()
};
var invalidUserKey = Guid.NewGuid();
var config = IntegrationTestHelper
.GetInitialIntegrationTestConfig(
GetInitialServices(GetMembershipService(keys)));
// This is a valid user request to update one
var userRequestModel = new UserUpdateRequestModel {
Name = "FooBar",
Email = "*****@*****.**",
};
var request = HttpRequestMessageHelper
.ConstructRequest(
httpMethod: HttpMethod.Put,
uri: string.Format(
"https://localhost/{0}/{1}",
"api/users",
invalidUserKey),
mediaType: "application/json",
username: Constants.ValidAdminUserName,
password: Constants.ValidAdminPassword);
request.Content = new ObjectContent <UserUpdateRequestModel>(
userRequestModel, new JsonMediaTypeFormatter());
var response = await IntegrationTestHelper
.GetResponseAsync(config, request);
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
Returns_200_And_User_If_Request_Authorized_But_Request_Is_Valid()
{
// Arrange
Guid[] keys = new[] {
Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()
};
var config = IntegrationTestHelper
.GetInitialIntegrationTestConfig(
GetInitialServices(GetMembershipService(keys)));
// This is a valid user request to update one
var userRequestModel = new UserUpdateRequestModel {
Name = "FooBar",
Email = "*****@*****.**",
};
var request = HttpRequestMessageHelper
.ConstructRequest(
httpMethod: HttpMethod.Put,
uri: string.Format(
"https://localhost/{0}/{1}",
"api/users",
keys[2]),
mediaType: "application/json",
username: Constants.ValidAdminUserName,
password: Constants.ValidAdminPassword);
request.Content = new ObjectContent <UserUpdateRequestModel>(
userRequestModel, new JsonMediaTypeFormatter());
// Act
var userDto = await IntegrationTestHelper.GetResponseMessageBodyAsync <UserDto>(config, request, HttpStatusCode.OK);
// Assert
Assert.Equal(userRequestModel.Name, userDto.Name);
Assert.Equal(userRequestModel.Email, userDto.Email);
}
public async Task <UserResponseModel> UpdateUser(UserUpdateRequestModel userUpdateRequestModel)
{
var updateUser = new User
{
Id = userUpdateRequestModel.Id,
Email = userUpdateRequestModel.Email,
Fullname = userUpdateRequestModel.Fullname,
Password = userUpdateRequestModel.Password,
JoinedOn = userUpdateRequestModel.JoinedOn
};
var updatedUser = await _userRepository.UpdateAsync(updateUser);
var updatedUserResponseModel = new UserResponseModel
{
Id = updatedUser.Id,
Email = updatedUser.Email,
Fullname = updatedUser.Fullname,
JoinedOn = updatedUser.JoinedOn
};
return(updatedUserResponseModel);
}
Returns_200_And_User_If_Request_Authorized_But_Request_Is_Valid() {
// Arrange
Guid[] keys = new[] {
Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()
};
var config = IntegrationTestHelper
.GetInitialIntegrationTestConfig(
GetInitialServices(GetMembershipService(keys)));
// This is a valid user request to update one
var userRequestModel = new UserUpdateRequestModel {
Name = "FooBar",
Email = "*****@*****.**",
};
var request = HttpRequestMessageHelper
.ConstructRequest(
httpMethod: HttpMethod.Put,
uri: string.Format(
"https://localhost/{0}/{1}",
"api/users",
keys[2]),
mediaType: "application/json",
username: Constants.ValidAdminUserName,
password: Constants.ValidAdminPassword);
request.Content = new ObjectContent<UserUpdateRequestModel>(
userRequestModel, new JsonMediaTypeFormatter());
// Act
var userDto = await IntegrationTestHelper.GetResponseMessageBodyAsync<UserDto>(config, request, HttpStatusCode.OK);
// Assert
Assert.Equal(userRequestModel.Name, userDto.Name);
Assert.Equal(userRequestModel.Email, userDto.Email);
}
Returns_400_If_Request_Authorized_But_Invalid() {
// Arrange
Guid[] keys = new[] {
Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()
};
var config = IntegrationTestHelper
.GetInitialIntegrationTestConfig(
GetInitialServices(GetMembershipService(keys)));
// This is a not valid user request to update one
var userRequestModel = new UserUpdateRequestModel {
Name = "ANameWhichIsMoreThan50CharsANameWhichIsMoreThan50Chars",
Email = "FooBarexample.com",
};
var request = HttpRequestMessageHelper
.ConstructRequest(
httpMethod: HttpMethod.Put,
uri: string.Format(
"https://localhost/{0}/{1}",
"api/users",
keys[1]),
mediaType: "application/json",
username: Constants.ValidAdminUserName,
password: Constants.ValidAdminPassword);
request.Content = new ObjectContent<UserUpdateRequestModel>(
userRequestModel, new JsonMediaTypeFormatter());
// Act
var httpError = await IntegrationTestHelper
.GetResponseMessageBodyAsync<HttpError>(
config, request, HttpStatusCode.BadRequest);
var modelState = (HttpError)httpError["ModelState"];
var nameError = modelState["requestModel.Name"] as string[];
var emailError = modelState["requestModel.Email"] as string[];
// Assert
Assert.NotNull(nameError);
Assert.NotNull(emailError);
}
Returns_404_If_Request_Authorized_But_User_Does_Not_Exist() {
// Arrange
Guid[] keys = new[] {
Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()
};
var invalidUserKey = Guid.NewGuid();
var config = IntegrationTestHelper
.GetInitialIntegrationTestConfig(
GetInitialServices(GetMembershipService(keys)));
// This is a valid user request to update one
var userRequestModel = new UserUpdateRequestModel {
Name = "FooBar",
Email = "*****@*****.**",
};
var request = HttpRequestMessageHelper
.ConstructRequest(
httpMethod: HttpMethod.Put,
uri: string.Format(
"https://localhost/{0}/{1}",
"api/users",
invalidUserKey),
mediaType: "application/json",
username: Constants.ValidAdminUserName,
password: Constants.ValidAdminPassword);
request.Content = new ObjectContent<UserUpdateRequestModel>(
userRequestModel, new JsonMediaTypeFormatter());
var response = await IntegrationTestHelper
.GetResponseAsync(config, request);
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task <IActionResult> UpdateUser(UserUpdateRequestModel model)
{
var updatedUser = await _userService.UpdateUser(model);
return(Ok(updatedUser));
}
public async Task <IActionResult> Update([FromBody] UserUpdateRequestModel userUpdateRequestModel)
{
var result = await _userService.UpdateUser(userUpdateRequestModel);
return(Ok(new GenericResponse(true)));
}
public IHttpActionResult Post(UserUpdateRequestModel model)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var currentUserId = this.User.Identity.GetUserId();
var updatedProfileId = this.users.Update(currentUserId, model.FirstName, model.LastName, model.DateOfBirth, model.IsMale, model.Description);
return this.Ok(updatedProfileId);
}
