public async Task <IHttpActionResult> UpdateUser(UpdateUserBindingModel updateUserModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var u = AppUserManager.FindByName(updateUserModel.Username);
if (updateUserModel.CustomerInfoId > 0)
{
u.CustomerInfoId = updateUserModel.CustomerInfoId;
}
else if (updateUserModel.PhoneNumber != null)
{
u.PhoneNumber = updateUserModel.PhoneNumber;
}
IdentityResult updateUserResult = await AppUserManager.UpdateAsync(u);
if (updateUserResult.Succeeded)
{
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = u.Id }));
return(Created(locationHeader, TheModelFactory.Create(u)));
}
else
{
return(GetErrorResult(updateUserResult));
}
}
public async Task <IHttpActionResult> UpdateUser(UpdateUserBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await this.AppUserManager.FindByIdAsync(model.Id);
if (user != null)
{
user.UserName = model.Username;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
IdentityResult updateUserResult = await this.AppUserManager.UpdateAsync(user);
if (!updateUserResult.Succeeded)
{
return(GetErrorResult(updateUserResult));
}
GetUserInfoOutput output = new GetUserInfoOutput();
output.User = this.TheModelFactory.Create(user);
return(Ok(output));
}
return(NotFound());
}
public IHttpActionResult PutUser(int id, UpdateUserBindingModel u)
{
var user = AutoMapper.Mapper.Map <UpdateUserBindingModel, ApplicationUser>(u);
var oldUser = userService.Get(id);
// user.Birthday = oldUser.Birthday;
user.Gender = oldUser.Gender;
user.UserName = oldUser.Email;
user.Id = oldUser.Id;
user.PasswordHash = oldUser.PasswordHash;
user.EmailConfirmed = oldUser.EmailConfirmed;
user.SecurityStamp = oldUser.SecurityStamp;
var identity = (ClaimsIdentity)User.Identity;
var claims = identity.Claims;
var userId = int.Parse(claims.Where(c => c.Type == ClaimTypes.NameIdentifier).FirstOrDefault().Value);
if (oldUser == null || userId != user.Id)
{
return(BadRequest());
}
try
{
userService.Update(oldUser, user);
unitOfWork.Commit();
}
catch (Exception e)
{
return(BadRequest());
}
return(Ok());
}
public async Task <Response <object> > UpdateAsync(UpdateUserBindingModel bindingModel, int userId)
{
var response = await ValidateUpdateViewModel(userId);
if (response.ErrorOccurred)
{
return(response);
}
var user = await _userRepository.GetByAsync(x => x.Id == userId);
_userRepository.Detach(user);
var updatedUser = _mapper.Map <User>(bindingModel);
updatedUser.Id = user.Id;
bool updateSucceed = await _userRepository.UpdateAsync(updatedUser);
if (!updateSucceed)
{
response.AddError(Key.User, Error.UpdateError);
}
response.SuccessResult = bindingModel;
return(response);
}
public IHttpActionResult UpdateUser([FromBody] UpdateUserBindingModel model)
{
if (ModelState.IsValid)
{
UserInfoDTO user = this.userInfoService.GetById(model.Id);
if (user == null)
{
return(BadRequest("User not found"));
}
user.UserName = model.UserName;
user.Email = model.Email;
user.Roles = new List <RoleDTO>();
foreach (var role in model.Roles)
{
user.Roles.Add(new RoleDTO()
{
Name = role.Name
});
}
this.userInfoService.Update(user);
return(Ok());
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <IHttpActionResult> UpdateUser(UpdateUserBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string idUser = User.Identity.GetUserId();
ApplicationDbContext applicationDbContext = new ApplicationDbContext();
List <ApplicationUser> applicationUsers = applicationDbContext.Users.Where(x => x.Id == idUser).ToList();
if (!applicationUsers.Any())
{
return(NotFound());
}
DbDataContext dbDataContext = new DbDataContext();
List <UserInfo> userInfos = dbDataContext.UserInfo.Where(x => x.IdAspNetUser == new Guid(idUser)).ToList();
//Controllo se c'è il record dentro dbData
if (!userInfos.Any())
{
return(NotFound());
}
userInfos[0].Nome = model.Name;
userInfos[0].Cognome = model.Surname;
userInfos[0].DataDiNascita = (model.DataNascita ?? null);
userInfos[0].FotoProfilo = (model.ImmagineProfilo ?? null);
dbDataContext.SaveChanges();
//TODO: devo modificare anche la Email?
return(Ok());
}
async void ToolbarItem_Clicked(System.Object sender, System.EventArgs e)
{
if (!string.IsNullOrEmpty(entCognome.Text) && !string.IsNullOrEmpty(entNome.Text))
{
AccountClient accountClient = new AccountClient(await Api.ApiHelper.GetApiClient());
UpdateUserBindingModel updateUserBindingModel = new UpdateUserBindingModel()
{
Name = entNome.Text,
Surname = entCognome.Text,
BirthName = entNome.Text,
//DataNascita = pkDataNascita.Date,
DataNascita = dpDataNascita.Date,
ImmagineProfilo = viewModel.FotoProfilo,
Email = viewModel.Email
};
//TODO: gestire la modifica della Email.
await accountClient.UpdateUserAsync(updateUserBindingModel);
ApiHelper.RemoveUserInfo();
//Refresh del menu
MenuPage menuPage = (MenuPage)((MasterDetailPage)Application.Current.MainPage).Master;
await menuPage.UpdateMenuData(Models.MenuItemType.Account);
await DisplayAlert(null, "Salvataggio effettuato", "OK");
}
else
{
await DisplayAlert("Attenzione", "è necessario compilare tutti i campi", "OK");
}
} //private void entDataNascita_Focused(object sender, FocusEventArgs e)
public async Task <IActionResult> UpdateAsync(UpdateUserBindingModel bindingModel)
{
var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier)?.Value);
var result = await _userService.UpdateAsync(bindingModel, userId);
if (result.ErrorOccurred)
{
return(BadRequest(result));
}
return(Ok(result));
}
public IHttpActionResult UpdateUser(UpdateUserBindingModel model)
{
User user = GetCurrentUser();
user = user.Update(model.Name, model.Mobile);
UserService.Obj.Update(user);
var userProfile = user.ToUserProfileBindingModel();
userProfile.PhotoId = ImageService.Obj.FindByUserId(user.Id)?.ImageId;
return(Ok(userProfile));
}
public UpdatedUserAPIModel UpdateUser(UpdateUserBindingModel model)
{
if (model == null)
{
throw new ArgumentNullException("UpdateUserBindingModel can not be null");
}
var updatedUser = _repo.FindById(model.Id);
if (updatedUser == null)
{
throw new NotFoundException("User is not found.");
}
_mapper.Map(model, updatedUser);
_repo.Update(updatedUser);
_repo.SaveChanges();
return(_mapper.Map <UpdatedUserAPIModel>(updatedUser));
}
public async Task <IHttpActionResult> UpdateUser(UpdateUserBindingModel user)
{
var oldUser = UserManager.FindByEmail(user.Email);
oldUser.Ime = user.Ime;
oldUser.Prezime = user.Prezime;
oldUser.DatRodj = user.DatRodj;
oldUser.Adresa = user.Adresa;
oldUser.TipKorisnika = user.TipKorisnika;
oldUser.Status = "zahtev se procesira";
IdentityResult result = await UserManager.UpdateAsync(oldUser);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok(new GetUserBindingModel(oldUser)));
}
public async Task <ActionResult> UpdateUserProfile([FromBody] UpdateUserBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Model validation failed"));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
// Don't reveal that the user does not exist
//return RedirectToAction(nameof(ResetPasswordConfirmation));
return(BadRequest("User Not Found"));
}
//user.UserName = model.Email;
//user.Email = model.Email;
//user.Civility = model.Civility;
//user.FirstName = model.FirstName;
//user.LastName = model.LastName;
user.IsActive = model.IsActive;
user.IsPasswordTemporary = model.IsPasswordTemporary;
user.DateModified = DateTime.UtcNow;
var result = await _userManager.UpdateAsync(user);
var addedUser = await _userManager.FindByEmailAsync(user.Email);
if (result.Succeeded)
{
return(Ok(user));
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
//await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
}
return(BadRequest("Request Failed"));
}
public HttpResponseMessage UpdateUserInfo(UpdateUserBindingModel model)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(System.Net.HttpStatusCode.BadRequest, ModelState));
}
var user = UserManager.FindById(model.Id);
user.Email = model.Email;
var personNameClaim = user.Claims.FirstOrDefault(n => n.ClaimType == "personNameId");
if (personNameClaim != null)
{
int personNameId = Convert.ToInt32(personNameClaim.ClaimValue);
new PersonNameRepo().Update(new PersonName(personNameId, model.FirstName, model.LastName));
}
else
{
var newPersonName = new PersonName(model.FirstName, model.LastName);
new PersonNameRepo().Add(newPersonName);
foreach (var claim in UserManager.GetClaims(user.Id).Where(c => c.Type == "personNameId"))
{
UserManager.RemoveClaim(user.Id, claim);
}
UserManager.AddClaim(user.Id, new Claim("personNameId", newPersonName.Id.ToString()));
}
foreach (var claim in UserManager.GetClaims(user.Id).Where(c => c.Type == "organizationId"))
{
UserManager.RemoveClaim(user.Id, claim);
}
UserManager.AddClaim(user.Id, new Claim("organizationId", model.OrganizationId.ToString()));
return(Request.CreateResponse(System.Net.HttpStatusCode.OK, GetUser(user)));
}
public async Task <IHttpActionResult> UpdateUser(UpdateUserBindingModel createUserModel)
{
//throw new ApiBusinessException(0002, "Nombre de usuario duplicado", System.Net.HttpStatusCode.BadRequest, "Http");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (var dataContext = HttpContext.Current.GetOwinContext().Get <ApplicationDbContext>())
{
using (var trans = dataContext.Database.BeginTransaction(IsolationLevel.ReadCommitted))
{
try
{
var user = this.AppUserManager.FindById(User.Identity.GetUserId());
var userduplicate = this.AppUserManager.FindByName(user.UserName);
if (userduplicate != null && userduplicate.Id != user.Id)
{
throw new ApiBusinessException(0002, "Nombre de usuario duplicado", System.Net.HttpStatusCode.BadRequest, "Http");
}
userduplicate = this.AppUserManager.FindByEmail(user.Email);
if (userduplicate != null && userduplicate.Id != user.Id)
{
throw new ApiBusinessException(0003, "Email duplicado", System.Net.HttpStatusCode.BadRequest, "Http");
}
//var userdniduplicate = dataContext.PeatonUsers.Where(t => t.dni.Equals(createUserModel.dni)).FirstOrDefault();
//if (userdniduplicate != null && userdniduplicate.Id != user.Id)
// throw new ApiBusinessException(0004, "Dni duplicado", System.Net.HttpStatusCode.BadRequest, "Http");
//var userdniduplicateplayer = dataContext.PlayerUsers.Where(t => t.dni.Equals(createUserModel.dni)).FirstOrDefault();
//if (userdniduplicateplayer != null)
// throw new ApiBusinessException(0004, "Dni duplicado", System.Net.HttpStatusCode.BadRequest, "Http");
user.UserName = createUserModel.Username;
user.Email = createUserModel.Email;
user.Name = createUserModel.Name;
var passwordResult = this.AppUserManager.CheckPassword(user, createUserModel.OldPassword);
if (!passwordResult)
{
throw new ApiBusinessException(0008, "La contraseña actual no es correcta", System.Net.HttpStatusCode.BadRequest, "Http");
}
if (!String.IsNullOrEmpty(createUserModel.Password) &&
!String.IsNullOrEmpty(createUserModel.ConfirmPassword) &&
createUserModel.Password.Equals(createUserModel.ConfirmPassword))
{
IdentityResult addUserResult = this.AppUserManager
.ChangePassword(User.Identity.GetUserId(), createUserModel.OldPassword, createUserModel.Password);
if (!addUserResult.Succeeded)
{
if (addUserResult.Errors.Contains("Incorrect password."))
{
throw new ApiBusinessException(0008, "La contraseña actual no es correcta", System.Net.HttpStatusCode.BadRequest, "Http");
}
trans.Rollback();
return(GetErrorResult(addUserResult));
}
}
//var userpeaton = dataContext.PeatonUsers.FirstOrDefault(t => t.idpeatonusers == createUserModel.idpeatonusers);
//userpeaton.address = createUserModel.address;
//userpeaton.addressnumber = createUserModel.addressnumber;
//userpeaton.phonenumber = createUserModel.phonenumber;
////userpeaton.age = createUserModel.age;
//userpeaton.dni = createUserModel.dni;
//userpeaton.genre = createUserModel.genre;
//userpeaton.idlocation = createUserModel.idlocation;
//userpeaton.name = createUserModel.FirstName;
//userpeaton.lastname = createUserModel.LastName;
//userpeaton.profession = createUserModel.profession.Replace(" / ", "_");
////userpeaton.profilephoto = Cryptography.Decrypt(createUserModel.profilephoto);
//userpeaton.profilephoto = createUserModel.profilephoto;
//userpeaton.civilstatus = createUserModel.civilstatus;
//userpeaton.apartment = createUserModel.apartment;
//userpeaton.floor = createUserModel.floor;
//dataContext.SaveChanges();
//Points Security
//SetFullProfilePoints(user, dataContext);
//End Points
trans.Commit();
Uri locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));
return(Created(locationHeader, TheModelFactory.Create(user)));
}
catch (Exception ex)
{
trans.Rollback();
throw HandlerExceptions.GetInstance().RunCustomExceptions(ex);
}
}
}
}
public IActionResult UpdateUser(UpdateUserBindingModel model)
{
var updateUser = _adminService.UpdateUser(model);
return(Ok(updateUser));
}
public async Task<IHttpActionResult> UpdateUserAsync(UpdateUserBindingModel updateUserModel)
{
if (!ModelState.IsValid)
{
var errorResult = ModelState.GetModelStateErrors();
return BadRequest(errorResult.ToAggregateString());
}
var user = await AppUserManager.FindByNameAsync(updateUserModel.UserName);
if (user == null)
return NotFound();
user.FirstName = updateUserModel.FirstName;
user.LastName = updateUserModel.LastName;
user.Email = updateUserModel.Email;
user.JoinDate = updateUserModel.JoinDate;
user.Roles.Clear();
user.Roles.AddRange(updateUserModel.Roles);
user.CreateClaimsFromRoles(updateUserModel.Roles);
var updateUserResult = await AppUserManager.UpdateAsync(user);
if (!updateUserResult.Succeeded)
{
return GetErrorResult(updateUserResult);
}
var userReturnModel = TheModelFactory.Create(user);
userReturnModel.OkMessage = "Atualizou usuário " + user.UserName;
return Ok(userReturnModel);
}
public async Task <IHttpActionResult> UpdateUser(UpdateUserBindingModel model)
{
string slog = string.Format("UpdateUser model: {0}", JsonConvert.SerializeObject(model));
logger.Debug(slog);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = userService.GetUser(model.Id);
if (user != null)
{
try
{
bool isPhonenumberChanged = false;
string phoneCode = string.Empty;
Random rnd = new Random(DateTime.Now.Second);
phoneCode = rnd.Next(1000, 9999).ToString();
if (user.PhoneNumber != model.phoneNumber)
{
isPhonenumberChanged = true;
user.PhoneNumberCode = phoneCode;
user.PhoneNumber = model.phoneNumber;
}
user.FirstName = model.firstName;
user.LastName = model.lastName;
user.PostalCode = model.billingZipCode;
user.StreetAddress = model.billingStreetNumber;
userService.Update(model.Id, user);
if (isPhonenumberChanged)
{
// Send SMS to phone
await this.AppUserManager.SendSmsAsync(user.Id, "Vethentia Phone code is " + phoneCode);
}
await AppSignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
}
catch (Exception ex)
{
logger.Error("UpdateUser", ex);
throw;
}
}
// return Created(locationHeader, TheModelFactory.Create(user));
RegisterResponseBindingModel resModel = new RegisterResponseBindingModel()
{
msgId = 16,
phoneNumber = model.phoneNumber,
status = 0,
userId = user.Id
};
return(Ok(resModel));
}
public async Task <IHttpActionResult> PutUser(string username, UpdateUserBindingModel user)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (username != user.Username)
{
return(BadRequest());
}
var appUser = await this.AppUserManager.FindByEmailAsync(user.Email);
appUser.FirstName = user.FirstName;
appUser.LastName = user.LastName;
appUser.Email = user.Email;
var result = await this.AppUserManager.UpdateAsync(appUser);
if (result.Succeeded)
{
return(Ok("Update Successfull!"));
}
else
{
return(GetErrorResult(result));
}
//db.Entry(car).State = EntityState.Modified;
//if (car.img == null || car.img.Length == 0)
//{
// db.Entry(car).Property(x => x.img).IsModified = false;
//}
//try
//{
// await db.SaveChangesAsync();
//}
//catch (DbUpdateConcurrencyException)
//{
// if (!CarExists(id))
// {
// return NotFound();
// }
// else
// {
// throw;
// }
//}
//return StatusCode(HttpStatusCode.NoContent);
//return Json(car);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task UpdateUser_should_not_change_his_password_hash()
{
using (var store = NewDocumentStore())
{
string passwordHash;
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new ApplicationRole("Admin"));
await session.SaveChangesAsync();
// Arrange
var userModel = new CreateUserBindingModel
{
Username = "******",
FirstName = "Jeremy",
LastName = "Holt",
Email = "*****@*****.**",
Password = "******"
};
userModel.Roles.Add("Admin");
var controller = GetAccountsController(session);
await controller.CreateUser(userModel);
// Check saved properly
var user = await session.LoadAsync<ApplicationUser>(ApplicationUser.GenerateKey("jeremyholt"));
user.PasswordHash.Should().NotBeNull();
passwordHash = user.PasswordHash;
}
using (var session = store.OpenAsyncSession())
{
// Act - load and change user's first name
var controller = GetAccountsController(session);
var updateModel = new UpdateUserBindingModel
{
UserName = "******",
FirstName = "Jeremy",
LastName = "Last name",
Email = "*****@*****.**",
JoinDate = new DateTime(2013, 5, 6)
};
updateModel.Roles.AddRange(new List<string> {"Admin", "Accounts"});
await controller.UpdateUserAsync(updateModel);
// Assert
var actual = (OkNegotiatedContentResult<ReturnUserModel>) (await controller.GetUserByName("jeremyholt"));
actual.Content.FirstName.Should().Be("Jeremy");
actual.Content.LastName.Should().Be("Last name");
actual.Content.Roles.Should().HaveCount(2).And.Contain("Admin").And.Contain("Accounts");
actual.Content.Claims.Should().HaveCount(2).And.Contain(c => c.Type == ClaimTypes.Role && c.Value == "Accounts");
// Load user directly from db
var user = await session.LoadAsync<ApplicationUser>(ApplicationUser.GenerateKey("jeremyholt"));
user.LastName.Should().Be("Last name");
user.PasswordHash.Should().Be(passwordHash);
user.JoinDate.Should().Be(new DateTime(2013, 5, 6));
}
}
}
