public IActionResult UpdateUser(int id, [FromBody] UpdateUserViewModel userVM)
{
try
{
var user = _context.Users.Include("UserSkills").FirstOrDefault(u => u.UserId == id);
if (user == null)
{
return(Json(NotFound("User ID with " + id + " is not found")));
}
if (userVM.Email != null)
{
if (_context.Users.Any(u => u.Email == userVM.Email))
{
if (_context.Users.FirstOrDefault(u => u.UserId == id).Email == userVM.Email)
{
}
else
{
return(Json(StatusCode(409, "Email already exist.")));
}
}
}
else
{
userVM.Email = _context.Users.FirstOrDefault(u => u.UserId == id).Email;
}
var oldPath = user.CVTemplate;
var dir = _configuration.GetSection("Directory:ForLocalGeneratedCV").Value;
var newPath = dir + "\\" + id + "\\" + userVM.FirstName + "_" + userVM.LastName + "_CV.pdf";
newPath = newPath.Replace(@"\\", @"\");
newPath = newPath.Replace(@":\", @":\\");
if (oldPath != newPath)
{
System.IO.File.Move(oldPath, newPath);
user.CVTemplate = newPath;
_context.Update(user);
_context.SaveChanges();
}
userVM.UserId = id;
_map.Map(userVM, user);
_context.SaveChanges();
return(Json(new NoContentResult()));
}
catch (Exception ex)
{
LogWrite(ex.Message);
return(Json(BadRequest(ex)));
}
}
public async Task <IActionResult> UpdateUser([FromBody] UpdateUserViewModel user_model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (user_model._id_rol < 1)
{
return(BadRequest());
}
if (user_model._id_user < 1)
{
return(BadRequest());
}
var user = await _context.Users.FirstOrDefaultAsync(k => k._id_user == user_model._id_user);
if (user == null)
{
return(NotFound());
}
user._id_rol = user_model._id_rol;
user.kind_of_document = user_model.kind_of_document;
user.document_number = user_model.document_number;
user.telephone = user_model.telephone;
user.adress = user_model.adress;
user.email = user_model.email;
user.name = user_model.name;
if (user_model.update_password)
{
UdemyProject.Web.Utils.Utils.EncryptPassword(user_model.password, out byte[] hash, out byte[] salt);
user.password_hash = hash;
user.password_salt = salt;
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
public UpdateUserViewModel UpdateViewModel(UpdateUserViewModel viewModel)
{
viewModel.RoleGroupList = _roleGroupService.GetRoleGroups(
new Services.Requests.RoleGroup.GetRoleGroupsRequest {
Skip = 0, Take = 0
}).RoleGroups.Select(x => new SelectListItem
{
Text = x.Name,
Value = x.Id.ToString(),
Selected = viewModel.RoleId == x.Id ? true : false
}).ToList();
return(viewModel);
}
public ActionResult Update(UpdateUserViewModel viewModel)
{
var request = viewModel.MapTo <UpdateUserRequest>();
var response = _userService.Update(request);
TempData["IsSuccess"] = response.IsSuccess;
TempData["Message"] = response.Message;
if (response.IsSuccess)
{
return(RedirectToAction("Index"));
}
return(View("Update", viewModel));
}
public async Task <IActionResult> UpdateUser()
{
var user = await userHelper.FindByEmailAsync(User.Identity.Name);
var model = new UpdateUserViewModel();
if (user != null)
{
model.FirstName = user.FirstName;
model.LastName = user.LastName;
}
return(View(model));
}
public async Task <IActionResult> UpdateUser(string userId, string oldClaim)
{
var user = await _userManager.FindByIdAsync(userId);
var model = new UpdateUserViewModel
{
Email = user.Email,
PhoneNumber = user.PhoneNumber,
UserId = user.Id,
OldClaim = oldClaim
};
return(View(model));
}
public async Task <IActionResult> UpdateUserData([FromForm] UpdateUserViewModel userData)
{
try
{
await _accountFacade.UpdateUserData(userData);
return(Ok());
}
catch (Exception e)
{
Response.StatusCode = 500;
return(Json(e.Message + e.InnerException));
}
}
public static void Update(this ApplicationUser user, UpdateUserViewModel uvm)
{
user.UserId = uvm.UserId;
user.FirstName = uvm.FirstName;
user.LastName = uvm.LastName;
user.MiddleName = uvm.MiddleName;
user.CompanyName = uvm.CompanyName;
user.CompanyContact = uvm.CompanyContact;
user.CompanyAddress = uvm.CompanyAddress;
user.Discount = uvm.Discount / (decimal)100;
user.Tax = uvm.Tax / (decimal)100;
user.OtherRemarks = uvm.OtherRemarks;
user.OtherFees = uvm.OtherFees;
}
public IActionResult Update(int id)
{
var user = userManager.FindByIdAsync(id.ToString()).Result;
if (user != null)
{
UpdateUserViewModel model = new UpdateUserViewModel
{
Email = user.Email
};
return(View(user));
}
return(NotFound());
}
public async Task <IActionResult> Actualizar([FromBody] UpdateUserViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.Id <= 0)
{
return(BadRequest());
}
var usuario = await _context.SecurityUsers.FirstOrDefaultAsync(x => x.Id == model.Id);
usuario.SecurityRoleId = model.SecurityRoleId;
usuario.Nombre = model.Nombre;
usuario.Tipo_documento = model.Tipo_documento;
usuario.Num_documento = model.Num_documento;
usuario.Direccion = model.Direccion;
usuario.Telefono = model.Telefono;
usuario.Email = model.Email.ToLower();
if (model.Act_password == true)
{
CrearPasswordHash(model.Password, out byte[] passwordHash, out byte[] passwordSalt);
usuario.Password_hash = passwordHash;
usuario.Password_salt = passwordSalt;
}
//_context.Entry(categoria).State = EntityState.Modified;
if (usuario == null)
{
return(NotFound());
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Exception
return(BadRequest());
}
return(Ok());
}
public UpdateUserViewModel GetUserById(string id)
{
var user = this.userManager.FindByIdAsync(id).Result;
var model = new UpdateUserViewModel
{
UserName = user.UserName,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber
};
return(model);
}
public ActionResult Update(Guid userId, UpdateUserViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try {
_update.Value.Invoke(new UpdateUserRequestModel {
Id = userId, UserName = model.UserName
}, this);
return(_response);
} catch (UserDoesntExistException e) {
throw new HttpException(404, "user not found", e);
}
}
public async Task <IActionResult> UpdateUser()
{
//find the User with id
User u = await _userManagerService.GetUserAsync(HttpContext.User);
//mapping from m to vm
UpdateUserViewModel vm = new UpdateUserViewModel
{
UserName = u.UserName,
Email = u.Email,
};
//pass it to the view
return(View(vm));
}
public IActionResult Update(string Id)
{
var user = userManager.FindByIdAsync(Id).Result;
if (user != null)
{
UpdateUserViewModel model = new UpdateUserViewModel
{
UserName = user.UserName,
Email = user.Email
};
return(View(model));
}
return(NotFound());
}
public async Task <IActionResult> UpdateUserAsync(UpdateUserViewModel model)
{
ApplicationUserDto user = new ApplicationUserDto
{
Id = model.User.Id,
FirstName = model.User.FirstName,
LastName = model.User.LastName,
UserName = model.User.UserName,
Email = model.User.Email
};
await applicationUserService.UpdateAsync(user);
return(RedirectToAction("UsersList", "Account"));
}
public UpdateUserPage(User user)
{
InitializeComponent();
var viewModel = new UpdateUserViewModel();
viewModel.UserId = user;
BindingContext = viewModel;
var userid = user.id;
MessagingCenter.Send(new PassIdPatient()
{
idPatient = userid
}, "UpdateUserId");
}
public async Task <IActionResult> Update([FromBody] UpdateUserViewModel user)
{
// find signed in user
var dbUser = await db.Users.Include("UserComponents.Component").FirstOrDefaultAsync(u => u.Username == User.Identity.Name);
// var ghc = await db.Components.FirstOrDefaultAsync(c => c.Name == "GITHUB");
// var glc = await db.Components.FirstOrDefaultAsync(c => c.Name == "GITLAB");
var ughc = dbUser.UserComponents.FirstOrDefault(uc => uc.Component.Name == "GITHUB");
var uglc = dbUser.UserComponents.FirstOrDefault(uc => uc.Component.Name == "GITLAB");
// if user entered right password
if (CryptoHelper.VerifyHashedPassword(dbUser.Password, user.OldPassword))
{
if (!String.IsNullOrEmpty(user.NewPassword))
{
dbUser.Password = CryptoHelper.HashPassword(user.NewPassword);
}
if (!String.IsNullOrEmpty(user.NewEmailAddress))
{
dbUser.EmailAddress = user.NewEmailAddress;
}
if (!String.IsNullOrEmpty(user.GitHubKey) && ughc != null)
{
ughc.AccessToken = user.GitHubKey;
db.Entry(ughc).State = EntityState.Modified;
}
if (!String.IsNullOrEmpty(user.GitLabKey) && uglc != null)
{
uglc.AccessToken = user.GitLabKey;
db.Entry(uglc).State = EntityState.Modified;
}
// save changes
db.Entry(dbUser).State = EntityState.Modified;
await db.SaveChangesAsync();
return(Ok(new { success = true }));
}
else
{
return(Ok(new { success = false }));
}
}
public async Task <IActionResult> _UpdateUser(UpdateUserViewModel model)
{
bool Status = false;
string Message = string.Empty;
var user = _userManager.FindByEmailAsync(model.Email).Result;
if (user == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
ModelState.AddModelError("", "invalid or incomplete information");
}
if (model == null)
{
return(NotFound("Empty data found"));
}
else
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Created = DateTime.Now;
user.UserName = model.Email;
user.Email = model.Email;
user.PhoneNumber = "03484686261";
user.IsEnable = true;
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
Status = true;
Message = $"User:{user.FirstName+user.LastName}: Updated Successfulllllly";
}
else
{
Status = true;
Message = $"Error Occured Updating User :{user.FirstName+user.LastName}:";
}
}
return(Json(new { status = Status, message = Message }));
}
public async Task <ActionResult> ChangePassword([FromForm] UpdateUserViewModel updateUserViewModel)
{
ClaimsPrincipal currentUser = this.User;
var hashed = BCrypt.Net.BCrypt.HashPassword(updateUserViewModel.Password);
var user = await _userRepository.GetUser(updateUserViewModel.UserName);
if (BCrypt.Net.BCrypt.Verify(updateUserViewModel.OldPassword, user.Password))
{
user.Password = hashed;
await _userRepository.Update(user);
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> EditUser(UpdateUserViewModel viewModel)
{
var token = HttpContext.Session.GetString("Token");
var response = await _userApiClient.UpdateUser(viewModel, token);
if (response.UserName != null)
{
TempData["Result"] = "Update Success";
return(Redirect("/User/Index"));
}
else
{
TempData["ResultFaild"] = "Update faild ";
return(Redirect("EditUser"));
}
}
public IActionResult Edit(string id)
{
if (string.IsNullOrEmpty(id))
{
return(this.NotFound());
}
UpdateUserViewModel model = this.usersService.GetUserById(id);
if (model == null)
{
return(this.NotFound());
}
return(View(model));
}
public UpdateUserViewModel MapToUpdateUserViewModel(User from)
{
UpdateUserViewModel viewModel = new UpdateUserViewModel
{
FirstName = from.FirstName,
LastName = from.LastName,
Id = from.Id
};
if (from.Adress != null)
{
viewModel.Adress = MapAdress(from.Adress);
}
return(viewModel);
}
public async Task <IActionResult> UpdateUser(string userId)
{
var model = new UpdateUserViewModel();
var user = await _adminService.GetUser(userId);
if (user != null)
{
model.UserName = user.UserName;
model.Email = user.Email;
model.Roles = _adminService.GetRolesAsSelectList(user.RoleName);
return(PartialView("Users/_UpdateUserPartial", model));
}
return(RedirectToAction("ListUsers"));
}
// GET: Admin/Details/5
public ActionResult Details(string id)
{
var currUser = userRepo.ResultTable.Where(x => x.Id == id).First();
var model = new UpdateUserViewModel()
{
Id = id,
FirstName = currUser.FirstName,
LastName = currUser.LastName,
Email = currUser.Email,
Phone = currUser.PhoneNumber,
CurrentRole = currUser.Roles.First().ToString(),
};
return(View(model));
}
public async Task <IActionResult> UpdateUser(string id)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(RedirectToAction("UserManagement", _userManager.Users));
}
var vm = new UpdateUserViewModel()
{
Id = user.Id, Email = user.Email, UserName = user.UserName, BirthDate = user.BirthDate, City = user.City, Country = user.Country
};
return(View(vm));
}
public IActionResult Update([FromBody] UpdateUserViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(GetModelStateErrorResponse(ModelState)));
}
var resp = UpdateUser(model);
if (resp.Type != ResponseType.Success)
{
return(BadRequest(resp));
}
return(Ok(resp));
}
public async Task <IActionResult> Update([FromQuery] int id, [FromBody] UpdateUserViewModel updatedUser)
{
var idWorkAround = int.TryParse(updatedUser.Id, out int idResult) ? idResult : throw new NotImplementedException();
var user = await _userManager.GetEntityById(idWorkAround);
var roles = user.UserRoles.Select(x => x.Role.Name).ToList();
await _userManagerApp.RemoveFromRolesAsync(user, roles);
var role = await _roleManager.FindByIdAsync(updatedUser.RoleId.ToString());
await _userManagerApp.AddToRoleAsync(user, role.Name);
var result = await _userManager.Update(updatedUser);
return(Ok(result));
}
public async Task UpdatePost_InvalidModelStateReturnCorrectView_ReturnsUpdateView()
{
//TODO Find way to pass file to
var session = new SessionHelperFake();
var user = new User
{
ID = 1,
UserName = "******",
Email = "*****@*****.**",
Bio = "Hello I am the Sixth test user",
ProfileImagePath = "../Images/TestUserSix/Profile.png",
DateJoined = new DateTime(2017, 1, 14),
DOB = new DateTime(1955, 5, 7),
GenderId = 1,
UserType = new UserType {
ID = 2, Description = "FeaturedUser"
},
Nationality = new Nationality {
ID = 1, Description = "US and A"
},
NationalityID = 1,
UserTypeID = 2,
};
session.Add("CurrentUser", user);
using (var controller = new AccountController(new UserManagerFake(),
new NationalityManagerFake(),
new GenderManagerFake(),
session))
{
controller.ModelState.AddModelError("SessionName", "Required");
var viewModel = new UpdateUserViewModel
{
CurrentUser = new User()
};
HttpPostedFileBase file = new HttpTestFileStub();
var result = await controller.Update(viewModel, file) as ViewResult;
var expectedViewName = "Update";
Assert.AreEqual(expectedViewName, result.ViewName);
}
}
/// <summary>
/// Update profile method
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public ActionResult UpdateUserProfile(string type = "")
{
try
{
string mobileNumber = LoggedInUser.MobileNumber;
var getuserInfo = ObjIUserService.GetuserInfo(mobileNumber);
UpdateUserViewModel objUserInfoViewModel = new UpdateUserViewModel
{
retailer_name = getuserInfo.retailer_name,
mobile_number = getuserInfo.mobile_number,
email_id = getuserInfo.email_id,
address = getuserInfo.address,
state = getuserInfo.state,
district = getuserInfo.district,
taluka = getuserInfo.taluka,
cstn_number = getuserInfo.cstn_number,
vat_number = getuserInfo.vat_number,
pan_number = getuserInfo.pan_number,
license_no = getuserInfo.license_no,
imei_number = getuserInfo.imei_number,
EntryDate = getuserInfo.EntryDate,
pincode = getuserInfo.pincode,
seed_license_validity = getuserInfo.seed_license_validity,
gst_number = getuserInfo.gst_number,
firm_name = getuserInfo.firm_name,
depo = getuserInfo.depo,
Flag = getuserInfo.Flag,
town = getuserInfo.town,
sap_retailer_id = getuserInfo.sap_retailer_id,
fcm_token = getuserInfo.fcm_token,
fcm_subscription_topic = getuserInfo.fcm_subscription_topic,
bank_account_number = getuserInfo.bank_account_number,
birth_date = getuserInfo.birth_date,
retailer_last_name = getuserInfo.retailer_last_name,
houseNo = getuserInfo.houseNo,
streetLine1 = getuserInfo.streetLine1,
streetLine2 = getuserInfo.streetLine2,
//profileUpdate = Convert.ToBoolean(getuserInfo.profileUpdate),
user_company = getuserInfo.user_company
};
return(View(objUserInfoViewModel));
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult UpdateUser(UpdateUserViewModel model, string returnUrl)
{
ViewBag.ReturnUrl = returnUrl;
ViewBag.PageTitle = "User Management";
Dictionary <string, string> sectionNames = new Dictionary <string, string>();
Dictionary <string, string> subSectionNames = new Dictionary <string, string>();
sectionNames["section1"] = "Change User Profile";
subSectionNames["section1"] = "";
ViewBag.PageSectionTitle = sectionNames;
ViewBag.PageSectionSubTitle = subSectionNames;
if (!ModelState.IsValid)
{
TempData["ErrorMessage"] = "Please check the input";
return(View(model));
}
var user = UserManager.FindByName(model.UserName);
if (user != null)
{
user.Email = model.EmailAddress;
im.RemoveAllRoles(model.UserId);
if (model.Roles != null)
{
foreach (var role in model.Roles)
{
im.AddUserToRole(model.UserName, role);
}
}
try
{
UserManager.Update(user);
TempData["SuccessMessage"] = "Successfully saved";
}
catch
{
TempData["ErrorMessage"] = "Can't update user profile";
return(View(model));
}
}
ModelState.Clear();
return(RedirectToAction("UpdateUser", new { userName = model.UserName, returnUrl }));
}
public ActionResult Edit(string id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
AspNetUser user = _foodOrderingDb.AspNetUsers.Find(id);
if (user == null)
{
return HttpNotFound();
}
UpdateUserViewModel userModel = new UpdateUserViewModel
{
Id = user.Id,
Email = user.Email,
CompanyCode = user.Company == null ? "" : user.Company.CompanyCode,
Role = user.AspNetRoles.Any() ? (Roles)Enum.Parse(typeof(Roles), user.AspNetRoles.Select(x => x.Name).First()) : 0
};
return View(userModel);
}
public async Task<ActionResult> Edit(UpdateUserViewModel userModel)
{
if (ModelState.IsValid)
{
ApplicationUser user = await UserManager.FindByIdAsync(userModel.Id);
Company company = _foodOrderingDb.Companies.FirstOrDefault(x => x.CompanyCode.Equals(userModel.CompanyCode)); //TODO: Instead of this, lets use AttributeValidation
if (company == null)
{
user.Email = userModel.Email;
}
else
{
user.Email = userModel.Email;
user.CompanyId = company.Id;
}
if (!string.IsNullOrWhiteSpace(userModel.Password))
{
await UserManager.RemovePasswordAsync(user.Id);
await UserManager.AddPasswordAsync(user.Id, userModel.Password);
}
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
AspNetUser netUser = _foodOrderingDb.AspNetUsers.Find(user.Id);
var userRoles = netUser.AspNetRoles.Select(x => x.Name).ToArray();
await UserManager.RemoveFromRolesAsync(user.Id, userRoles);
var selectedRole = userModel.Role.ToString();
if (string.IsNullOrEmpty(selectedRole))
{
await UserManager.AddToRolesAsync(user.Id, "RegularUser");
}
else
{
await UserManager.AddToRolesAsync(user.Id, selectedRole);
}
return RedirectToAction("List");
}
}
return View(userModel);
}
