public static void UpdateUser(UpdateUserRequestModel model)
{
var connection = new SqlConnection(GlobalSettings.ConnectionString);
connection.Open();
var commandString = @"UPDATE [User] SET Name=@Name,
Lastname=@Lastname,
PhoneNumber=@PhoneNumber
WHERE Id=@Id"
;
using (var command = new SqlCommand(commandString, connection))
{
command.Parameters.AddWithValue("@Name", model.Name);
command.Parameters.AddWithValue("@Lastname", model.Lastname);
command.Parameters.AddWithValue("@PhoneNumber", model.PhoneNumber);
command.Parameters.AddWithValue("@Id", model.UserId);
command.ExecuteNonQuery();
}
connection.Close();
}
public void PutTest()
{
User user = GetUser();
UpdateUserRequestModel userRequest = GetUpdateUserRequestModel();
UserResponseModel userResponse = GetUserResponseModel();
ValidationResponse <User> validationResponse = GetOkValidationResponse();
_mockMapper
.Setup(mapper => mapper.Map <UpdateUserRequestModel, User>(userRequest))
.Returns(user);
_mockService
.Setup(serv => serv.Update(user))
.Returns(validationResponse);
_mockMapper
.Setup(mapper => mapper.Map <User, UserResponseModel>(validationResponse.ResponseData))
.Returns(userResponse);
IActionResult actionResult = _controller.Put(_userId, userRequest);
OkObjectResult actual = (OkObjectResult)actionResult;
string actualName = ((UserResponseModel)actual.Value).FullName;
Assert.Equal(user.FullName, actualName);
Assert.Equal(StatusCodes.Status200OK, actual.StatusCode);
}
public async Task <ResultModel <bool> > UpdateUser(string userId, UpdateUserRequestModel model)
{
var user = await GetById(userId);
if (user == null)
{
return(new ResultModel <bool>
{
Errors = { UserErrors.InvalidUserId }
});
}
user.Biography = model.Biography;
// In case the user deteles his display name. I need it because I render it on the front-end (the header).
user.DisplayName = string.IsNullOrWhiteSpace(model.DisplayName) || model.DisplayName == "" ?
user.DisplayName = user.UserName :
user.DisplayName = model.DisplayName;
user.Email = model.Email;
user.ProfilePictureUrl = model.ProfilePictureUrl;
this.dbContext.Update(user);
await this.dbContext.SaveChangesAsync();
return(new ResultModel <bool>
{
Result = true,
Success = true,
});
}
public async Task <ActionResult <UserDto> > Update(UpdateUserRequestModel model)
{
var user = await _repository.Update(User.GetId(), model);
return(user != null
? Accepted(nameof(Update), model)
: StatusCode(StatusCodes.Status500InternalServerError, null));
}
public Task <IActionResult> Update([FromBody] UpdateUserRequestModel model)
{
return(HandleCommand(new UpdateUserCommand
{
UserId = User.GetId(),
Model = model
}));
}
public int Update(UpdateUserRequestModel model)
{
var user = _repo.GetById(model.Id);
user.Age = model.Age;
user.Login = model.Name;
return(_repo.Update(user));
}
public async Task <ActionResult> UpdateUser([FromBody] UpdateUserRequestModel input)
{
var userId = this.User.GetId();
await this.identityService.UpdateUserAsync(userId, input.FullName, input.UserName, input.ImageUrl);
return(this.Ok());
}
public async Task <IActionResult> UpdateUserByIdObjectAsParam(Guid id, UpdateUserRequestModel userRequestModel)
{
//*****************Calls update controller on Identity API, so the db is synced***************************
//var identityBaseurl = _identityConfig.Value.IdentityServerUrl + "/identity/users/" + id;
var identityBaseurl = "https://localhost:5001/identity/users/" + id;
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders
.Accept
.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
var jsonUpdateStatement = JsonConvert.SerializeObject(new UpdateIdentityUser
{
Email = userRequestModel.Email,
Password = userRequestModel.Password,
AuthLevel = userRequestModel.AccessLevel,
}, Formatting.Indented);
var httpContent = new StringContent(jsonUpdateStatement, System.Text.Encoding.UTF8, "application/json");
var identityResult = await httpClient.PutAsync(identityBaseurl, httpContent);
if (!identityResult.IsSuccessStatusCode)
{
return(StatusCode(400, "Identity server could not be reached."));
}
//*********************Update API db (seperate from identity db)************************
//Gets user from database to handle null and empty variables in the request model
var user = await QueryRouter.QueryAsync <GetUserById, User>(new GetUserById(id));
//if the variables are empty or null, (or 0 for access level), they wont be updated
if (user != null)
{
if (string.IsNullOrWhiteSpace(userRequestModel.Name) && !string.IsNullOrWhiteSpace(user.Name))
{
userRequestModel.Name = user.Name;
}
if (string.IsNullOrWhiteSpace(userRequestModel.Email) && !string.IsNullOrWhiteSpace(user.Email))
{
userRequestModel.Email = user.Email;
}
if (userRequestModel.AccessLevel == 0)
{
userRequestModel.AccessLevel = user.AccessLevel;
}
if (userRequestModel.Wage == 0)
{
userRequestModel.Wage = user.BaseWage;
}
}
var result = await CommandRouter.RouteAsync <UpdateUserCommand, IdResponse>(
new UpdateUserCommand(userRequestModel.Name, userRequestModel.Email, userRequestModel.Password,
userRequestModel.AccessLevel, userRequestModel.Wage, userRequestModel.EmploymentDate, id));
return(new ObjectResult(result));
}
public async Task <UserResponseModel> UpdateAsync(int id, UpdateUserRequestModel updateUserRequestModel)
{
const string actionName = nameof(UpdateAsync);
updateUserRequestModel = updateUserRequestModel ?? throw new ArgumentNullException(nameof(updateUserRequestModel));
if (id != updateUserRequestModel.Id)
{
throw new InconsistentException(nameof(updateUserRequestModel));
}
var username = await _userManager.Users.AnyAsync(x => x.UserName == updateUserRequestModel.UserName && x.Id != id);
if (username)
{
throw new DataAlreadyException(updateUserRequestModel.UserName);
}
var email = await _userManager.Users.AnyAsync(x => x.Email == updateUserRequestModel.Email && x.Id != id);
if (email)
{
throw new DataAlreadyException(updateUserRequestModel.Email);
}
var listRole = updateUserRequestModel.Role;
var _user = await _userManager.FindByIdAsync(id.ToString());
var roles = await _userManager.GetRolesAsync(_user);
foreach (var role in listRole)
{
if (await _userManager.IsInRoleAsync(_user, role) == false)
{
await _userManager.AddToRoleAsync(_user, role);
}
else
{
foreach (var item in roles)
{
if (!item.Contains(role))
{
await _userManager.RemoveFromRoleAsync(_user, item);
}
}
}
}
Logger.LogDebug(LoggingMessage.ProcessingInService, actionName, seviceName, updateUserRequestModel);
var user = await _userRepository.GetAsync(id);
_Mapper.Map(updateUserRequestModel, user);
var respone = await _userRepository.UpdateAsync(user, true);
Logger.LogInfomation(LoggingMessage.ActionSuccessfully, actionName, seviceName, respone);
return(_Mapper.Map <UserResponseModel>(respone));
}
public async Task <IHttpActionResult> Put(UpdateUserRequestModel model)
{
var authenticatedUser = this.User.Identity.GetUserId();
var updateUserResult = await this.usersServices.Update(
authenticatedUser,
model.Email);
return(this.Ok(updateUserResult));
}
/// <summary>
/// Updates the user profile.
/// </summary>
/// <param name="updatedUserProfile">The updated user profile(new profile).</param>
public void UpdateProfile([FromBody] UpdateUserRequestModel updatedUserProfile)
{
user = new UserDto
{
ID = updatedUserProfile.UserID,
Password = updatedUserProfile.Password,
Email = updatedUserProfile.Email,
Image = updatedUserProfile.Image,
};
userManger.UpdateUserProfile(user);
}
public async Task <IActionResult> UpdateUser(int id, [FromBody] UpdateUserRequestModel user)
{
await _userRepository.Update(new User
{
Id = id,
Email = user.Email,
Name = user.Name,
Surname = user.Surname
});
return(Ok());
}
public async Task <IActionResult> UpdateUser(Guid id, [FromBody] UpdateUserRequestModel requestModel)
{
//apparently Guids can be made 'nullable', so a null check is made, although guid is a value type and thus cannot be null pr. default
if (id == Guid.Empty || id == null)
{
return(StatusCode(400));
}
var result = await _userHandler.UpdateUser(id, requestModel);
return(StatusCode(!result.IsSuccessful ? 400 : 200, result.Message));
}
public async Task <ActionResult> UpdateUserInformation(UpdateUserRequestModel model)
{
string userId = this.User.GetId();
Result result = await this.identityService.UpdateUserInformation(model.FirstName, model.LastName, model.Birthday, model.Mobile, model.FacebookUrl, model.FavoriteSport, userId);
if (!result.Succeeded)
{
return(BadRequest(result.Error));
}
return(Ok());
}
public async Task <ActionResult> Update(string userId, [FromBody] UpdateUserRequestModel model)
{
var updateRequest = await this.usersService.UpdateAsync(userId, model);
if (!updateRequest.Success)
{
return(this.BadRequest(new ErrorsResponseModel
{
Errors = updateRequest.Errors,
}));
}
return(this.Ok());
}
public async Task <ActionResult> Update(UpdateUserRequestModel model)
{
var userId = this.User.GetId();
var updated = await this.identityService.EditUser(userId, model.Name,
model.City, model.Address, model.Country, model.Avatar);
if (!updated)
{
return(BadRequest());
}
return(Ok());
}
public async Task <UserDto> Update(string id, UpdateUserRequestModel model)
{
var user = await _userManager.FindByIdAsync(id);
user.FirstName = model.FirstName;
user.OtherName = model.OtherName;
user.LastName = model.LastName;
user.PhoneNumber = model.PhoneNumber;
_db.Users.Update(user);
await _db.SaveChangesAsync();
return(await GetById(user.Id));
}
public async Task UpdateAsync(UpdateUserRequestModel requestModel)
{
var user = await userRepository.GetByCPFAsync(requestModel.CPF);
switch (user != null)
{
case true:
{
await userRepository.UpdateAsync(mapper.Map <UserModel>(requestModel));
break;
}
case false: throw new Exception("The user doenst exists.");
}
}
public async Task <ActionResult <UserResponseModel> > UpdateAsync(int id, [FromBody] UpdateUserRequestModel updateUserRequestModel)
{
const string actionName = nameof(UpdateAsync);
if (id != updateUserRequestModel.Id)
{
throw new InconsistentException(nameof(updateUserRequestModel));
}
Logger.LogDebug(LoggingMessage.ProcessingRequestWithModel, actionName, updateUserRequestModel);
var response = await _userAppService.UpdateAsync(id, updateUserRequestModel);
Logger.LogInfomation(LoggingMessage.RequestResults, actionName);
return(Ok(response));
}
public async Task <IActionResult> UpdateUser([FromBody] UpdateUserRequestModel model)
{
var user = await _userService.UpdateUserAsync(model);
if (user == null)
{
return(BadRequest(new { message = "Kullanici güncellenirken hata oluştu!" }));
}
var resModel = new ByNameResponseModel()
{
UserName = user.UserName
};
return(Ok(resModel));
}
public async Task <User> UpdateUserAsync(UpdateUserRequestModel model)
{
var user = await _userRepository.GetByIdAsync(model.Id);
if (user != null)
{
user.UserName = model.UserName;
user.Email = model.Email;
user.Address = model.Address;
user.Email = model.Email;
user.Password = model.Password;
_userRepository.Update(user);
}
return(user);
}
public async Task <MiscResponse <UserResponseModel> > UpdateUserAsync(UpdateUserRequestModel model)
{
var existingUser = this._userRepo.Find(x => x.Id == model.Id).FirstOrDefault();
if (existingUser == null)
{
throw new ArgumentException($"A user does not exist with the given id '{model.Id}'");
}
if (!string.IsNullOrWhiteSpace(model.Email))
{
var existingUserWithEmail = this._userRepo.Find(x => x.Email == model.Email && x.Id != model.Id);
if (existingUserWithEmail.Any())
{
throw new ArgumentException($"A user already exists with the updated email '{model.Email}'");
}
existingUser.Email = model.Email;
}
if (string.IsNullOrWhiteSpace(model.Name))
{
existingUser.Name = model.Name;
}
if (string.IsNullOrWhiteSpace(model.Password))
{
existingUser.Salt = generateSalt();
existingUser.PasswordHash = hashPassword(model.Password, existingUser.Salt);
var userTokens = this._userTokenRepo.Find(x => x.UserId == model.Id).ToList();
var updates = userTokens.Select(x => this._userTokenRepo.DeleteAsync(x)).ToArray();
Task.WaitAll(updates);
}
if (model.IsAdmin.HasValue)
{
existingUser.IsAdmin = model.IsAdmin.Value;
}
await this._userRepo.UpdateAsync(existingUser);
return(new MiscResponse <UserResponseModel> {
Data = existingUser.ToModel(),
Message = "User updated successfully"
});
}
public UpdateUserResponseModel UpdateUser(UpdateUserRequestModel model)
{
var response = new UpdateUserResponseModel();
try
{
UserManager.UpdateUser(model);
response.IsSuccess = true;
response.Message = "Başarılı";
}
catch (Exception ex)
{
response.IsSuccess = false;
response.Message = ex.Message;
}
return(response);
}
public async Task <ActionResult> UpdateUser(string userId, UpdateUserRequestModel model)
{
var loggedUserId = this.User.GetId();
if (loggedUserId != userId)
{
return(Unauthorized(UserErrors.UserHaveNoPermissionToUpdate));
}
var result = await this.userService.UpdateUser(loggedUserId, model);
if (!result.Success)
{
return(BadRequest(result.Errors));
}
return(Ok(result.Result));
}
public async Task <UserResponseModel> UpdateUser(UpdateUserRequestModel model)
{
var updatedUser = new Users
{
Id = model.Id,
Email = model.Email,
Fullname = model.Fullname,
Password = model.Password,
JoinedOn = model.JoinedOn
};
await _userRepository.UpdateAsync(updatedUser);
var userResponseModel = new UserResponseModel {
Id = updatedUser.Id,
Fullname = updatedUser.Fullname
};
return(userResponseModel);
}
public async Task <ActionResult> UpdateUserAsync([FromBody] UpdateUserRequestModel userModel)
{
if (!Guid.TryParse(userModel.Id, out var userId))
{
return(BadRequest());
}
var user = await _userRepository.FindOrDefaultAsync(userId);
if (user == null)
{
return(NotFound(new { Message = $"User with id {userModel.Id} not found." }));
}
user.SetUserInformation(userModel.CurrencyId, userModel.CountryId);
_userRepository.Update(user);
await _userRepository.UnitOfWork.SaveChangesAsync();
return(CreatedAtAction(nameof(GetByIdAsync), new { id = user.Id.ToString() }, null));
}
public async Task <Response> UpdateUser(Guid id, UpdateUserRequestModel updateUserRequestModel)
{
var user = await _userRepository.GetUser(id);
if (!string.IsNullOrWhiteSpace(updateUserRequestModel.Password))
{
user.Password = BCrypt.Net.BCrypt.HashPassword(updateUserRequestModel.Password);
}
if (!string.IsNullOrWhiteSpace(updateUserRequestModel.Email))
{
user.Email = updateUserRequestModel.Email;
}
if (updateUserRequestModel.AuthLevel != 0)
{
user.AuthLevel = updateUserRequestModel.AuthLevel;
}
return(await _userRepository.UpdateUser(user));
}
public void PutUserAlreadyExistTest()
{
User user = GetUser();
UpdateUserRequestModel userRequest = GetUpdateUserRequestModel();
ValidationResponse <User> validationResponse = GetFailedValidationResponse();
_mockMapper
.Setup(mapper => mapper.Map <UpdateUserRequestModel, User>(userRequest))
.Returns(user);
_mockService
.Setup(serv => serv.Update(user))
.Returns(validationResponse);
IActionResult actionResult = _controller.Put(_userId, userRequest);
BadRequestObjectResult actual = (BadRequestObjectResult)actionResult;
Assert.Equal(StatusCodes.Status400BadRequest, actual.StatusCode);
}
public async Task <User> UpdateUser(UpdateUserRequestModel request)
{
var user = await _userRepo.GetUser(request.UserId);
if (user == null)
{
return(user);
}
user.FirstName = request.FirstName;
user.LastName = request.LastName;
user.Email = request.Email;
user.PhoneNumber = request.PhoneNumber;
user = await _userRepo.UpdateUser(user);
await BuildUpUser(user);
return(user);
}
/// <summary>
/// Update
/// </summary>
/// <param name="userRequestModel"></param>
/// <param name="ct"></param>
/// <returns></returns>
public async Task <UserResponseModel> UpdateUserAsync(UpdateUserRequestModel userRequestModel, int agencyId, CancellationToken ct = default)
{
User user = await _userRepository.GetAll().Include(x => x.Employee)
.Where(x => x.Id == userRequestModel.Id && x.Employee.AgencyId == agencyId)
.FirstOrDefaultAsync(ct);
if (user is null)
{
throw new UserNotFoundException();
}
user = _mapper.Map(userRequestModel, user);
_userRepository.Update(user);
await _unitOfWork.SaveChangesAsync(ct);
var data = _mapper.Map <UserResponseModel>(user);
return(data);
}
