public ActionResult Edit(EditUserModel model)
{
var command = new EditProfileCommand(UserInfo.Id, model.Brag, model.Latitude, model.Longitude);
ExecuteCommand(command);
TempData[ViewDataKeys.Message] = new SuccessMessage(Resources.ProfileUpdateSuccess);
return RedirectToAction("Profile");
}
public ActionResult Edit(EditUserModel model)
{
Validate(model);
if (ModelState.IsValid)
{
_repository.Update(model);
return(RedirectToAction("Index"));
}
return(View(model));
}
public async Task <IActionResult> DeleteUser(EditUserModel model, CancellationToken token = default)
{
if (model.AccountId.HasValue)
{
await _accountRepository.DeleteAsync(model.AccountId.Value, token);
this.SetResultMessage($"<strong>Successfully deleted</strong> {model.DisplayName}.");
}
return(RedirectToAction("Users"));
}
public ApplicationUser EditUserModelToAppUser(EditUserModel UVM)
{
ApplicationUser appUser = new ApplicationUser();
appUser.UserName = UVM.UserName;
appUser.Email = UVM.Email;
appUser.Age = UVM.Age;
appUser.FirstName = UVM.FirstName;
appUser.LastName = UVM.LastName;
return(appUser);
}
public ActionResult EditUser(EditUserModel model)
{
var repo = UserRepositoryFactory.GetRepository();
model.user.FirstName = model.details.FirstName;
model.user.LastName = model.details.LastName;
model.user.FullName = $"{model.details.FirstName} {model.details.LastName}";
model.user.Email = model.details.Email;
model.user.UserName = model.user.Email;
repo.EditUser(model.user, model.details);
return(View("EditUser", model));
}
public async Task <IActionResult> Edit(string id)
{
var user = await _userManager.FindByIdAsync(id);
var vm = new EditUserModel
{
Id = user.Id,
Email = user.Email
};
return(View(vm));
}
public ActionResult Edit(EditUserModel newUser)
{
if (ModelState.IsValid)
{
try
{
var user = db.Users.FirstOrDefault(u => u.Id.Equals(newUser.Id));
var users = db.Users;
foreach (var checkUser in users)
{
if (checkUser.Username == newUser.Username && checkUser.Id != newUser.Id)
{
ModelState.AddModelError("UsernameError", "Username already exists!");
return(View());
}
}
if (newUser.FirstName.Any(char.IsDigit))
{
Response.Write("Names can't contain numbers!");
return(View());
}
if (newUser.LastName.Any(char.IsDigit))
{
Response.Write("Names can't contain numbers!");
return(View());
}
user.FirstName = newUser.FirstName;
user.LastName = newUser.LastName;
user.Username = newUser.Username;
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
((User)Session["currentUser"]).Username = user.Username;
Response.Redirect($"~/Users/Profile?username={user.Username}");
}
catch
{
RedirectToAction("Error", "Home");
}
}
return(View());
}
public ActionResult Edit(EditUserModel model)
{
if (ModelState.IsValid)
{
var user = new ProjectCureData.Models.User
{
UserId = model.UserId,
UserEmail = model.UserName,
UserFirstName = model.FirstName,
UserLastName = model.LastName,
UserRoleId = model.RoleId,
UserActiveIn = model.IsActive,
UserNotifyFiveDays = model.Notify5Days,
UserNotifyTenDays = model.Notify10Days,
};
var existingUser = Repository.GetUserById(user.UserId);
Repository.SaveUser(user);
var notifier = new EmailNotifier();
if (model.IsNew)
{
//set password for new user and notify via email
var newPassword = GetNewPassword();
user.UserPassword = newPassword;
Repository.UpdatePassword(user);
notifier.GiveTemporaryPasswordNotification(Repository, user.UserEmail, newPassword);
}
else if (!model.IsNew && !user.UserActiveIn)
{
if (existingUser != null && existingUser.UserActiveIn)
{
//unassign from events, and send notifications
//remove manager from future events if being inactivated
var unassociatedEvents = Repository.RemoveManagerFromEvents(user.UserId);
foreach (var evt in unassociatedEvents)
{
notifier.EventCancellationNotification(Repository, evt, user.UserEmail);
}
}
}
}
model.Roles = Repository.GetRoleList();
return(PartialView("Edit", model));
}
private EditUserModel GetUserLogin()
{
var userLogin = (user)Session["loginsession"];
EditUserModel editUser = new EditUserModel()
{
id = userLogin.id,
Email = userLogin.email,
FullName = userLogin.full_name,
UserName = userLogin.username
};
return(editUser);
}
public void Update(EditUserModel model)
{
using (var ctx = new ManageExpensesContext2())
{
var user = ctx.Users.Where(u => u.Id == model.Id).Single();
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Password = model.Password;
ctx.SaveChanges();
}
}
public ActionResult Edit(EditUserModel model)
{
var user = userRepository.Load(model.Id);
user.DateofBirth = Convert.ToDateTime(model.DateofBirth);
user.Email = model.Email;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.SecondName = model.SecondName;
user.UserName = model.UserName;
userRepository.Change(user);
return(RedirectToAction("Index", "Home"));
}
public IHttpActionResult UpdateUserDetails(EditUserModel editUserModel)
{
var updateUserResult = _userManagement.UpdateUser(editUserModel);
if (updateUserResult.IsSuccess)
{
return(Ok("User Profile Updated Successfully"));
}
else
{
return(GetErrorResult(updateUserResult));
}
}
public async Task <ActionResult> EditCurrentUser()
{
ApplicationUser user = await UserManager.FindByEmailAsync(User.Identity.Name);
if (user != null)
{
EditUserModel editModel = new EditUserModel {
Year = user.Year
};
return(View(editModel));
}
return(RedirectToAction("Login", "Account"));
}
public ActionResult EditUser(EditUserModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
model.Save();
if (model.Roles.Contains(UserRole.OrgManager.ToString()))
{
return(RedirectToAction("EditUser", new { id = model.EmployeeId }));
}
return(RedirectToAction("Users"));
}
// GET: UserManagement/Edit/5
public async Task <ActionResult> Edit(string id)
{
var tempUser = _userManager.FindByIdAsync(id).Result;
var tempRole = await _userManager.GetRolesAsync(tempUser);
var editUserModel = new EditUserModel()
{
User = tempUser,
Roles = new SelectList(_roleManager.Roles, "Name", "Name", "Name")
};
return(View(editUserModel));
}
public async Task <ActionResult> Edit(string id)
{
ApplicationUser user = await UserManager.FindByIdAsync(id);
if (user != null)
{
EditUserModel editModel = new EditUserModel {
Year = user.Year
};
return(View(editModel));
}
return(RedirectToAction("Login", "Account"));
}
public async Task <ActionResult> Edit()
{
AppUser user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
EditUserModel model = new EditUserModel {
Name = user.Name
};
return(View(model));
}
return(RedirectToAction("Login", "Account"));
}
public ActionResult PutUser(string id, [FromBody] EditUserModel user)
{
ApplicationUser applicationUser = db.applicationUsers.Where(u => u.Id == id).SingleOrDefault();
applicationUser.FirstName = user.FirstName;
applicationUser.LastName = user.LastName;
applicationUser.Email = user.Email;
applicationUser.PhoneNumber = user.Phone;
db.SaveChanges();
return(Ok(applicationUser));
}
public ActionResult Edit(int?id)
{
using (PHMSDbContext db = new PHMSDbContext())
{
var v = db.Users.Where(u => u.Id == id).FirstOrDefault();
EditUserModel user = new EditUserModel();
user.Id = v.Id;
user.FirstName = v.FirstName;
user.LastName = v.LastName;
user.DateOfBirth = v.DateOfBirth;
return(View(user));
}
}
public ActionResult Edit(Guid id)
{
User tUser = db.Users.Find(id);
if (tUser != null)
{
EditUserModel user = new EditUserModel {
UserId = id, Username = tUser.Username, Email = tUser.Email, IsApproved = tUser.IsApproved, ExtraField = tUser.ExtraField
};
return(View(user));
}
return(View(new EditUserModel()));
}
public async Task Edit(string id, [FromBody] EditUserModel model)
{
AppUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
user.Email = model.Email;
user.UserName = model.Name;
IdentityResult validEmail = await userValidator.ValidateAsync(userManager, user);
if (!validEmail.Succeeded)
{
await Response.WriteAsync($"{validEmail}");
return;
}
IdentityResult validPass = null;
if (!string.IsNullOrEmpty(model.Password))
{
validPass = await passwordValidator.ValidateAsync(userManager, user, model.Password);
if (validPass.Succeeded)
{
user.PasswordHash = passwordHasher.HashPassword(user, model.Password);
}
else
{
await Response.WriteAsync($"{validPass}");
return;
}
}
if ((validEmail.Succeeded && validPass == null) || (validEmail.Succeeded && model.Password != string.Empty && validPass.Succeeded))
{
IdentityResult result = await userManager.UpdateAsync(user);
if (result.Succeeded)
{
await Response.WriteAsync("User successfully changed");
}
else
{
await Response.WriteAsync($"{result}");
}
}
}
else
{
await Response.WriteAsync("User Not Found");
}
}
public async Task <IActionResult> EditUser(EditUserModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
//Skill associations
var user = _dataAccess.GetUser(viewModel.UserId);
user.AssociatedSkills.RemoveAll(usk => viewModel.AssociatedSkills == null || !viewModel.AssociatedSkills.Any(msk => msk.SkillId == usk.SkillId));
if (viewModel.AssociatedSkills != null)
{
user.AssociatedSkills.AddRange(viewModel.AssociatedSkills.Where(msk => !user.AssociatedSkills.Any(usk => usk.SkillId == msk.SkillId)));
}
if (user.AssociatedSkills != null && user.AssociatedSkills.Count > 0)
{
user.AssociatedSkills.ForEach(usk => usk.UserId = user.Id);
}
await _dataAccess.UpdateUser(user);
var organizationAdminClaim = new Claim(Security.ClaimTypes.UserType, "OrgAdmin");
if (viewModel.IsOrganizationAdmin)
{
//add organization admin claim
var result = await _userManager.AddClaimAsync(user, organizationAdminClaim);
if (result.Succeeded)
{
var callbackUrl = Url.Action("Login", "Admin", new { Email = user.Email }, protocol: HttpContext.Request.Scheme);
await _emailSender.SendEmailAsync(user.Email, "Account Approval", "Your account has been approved by an administrator. Please <a href=" + callbackUrl + ">Click here to Log in</a>");
}
else
{
return(Redirect("Error"));
}
}
else if (user.IsUserType(UserType.OrgAdmin))
{
//remove organization admin claim
var result = await _userManager.RemoveClaimAsync(user, organizationAdminClaim);
if (!result.Succeeded)
{
return(Redirect("Error"));
}
}
return(RedirectToAction(nameof(Index)));
}
public ActionResult Edit(string id, EditUserModel UpdatedUser)
{
ApplicationUser user = db.Users.Find(id);
try
{
var roleManager = new RoleManager <IdentityRole>(new
RoleStore <IdentityRole>(db));
var UserManager = new UserManager <ApplicationUser>(new
UserStore <ApplicationUser>(db));
if (ModelState.IsValid)
{
if (TryUpdateModel(UpdatedUser))
{
user.UserName = UpdatedUser.UserName;
user.Email = UpdatedUser.Email;
var roles = (from role in db.Roles select role).ToList();
foreach (var role in roles)
{
UserManager.RemoveFromRole(id, role.Name);
}
var selectedRole =
db.Roles.Find(HttpContext.Request.Params.Get("newRole"));
UserManager.AddToRole(id, selectedRole.Name);
db.SaveChanges();
}
else
{
UpdatedUser.AllRoles = GetAllRoles();
UpdatedUser.Id = id;
return(View(UpdatedUser));
}
TempData["Message"] = "Sucesfully edited user!";
return(RedirectToAction("Index"));
}
else
{
UpdatedUser.AllRoles = GetAllRoles();
UpdatedUser.Id = id;
return(View(UpdatedUser));
}
}
catch (Exception e)
{
Response.Write(e.Message);
TempData["ErrMessage"] = "User edit failed because of the following error: " + e.Message;
UpdatedUser.AllRoles = GetAllRoles();
UpdatedUser.Id = id;
return(View(UpdatedUser));
}
}
public ActionResult EditUser(int id)
{
if (Session["Email"] != null && Session["UserID"] != null)
{
ViewBag.ActiveMenu = "AddUser";
EditUserModel _EditUserModel = _UsersManagementService.ViewUserDetailsList().Find(uid => uid.UserID == id);
_EditUserModel.sex = _SystemTools.GetGender();
return(View(_EditUserModel));
}
else
{
return(RedirectToAction("Login", "Home"));
}
}
public async Task <IActionResult> Edit(string id)
{
User user = await userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
EditUserModel model = new EditUserModel {
Id = user.Id, Nickname = user.Nickname
};
return(View(model));
}
public ActionResult EditUser(string userId)
{
MxUser mxUser = GetMxUser();
if (mxUser.IsInRole("USERS_View"))
{
var model = new EditUserModel(new MxUser(userId), mxUser);
return(View(model));
}
else
{
return(RedirectToAction("NoAccess", "Account", new { returnUrl = "Admin/UserAdmin" }));
}
}
public async Task UpdateAsync(int id, EditUserModel userModel)
{
byte[] salt = Helpers.GenerateSalt();
User user = await DBContext.Users.FindAsync(id);
user.Email = userModel.Email;
user.Name = userModel.Name;
user.Password = Helpers.HashPassword(userModel.Password, salt);
user.Salt = salt;
user.Role = userModel.UserType;
user.Surname = userModel.Surname;
user.UserName = userModel.UserName;
await Task.Run(() => DBContext.Users.Update(user));
}
public async Task <ActionResult <ApplicationUser> > EditUser(EditUserModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = await _repo.EditUserAsync(model);
if (user != null)
{
return(user);
}
return(BadRequest());
}
/// <summary>
/// Updates user details in the database.
/// </summary>
/// <param name="model">EditUserModel.</param>
/// <returns>Awaitable task.</returns>
public Task UpdateUserAsync(EditUserModel model)
{
var user = new User
{
Id = this.currentUserProvider.GetCurrentUserId(),
Cookie = model.If_session,
LastActivity = DateTime.UtcNow,
Usess = model.Usess,
Uid = model.Uid,
TrackerId = model.TrackerId,
};
return(this.userDAO.EditAsync(user));
}
public async Task <ActionResult> EditUser(long id)
{
var user = await _handler.GetByIdAsync(id);
var model = new EditUserModel()
{
Id = user.Id,
LastName = user.LastName,
FirstName = user.FirstName,
Email = user.Email
};
return(View(model));
}
public ActionResult Edit(EditUserModel model)
{
try {
User user = _repository.GetUser(model.UserName);
ModelCopier.CopyModel(model, user);
_repository.Update(user);
return(RedirectToAction("Details", new { id = model.UserName }));
} catch (Exception) {
ModelState.AddModelError("", "Edit Failure, see inner exception.");
}
return(View(model));
}
public ActionResult Edit(EditUserModel user)
{
// var errors = ModelState
//.Where(x => x.Value.Errors.Count > 0)
//.Select(x => new { x.Key, x.Value.Errors })
//.ToArray();
if (ModelState.IsValid)
{
var userToUpdatebrands = db.User_Info.SingleOrDefault(u => u.UidNo == user.Uidno);
if (userToUpdatebrands != null)
{
userToUpdatebrands.First_name = user.First_name;
userToUpdatebrands.Last_name = user.Last_name;
userToUpdatebrands.E_mail_id = user.Email_id;
userToUpdatebrands.Mobile_number = user.Mobile_number;
userToUpdatebrands.Address_Communication = user.Address_Communication;
userToUpdatebrands.DOB = user.DOB;
userToUpdatebrands.Gender = user.Gender;
userToUpdatebrands.Usr_type = user.user_type;
db.SaveChanges();
}
TempData["Usr_Message"] = ConfigurationManager.AppSettings["EDT_SUC"];
return RedirectToAction("Index");
}
return View(user);
}
public void EditUser(Guid id, EditUserModel user)
{
var db = this.GetDbContext();
////var oldUser = GetUser(id);
////var newUser = GetUser(id);
var newUser = db.Users.Single(u => u.Id == id);
////db.Users.Attach(newUser);
object[] data = new object[2];
newUser.Name = user.Name;
if (!string.IsNullOrEmpty(user.Password))
{
newUser.Password = this.EncryptPassword(user.Password);
}
newUser.Email = user.Email;
newUser.OpenId = user.OpenId ?? string.Empty;
newUser.UserId = user.UserId;
db.SubmitChanges();
////data[0] = oldUser;
////data[1] = newUser;
this.lmsService.Inform(UserNotifications.UserEdit, newUser);
}
public ActionResult EditUser(EditUserModel model)
{
return Handler.Get<EditUserHandler>().Handle(model).ToJson();
}
public async Task<ActionResult> EditUser(EditUserModel model)
{
var user = await UserManager.FindByIdAsync(model.Id);
if (user != null)
{
user.Email = model.Email;
user.PhoneNumber = model.PhoneNumber;
var validEmail = await UserManager.UserValidator.ValidateAsync(user);
if (!validEmail.Succeeded)
{
AddErrorsFromResult(validEmail);
}
IdentityResult validPassword = null;
if (!string.IsNullOrEmpty(model.Password))
{
validPassword = await UserManager.PasswordValidator.ValidateAsync(model.Password);
if (validPassword.Succeeded)
{
user.PasswordHash = UserManager.PasswordHasher.HashPassword(model.Password);
}
else
{
AddErrorsFromResult(validPassword);
}
}
if (validPassword != null && ((!validEmail.Succeeded || model.Password == string.Empty || !validPassword.Succeeded)))
{
return View(model);
}
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
var userRoles = await UserManager.GetRolesAsync(user.Id);
result = await UserManager.RemoveFromRolesAsync(user.Id, userRoles.ToArray());
if (!result.Succeeded)
{
return View(model);
}
result = await UserManager.AddToRolesAsync(user.Id, model.SelectedRoles);
if (result.Succeeded)
{
return RedirectToAction("Users");
}
}
else
{
AddErrorsFromResult(result);
}
}
else
{
ModelState.AddModelError("", "User was not found.");
}
return View(model);
}
public void EditUser(Guid id, EditUserModel user)
{
using (var db = new UserManagementDBContext())
{
var oldUser = db.Users.Single(u => u.Id == id);
oldUser.Name = user.Name;
if (user.Password != null && user.Password != string.Empty)
oldUser.Password = EncryptPassword(user.Password);
oldUser.Email = user.Email;
oldUser.OpenId = user.OpenId ?? string.Empty;
oldUser.RoleId = user.RoleId;
db.SaveChanges();
_LmsService.Inform(UserNotifications.UserEdit, oldUser);
}
}
public ActionResult Edit(EditUserModel model, string[] privilegeName)
{
this.ShowTitle("User Management");
this.ShowBreadcrumb("User", "Edit");
var roles = _iSecurityService.GetRoles().ToList();
var roleModels = roles.Count() == 0 ? null : (roles.Select(role => new SelectRoleModel
{
RoleName = role.RoleName,
Assigned = role.Users.Where(x => x.UserName.ToLower() == model.UserName.ToLower()).Count() == 0 ? false : true
}).ToList());
model.RoleModels = roleModels;
if (ModelState.IsValid)
{
User user = _iSecurityService.GetUser(model.UserName);
if (user != null)
{
bool changePasswordSucceeded;
if (model.OldPassword != null && model.NewPassword != null && model.ConfirmPassword != null)
{
try
{
MembershipUser currentUser = Membership.GetUser(model.UserName, userIsOnline: true);
changePasswordSucceeded = currentUser.ChangePassword(model.OldPassword, model.NewPassword);
}
catch (Exception)
{
changePasswordSucceeded = false;
}
}
else
{
changePasswordSucceeded = true;
}
if (changePasswordSucceeded)
{
try
{
var selectRoles = roles;
var lstRoles = new List<Role>();
foreach (var roleName in privilegeName)
{
string id = roleName;
lstRoles.Add(selectRoles.Where(x => x.RoleName == id).FirstOrDefault());
}
user.Roles = lstRoles;
Profile profile = _iProfileService.GetProfiles().Where(x => x.UserName.ToLower() == model.UserName.ToLower()).FirstOrDefault();
if (profile != null)
{
profile.FirstName = model.FirstName;
profile.LastName = model.LastName;
profile.SurName = model.SurName;
profile.Address = model.Address;
profile.DateOfBirth = Convert.ToDateTime(model.DateOfBirth);
profile.MobileNumber = model.MobileNumber;
profile.PhoneNumber = model.PhoneNumber;
profile.ThumbImageUrl = model.ThumbImageUrl;
profile.SmallImageUrl = model.SmallImageUrl;
profile.UserName = model.UserName;
_iProfileService.UpdateProfile(profile);
user.Profile = profile;
}
else
{
Profile tempProfile = new Profile
{
FirstName = model.FirstName,
LastName = model.LastName,
SurName = model.SurName,
Address = model.Address,
DateOfBirth = Convert.ToDateTime(model.DateOfBirth),
MobileNumber = model.MobileNumber,
PhoneNumber = model.PhoneNumber,
ThumbImageUrl = model.ThumbImageUrl,
SmallImageUrl = model.SmallImageUrl,
UserName = model.UserName
};
_iProfileService.CreateProfile(tempProfile);
user.Profile = tempProfile;
}
_iSecurityService.UpdateUser(user);
this.ShowMessage("User updated successfully", MessageType.Success);
return RedirectToAction("Index");
}
catch (Exception)
{
//throw;
}
}
else
{
ModelState.AddModelError("", "The current password is incorrect or the new password is invalid.");
}
}
}
//return PartialView("_Edit", model);
return View(model);
}
public ActionResult UpdateUser(FormCollection collection)
{
EditUserModel model=new EditUserModel();
ResultModel resultModel=new ResultModel();
this.TryUpdateModel(model);
string ErrorMessage=UserNameAvailable(model.Login,model.UserId);
if(String.IsNullOrEmpty(ErrorMessage)==false) {
ModelState.AddModelError("Login",ErrorMessage);
}
ErrorMessage=EmailAvailable(model.Email,model.UserId);
if(String.IsNullOrEmpty(ErrorMessage)==false) {
ModelState.AddModelError("Email",ErrorMessage);
}
if(model.ChangePassword) {
if(string.IsNullOrEmpty(model.Password))
ModelState.AddModelError("Password","Password is required");
}
if(ModelState.IsValid) {
USER user=AdminRepository.FindUser(model.UserId);
if(user==null) {
user=new USER();
user.CreatedDate=DateTime.Now;
}
user.EntityID=Authentication.CurrentEntity.EntityID;
user.LastUpdatedDate=DateTime.Now;
user.FirstName=model.FirstName;
user.LastName=model.LastName;
user.MiddleName=model.MiddleName;
user.PhoneNumber=model.PhoneNumber;
if(model.ChangePassword) {
user.PasswordSalt=SecurityExtensions.CreateSalt();
user.PasswordHash=model.Password.CreateHash(user.PasswordSalt);
}
user.Login=model.Login;
user.Email=model.Email;
user.Enabled=model.Enabled;
user.IsAdmin=model.IsAdmin;
IEnumerable<ErrorInfo> errorInfo=AdminRepository.SaveUser(user);
if(errorInfo!=null) {
resultModel.Result+=ValidationHelper.GetErrorInfo(errorInfo);
} else {
resultModel.Result="True||"+user.UserID;
}
} else {
foreach(var values in ModelState.Values.ToList()) {
foreach(var err in values.Errors.ToList()) {
if(string.IsNullOrEmpty(err.ErrorMessage)==false) {
resultModel.Result+=err.ErrorMessage+"\n";
}
}
}
}
return View("Result",resultModel);
}
public void EditUser(Guid id, EditUserModel user)
{
var db = GetDbContext();
var oldUser = db.Users.Single(u => u.Id == id);
oldUser.Name = user.Name;
if (!string.IsNullOrEmpty(user.Password))
{
oldUser.Password = EncryptPassword(user.Password);
}
oldUser.Email = user.Email;
oldUser.OpenId = user.OpenId ?? string.Empty;
db.SubmitChanges();
_LmsService.Inform(UserNotifications.UserEdit, oldUser);
}
public ActionResult Users()
{
ViewData["MenuName"]="AdminManagement";
ViewData["SubmenuName"]="UserManagement";
ViewData["PageName"]="User";
EditUserModel model=new EditUserModel();
model.Entities=SelectListFactory.GetEntitiesSelectList(AdminRepository.GetAllEntities());
return View(model);
}
public ActionResult Edit(int id = 0)
{
var model = from p in db.User_Info
select new EditUserModel
{
First_name = p.First_name,
Last_name = p.Last_name,
Address_Communication = p.Address_Communication,
Email_id = p.E_mail_id,
Mobile_number = p.Mobile_number,
Uidno = p.UidNo,
user_type = p.Usr_type,
DOB=p.DOB,
Gender=p.Gender
};
EditUserModel editprddetails = null;
foreach (var m in model)
{
editprddetails = new EditUserModel();
editprddetails.Uidno = m.Uidno;
editprddetails.First_name = m.First_name;
editprddetails.Last_name = m.Last_name;
editprddetails.Address_Communication = m.Address_Communication;
editprddetails.Email_id = m.Email_id;
editprddetails.Mobile_number = m.Mobile_number;
editprddetails.DOB = m.DOB;
editprddetails.Gender = m.Gender;
editprddetails.user_type = m.user_type;
}
var list = new SelectList(new[] { new { ID = "M", Name = "Male" }, new { ID = "F", Name = "FeMale" }, new { ID = "O", Name = "Others" } }, "ID", "Name", 1);
ViewBag.Genders = list;
return View(editprddetails);
}
public void EditUser(Guid id, EditUserModel user)
{
this.storage.EditUser(id, user);
this.cacheProvider.Invalidate("user-" + id, "users");
}
//
// GET: /User/Edit/by id
public ActionResult Edit(string id = null)
{
this.ShowTitle("User Management");
this.ShowBreadcrumb("User", "Edit");
if (!string.IsNullOrEmpty(id))
{
var roles = _iSecurityService.GetRoles().ToList();
var roleModels = roles.Count() == 0 ? null : (roles.Select(role => new SelectRoleModel
{
RoleName = role.RoleName,
Assigned = role.Users.Where(x => x.UserName.ToLower() == id.ToLower()).Count() == 0 ? false : true
}).ToList());
User user = _iSecurityService.GetUser(id);
Profile profile = _iProfileService.GetProfiles().Where(x => x.UserName.ToLower() == id.ToLower()).FirstOrDefault();
if (user == null)
{
this.ShowMessage("Sorry! Data not found. You've been redirected to the default page instead.", MessageType.Error);
return RedirectToAction("Index");
}
EditUserModel editUserModel = new EditUserModel();
if (profile == null)
{
editUserModel.UserName = user.UserName;
editUserModel.Email = user.Email;
editUserModel.OldPassword = null;
editUserModel.NewPassword = null;
editUserModel.ConfirmPassword = null;
}
else
{
editUserModel.UserName = user.UserName;
editUserModel.Email = user.Email;
editUserModel.OldPassword = null;
editUserModel.NewPassword = null;
editUserModel.ConfirmPassword = null;
editUserModel.FirstName = profile.FirstName;
editUserModel.LastName = profile.LastName;
editUserModel.SurName = profile.SurName;
editUserModel.DateOfBirth = profile.DateOfBirth == null ? null : profile.DateOfBirth.Value.ToString("MM/dd/yyyy");
editUserModel.Address = profile.Address;
editUserModel.PhoneNumber = profile.PhoneNumber;
editUserModel.MobileNumber = profile.MobileNumber;
editUserModel.ThumbImageUrl = profile.ThumbImageUrl;
editUserModel.SmallImageUrl = profile.SmallImageUrl;
}
editUserModel.RoleModels = roleModels;
//return PartialView("_Edit", editUserModel);
return View(editUserModel);
}
this.ShowMessage("Sorry! Data not found. You've been redirected to the default page instead.", MessageType.Error);
return RedirectToAction("Index");
}
