public ActionResult UpdateUser(UpdateUserVM vm)
{
var repo = EmployeesRepositoryFactory.GetRepository();
var employeeToUpdate = repo.GetById(vm.EmployeeId);
var UserManager = HttpContext.GetOwinContext().GetUserManager <ApplicationUserManager>();
var user = UserManager.Users.Where(u => u.EmployeeId == vm.EmployeeId).FirstOrDefault();
employeeToUpdate.FirstName = vm.FirstName;
employeeToUpdate.LastName = vm.LastName;
employeeToUpdate.DepartmentId = vm.DepartmentId;
if (ModelState.IsValid)
{
if (!string.IsNullOrEmpty(vm.NewPassword))
{
user.PasswordHash = UserManager.PasswordHasher.HashPassword(vm.NewPassword);
var result = UserManager.Update(user);
}
repo.Update(employeeToUpdate, vm.Email, vm.IsDisabled);
return(RedirectToAction("Users"));
}
vm.NewPassword = "";
vm.ConfirmNewPassword = "";
vm.SetDepartmentItems(DepartmentsRepositoryFactory.GetRepository().GetAll());
return(View("UpdateUser", vm));
}
public UpdateUser(User selectedItem)
{
InitializeComponent();
_vm = new UpdateUserVM(Navigation);
BindingContext = _vm;
_vm.User = selectedItem;
}
public async Task <ActionResult> EditUser(UpdateUserVM model)
{
if (ModelState.IsValid)
{
var user = UserManager.FindById(model.UserId);
if (model.Password != null)
{
user.PasswordHash = UserManager.PasswordHasher.HashPassword(model.Password);
}
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Email = model.Email;
user.Role = model.Role;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Users", "Admin"));
}
else
{
return(View(model));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
// Get Meathod for Edit User Profile
public ActionResult EditProfile(int id)
{
User user = IUserBL.GetUserByID(id);
var config = new MapperConfiguration(cfg => { cfg.CreateMap <User, UpdateUserVM>(); });
IMapper iMapper = config.CreateMapper();
UpdateUserVM userModel = iMapper.Map <User, UpdateUserVM>(user);
return(View(userModel));
}
// UserProfile Page
public ActionResult UserProfile(int id)
{
User user = IUserBL.GetUserByID(id);
var config = new MapperConfiguration(cfg => { cfg.CreateMap <User, UpdateUserVM>(); });
IMapper iMapper = config.CreateMapper();
UpdateUserVM userModel = iMapper.Map <User, UpdateUserVM>(user);
ViewBag.WishList = IUserBL.GetUserWishlist(id);
ViewBag.UserCartDetails = IUserBL.GetUserCartDetails(id);
ViewBag.UserOrderDetails = IUserBL.GetUserOrderDetails(id);
return(View(userModel));
}
public object Update([FromBody] UpdateUserVM userVM,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
var user = Mapper.Map <UpdateUserVM, User>(userVM);
var result = _userService.Update(user, userVM.OldPassword);
if (result.Success)
{
return(_signManager.GenerateTokenAndSetIdentity(result.Value, signingConfigurations, tokenConfigurations));
}
return(result);
}
public ActionResult EditUser(string id)
{
var user = UserManager.FindById(id);
UpdateUserVM model = new UpdateUserVM()
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Role = user.Role,
UserId = id
};
return(View(model));
}
public ActionResult UpdateUser(int id)
{
var viewModel = new UpdateUserVM();
var employee = EmployeesRepositoryFactory.GetRepository().GetById(id);
var UserManager = HttpContext.GetOwinContext().GetUserManager <ApplicationUserManager>();
viewModel.FirstName = employee.FirstName;
viewModel.LastName = employee.LastName;
viewModel.DepartmentId = employee.DepartmentId;
viewModel.SetDepartmentItems(DepartmentsRepositoryFactory.GetRepository().GetAll());
viewModel.Email = UserManager.Users.Where(u => u.EmployeeId == id).FirstOrDefault().Email;
viewModel.IsDisabled = UserManager.Users.Where(u => u.EmployeeId == id).FirstOrDefault().IsDisabled;
viewModel.EmployeeId = employee.EmployeeId;
return(View(viewModel));
}
public IHttpActionResult UpdateUsertoDB([FromBody] UpdateUserVM filter)
{
if (filter == null)
{
return(Content(HttpStatusCode.BadRequest, "Request body not valid"));
}
try
{
PrenotesUser UpdateUser = arcodb.PrenotesUsers.Where(a => a.Username == filter.user && a.Deleted == false).FirstOrDefault();
UpdateUser.Admin = filter.admin;
UpdateUser.Manager = filter.manager;
UpdateUser.DefaultSite = filter.defaultsite;
List <UserSiteLocation> UserOldLocation = arcodb.UserSiteLocations.Where(a => a.UserId == UpdateUser.Id).ToList();
arcodb.UserSiteLocations.RemoveRange(UserOldLocation);
//arcodb.PrenotesUsers.Add(UpdateUser);
arcodb.SaveChanges();
UserSiteLocation bridge1 = new UserSiteLocation();
bridge1.SiteLocationId = filter.defaultsite;
bridge1.UserId = UpdateUser.Id;
arcodb.UserSiteLocations.Add(bridge1);
foreach (var item in filter.othersites)
{
if (item.selected == true)
{
UserSiteLocation bridge = new UserSiteLocation();
bridge.SiteLocationId = item.SiteID;
bridge.UserId = UpdateUser.Id;
arcodb.UserSiteLocations.Add(bridge);
}
}
arcodb.SaveChanges();
return(Content(HttpStatusCode.OK, "User added successfully"));
}
catch (Exception ex)
{
Log.Error("There was an unexpected error while filtering a list of users from AD.", ex);
return(Content(HttpStatusCode.InternalServerError, "There was an unexpected error while filtering a list of users from AD."));
}
}
public ActionResult Update(UpdateUserVM userModel)
{
if (ModelState.IsValid)
{
var config = new MapperConfiguration(cfg => { cfg.CreateMap <UpdateUserVM, User>(); });
IMapper iMapper = config.CreateMapper();
User user = iMapper.Map <UpdateUserVM, User>(userModel);
ViewBag.Alert = IUserBL.EditUser(user);
if (ViewBag.Alert == null)
{
ViewBag.Message = "Update Successfull";
ViewBag.Alert = null;
}
}
return(RedirectToAction("LogOut"));
}
public IActionResult Update([FromBody] UpdateUserVM updateUserVM, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _mapper.Map <User>(updateUserVM);
user.Id = new Guid(Thread.CurrentPrincipal?.Identity?.Name);
var result = _userService.Update(user);
if (!result.Success)
{
return(Conflict(result));
}
return(Ok(_signManager.GenerateTokenAndSetIdentity(result.Value, signingConfigurations, tokenConfigurations)));
}
public IActionResult Update([FromBody] UpdateUserVM updateUserVM,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = Mapper.Map <UpdateUserVM, User>(updateUserVM);
var result = _userService.Update(user);
if (result.Success)
{
return(Ok(_signManager.GenerateTokenAndSetIdentity(result.Value, signingConfigurations, tokenConfigurations)));
}
return(Conflict(result));
}
public async Task <ActionResult> AddUser(UpdateUserVM model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, Role = model.Role
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
var addedUser = UserManager.FindByEmail(user.Email);
if (addedUser.Role == "Admin")
{
UserManager.AddToRole(addedUser.Id, "admin");
}
else if (addedUser.Role == "Sales")
{
UserManager.AddToRole(addedUser.Id, "sales");
}
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ResponseResult> UpdateUser(UpdateUserVM user) => await usersClient.UpdateAsync(user);
public ActionResult AddUser()
{
UpdateUserVM model = new UpdateUserVM();
return(View(model));
}
public async Task <ActionResult <ResponseResult> > Update([FromBody] UpdateUserVM model)
{
var response = await business.Update(model.UserId, model.NewUserName);
return(Ok(response));
}
