public async Task <KeyValuePair <bool, string> > UpdateUser(int userId, UserToUpdateDto userToUpdateDto)
{
var user = await _unitOfWork.Users.GetById(userId);
if (user == null)
{
return(new KeyValuePair <bool, string>(false, "Specified user doesn't exist."));
}
var country = await _unitOfWork.Countries.GetCountryWithCities(userToUpdateDto.Country);
var city = await _unitOfWork.Cities.GetCityById(userToUpdateDto.City, userToUpdateDto.Country);
if (city == null || country == null || !country.Cities.Contains(city))
{
return(new KeyValuePair <bool, string>(false, "Specified country or city doesn't exist!"));
}
user.City = city;
user.Country = country;
user.Email = userToUpdateDto.Email;
if (await _unitOfWork.Complete())
{
return(new KeyValuePair <bool, string>(true, "User successfully updated."));
}
return(new KeyValuePair <bool, string>(false, "User can't be updated."));
}
public async Task <IActionResult> UpdateUser(int userId, UserToUpdateDto userToUpdateDto)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
return(Ok(await _usersService.UpdateUser(userId, userToUpdateDto)));
}
public async Task UpdateUser_ShouldUpdate()
{
// Arrange
var responseMessage = "User successfully updated.";
var userId = 1;
var firstname = "Jelena";
var lastname = "Ralevic";
var countryId = 2;
var cityId = 3;
var user = new PowerUser()
{
Id = userId,
Firstname = firstname,
Lastname = lastname
};
var userToUpdateDto = new UserToUpdateDto()
{
Country = countryId,
City = cityId
};
var city = new City()
{
Id = cityId,
Name = "Beograd",
CountryId = countryId,
};
var country = new Country()
{
Id = countryId,
Name = "Srbija",
Cities = new List <City>()
{
city
}
};
_unitOfWorkMock.Setup(x => x.Users.GetById(It.IsAny <int>()))
.ReturnsAsync(user);
_unitOfWorkMock.Setup(x => x.Countries.GetCountryWithCities(countryId))
.ReturnsAsync(country);
_unitOfWorkMock.Setup(x => x.Cities.GetCityById(cityId, countryId))
.ReturnsAsync(city);
_unitOfWorkMock.Setup(x => x.Complete())
.ReturnsAsync(true);
// Act
var result = await _sut.UpdateUser(userId, userToUpdateDto);
// Assert
Assert.Equal(responseMessage, result.Value);
}
public async Task <IActionResult> Put(int id, UserToUpdateDto user)
{
UserDto updatedUser = await _service.UpdateUser(user, id);
if (updatedUser == null)
{
return(StatusCode(404));
}
return(StatusCode(200, updatedUser));
}
public async Task <IActionResult> EditUser(int id, UserToUpdateDto userToUpdateDto)
{
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == id);
var userToreturn = _mapper.Map(userToUpdateDto, user);
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task <UserDto> UpdateUserByIdAsync(UserToUpdateDto user, int id)
{
GetClient();
UserDto updatedUser = null;
HttpResponseMessage response = await client.PutAsJsonAsync($"api/users/{id}", user);
if (response.IsSuccessStatusCode)
{
updatedUser = await response.Content.ReadAsAsync <UserDto>();
}
return(updatedUser);
}
public async Task <IActionResult> UpdateUser(int id, UserToUpdateDto userToUpdateDto)
{
var user = await accountManager.GetUser(id);
user = mapper.Map <UserToUpdateDto, User>(userToUpdateDto, user);
if (await database.Complete())
{
return(NoContent());
}
throw new AccountException("Konto nie zostało zaktualizowane");
}
public async Task <IActionResult> UpdateUser([FromBody] UserToUpdateDto dto)
{
if (dto.Username != User.FindFirst(ClaimTypes.Name).Value)
{
return(Unauthorized());
}
var result = await repo.UpdateUser(dto);
if (result)
{
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> UpdateUser(int id, UserToUpdateDto userToUpdateDto)
{
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userFromRepo = await _repo.GetUser(id);
_mapper.Map(userToUpdateDto, userFromRepo);
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Updating user {id} failed in save");
}
public ActionResult UpdateUser(Guid userId, UserToUpdateDto user)
{
var getUser = repo.GetUser(userId);
if (getUser == null)
{
return(NotFound());
}
var userEntity = mapper.Map(user, getUser);
repo.UpdateUser(userEntity);
repo.Save();
return(NoContent());
}
public async Task <ActionResult <bool> > updateUser(UserToUpdateDto user)
{
User updatedUser = new User();
foreach (var field in user.GetType().GetProperties())
{
PropertyInfo pi = updatedUser.GetType().GetProperty(field.Name);
if (pi != null && field.Name != "Token" && field.Name != "Type")
{
pi.SetValue(updatedUser, field.GetValue(user));
}
}
bool updated = await _userService.updateUserFromDB(updatedUser);
return(Ok(updated));
}
public async Task <IActionResult> UpdateUser(int id, UserToUpdateDto userToUpdateDto)
{
// has to match with whats in token
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userFromRepo = await _repo.GetUser(id);
_mapper.Map(userToUpdateDto, userFromRepo);
if (await _repo.SaveAll())
{
// because its the appropriate response
return(NoContent());
}
throw new Exception($"Updating user {id} failed on save");
}
public async Task <ActionResult <UserToUpdateDto> > UpdateUser(UserToUpdateDto userUpdate, string id)
{
var user = await _userManager.FindByIdAsync(id);
user.Birthday = userUpdate.Birthday;
user.FirstName = userUpdate.FirstName;
user.DisplayName = userUpdate.DisplayName;
user.LastName = userUpdate.LastName;
user.Phone = userUpdate.Phone;
user.Gender = userUpdate.Gender;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(Ok(_mapper.Map <AppUser, UserToUpdateDto>(user)));
}
return(BadRequest("Problem updating the user"));
}
public async Task <IActionResult> UpdateUser(string id, UserToUpdateDto userToUpdate)
{
var user = await _repo.GetUserAsync(id);
if (id.Equals(userToUpdate.Id))
{
BadRequest("You are not permitted");
}
_mapper.Map(userToUpdate, user);
if (await _repo.SaveAll())
{
return(Ok(user));
}
throw new Exception("Article failed to update");
}
public async Task <IActionResult> Put(int id, [FromBody] UserToUpdateDto userUpdateDto)
{
var userFromRepo = await _repo.GetUser(id);
if (userFromRepo == null)
{
return(BadRequest("The user doesn't exist"));
}
//questionUpdateDto.Id = id;
var user = _mapper.Map <User>(userUpdateDto);
var updatedUser = await _repo.UpdateUser(user);
var userToReturn = _mapper.Map <UserForClientDto>(updatedUser);
return(Ok(userToReturn));
}
public async Task <IActionResult> UpdateUser(int id, UserToUpdateDto user)
{
if (id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var userToUpdate = await _datingRepo.GetUser(id);
_autoMapper.Map(user, userToUpdate);
if (await _datingRepo.SaveAll())
{
return(NoContent());
}
throw new Exception("failed to update user");
}
public async Task <ActionResult <UserToUpdateDto> > UpdateInfoUser(UserToUpdateDto userUpdate)
{
var user = await _userManager.FindByEmailFromClaimsPriciple(HttpContext.User);
user.Birthday = userUpdate.Birthday;
user.FirstName = userUpdate.FirstName;
user.DisplayName = userUpdate.DisplayName;
user.LastName = userUpdate.LastName;
user.Phone = userUpdate.Phone;
user.Gender = userUpdate.Gender;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(Ok(_mapper.Map <AppUser, UserToUpdateDto>(user)));
}
return(BadRequest("Problem updating the user"));
}
public async Task <IActionResult> UpdateUser(string id, UserToUpdateDto userToUpdate)
{
if (!id.Equals(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
//var userFromRepo = await _repo.GetUser(id, false);
var userFromRepo = await _userManager.FindByEmailAsync(userToUpdate.Email);
_mapper.Map(userToUpdate, userFromRepo);
var user = _mapper.Map <UserForDetailed>(userFromRepo);
if (await _repo.SaveAll())
{
return(Ok(user));
}
throw new Exception("Failed to save");
}
public async Task <IActionResult> PartiallyUpdateUser(Guid id, [FromBody] JsonPatchDocument <UserManipulationDto> patch)
{
if (patch is null)
{
return(BadRequest());
}
UserDto outerFacingModelUser;
UserToUpdateDto dto = new UserToUpdateDto();
patch.ApplyTo(dto);
User resourceEntity = await _userQuery.ExecuteGetResourceByIdWithTracking(id);
if (resourceEntity is null)
{
outerFacingModelUser = _userCommand.ExecuteAddResource(dto, id);
if (!(await _userCommand.ExecuteSaveAsync()))
{
throw new Exception("There was a problem with saving the user resource");
}
outerFacingModelUser
.ShapeData(null)
.TryAdd("links", CreateLinks(id, null));
return(CreatedAtRoute("GetUser", new { id = id }, outerFacingModelUser));
}
_userCommand.ExecuteUpdateResource(resourceEntity, dto);
if (!(await _userCommand.ExecuteSaveAsync()))
{
throw new Exception("There was a problem with saving the user resource");
}
Response.Headers.Add("Location", _urlHelper.Link("GetUser", new { id = resourceEntity.Id }));
return(NoContent());
}
public async Task <UserDto> UpdateUser(UserToUpdateDto updatedUser, int userId)
{
User userToUpdate = await _context.Users.Include(x => x.Address).FirstOrDefaultAsync(x => x.Id == userId);
if (userToUpdate != null)
{
userToUpdate.FirstName = updatedUser.FirstName;
userToUpdate.LastName = updatedUser.LastName;
userToUpdate.Email = updatedUser.Email.ToLower();
userToUpdate.PhoneNumber = updatedUser.PhoneNumber;
userToUpdate.Address.Country = updatedUser.Address.Country;
userToUpdate.Address.City = updatedUser.Address.City;
userToUpdate.Address.PostalCode = updatedUser.Address.PostalCode;
userToUpdate.Address.Street = updatedUser.Address.Street;
userToUpdate.Address.HouseNumber = updatedUser.Address.HouseNumber;
userToUpdate.Address.BoxNumber = updatedUser.Address.BoxNumber;
return(ConvertToUserDto(await UpdateAsync(userToUpdate)));
}
return(null);
}
public async Task <IActionResult> UpdateUser([FromRoute] Guid id, [FromBody] UserToUpdateDto dto)
{
if (dto is null)
{
return(BadRequest());
}
UserDto outerFacingModelUser;
User resourceEntity = await _userQuery.ExecuteGetResourceByIdWithTracking(id);
if (resourceEntity is null)
{
outerFacingModelUser = _userCommand.ExecuteAddResource(dto, id);
if (!(await _userCommand.ExecuteSaveAsync()))
{
throw new Exception("There was a problem with saving the user resource");
}
outerFacingModelUser
.ShapeData(null)
.TryAdd("links", CreateLinks(id, null));
return(CreatedAtRoute("GetUser", new { id = id }, outerFacingModelUser));
}
//if it does update the user with tracking
_userCommand.ExecuteUpdateResource(resourceEntity, dto);
//then save changes
if (!(await _userCommand.ExecuteSaveAsync()))
{
throw new Exception("There was a problem with saving the user resource");
}
Response.Headers.Add("Location", _urlHelper.Link("GetUser", new { id = resourceEntity.Id }));
return(NoContent());
}
public async Task UpdateUser_ShouldNotUpdate_WhenCityIsInvalid()
{
// Arrange
var responseMessage = "Specified country or city doesn't exist!";
var userId = 1;
var firstname = "Jelena";
var lastname = "Ralevic";
var countryId = 2;
var cityId = 3;
var user = new PowerUser()
{
Id = userId,
Firstname = firstname,
Lastname = lastname
};
var userToUpdateDto = new UserToUpdateDto()
{
Country = countryId,
City = cityId
};
_unitOfWorkMock.Setup(x => x.Users.GetById(It.IsAny <int>()))
.ReturnsAsync(user);
_unitOfWorkMock.Setup(x => x.Countries.GetCountryWithCities(countryId))
.ReturnsAsync(It.IsAny <Country>());
_unitOfWorkMock.Setup(x => x.Cities.GetCityById(cityId, countryId))
.ReturnsAsync(() => null);
// Act
var result = await _sut.UpdateUser(userId, userToUpdateDto);
// Assert
Assert.Equal(responseMessage, result.Value);
}
public static void TestFillBy()
{
var registrationTime = DateTime.Now.AddYears(-1);
var userDto = new UserToUpdateDto
{
Login = "******",
Name = "Jack"
};
var userEntity = new UserEntity
{
Id = 777,
Login = "******",
RegistrationTime = registrationTime,
};
// userEntity дополняется значениями из userDto
Mapper.Map(userDto, userEntity);
Assert.AreEqual(777, userEntity.Id);
Assert.AreEqual("SuperAdmin", userEntity.Login);
Assert.AreEqual("Jack", userEntity.Name);
Assert.AreEqual(registrationTime, userEntity.RegistrationTime);
}
public static void TestFillByReturnSyntax()
{
var registrationTime = DateTime.Now.AddYears(-1);
var userDto = new UserToUpdateDto
{
Login = "******",
Name = "Jack"
};
// Mapper.Map возвращает ссылку на второй аргумент.
// Поэтому можно вторым аргументом передавать только что созданный объект,
// а потом получать ссылку на него как возвращаемое значение Map.
var userEntity = Mapper.Map(userDto, new UserEntity
{
Id = 777,
Login = "******",
RegistrationTime = registrationTime,
});
Assert.AreEqual(777, userEntity.Id);
Assert.AreEqual("SuperAdmin", userEntity.Login);
Assert.AreEqual("Jack", userEntity.Name);
Assert.AreEqual(registrationTime, userEntity.RegistrationTime);
}
public async Task <bool> UpdateUser(UserToUpdateDto userToUpdateDto)
{
Tuple <bool, string> result = await Exist(userToUpdateDto.Username);
if (result.Item1)
{
if (result.Item2 == "Admin")
{
var user = await context.Admins.FirstAsync(x => x.Username == userToUpdateDto.Username);
byte[] passwordHash, passwordSalt;
user.FirstName = userToUpdateDto.FirstName;
user.LastName = userToUpdateDto.LastName;
if (!String.IsNullOrEmpty(userToUpdateDto.Password))
{
CreatePasswordHash(userToUpdateDto.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
}
user.Gender = user.Gender == "female" ? Gender.Female : Gender.Male;
await context.SaveChangesAsync();
return(true);
}
else if (result.Item2 == "Host")
{
var user = await context.Hosts.FirstOrDefaultAsync(x => x.Username == userToUpdateDto.Username);
byte[] passwordHash, passwordSalt;
user.FirstName = userToUpdateDto.FirstName;
user.LastName = userToUpdateDto.LastName;
if (!String.IsNullOrEmpty(userToUpdateDto.Password))
{
CreatePasswordHash(userToUpdateDto.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
}
user.Gender = user.Gender == "female" ? Gender.Female : Gender.Male;
await context.SaveChangesAsync();
return(true);
}
else
{
var user = await context.Guests.FirstOrDefaultAsync(x => x.Username == userToUpdateDto.Username);
byte[] passwordHash, passwordSalt;
user.FirstName = userToUpdateDto.FirstName;
user.LastName = userToUpdateDto.LastName;
if (!String.IsNullOrEmpty(userToUpdateDto.Password))
{
CreatePasswordHash(userToUpdateDto.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
}
user.Gender = userToUpdateDto.Gender == "female" ? Gender.Female : Gender.Male;
await context.SaveChangesAsync();
return(true);
}
}
return(false);
}
static void Main()
{
//Create address
AddressToCreateDto createdAddress = new AddressToCreateDto
{
Country = "Belgium",
City = "Brussel",
PostalCode = "1000",
Street = "testStraat",
HouseNumber = "20"
};
//Create user
UserToCreateDto createdUser = new UserToCreateDto
{
FirstName = "Mich",
LastName = "dg",
Email = "*****@*****.**",
PhoneNumber = "+3256798487",
Psw = "hallo",
Address = createdAddress
};
//Update address
AddressToUpdateDto updatedAddress = new AddressToUpdateDto
{
Country = "Belgium",
City = "Brussel",
PostalCode = "1000",
Street = "testStraat1",
HouseNumber = "35"
};
//Update user
UserToUpdateDto updatedUser = new UserToUpdateDto
{
FirstName = "Michael",
LastName = "DG",
Email = "*****@*****.**",
PhoneNumber = "+3256798489",
Address = updatedAddress
};
//Login
UserToLoginDto login = new UserToLoginDto
{
Email = "*****@*****.**",
Password = "******"
};
//Create company
CompanyToCreateDto createdCompany = new CompanyToCreateDto
{
Name = "Microsoft1",
Address = createdAddress
};
//Update company
CompanyToUpdateDto updatedCompany = new CompanyToUpdateDto
{
Name = "Microsoft 2",
Address = updatedAddress
};
//Create companyrole
CompanyRoleToCreateDto createdCompanyRole = new CompanyRoleToCreateDto
{
Name = "CompanyRole1",
Description = "It's just a test",
IsDefault = true,
ManageCompany = true,
ManageUsers = false,
ManageProjects = true,
ManageRoles = true
};
//Update companyrole
CompanyRoleToUpdateDto updatedCompanyRole = new CompanyRoleToUpdateDto
{
Name = "CompanyRole1Updated",
Description = "It's just a test for something",
IsDefault = true,
ManageCompany = true,
ManageUsers = true,
ManageProjects = true,
ManageRoles = true
};
//Create project
ProjectToCreateDto createdProject = new ProjectToCreateDto
{
CompanyID = 1,
Name = "Tim",
Description = "desc"
};
//Update project
ProjectToUpdateDto updatedProject = new ProjectToUpdateDto
{
CompanyID = 2,
Name = "Kevin",
Description = "desc 2"
};
//Testen API calls
UserServices userServices = new UserServices();
CompanyServices companyServices = new CompanyServices();
ProjectServices projectServices = new ProjectServices();
CompanyRoleServices companyRoleServices = new CompanyRoleServices();
LogServices logServices = new LogServices();
SessionServices sessionServices = new SessionServices();
UserDto user1 = new UserDto();
CompanyDto c = new CompanyDto();
CompanyRoleDto cr = new CompanyRoleDto();
ProjectDto p = new ProjectDto();
//Userservices //OK
//user1 = userServices.GetUserByIdAsync(1).GetAwaiter().GetResult();
//List<UserDto> userlist = userServices.GetAllUsersAsync().GetAwaiter().GetResult();
//user1 = userServices.CreateUserAsync(createdUser).GetAwaiter().GetResult();
//user1 = userServices.UpdateUserByIdAsync(updatedUser, 1).GetAwaiter().GetResult();
//user1 = userServices.DeleteUserByIdAsync(3).GetAwaiter().GetResult();
//List<LogDto> user = userServices.GetAllUserLogsAsync(1).GetAwaiter().GetResult();
//List<UserDto> users = userServices.GetUserByEmailAsync("*****@*****.**").GetAwaiter().GetResult();
//List<LogDto> lk = userServices.GetAllUserLogsAsync(5).GetAwaiter().GetResult();
//Sessionservices //OK
//string str = sessionServices.CreateSession(login);
//string str = sessionServices.DeleteSessionAsync().GetAwaiter().GetResult();
//Companyservices //OK
//List<CompanyDto> companylist = companyServices.GetAllCompaniesAsync().GetAwaiter().GetResult();
//c = companyServices.GetCompanyByIdAsync(1).GetAwaiter().GetResult();
//c = companyServices.CreateCompanyAsync(createdCompany).GetAwaiter().GetResult();
//c = companyServices.UpdateCompanyByIdAsync(updatedCompany, 1).GetAwaiter().GetResult();
//List<UserDto> cl = companyServices.GetUsersFromCompanyByIdAsync(1).GetAwaiter().GetResult();
//bool b = companyServices.AddUserToCompanyByIdAsync(1, 8).GetAwaiter().GetResult();
//CompanyRoleservices //OK
//cr = companyRoleServices.CreateCompanyRoleAsync(createdCompanyRole, 1).GetAwaiter().GetResult();
//List<CompanyRoleDto> crlist = companyRoleServices.GetAllCompanyRolesAsync(1).GetAwaiter().GetResult();
//cr = companyRoleServices.GetCompanyRoleByIdAsync(1, 3).GetAwaiter().GetResult();
//cr = companyRoleServices.UpdateCompanyRoleByIdAsync(updatedCompanyRole, 1, 3).GetAwaiter().GetResult();
//Projectservices //OK
//bool bp = projectServices.UpdateProjectByIdAsync(updatedProject, 1).GetAwaiter().GetResult();
//List<ProjectDto> projects = companyServices.GetAllCompanyProjectsAsync(1).GetAwaiter().GetResult();
//List<ProjectDto> projects = userServices.GetAllUserProjectsAsync(1).GetAwaiter().GetResult();
//bool pu = projectServices.RemoveUserToProjectAsync(1, 1).GetAwaiter().GetResult();
//bool u = projectServices.AddUserToProjectAsync(1, "*****@*****.**").GetAwaiter().GetResult();
//bool u = projectServices.RemoveUserToProjectAsync(1, 7).GetAwaiter().GetResult();
}
public async Task <ActionResult <UsersWithRolesToReturnDto> > UpdateUser(string id, UserToUpdateDto userToUpdate)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound(new ApiResponse(404)));
}
var userFromDb = await _context.Users.SingleOrDefaultAsync(p => p.Id == id);
if (userFromDb == null)
{
return(NotFound(new ApiResponse(404)));
}
try
{
if (userFromDb.Email != userToUpdate.Email)
{
if (CheckEmailExistsAsync(userToUpdate.Email).Result.Value)
{
return(BadRequest(new ApiResponse(400, "Email address is in use!")));
}
userFromDb.Email = userToUpdate.Email;
userFromDb.NormalizedEmail = userToUpdate.Email.ToUpper();
}
userFromDb.UserName = userToUpdate.UserName;
userFromDb.NormalizedUserName = userToUpdate.UserName.ToUpper();
userFromDb.DisplayName = userToUpdate.DisplayName;
userFromDb.PhoneNumber = userToUpdate.PhoneNumber;
bool isLockedOut = await CheckUserIsLockedOut(userFromDb);
if (isLockedOut)
{
if (userToUpdate.LockoutEnd.HasValue)
{
userFromDb.LockoutEnd = userToUpdate.LockoutEnd;
}
else
{
userFromDb.LockoutEnd = DateTime.Now.AddYears(100);
}
}
// Update roles list
List <RolesListOfSelectedUser> appRoles = userToUpdate.RolesList;
List <string> new_Roles = new List <string>();
foreach (var itemRole in appRoles)
{
if (itemRole.SelectedRole)
{
new_Roles.Add(itemRole.Name);
}
}
if (new_Roles.Count < 1)
{
return(BadRequest(new ApiResponse(400, "Please select at least one role.")));
}
var old_Roles = await _userManager.GetRolesAsync(userFromDb);
var result = await _userManager.RemoveFromRolesAsync(userFromDb, old_Roles);
if (!result.Succeeded)
{
return(BadRequest(new ApiResponse(400, "Failed to remove old roles.")));
}
result = await _userManager.AddToRolesAsync(userFromDb, new_Roles);
if (!result.Succeeded)
{
return(BadRequest(new ApiResponse(400, "Failed to add new roles.")));
}
// Without this row, return will be zero even though record has been updated into Database successfully.
_context.Entry(userFromDb).State = EntityState.Modified;
var completed = await Complete();
if (completed <= 0)
{
return(BadRequest(new ApiResponse(400, "Problem in Update user!")));
}
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(new ApiResponse(400, "Problem in Update user! " + ex.Message)));
}
}
