public void ManageData(string userId, ManageUserViewModel user)
{
var userFromDb = this.Data.Users
.GetById(userId);
userFromDb.FirstName = user.FirstName;
userFromDb.SecondName = user.SecondName;
userFromDb.LastName = user.LastName;
userFromDb.Gender = user.Gender;
userFromDb.Age = user.Age;
userFromDb.Town = user.Town;
userFromDb.Country = user.Country;
userFromDb.Website = user.Website;
this.Data.Users.SaveChanges();
}
public async Task<string> aj_MasterPasswordUpdate(ManageUserViewModel md)
{
ResultInfo rAjaxResult = new ResultInfo();
try
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), md.OldPassword, md.NewPassword);
if (result.Succeeded)
{
rAjaxResult.result = true;
}
else
{
rAjaxResult.message = String.Join(":", result.Errors);
rAjaxResult.result = false;
}
}
else
{
List<string> errMessage = new List<string>();
foreach (ModelState modelState in ModelState.Values)
foreach (ModelError error in modelState.Errors)
errMessage.Add(error.ErrorMessage);
rAjaxResult.message = String.Join(":", errMessage);
rAjaxResult.result = false;
}
}
catch (Exception ex)
{
rAjaxResult.result = false;
rAjaxResult.message = ex.Message;
}
return defJSON(rAjaxResult);
}
//[Authorize(Roles = "ADMINISTRATOR")]
public async Task <IActionResult> ManageUsers()
{
//ViewData["StatusMessage"] =
// message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
// : message == ManageMessageId.AddLoginSuccess ? "The external login was added."
// : message == ManageMessageId.Error ? "An error has occurred."
// : "";
//var user = GetCurrentUserAsync();
//if (user == null)
//{
// return View("Error");
//}
var manageUsers = new List <ManageUser>();
var appUsers = from appUser in _userManager.Users
select appUser;
//Get all the Roles for our users
foreach (var appUser in appUsers)
{
var manageUser = new ManageUser()
{
Id = appUser.Id,
Email = appUser.Email,
UserName = appUser.UserName,
Roles = string.Join(",", await _userManager.GetRolesAsync(appUser))
};
manageUsers.Add(manageUser);
}
var model = new ManageUserViewModel();
model.Users = manageUsers;
return(View(model));
}
public async Task <IActionResult> ManageUsers(ManageUserViewModel manageUsers)
{
List <User> users;
IList <string> roles;
ManageUserViewModel manageUserVm;
List <UserViewModel> usersVm = new List <UserViewModel>();
if (string.IsNullOrEmpty(manageUsers.Input))
{
return(View());
}
users = await userManager.Users.Where(u => u.UserName.Contains(manageUsers.Input)).ToListAsync();
if (users.Count == 0)
{
ModelState.AddModelError(string.Empty, "No user found with this name.");
manageUserVm = new ManageUserViewModel();
return(View(manageUserVm));
}
foreach (var user in users)
{
roles = await userManager.GetRolesAsync(user);
var userRole = roles.OrderBy(r => r).First();
usersVm.Add(new UserViewModel
{
UserId = user.Id,
Name = user.UserName,
Role = userRole,
IsBanned = user.IsBanned
});
}
manageUserVm = new ManageUserViewModel(usersVm);
return(View(manageUserVm));
}
public ActionResult ManageUser(string id = null)
{
if (string.IsNullOrEmpty(id))
{
return(View(new ManageUserViewModel()));
}
var user = _userService.GetUser(id);
if (user == null)
{
return(HttpNotFound());
}
var viewModel = new ManageUserViewModel()
{
Id = user.Id,
Name = user.Name,
Email = user.Email,
Roles = Mapper.Map <IEnumerable <ApplicationRoleViewModel> >(user.Roles.Select(r => r.Role))
};
return(View(viewModel));
}
public async Task <IActionResult> ChangePassword(ManageUserViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await GetCurrentUserAsync();
if (user != null)
{
var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User changed their password successfully.");
return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.ChangePasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error }));
}
public IActionResult EditUser(ManageUserViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var user = _userRepository.GetUserByID(model.Id);
if (user == null)
{
return(RedirectToAction("ManageUsers"));
}
user.Email = model.Email;
user.Enabled = model.Enabled;
user.SubscriptionModelId = model.SubscriptionModelId;
_userRepository.UpdateUser(user);
_logger.Log(CurrentUser.Id, $"Edited user: {user.UserName}; Set Email: {model.Email}, Enabled: {model.Enabled}, SubscriptionModelId: {model.SubscriptionModelId}");
return(RedirectToAction("ManageUsers"));
}
public virtual ActionResult LockedUser(ManageUserViewModel model)
{
if (string.IsNullOrWhiteSpace(model.User.UserName))
{
throw new ArgumentNullException("userName");
}
OracleDatastore db = null;
try
{
db = new OracleDatastore(this.HttpContext.Trace);
DbConnectionStringBuilder dcms8 = new DbConnectionStringBuilder();
dcms8.ConnectionString = ConfigurationManager.ConnectionStrings["dcms8"].ConnectionString;
// Creating the connection as super user
db.CreateConnection(dcms8.ConnectionString, string.Empty);
const string QUERY_ALTER_USER = "******";
var sql = string.Format(QUERY_ALTER_USER, model.User.UserName);
db.ExecuteNonQuery(sql, null);
AddStatusMessage(string.Format("{0} user account has been locked", model.User.UserName));
}
catch (ProviderException ex)
{
ModelState.AddModelError("", ex.Message);
}
finally
{
if (db != null)
{
db.Dispose();
}
}
return(RedirectToAction(Actions.ManageUser(model.User.UserName)));
}
public async Task <ActionResult> ChangePassword(ManageUserViewModel model)
{
if (ModelState.IsValid)
{
var um = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
var result = await um.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var json = new
{
okMsg = "用户密码修改成功"
};
return(Json(json, "text/html", JsonRequestBehavior.AllowGet));
}
else
{
var json = new
{
okMsg = "用户密码修改失败"
};
return(Json(json, "text/html", JsonRequestBehavior.AllowGet));
}
}
else
{
var json = new
{
okMsg = "输入信息格式有误"
};
return(Json(json, "text/html", JsonRequestBehavior.AllowGet));
}
}
//
// GET: /Account/Manage
public ActionResult Manage(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
: message == ManageMessageId.Error ? "An error has occurred."
: "";
ViewBag.HasLocalPassword = HasPassword();
ViewBag.ReturnUrl = Url.Action("Manage");
string currUserId = User.Identity.GetUserId();
ApplicationUser user = ctx.Users.Where(u => u.Id == currUserId).First();
ManageUserViewModel manageUserViewModel = new ManageUserViewModel()
{
UserName = user.UserName,
AssociationName = user.AssociationName,
Email = user.Email,
Adress = user.Adress,
OIB = user.OIB
};
return(View(manageUserViewModel));
}
public async Task <IActionResult> Manage(ManageUserViewModel model)
{
if (ModelState.IsValid)
{
var userPhones = (await _userProvider.GetUserPhones()).Model;
var cityCode = model.AddressModel.DeliveryLocationType == AddressType.City ? model.AddressModel.City.CityCode : model.AddressModel.Locality.LocationCode;
await _userProvider.UpdatetUserAddress(new UpdateUserAddressModel(cityCode, model.AddressModel.Locality.LocalityCode, model.AddressModel.RegionCode, (DeleveryLocationType?)model.AddressModel.DeliveryLocationType,
model.AddressModel.Address));
var homePhoneTask = ChangePhone(userPhones.Home, model.PhoneHome, PhoneType.Home);
var additionalPhoneTask = ChangePhone(userPhones.Additional, model.PhoneAdditional, PhoneType.Additional);
var mobilePhoneTask = ChangePhone(userPhones.Mobile, model.PhoneMobile, PhoneType.Mobile);
var workPhoneTask = ChangePhone(userPhones.Work, model.PhoneWork, PhoneType.Work);
await Task.WhenAll(homePhoneTask, additionalPhoneTask, mobilePhoneTask, workPhoneTask);
ShowSuccess("Контакты успешно обновленны!");
return(RedirectToAction(nameof(UserController.Manage)));
}
return(View(model));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
var dato1 = await UserManager.FindAsync(User.Identity.Name, model.OldPassword);
if (result.Succeeded)
{
var oUID = db.Usuarios.DefaultIfEmpty(null).FirstOrDefault(x => x.NombreDeUsuario == dato1.UserName && x.ClaveDeUsuario == dato1.PasswordHash).Id;
Usuario oUsua = db.Usuarios.DefaultIfEmpty(null).FirstOrDefault(x => x.Id == oUID);
var datoN = await UserManager.FindAsync(User.Identity.Name, model.NewPassword);
if (oUsua != null)
{
oUsua.ClaveDeUsuario = datoN.PasswordHash;
db.Entry(oUsua).State = EntityState.Modified;
}
db.SaveChanges();
return(RedirectToAction("Home", "Index"));
//return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
var dato1 = await UserManager.FindAsync(User.Identity.Name, model.OldPassword);
if (result.Succeeded)
{
var oUID = db.Usuarios.DefaultIfEmpty(null).FirstOrDefault(x => x.NombreDeUsuario == dato1.UserName && x.ClaveDeUsuario == dato1.PasswordHash).Id;
Usuario oUsua = db.Usuarios.DefaultIfEmpty(null).FirstOrDefault(x => x.Id == oUID);
var datoN = await UserManager.FindAsync(User.Identity.Name, model.NewPassword);
if (oUsua != null)
{
oUsua.ClaveDeUsuario = datoN.PasswordHash;
db.Entry(oUsua).State = EntityState.Modified;
}
db.SaveChanges();
return(RedirectToAction("Home", "Index"));
//return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return(View(model));
}
public async Task<IActionResult> Manage(ManageUserViewModel model)
{
ViewBag.ReturnUrl = Url.Action("Manage");
if (ModelState.IsValid)
{
var user = await GetCurrentUserAsync();
var result = await UserManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
// 如果我们进行到这一步时某个地方出错，则重新显示表单
return View(model);
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
ViewBag.menuItemActive = "Compte";
// Si nous sommes arrivés là, un échec s’est produit. Réafficher le formulaire
return View();
}
// GET: Entry
public async Task <ActionResult> ManageUsers(int id)
{
if (User.IsInRole("Admin") || User.IsInRole("Main") || User.IsInRole("Tech") || User.IsInRole(id.ToString() + "-Admin") || User.IsInRole(id.ToString() + "-Main") || User.IsInRole(id.ToString() + "-Tech"))
{
var UserModel = new ManageUserViewModel();
var RoleUserlist = new List <UserListModel>();
var Userlist = new List <UserNameViewModel>();
var users = await context.Users.ToListAsync();
if (id != 0)
{
foreach (var user in users)
{
if (await userManager.IsInRoleAsync(user, "Comp" + id.ToString()))
{
var listitem = new UserListModel();
if (await userManager.IsInRoleAsync(user, id.ToString() + "-Judge"))
{
listitem.Roles.Add("Judge");
if (await userManager.IsInRoleAsync(user, "Field1"))
{
listitem.Roles.Add("Field1");
}
if (await userManager.IsInRoleAsync(user, "Field2"))
{
listitem.Roles.Add("Field2");
}
if (await userManager.IsInRoleAsync(user, "Field3"))
{
listitem.Roles.Add("Field3");
}
if (await userManager.IsInRoleAsync(user, "Field4"))
{
listitem.Roles.Add("Field4");
}
if (await userManager.IsInRoleAsync(user, "Field5"))
{
listitem.Roles.Add("Field5");
}
if (await userManager.IsInRoleAsync(user, "Field6"))
{
listitem.Roles.Add("Field6");
}
if (await userManager.IsInRoleAsync(user, "AllFields"))
{
listitem.Roles.Add("AllFields");
}
}
if (await userManager.IsInRoleAsync(user, id.ToString() + "-Admin"))
{
listitem.Roles.Add("Admin");
}
if (await userManager.IsInRoleAsync(user, id.ToString() + "-Field"))
{
listitem.Roles.Add("FieldStaff");
}
if (await userManager.IsInRoleAsync(user, id.ToString() + "-Manager"))
{
listitem.Roles.Add("Manager");
}
if (await userManager.IsInRoleAsync(user, id.ToString() + "-Main"))
{
listitem.Roles.Add("Main");
}
if (await userManager.IsInRoleAsync(user, id.ToString() + "-Tech"))
{
listitem.Roles.Add("Tech");
}
if (await userManager.IsInRoleAsync(user, "Locked"))
{
listitem.Roles.Add("Locked");
}
listitem.UserID = user.Id;
listitem.UserName = user.UserName;
RoleUserlist.Add(listitem);
}
else
{
if (!await userManager.IsInRoleAsync(user, "ota"))
{
var useritem = new UserNameViewModel();
if (await userManager.IsInRoleAsync(user, "Locked"))
{
useritem.Locked = true;
}
else
{
useritem.Locked = false;
}
useritem.Username = user.UserName;
useritem.UUID = user.Id;
Userlist.Add(useritem);
}
}
}
UserModel.roleSpecificUsers = RoleUserlist;
UserModel.nonUsers = Userlist;
UserModel.roleSpecificPage = true;
}
else
{
//CHANGE TO WHICH COMPETITION EACH USER IS APART OF
foreach (var user in users)
{
var listitem = new UserListModel();
if (await userManager.IsInRoleAsync(user, "Judge"))
{
listitem.Roles.Add("Judge");
if (await userManager.IsInRoleAsync(user, "Field1"))
{
listitem.Roles.Add("Field1");
}
if (await userManager.IsInRoleAsync(user, "Field2"))
{
listitem.Roles.Add("Field2");
}
if (await userManager.IsInRoleAsync(user, "Field3"))
{
listitem.Roles.Add("Field3");
}
if (await userManager.IsInRoleAsync(user, "Field4"))
{
listitem.Roles.Add("Field4");
}
if (await userManager.IsInRoleAsync(user, "Field5"))
{
listitem.Roles.Add("Field5");
}
if (await userManager.IsInRoleAsync(user, "Field6"))
{
listitem.Roles.Add("Field6");
}
if (await userManager.IsInRoleAsync(user, "AllFields"))
{
listitem.Roles.Add("AllFields");
}
}
if (await userManager.IsInRoleAsync(user, "Admin"))
{
listitem.Roles.Add("Admin");
}
if (await userManager.IsInRoleAsync(user, "FieldStaff"))
{
listitem.Roles.Add("FieldStaff");
}
if (await userManager.IsInRoleAsync(user, "Manager"))
{
listitem.Roles.Add("Manager");
}
if (await userManager.IsInRoleAsync(user, "Main"))
{
listitem.Roles.Add("Main");
}
if (await userManager.IsInRoleAsync(user, "Tech"))
{
listitem.Roles.Add("Tech");
}
if (await userManager.IsInRoleAsync(user, "Locked"))
{
listitem.Roles.Add("Locked");
}
listitem.UserID = user.Id;
listitem.UserName = user.UserName;
RoleUserlist.Add(listitem);
}
UserModel.roleSpecificUsers = RoleUserlist;
UserModel.roleSpecificPage = false;
}
//users = userManager.Users.Where(u => u.Roles)
return(View(UserModel));
}
else
{
return(View("IsNotAuthenticated"));
}
}
public async Task<ActionResult> ManageProfile(ManageUserViewModel model)
{
ViewBag.ReturnUrl = Url.Action("Manage");
ModelState.Remove("OldPassword");
ModelState.Remove("NewPassword");
ModelState.Remove("ConfirmPassword");
if (ModelState.IsValid)
{
ApplicationUser appUserModel = UserManager.FindById(User.Identity.GetUserId());
appUserModel.Email = model.Email;
appUserModel.MobileNo = model.MobileNo;
appUserModel.UserName = model.MobileNo;
IdentityResult result = await UserManager.UpdateAsync(appUserModel);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.ProfileChangedSuccess });
}
else
{
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return View("Manage", model);
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
string currentUserId = User.Identity.GetUserId();
var currentUser = db.Users.Where(m => m.Id == currentUserId).FirstOrDefault();
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
if (model.department != null)
{
currentUser.department = model.department;
//db.Entry(currentUser.add).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.telphone != null)
{
currentUser.telphone = model.telphone;
//db.Entry(currentUser.telphone).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.mobile != null)
{
currentUser.mobile = model.mobile;
//db.Entry(currentUser.mobile).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.Email != null)
{
currentUser.Email = model.Email;
//db.Entry(currentUser.Email).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.parent != null)
{
currentUser.parent = model.parent;
//db.Entry(currentUser.parent).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.relation != null)
{
currentUser.relation = model.relation;
//db.Entry(currentUser.relation).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.emergence != null)
{
currentUser.emergence = model.emergence;
//db.Entry(currentUser.emergence).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.dorm != null)
{
currentUser.dorm = model.dorm;
//db.Entry(currentUser.dorm).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.food != null)
{
currentUser.food = model.food;
//db.Entry(currentUser.food).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.eatother != null)
{
currentUser.eatother = model.eatother;
//db.Entry(currentUser.eatother).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.disease != null)
{
currentUser.disease = model.disease;
//db.Entry(currentUser.disease).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.disother != null)
{
currentUser.disother = model.disother;
//db.Entry(currentUser.disother).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.lowincomes != null)
{
currentUser.lowincomes = model.lowincomes;
//db.Entry(currentUser.lowincomes).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.size != null)
{
currentUser.size = model.size;
//db.Entry(currentUser.size).State = EntityState.Modified;
//db.SaveChanges();
}
if (model.other != null)
{
currentUser.other = model.other;
//db.Entry(currentUser.other).State = EntityState.Modified;
//db.SaveChanges();
}
db.Entry(currentUser).State = EntityState.Modified;
db.SaveChanges();
if (model.NewPassword != null)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
await SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
else
{
AddErrors(result);
}
}
return(RedirectToAction("Index", "Home"));
}
}
else
{
// 使用者沒有密碼，因此，請移除遺漏 OldPassword 欄位所導致的任何驗證錯誤
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
// 如果執行到這裡，發生某項失敗，則重新顯示表單
return(View(model));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
#region Properties
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
#endregion
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
#region Auth Check
if (result.Succeeded)
{
User user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
await SignInAsync(user, false);
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
#endregion
AddErrors(result);
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
#region Auth Check
if (result.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
#endregion
AddErrors(result);
}
}
// If we got this far, something failed, redisplay form
return(View("~/Views/Account/Manage.cshtml", model));
}
public async Task<string> aj_MasterPasswordUpdate(ManageUserViewModel md)
{
ResultInfo rAjaxResult = new ResultInfo();
try
{
if (ModelState.IsValid)
{
if (this.LoginUserFlag == "Y")
{
if (md.ConfirmPassword != md.NewPassword)
{
rAjaxResult.message = Resources.Res.Log_Err_NewPasswordNotSure;
rAjaxResult.result = false;
return defJSON(rAjaxResult);
}
if (md.OldPassword == md.NewPassword)
{
rAjaxResult.message = Resources.Res.Log_Err_NewPasswordSame;
rAjaxResult.result = false;
return defJSON(rAjaxResult);
}
using (var db0 = getDB0())
{
var getUser = db0.Sales.Find(this.UserId);
if (md.OldPassword != EncryptString.desDecryptBase64(HttpUtility.UrlDecode(getUser.password)))
{
rAjaxResult.message = Resources.Res.Log_Err_Password;
rAjaxResult.result = false;
return defJSON(rAjaxResult);
}
else {
getUser.password= HttpUtility.UrlEncode(EncryptString.desEncryptBase64(md.NewPassword));
db0.SaveChanges();
}
}
}
else if (this.LoginUserFlag == "N")
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), md.OldPassword, md.NewPassword);
if (result.Succeeded)
{
rAjaxResult.result = true;
}
else
{
rAjaxResult.message = String.Join(":", result.Errors);
rAjaxResult.result = false;
}
}
}
else
{
List<string> errMessage = new List<string>();
foreach (ModelState modelState in ModelState.Values)
foreach (ModelError error in modelState.Errors)
errMessage.Add(error.ErrorMessage);
rAjaxResult.message = String.Join(":", errMessage);
rAjaxResult.result = false;
}
}
catch (Exception ex)
{
rAjaxResult.result = false;
rAjaxResult.message = ex.Message;
}
return defJSON(rAjaxResult);
}
public async Task <ActionResult <string> > UpdateUser([FromBody] ManageUserViewModel registerUser)
{
if (ModelState.IsValid)
{
var user2 = await _userManager.FindByNameAsync(User.Identity.Name);
var user = new LMSUser {
UserName = registerUser.Email, Email = registerUser.Email, FirstName = registerUser.FirstName, LastName = registerUser.LastName
};
// var Role = registerUser.Role;
user2.FirstName = registerUser.FirstName;
user2.LastName = registerUser.LastName;
if (User.Identity.Name != registerUser.Email)
{
throw new AccessViolationException("User tryed to update other user");
}
if (registerUser.Password != "")
{// then try to update password
var changePasswordResult = await _userManager.ChangePasswordAsync(user2, registerUser.Oldpassword, registerUser.Password);
if (!changePasswordResult.Succeeded)
{
_logger.LogInformation("Failed to update Password by user");
foreach (var error in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
else
{
_logger.LogInformation("Password updated by user");
}
}
var result = await _userManager.UpdateAsync(user2);
if (result.Succeeded)
{
_logger.LogInformation("User updated by user");
// var roles = await _userManager.GetRolesAsync(user2);
/*if (!roles.Contains(Role))
* {
* _logger.LogInformation("User role updated by user");
* var ok2 = await _userManager.RemoveFromRoleAsync(user2, roles[0]);
* if (!ok2.Succeeded)
* {
* ModelState.AddModelError(string.Empty, string.Join("\n", ok2.Errors));
* }
* var ok = await _userManager.AddToRoleAsync(user2, Role);
* if (!ok.Succeeded)
* {
* ModelState.AddModelError(string.Empty, string.Join("\n", ok.Errors));
* }
* }*/
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
if (ModelState.Count > 0)
{ // errors
return(StatusCode(500, ModelState));
}
var res = Json(new
{
status = true
});
return(Ok(res));
}
return(StatusCode(500, ModelState));
}
public async Task <ActionResult <string> > UpdateUserAdmin([FromBody] ManageUserViewModel registerUser)
{
if (ModelState.IsValid)
{
var user = new LMSUser {
UserName = registerUser.Email, Email = registerUser.Email, FirstName = registerUser.FirstName, LastName = registerUser.LastName
};
var Role = registerUser.Role;
var user2 = await _userManager.FindByIdAsync(registerUser.Id);
user2.FirstName = registerUser.FirstName;
user2.LastName = registerUser.LastName;
var result = await _userManager.UpdateAsync(user2);
if (result.Succeeded)
{
_logger.LogInformation("User updated by admin");
var roles = await _userManager.GetRolesAsync(user2);
if (!roles.Contains(Role))
{
_logger.LogInformation("User role updated by Admin");
var ok2 = await _userManager.RemoveFromRoleAsync(user2, roles[0]);
if (!ok2.Succeeded)
{
throw new Exception(string.Join("\n", ok2.Errors));
}
var ok = await _userManager.AddToRoleAsync(user2, Role);
if (!ok.Succeeded)
{
throw new Exception(string.Join("\n", ok.Errors));
}
}
/* var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
* var callbackUrl = Url.Page(
* "/Account/ConfirmEmail",
* pageHandler: null,
* values: new { userId = user.Id, code = code },
* protocol: Request.Scheme);
*
* await _emailSender.SendEmailAsync(registerUser.Email, "Confirm your email",
* $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
*/
// teacher makes users so no log in.
// await _signInManager.SignInAsync(user, isPersistent: false);
var res = Json(new
{
status = true
});
return(Ok(res));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(StatusCode(500, ModelState));
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
else
{
// Для пользователя не указан пароль, поэтому все ошибки проверки из-за отсутствия поля OldPassword будут удалены
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
// Появление этого сообщения означает наличие ошибки; повторное отображение формы
return View(model);
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
var userId = User.Identity.GetUserId();
var localUserName = await Logins.GetProviderKey(User.Identity.GetUserId(),
IdentityConfig.LocalLoginProvider);
var hasLocalLogin = localUserName != null;
ViewBag.HasLocalPassword = hasLocalLogin;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasLocalLogin)
{
if (ModelState.IsValid)
{
var changePasswordSucceeded = await ChangePassword(localUserName,
model.OldPassword,
model.NewPassword);
if (changePasswordSucceeded)
{
return(RedirectToAction("Manage",
new
{
Message = ManageMessageId.ChangePasswordSuccess
}));
}
else
{
ModelState.AddModelError(String.Empty,
"The current password is incorrect or the new password is invalid.");
}
}
}
else
{
// User does not have a local password so remove any validation errors caused by a missing OldPassword field
var state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
try
{
// Create the local login info and link the local account to the user
localUserName = User.Identity.GetUserName();
if (await Secrets.Create(new UserSecret(localUserName,
model.NewPassword)) &&
await Logins.Add(new UserLogin(userId,
IdentityConfig.LocalLoginProvider,
localUserName)))
{
return(RedirectToAction("Manage",
new
{
Message = ManageMessageId.SetPasswordSuccess
}));
}
else
{
ModelState.AddModelError(String.Empty,
"Failed to set password");
}
}
catch (Exception e)
{
ModelState.AddModelError(String.Empty,
e);
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
string userId = User.Identity.GetUserId();
bool hasLocalLogin = await IdentityManager.Logins.HasLocalLoginAsync(userId);
ViewBag.HasLocalPassword = hasLocalLogin;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasLocalLogin)
{
if (ModelState.IsValid)
{
IdentityResult result = await IdentityManager.Passwords.ChangePasswordAsync(User.Identity.GetUserName(), model.OldPassword, model.NewPassword);
if (result.Success)
{
return RedirectToAction("Manage", new { Message = "Your password has been changed." });
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a local password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
// Create the local login info and link it to the user
IdentityResult result = await IdentityManager.Logins.AddLocalLoginAsync(userId, User.Identity.GetUserName(), model.NewPassword);
if (result.Success)
{
return RedirectToAction("Manage", new { Message = "Your password has been set." });
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
var dbUser = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (dbUser != null)
{
//var lastChangeDate = dbUser.LastPasswordChangedDate ?? DateTime.MinValue;
//if (lastChangeDate.AddHours(24) <= DateTime.Now)
//{
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
dbUser.LastPasswordChangedDate = DateTime.Now;
await UserManager.UpdateAsync(dbUser);
//var userEmail = ServiceFactory.Create<IAspNetUserService>("AspNetUserService").GetCurrentUserEmailAddress();
//if (!string.IsNullOrEmpty(userEmail))
//{
// var receiverList = new List<string>();
// receiverList.Add(userEmail);
// var changeDate = dbUser.LastPasswordChangedDate.Value;
// var changeDateString = changeDate.ToPersianString() + " " + $"{changeDate.Hour}:{changeDate.Minute}:{changeDate.Second}";
// var emailProvider = ObjectRegistry.GetObject<IEmailProvider>("EmailProvider");
// emailProvider.Notify($"کاربر گرامی رمز عبور شما در تاریخ {changeDateString} با موفقیت تغییر یافت",
// "تغییر رمز عبور", receiverList, null);
//}
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
//}
//else
//{
// var error = new List<string>();
// error.Add("هنوز 24 ساعت از زمان آخرین تغییر رمز عبور شما نگذشته است. لطفا بعدا سعی کنید");
// AddErrors(new IdentityResult(error));
//}
}
else
{
var error = new List <string>();
error.Add("کاربر جاری پیدا نشد");
AddErrors(new IdentityResult(error));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task<JsonResult> BanUser(ManageUserViewModel model)
{
var context = new PhotoContestDbContext();
var store = new UserStore<User>(context);
var manager = new UserManager<User>(store);
await manager.SetLockoutEnabledAsync(model.Id, true);
await manager.SetLockoutEndDateAsync(model.Id, DateTime.Now.AddDays(14));
return this.Json(
string.Format("Successfully locked user {0}", model.UserName),
JsonRequestBehavior.AllowGet);
}
//
// GET: /Account/Manage
public ActionResult Manage(ManageMessageId? message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
: message == ManageMessageId.ProfileChangedSuccess ? "Profile changed successfully."
: message == ManageMessageId.Error ? "An error has occurred."
: "";
ViewBag.HasLocalPassword = HasPassword();
ApplicationUser appUserModel = UserManager.FindById(User.Identity.GetUserId());
ManageUserViewModel manageUserViewModel = new ManageUserViewModel();
manageUserViewModel.Email = appUserModel.Email;
manageUserViewModel.MobileNo = appUserModel.MobileNo;
ViewBag.ReturnUrl = Url.Action("Manage");
return View(manageUserViewModel);
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(
User.Identity.GetUserId <long>(),
model.OldPassword,
model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(
User.Identity.GetUserId <long>());
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Manage", new
{
Message = ManageMessageId.ChangePasswordSuccess
}));
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused
// by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(
User.Identity.GetUserId <long>(), model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Manage", new
{
Message = ManageMessageId.SetPasswordSuccess
}));
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public Task <IdentityResult> ChangePassword(string id, [FromBody] ManageUserViewModel model)
{
return(UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword));
}
public ManageUsersControl()
{
InitializeComponent();
VM = new ManageUserViewModel();
(Content as FrameworkElement).DataContext = VM;
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.HasAvatar = CurrentUser.AvatarURL != null;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
// Появление этого сообщения означает наличие ошибки; повторное отображение формы
return View(model);
}
public ActionResult Manage(ManageUserViewModel manageUserViewModel)
{
var currentUser = (User)Session["CurrentUser"];
var userName = string.Empty;
if (currentUser != null)
{
userName = currentUser.User_Name;
}
if (ModelState.IsValid)
{
var userModel = new UserModel();
var updatedUser = userModel.EditUser(manageUserViewModel.User.User_Id, manageUserViewModel.User.First_Name, manageUserViewModel.User.Last_Name, manageUserViewModel.User.Initials, manageUserViewModel.User.Email_Address);
if (updatedUser == null)
{
ViewBag.Message = "An Error Occurred, Please contact Support";
return(View(manageUserViewModel));
}
if ((!string.IsNullOrEmpty(manageUserViewModel.OldPassword)) && (!string.IsNullOrEmpty(manageUserViewModel.NewPassword)) && (!string.IsNullOrEmpty(manageUserViewModel.ConfirmPassword)))
{
if (manageUserViewModel.OldPassword != updatedUser.Password)
{
ModelState.AddModelError("", "The Old Password does not match the Current User Password! Please try again.");
manageUserViewModel.OldPassword = string.Empty;
manageUserViewModel.NewPassword = string.Empty;
manageUserViewModel.ConfirmPassword = string.Empty;
return(View(manageUserViewModel));
}
if (manageUserViewModel.NewPassword != manageUserViewModel.ConfirmPassword)
{
ModelState.AddModelError("", "The New Password and Confirm Password does not match! Please try again.");
manageUserViewModel.OldPassword = string.Empty;
manageUserViewModel.NewPassword = string.Empty;
manageUserViewModel.ConfirmPassword = string.Empty;
return(View(manageUserViewModel));
}
// Change Password
updatedUser = userModel.ChangeUserPassword(manageUserViewModel.User.User_Id, manageUserViewModel.NewPassword);
if (updatedUser == null)
{
ViewBag.Message = "An Error Occurred, Please contact Support";
return(View(manageUserViewModel));
}
else
{
var auditTrail = new AuditTrailModel();
auditTrail.InsertAuditTrail(userName, "User Change Password" + ":" + userName, "SDICMS");
}
}
FormsAuthentication.SetAuthCookie(updatedUser.User_Name, false);
Session.Remove("CurrentUser");
Session.Remove("MenuLayout");
Session.Add("CurrentUser", updatedUser);
return(RedirectToAction("Index", "Home"));
}
return(View(manageUserViewModel));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
ApplicationUser user;
if (hasPassword)
{
if (ModelState.IsValid)
{
if (model.OldPassword != null && model.NewPassword != null)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
await SignInAsync(user, isPersistent : false);
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
else
{
AddErrors(result);
}
}
user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
user.Name = model.Name;
user.CountryId = model.CountryId;
user.HomePage = model.HomePage;
user.Street1 = model.Street1;
user.Street2 = model.Street2;
user.City = model.City;
user.SubdivisionId = model.SubdivisionId;
user.PostalCode = model.PostalCode;
IdentityResult res = await UserManager.UpdateAsync(user);
if (res.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
else
{
AddErrors(res);
return(View());
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
if (model.OldPassword == model.NewPassword)
{
ModelState.AddModelError("", AccountResources.NewPasswordMustBeNew);
return(View(model));
}
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
await SignInAsync(user, isPersistent : false);
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
else
{
foreach (string error in result.Errors)
{
switch (error)
{
case ("Incorrect password."):
{
ModelState.AddModelError("", AccountResources.InvalidPassword);
}
break;
default:
{
return(View("~/Views/Shared/Error.cshtml"));
}
}
}
return(View(model));
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
string userId = User.Identity.GetUserId();
bool hasLocalLogin = await this.IdentityManager.Logins.HasLocalLoginAsync(userId);
ViewBag.HasLocalPassword = hasLocalLogin;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasLocalLogin)
{
if (ModelState.IsValid)
{
IdentityResult result =
await
this.IdentityManager.Passwords.ChangePasswordAsync(
User.Identity.GetUserName(),
model.OldPassword,
model.NewPassword);
if (result.Success)
{
return(this.RedirectToAction("Manage", new { Message = "Your password has been changed." }));
}
else
{
this.AddErrors(result);
}
}
}
else
{
// User does not have a local password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
// Create the local login info and link it to the user
IdentityResult result =
await
this.IdentityManager.Logins.AddLocalLoginAsync(
userId,
User.Identity.GetUserName(),
model.NewPassword);
if (result.Success)
{
return(this.RedirectToAction("Manage", new { Message = "Your password has been set." }));
}
else
{
this.AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return(this.View(model));
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
ViewBag.HasLocalPassword = false;
ViewBag.ReturnUrl = Url.Action("Manage");
return View(model);
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = true;
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (ModelState.IsValid)
{
var user = await UserManager.FindByNameAsync(model.UserName);
if (!user.NeedReset)
{
ViewBag.Message = Messages.PasswordChangedBefore;
return(View("Error"));
}
if (user.DefaultPassword != null && user.NeedReset)
{
IdentityResult result = new IdentityResult();
if (model.OldPassword != model.NewPassword)
{
result = await UserManager.ChangePasswordAsync(user.Id, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
//string UserName = User.Identity.Name;
//user = await UserManager.FindAsync(UserName, model.NewPassword);
user.NeedReset = false;
user.DefaultPassword = null;
user.AccessFailedCount = 0;
UserManager.Update(user);
ViewBag.message = General.PasswordChanged;
await SignInAsync(user, false);
return(RedirectToAction("GeneralPurpose", "Home", new MessagesVM {
Message = General.PasswordChanged
}));
//return View("GeneralPurpose");
}
else
{
AddErrors(result);
}
}
else
{
//new & old are the same
ModelState.AddModelError("", Messages.InvalidUserName);
IdentityResult error = new IdentityResult();
AddErrors(error);
}
}
else if (user.DefaultPassword == null && user.NeedReset)
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
IdentityResult result = await UserManager.AddPasswordAsync(user.Id, model.NewPassword);
if (result.Succeeded)
{
user.NeedReset = false;
UserManager.Update(user);
ViewBag.message = General.PasswordChanged;
await SignInAsync(user, false);
return(RedirectToAction("GeneralPurpose", "Home", new MessagesVM {
Message = Messages.passwordSet
}));
//return View("GeneralPurpose");
//return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess,model= new LoginViewModel{UserName = user.UserName}});
}
else
{
AddErrors(result);
ViewBag.HasLocalPassword = false;
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
/// <summary>
/// This displays information about a specific user. If the user does not exist, it redirects to the user list page.
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public virtual ActionResult ManageUser(string userName)
{
//TC8 : Do not enter user name on textbox and click GO button
if (string.IsNullOrEmpty(userName))
{
return(RedirectToAction(Actions.UserList()));
}
var model = new ManageUserViewModel();
var userRoles = Roles.GetRolesForUser(userName);
var query = from capability in RoleAreaCapability.Capabilities
group capability by capability.RoleName into g
orderby g.Key
select new ManageUserRole
{
RoleName = g.Key,
Areas = from area in g
orderby area.AreaName
select new ManageUserRoleArea
{
AreaName = area.AreaName,
Purpose = area.Purpose
}
};
OracleMembershipUser user;
try
{
model.AssignedRoles = query.Where(p => userRoles.Contains(p.RoleName));
model.GrantableRoles = query.Where(p => !userRoles.Contains(p.RoleName));
user = Membership.Provider.GetUser(userName, false) as OracleMembershipUser;
}
catch (ProviderException ex)
{
ModelState.AddModelError("", ex.Message);
return(RedirectToAction(Actions.UserList()));
}
//TC 9 :Enter any invalid user and click GO button
if (user == null)
{
ModelState.AddModelError("", string.Format("User {0} does not exist.", userName));
return(RedirectToAction(Actions.UserList()));
}
model.User = new OracleUserModel
{
UserName = userName,
PasswordExpiryDate = user.PasswordExpiryDate == DateTime.MinValue ? (DateTime?)null : user.PasswordExpiryDate,
LastLockoutDate = user.LastLockoutDate == DateTime.MinValue ? (DateTime?)null : user.LastLockoutDate,
CreateDate = user.CreationDate,
//UserAuditLog = Mapper.Map<IEnumerable<UserAudit>>(user.AuditLog),
UserAuditLog = user.AuditLog.Select(p => new UserAudit
{
ActionName = p.ActionName,
ActionTime = p.ActionTime,
ByOracleUserName = p.ByOracleUserName,
ByOsUserName = p.ByOsUserName,
Result = p.Result,
RoleName = p.RoleName,
TerminalName = p.TerminalName
}),
//UserSessionLog = Mapper.Map<IEnumerable<UserSession>>(user.Sessions)
UserSessionLog = user.Sessions.Select(p => new UserSession
{
ActionName = p.ActionName,
ClientInfo = p.ClientInfo,
IsActive = p.IsActive,
LogonTime = p.LogonTime,
MachineName = p.MachineName,
Module = p.Module,
OsExecutableName = p.OsExecutableName,
OSUserName = p.OsUserName,
SerialNumber = p.SerialNumber,
SessionId = p.SessionId,
State = p.State
})
};
// The user we are trying to edit must be a DCMS user. We do not want to risk editing system users such as sys and dcms8.
// We ensure this by checking whether the user to edit has the DCMS8_USER role.
//model.IsEditable = userRoles.Contains(ViewModelBase.DcmsUserRole);
return(View(Views.ManageUser, model));
}
public ActionResult ForgotPassword(ManageUserViewModel model)
{
if (ModelState.IsValid)
{
ServiceLayer.Services.ResetPasswordService _ResetPasswordService = new ServiceLayer.Services.ResetPasswordService();
var token = "";
string UserName = WebSecurity.CurrentUserName;
//check user existance
var user = Membership.GetUser(UserName);
bool changePasswordSucceeded;
changePasswordSucceeded = user.ChangePassword(model.OldPassword, model.NewPassword);
if (!changePasswordSucceeded)
{
return(Content("Current password is not correct."));
}
if (user == null)
{
TempData["Message"] = "User Not exist.";
}
else
{
//generate password token
token = WebSecurity.GeneratePasswordResetToken(UserName);
//create url with above token
}
bool any = _ResetPasswordService.UpdatePassword(UserName, token);
bool response = false;
if (any == true)
{
response = WebSecurity.ResetPassword(token, model.NewPassword);
if (response == true)
{
try
{
// Here Maintain Password History
// MembershipUser u = Membership.GetUser(WebSecurity.CurrentUserName, false);
string RetPassword = HashData(model.NewPassword);
SecUserPasswordHistory _secUserPasswordHistory = new SecUserPasswordHistory();
byte[] array = Encoding.ASCII.GetBytes(RetPassword);
_secUserPasswordHistory.PasswordHash256 = array;
_secUserPasswordHistory.DeleteFlag = false;
_secUserPasswordHistory.RowVersion = null;
_secUserPasswordHistory.SecUserID = (WebSecurity.CurrentUserId);
_ResetPasswordService.AddPasswordHistory(_secUserPasswordHistory);
TempData["Message"] = "Password changed.";
}
catch (Exception ex)
{
TempData["Message"] = "Error occured while changing Password." + ex.Message;
}
}
else
{
TempData["Message"] = "Hey, avoid random request on this page.";
}
}
else
{
TempData["Message"] = "Username and token not maching.";
}
}
return(View(model));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword(model.UserId);
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid || (Helpers.ApplicationContext.CurrentUser.IsSuperAdmin && !String.IsNullOrEmpty(model.UserId) && !String.IsNullOrEmpty(model.NewPassword)))
{
IdentityResult result = null;
if (Helpers.ApplicationContext.CurrentUser.IsSuperAdmin)
{
result = await UserManager.RemovePasswordAsync(model.UserId);
if (result.Succeeded)
{
result = await UserManager.AddPasswordAsync(model.UserId, model.NewPassword);
}
else
{
ModelState.AddModelError("", "No fue posible remover la contraseña actual del usuario. Intente de nuevo.");
}
}
else
{
result = await UserManager.ChangePasswordAsync(model.UserId, model.OldPassword, model.NewPassword);
}
if (result.Succeeded)
{
return(RedirectToAction("Edit", new { id = model.UserId }));
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(model.UserId, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Edit", new { id = model.UserId }));
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <ActionResult> Manage(ManageUserViewModel model)
{
/***** Logging initial settings *****/
DbChangeLog log = new DbChangeLog();
log.UserName = User.Identity.Name;
log.Controller = "Account";
log.Action = "Password Change";
log.BeforeChange = "Old Password";
/***** end Logging initial settings *****/
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
log.AfterChange = "New Password";
context.SaveLog(log);
return(RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
else
{
log.AfterChange = "Log in error";
log.Error = result.ToString();
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
context.SaveLog(log);
return(RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess }));
}
else
{
AddErrors(result);
}
}
}
context.SaveLog(log);
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
else
{
// Der Benutzer besitzt kein Kennwort, daher werden alle Überprüfungsfehler, deren Ursache ein fehlendes Feld "OldPassword" ist, entfernt
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
// Wurde dieser Punkt erreicht, ist ein Fehler aufgetreten. Formular erneut anzeigen.
return View(model);
}
public async Task <ActionResult> Index(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set."
: message == ManageMessageId.Error ? "An error has occurred."
: message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added."
: message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed."
: "";
var userId = User.Identity.GetUserId();
using (var db = new ZapContext())
{
string aboutMe = "Nothing to tell.";
User u;
if (db.Users.Where(us => us.AppId == userId).Count() == 0)
{
// no user entry
u = new Models.User()
{
AboutMe = "Nothing to tell.",
AppId = userId,
Name = UserManager.FindById(userId).UserName,
ProfileImage = new UserImage(),
ThumbImage = new UserImage(),
Funds = new UserFunds(),
Settings = new UserSettings(),
DateJoined = DateTime.UtcNow,
};
db.Users.Add(u);
await db.SaveChangesAsync();
}
else
{
u = db.Users
.Include(usr => usr.LNTransactions)
.Include(usr => usr.EarningEvents)
.Include(usr => usr.Funds)
.Include(usr => usr.Settings)
.AsNoTracking()
.Where(us => us.AppId == userId).First();
aboutMe = u.AboutMe;
}
try
{
User.AddUpdateClaim("ColorTheme", u.Settings.ColorTheme ?? "light");
}
catch (Exception)
{
//TODO: handle (or fix test for HttpContext.Current.GetOwinContext().Authentication mocking)
}
ViewBag.UserName = u.Name;
ViewBag.UserId = u.Id;
var activityposts = GetPosts(0, 10, userId: u.Id);
// Get record of recent LN transactions
var recentTxs = u.LNTransactions
.Where(tx => tx.TimestampSettled != null)
.OrderByDescending(tx => tx.TimestampSettled)
.Take(5);
var txnView = new List <LNTxViewModel>();
foreach (var tx in recentTxs)
{
txnView.Add(new LNTxViewModel()
{
Timestamp = (DateTime)tx.TimestampSettled,
Type = tx.IsDeposit ? "Deposit" : "Withdrawal",
Value = tx.Amount,
});
}
var recentSpendings = u.SpendingEvents
.OrderByDescending(s => s.TimeStamp)
.Take(5);
var spendingsView = new List <SpendingsViewModel>();
foreach (var s in recentSpendings)
{
string link = "";
if (s.Post != null)
{
link = "Post " + s.Post.PostId.ToString();
}
else if (s.Comment != null)
{
link = "Comment " + s.Comment.CommentId.ToString();
}
else if (s.Group != null)
{
link = "Group " + s.Group.GroupId.ToString();
}
spendingsView.Add(new SpendingsViewModel()
{
TimeStamp = s.TimeStamp.Value,
Value = Convert.ToString(s.Amount),
Link = link,
});
}
var recentEarnings = u.EarningEvents
.OrderByDescending(e => e.TimeStamp)
.Take(5);
var earningsView = new List <EarningsViewModel>();
foreach (var e in recentEarnings)
{
earningsView.Add(new EarningsViewModel()
{
TimeStamp = e.TimeStamp.Value,
Value = e.Amount.ToString("0.#"),
Type = e.Type == 0 ? (e.OriginType == 0 ? "Post" : "Comment") : e.Type == 1 ? "Group" : e.Type == 2 ? "Community" : "Unknown",
ItemId = 0,
});
}
var gi = new List <GroupInfo>();
var userGroups = u.Groups.ToList();
foreach (var g in userGroups)
{
gi.Add(new GroupInfo()
{
Id = g.GroupId,
Name = g.GroupName,
Icon = "fa-bolt",
Level = 1,
Progress = 36,
NumPosts = g.Posts.Count(),
UserPosts = g.Posts.Where(p => p.UserId.Id == u.Id).Count(),
IsMod = g.Moderators.Contains(u),
IsAdmin = g.Administrators.Contains(u),
});
}
int numUserPosts = db.Posts.Where(p => p.UserId.AppId == userId).Count();
int numFollowers = db.Users.Where(p => p.Following.Select(f => f.Id).Contains(u.Id)).Count();
int numFollowing = u.Following.Count();
bool isFollowing = false;
// List of top persons following
var topFollowing = u.Following.OrderByDescending(us => us.TotalEarned).Take(20).ToList();
var topFollowers = u.Followers.OrderByDescending(us => us.TotalEarned).Take(20).ToList();
if (u.Settings == null)
{
u.Settings = new UserSettings();
}
List <PostViewModel> postViews = new List <PostViewModel>();
foreach (var p in activityposts)
{
postViews.Add(new PostViewModel()
{
Post = p,
ViewerIsMod = u != null ? u.GroupModeration.Contains(p.Group) : false,
ViewerUpvoted = u != null ? u.PostVotesUp.Select(pv => pv.PostId).Contains(p.PostId) : false,
ViewerDownvoted = u != null ? u.PostVotesDown.Select(pv => pv.PostId).Contains(p.PostId) : false,
});
}
var model = new ManageUserViewModel
{
HasPassword = HasPassword(),
User = u,
PhoneNumber = await UserManager.GetPhoneNumberAsync(userId),
TwoFactor = await UserManager.GetTwoFactorEnabledAsync(userId),
Logins = await UserManager.GetLoginsAsync(userId),
//BrowserRemembered = await AuthenticationManager.TwoFactorBrowserRememberedAsync(userId),
AboutMe = new AboutMeViewModel()
{
AboutMe = aboutMe
},
Financial = new FinancialViewModel()
{
Transactions = txnView, Earnings = earningsView, Spendings = spendingsView
},
UserGroups = new ManageUserGroupsViewModel()
{
Groups = gi
},
NumPosts = numUserPosts,
NumFollowers = numFollowers,
NumFollowing = numFollowing,
IsFollowing = isFollowing,
ActivityPosts = postViews,
TopFollowing = topFollowing,
TopFollowers = topFollowers,
UserBalance = u.Funds.Balance,
Settings = u.Settings,
};
return(View(model));
}
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
string userId = User.Identity.GetUserId();
string localUserName = await Logins.GetProviderKey(User.Identity.GetUserId(), IdentityConfig.LocalLoginProvider);
bool hasLocalLogin = localUserName != null;
ViewBag.HasLocalPassword = hasLocalLogin;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasLocalLogin)
{
if (ModelState.IsValid)
{
bool changePasswordSucceeded = await ChangePassword(localUserName, model.OldPassword, model.NewPassword);
if (changePasswordSucceeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
ModelState.AddModelError(String.Empty, "The current password is incorrect or the new password is invalid.");
}
}
}
else
{
// User does not have a local password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
try
{
// Create the local login info and link the local account to the user
localUserName = User.Identity.GetUserName();
if (await Secrets.Create(new UserSecret(localUserName, model.NewPassword)) &&
await Logins.Add(new UserLogin(userId, IdentityConfig.LocalLoginProvider, localUserName)))
{
return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
ModelState.AddModelError(String.Empty, "Failed to set password");
}
}
catch (Exception e)
{
ModelState.AddModelError(String.Empty, e);
}
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Manage(ManageUserViewModel model)
{
bool hasPassword = HasPassword();
ViewBag.HasLocalPassword = hasPassword;
ViewBag.ReturnUrl = Url.Action("Manage");
if (hasPassword)
{
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
await SignInAsync(user, isPersistent: false);
return RedirectToAction("Manage", new { Message = ManageMessageId.ChangePasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
else
{
// User does not have a password so remove any validation errors caused by a missing OldPassword field
ModelState state = ModelState["OldPassword"];
if (state != null)
{
state.Errors.Clear();
}
if (ModelState.IsValid)
{
IdentityResult result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
if (result.Succeeded)
{
return RedirectToAction("Manage", new { Message = ManageMessageId.SetPasswordSuccess });
}
else
{
AddErrors(result);
}
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task<ActionResult> Manage()
{
var viewModel = new ManageUserViewModel();
using (var db = new DatabaseContext())
{
var userId = User.Identity.GetUserId();
var user = await db.Users.Where(x => x.Id == userId).SingleOrDefaultAsync();
if (user.SlackToken != null)
{
var userRaw = new WebClient().DownloadString($"https://slack.com/api/auth.test?token={user.SlackToken}");
var userResp = JsonConvert.DeserializeAnonymousType(userRaw, new { user = "" });
viewModel.SlackUsername = userResp.user;
}
return View("Manage", viewModel);
}
}
