public IActionResult ManageAccountGet()
{
// Get the current user
User currentUser = ControllerHelper.GetGpgUserFromAspNetUser(User, dataRepository);
// Set properties on view model
var viewModel = new ManageAccountViewModel
{
User = currentUser,
IsUserBeingImpersonated = LoginHelper.IsUserBeingImpersonated(User)
};
// Return the Manage Account page
return(View("ManageAccount", viewModel));
}
//
// GET: /Account/Manage
public virtual ActionResult Manage(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.ChangeEmailSuccess ? "Your email has been changed."
: message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
: message == ManageMessageId.Error ? "An error occurred."
: "";
SetViewBag();
ManageAccountViewModel viewModel = GetBaseManageAccountViewModel();
return(View(MVC.Account.Views.Manage, viewModel));
}
public async Task <IActionResult> Edit(Guid userId)
{
var user = await _identityService.GetUserAsync(userId);
var model = new ManageAccountViewModel
{
Username = user.UserName,
Role = _identityService.GetRole(user),
RoleTypes = Util.GetSelectList(_identityService.GetRoles()),
UserId = user.Id,
Email = user.Email
};
return(View(model));
}
public ActionResult Manage(ManageAccountViewModel model)
{
if (ModelState.IsValid)
{
int accountId = GetAccountId();
var account = DataAccessor.AccountRepository.UpdateAccount(
new Account
{
Id = accountId,
Name = model.Name
});
Success("账户信息更新成功!", true);
return(View());
}
return(View());
}
public async Task <IActionResult> Manage(ManageAccountViewModel model)
{
if (ModelState.IsValid)
{
if (!context.GymUsers.Any(x => x.Email == model.Email))
{
await _gymUserService.Create(model.FirstName, model.LastName, model.Email, model.Telephone);
}
else
{
await _gymUserService.Update(model);
}
return(View(model));
}
return(View(model));
}
public async Task <ActionResult> Edit(ManageAccountViewModel model)
{
ApplicationDbContext appDb = new ApplicationDbContext();
if (ModelState.IsValid)
{
Account Enterprise = db.Accounts.Find(User.Identity.GetUserId());
if (Enterprise != null)
{
// set Enterprise object values
// create a new Enterprise object
db.Entry(Enterprise).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
return(View("EditProfile", model));
}
//
// GET: /Account/Manage
public virtual ActionResult Manage(ManageMessageId?message)
{
var tempMessage =
message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
: message == ManageMessageId.SetBoardGameGeekUserSuccess ? "Your BGG account has been linked with NemeStats successfully. Now you can import your games on the Gaming Group page."
: message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.ChangeEmailSuccess ? "Your email has been changed."
: message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
: message == ManageMessageId.Error ? "An error occurred."
: "";
this.SetToastMessage(TempMessageKeys.MANAGE_ACCOUNT_RESULT_TEMPMESSAGE, tempMessage, message.HasValue && message == ManageMessageId.Error ? "error" : "success");
SetViewBag();
ManageAccountViewModel viewModel = GetBaseManageAccountViewModel();
return(View(MVC.Account.Views.Manage, viewModel));
}
public async Task <ActionResult> Edit(ManageAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId <int>());
if (user != null)
{
await SignInAsync(user, isPersistent : false);
model.FirstName = user.Profile.FirstName;
model.LastName = user.Profile.LastName;
model.Theme = user.Profile.Theme;
model.UserPhoto = user.Profile.UserPhoto;
}
return(View(model));
}
//
// 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.SavedSuccessfuly ? "تم حفظ معلوماتكم بنجاح"
: "";
ViewBag.HasLocalPassword = OAuthWebSecurity.HasLocalAccount(WebSecurity.GetUserId(User.Identity.Name));
ViewBag.ReturnUrl = Url.Action("Manage");
ViewBag.Countries = servicesManager.CountryFrontService.GetOnlineCountries();
ManageAccountViewModel view_model = servicesManager.AccountFrontService.GetUserAccountInfo(WebSecurity.CurrentUserId);
view_model.LocalPasswordModel = new LocalPasswordModel();
return(View(view_model));
}
public ManageAccountViewModel GetUsers()
{
var model = new ManageAccountViewModel();
var users = (from user in _context.Users
join userRole in _context.UserRoles on user.Id equals userRole.UserId
join role in _context.Roles on userRole.RoleId equals role.Id
select new UserModel()
{
UserName = user.UserName,
RoleName = role.Name,
Id = user.Id
}).ToList();
foreach (var u in users)
{
model.UserList.Add(u);
}
return(model);
}
public async Task <ActionResult> ChangePassword(ManageAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await UserManager.ChangePasswordAsync(User.Identity.GetUserId <int>(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId <int>());
if (user != null)
{
await SignInAsync(user, isPersistent : false);
}
return(RedirectToAction("Index", new { Message = ManageMessageId.ChangePasswordSuccess }));
}
AddErrors(result);
return(View(model));
}
public static async Task <bool> ChangePasswordDialogAsync(this Form parent, ManageAccountViewModel viewModel)
{
NewPasswordViewModel newPasswordviewModel = new NewPasswordViewModel(String.Empty, String.Empty);
using (NewPassphraseDialog dialog = new NewPassphraseDialog(parent, Texts.ChangePassphraseDialogTitle, newPasswordviewModel))
{
DialogResult dialogResult = dialog.ShowDialog(parent);
if (dialogResult != DialogResult.OK || newPasswordviewModel.PasswordText.Length == 0)
{
return(false);
}
}
viewModel.ChangePasswordCompleteAsync = async(success) => { if (!success)
{
await New <IPopup>().ShowAsync(PopupButtons.Ok, Texts.MessageErrorTitle, Texts.ChangePasswordError);
}
};
await viewModel.ChangePassphraseAsync.ExecuteAsync(newPasswordviewModel.PasswordText);
return(viewModel.LastChangeStatus);
}
public async Task <IActionResult> Create(ManageAccountViewModel model)
{
if (!ModelState.IsValid)
{
model.RoleTypes = Util.GetSelectList(_identityService.GetRoles());
return(View(model));
}
var result = await _identityService.CreateUserAsync(model.Username, model.Password, model.Role, model.Email);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
model.RoleTypes = Util.GetSelectList(_identityService.GetRoles());
return(View(model));
}
public async Task <ManageAccountViewModel> RegisterAccount(ManageAccountViewModel model)
{
var roleName = GetRoleName(model.RoleId);
var userIdentity = new IdentityUser()
{
UserName = model.UserName,
PasswordHash = model.Password,
};
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(userIdentity, roleName);
}
//await _singInManager.SignInAsync(userIdentity, isPersistent: false);
return(model);
}
public async Task <ActionResult> RemoveExternalLogin(string loginProvider)
{
var model = new ManageAccountViewModel();
var user = await _userService.FindUserById(User.Identity.GetUserId());
var remove = user.Logins.First(l => l.LoginProvider.Equals(loginProvider, StringComparison.OrdinalIgnoreCase));
IdentityResult result = await _userService.RemoveLogin(User.Identity.GetUserId(), new UserLoginInfo(remove.LoginProvider, remove.ProviderKey));
if (result.Succeeded)
{
model.Successes.Add(string.Format("Succesfully unlinked {0} account.", remove.LoginProvider));
}
else
{
model.Errors.Add("Uhoh, something didn't quite go right with that. Sorry.");
}
model.User = await _userService.FindUserById(User.Identity.GetUserId());
return(await Index(model));
}
//
// GET: /Manage/Index
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 model = new ManageAccountViewModel
{
HasPassword = HasPassword(),
PhoneNumber = await UserManager.GetPhoneNumberAsync(User.Identity.GetUserId()),
TwoFactor = await UserManager.GetTwoFactorEnabledAsync(User.Identity.GetUserId()),
Logins = await UserManager.GetLoginsAsync(User.Identity.GetUserId()),
BrowserRemembered = await AuthenticationManager.TwoFactorBrowserRememberedAsync(User.Identity.GetUserId())
};
return(View(model));
}
public ActionResult Manage(int id)
{
var dbAccount = _accountRepo.GetAccountById(id);
if (dbAccount == null)
{
return(HttpNotFound());
}
if (dbAccount.Id == 1)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Forbidden action"));
}
var viewModel = new ManageAccountViewModel
{
Account = dbAccount,
AccountTypes = _accountRepo.GetAccountTypes()
};
return(View(viewModel));
}
public async Task <IActionResult> RegisterAccount(ManageAccountViewModel model)
{
if (ModelState.IsValid)
{
var roleName = _manageAccountRepo.GetRoleName(model.RoleId);
var userIdentity = new IdentityUser()
{
UserName = model.UserName,
PasswordHash = model.Password,
};
var result = await _userManager.CreateAsync(userIdentity, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(userIdentity, roleName);
}
//await _singInManager.SignInAsync(userIdentity, isPersistent: false);
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Manage(ManageAccountViewModel model, IEnumerable <HttpPostedFileBase> image_file)
{
if (ModelState.IsValid)
{
servicesManager.AccountFrontService.UpdateAccount(model);
if (model.Subscribe)
{
servicesManager.AccountService.Subscribe(model.UserId, servicesManager.AccountService.GetUserById(model.UserId).Email, 1);
}
else
{
servicesManager.AccountService.Unsubscribe(model.UserId, 1);
}
if (image_file.Count() > 0)
{
servicesManager.AccountService.ReplaceUserImages(WebSecurity.CurrentUserId, image_file);
}
return(RedirectToAction("Manage", "Account", new { message = ManageMessageId.SavedSuccessfuly }));
}
return(View(model));
}
public async Task <ActionResult> SetProfilePic(string provider)
{
var user = await _userService.FindUserById(User.Identity.GetUserId());
var model = new ManageAccountViewModel();
if (provider.Equals("facebook", StringComparison.OrdinalIgnoreCase) && user.IsLinkedWithFacebook())
{
user.ProfilePictureUrl = _mediaPullService.GetFacebookProfilePic(user.FacebookAccessToken);
await _userService.UpdateUser(user);
model.Successes.Add("You're now using your Facebook profile picutre.");
}
else if (provider.Equals("twitter", StringComparison.OrdinalIgnoreCase) && user.IsLinkedWithTwitter())
{
user.ProfilePictureUrl = _mediaPullService.GetTwitterProfilePic(user.TwitterAccessToken, user.TwitterAccessSecret);
await _userService.UpdateUser(user);
model.Successes.Add("You're now using your Twitter profile picutre.");
}
return(await Index(model));
}
public async Task <IActionResult> ChangePassword(ManageAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = await userManager.GetUserAsync(User);
user.PasswordHash = passwordHasher.HashPassword(user, model.ChangePassword.Password);
try
{
var result = await userManager.UpdateAsync(user);
}
catch (Exception ex)
{
throw ex;
}
model.ChangePassword = new ChangePasswordViewModel();
TempData["SuccessMessage"] = "Udało się zmienić hasło";
return(View("Manage", model));
}
TempData["ErrorMessage"] = "Uzupełnij poprawnie formularz zmiany hasła";
model.ChangePassword = new ChangePasswordViewModel();
return(View("Manage", model));
}
public async Task <IActionResult> Manage()
{
var oktaUserId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier)?.Value;
if (string.IsNullOrEmpty(oktaUserId))
{
// Need to display a user-friendly error view
throw new NotImplementedException("Todo: error view. Could not look up Okta user (this shouldn't happen)");
}
var viewModel = new ManageAccountViewModel();
try
{
var oktaUser = await _oktaClient.Users.GetUserAsync(oktaUserId);
viewModel.RewardsNumber = oktaUser.Profile.GetProperty <string>("rewardsNumber");
// todo remove
var extendedClient = (_oktaClient as ExtendedOktaClient);
var idps = await extendedClient
.GetCollection <IdentityProvider>($"/api/v1/users/{oktaUser.Id}/idps")
.ToArray();
viewModel.FacebookLinked = idps.Any(x => x.Type.Equals("facebook", StringComparison.OrdinalIgnoreCase));
var isGoogleLinked = idps.Any(x => x.Type.Equals("google", StringComparison.OrdinalIgnoreCase));
return(View(viewModel));
}
catch (OktaApiException)
{
// TODO: Need to display a user-friendly error view
throw new NotImplementedException("Unable to look up the Okta user");
}
}
public async Task <IActionResult> Edit(ManageAccountViewModel model)
{
try
{
if (!ModelState.IsValid)
{
model.RoleTypes = Util.GetSelectList(_identityService.GetRoles());
return(View(model));
}
var accountModel = new AccountModel
{
Username = model.Username,
Role = model.Role,
UserId = model.UserId,
Email = model.Email
};
var result = await _identityService.UpdateUser(accountModel);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
ModelState.AddModelError(string.Empty, error.Description);
}
}
catch (Exception e)
{
}
model.RoleTypes = Util.GetSelectList(_identityService.GetRoles());
return(View(model));
}
public async Task <IActionResult> Manage(string returnUrl)
{
var user = await userManager.GetUserAsync(User);
var vm = new ManageAccountViewModel
{
ChangePassword = new ChangePasswordViewModel(),
EditAccount = new EditAccountViewModel
{
Email = user.Email,
ApartmentNumber = user.ApartmentNumber,
BuildingNumber = user.BuildingNumber,
City = user.City,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber,
Street = user.Street,
ZipCode = user.ZipCode
},
ReturnUrl = returnUrl
};
return(View(vm));
}
public bool UpdateAccount(ManageAccountViewModel model)
{
UserProfile db_user = DAManager.UserProfilesRepository.Get(u => u.UserId == model.UserId).FirstOrDefault();
if (db_user == null)
{
return(false);
}
db_user.Name = model.Name;
db_user.CountryId = model.Country;
db_user.Gender = model.Gender == 1 ? true : false;
try
{
DAManager.Save();
return(true);
}
catch (Exception ex)
{
logService.WriteError(ex.Message, ex.Message, ex.StackTrace, ex.Source);
return(false);
}
}
public async Task <IActionResult> Manage()
{
try
{
var loggedUser = await userManager.GetUserAsync(User);
var gymUser = _gymUserService.Get(loggedUser.GymUserId).Result;
var viewModel = new ManageAccountViewModel
{
GymUserId = gymUser.GymUserId,
Email = gymUser.Email,
FirstName = gymUser?.FirstName ?? string.Empty,
LastName = gymUser?.LastName ?? string.Empty,
Telephone = gymUser?.Telephone ?? string.Empty,
User = loggedUser
};
return(View(viewModel));
}
catch (Exception e)
{
throw e;
}
}
public async Task <IdentityResult> ManageUser(ManageAccountViewModel model)
{
try
{
var user = await GetUserById(model.Id);
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.ModifiedBy = model.ModifiedBy;
user.ModifiedDate = DateTime.UtcNow;
user.PhoneNumber = model.PhoneNumber;
var res = await UserManager.UpdateAsync(user);
return(res);
}
catch (Exception e)
{
await LogError("ManageUser", e);
Trace.TraceError(string.Format("ManageUser in account service error: {0}", e.Message));
throw e;
}
}
public ActionResult Index()
{
ApplicationUser user = UserManager.FindById(User.Identity.GetUserId());
Account account = user.GameAccount;
ManageAccountViewModel model = new ManageAccountViewModel
{
AuthedUser = user,
DataObject = account,
GlobalIdentityHandle = account.GlobalIdentityHandle,
UIModuleCount = TemplateCache.GetAll <IUIModule>(true).Count(uimod => uimod.CreatorHandle.Equals(account.GlobalIdentityHandle)),
NotificationCount = ConfigDataCache.GetAll <IPlayerMessage>().Count(msg => msg.RecipientAccount == account),
UITutorialMode = account.Config.UITutorialMode,
GossipSubscriber = account.Config.GossipSubscriber,
PermanentlyMuteMusic = account.Config.MusicMuted,
PermanentlyMuteSound = account.Config.SoundMuted,
UILanguage = account.Config.UILanguage,
ChosenRole = user.GetStaffRank(User),
ValidRoles = (StaffRank[])Enum.GetValues(typeof(StaffRank)),
ValidLanguages = ConfigDataCache.GetAll <ILanguage>().Where(lang => lang.SuitableForUse && lang.UIOnly)
};
return(View(model));
}
public async Task <ActionResult> Manage(ManageMessageId?message)
{
ViewBag.StatusMessage =
message == ManageMessageId.ChangeUserNameSuccess ? "Your name has been changed."
: message == ManageMessageId.ChangeEmailSuccess ? "Your email has been changed."
: message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
: message == ManageMessageId.Error ? "An error has occurred."
: "";
var user = await _userManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
return(NotFound());
}
var model = new ManageAccountViewModel
{
UserName = user.UserName,
Email = user.Email,
};
return(View(model));
}
public IActionResult ManageAccount(UpdateWorkerDto updateWorkerDto)
{
var email = User.Claims.SingleOrDefault(c => c.Type == ClaimTypes.Email).Value;
var resultUser = _userService.GetByMail(email);
if (!resultUser.Success)
{
return(RedirectToAction("InternalError", "Error", new { errorMessage = resultUser.Message }));
}
var resultManager = _workerService.GetById(resultUser.Data.Id);
if (!resultManager.Success)
{
return(RedirectToAction("InternalError", "Error", new { errorMessage = resultManager.Message }));
}
var model = new ManageAccountViewModel()
{
UpdateWorkerDto = new UpdateWorkerDto
{
IdentityNo = resultManager.Data.IdentityNo,
FirstName = resultUser.Data.FirstName,
LastName = resultUser.Data.LastName,
Email = resultUser.Data.Email,
Street = resultManager.Data.Street,
GenderId = resultUser.Data.GenderId,
CityId = resultManager.Data.CityId,
PhoneNumber = resultUser.Data.PhoneNumber,
DistrictId = resultManager.Data.DistrictId,
AddressNumber = resultManager.Data.AddressNumber,
BirthDate = resultManager.Data.BirthDate,
HireDate = resultManager.Data.HireDate
},
GenderNamesSelectItems = new List <SelectListItem>
{
new SelectListItem()
}
};
foreach (var gender in _genderDal.GetList())
{
model.GenderNamesSelectItems.Add(new SelectListItem
{
Text = gender.GenderName,
Value = gender.GenderId.ToString()
});
}
if (!ModelState.IsValid)
{
return(View(model));
}
var user = _userService.GetByMail(updateWorkerDto.Email);
if (!user.Success)
{
return(RedirectToAction("InternalError", "Error", new { errorMessage = user.Message }));
}
user.Data.FirstName = updateWorkerDto.FirstName;
user.Data.LastName = updateWorkerDto.LastName;
user.Data.GenderId = updateWorkerDto.GenderId;
user.Data.PhoneNumber = updateWorkerDto.PhoneNumber;
var manager = _workerService.GetById(user.Data.Id);
if (!manager.Success)
{
return(RedirectToAction("InternalError", "Error", new { errorMessage = manager.Message }));
}
manager.Data.Street = updateWorkerDto.Street;
manager.Data.AddressNumber = updateWorkerDto.AddressNumber;
manager.Data.CityId = updateWorkerDto.CityId;
manager.Data.DistrictId = updateWorkerDto.DistrictId;
var result = _workerService.Update(manager.Data, user.Data);
if (!result.Success)
{
return(RedirectToAction("InternalError", "Error", new { errorMessage = result.Message }));
}
TempData.Add(TempDataTypes.ManageInfo, Messages.UserUpdatedSuccessfully);
return(RedirectToAction("ManageAccount", "Admin"));
}
