public IActionResult SaveMyAccount(MyAccountViewModel model)
{
string userId = HttpContext.Session.GetString("CurrentUserId");
if (string.IsNullOrEmpty(userId))
{
return(RedirectToAction("Login", "Users"));
}
int currentUserId = Int32.Parse(userId);
Users user = _context.Users.Where(e => e.UserId == currentUserId).FirstOrDefault();
user.FirstName = model.FirstName ?? user.FirstName;
user.LastName = model.LastName ?? user.LastName;
user.Password = model.Password != null?Encryption.Encrypt(model.Password) : user.Password;
_context.Users.Update(user);
_context.SaveChanges();
MyAccountViewModel vm = new MyAccountViewModel();
vm.UserId = user.UserId;
vm.Email = user?.Email;
vm.FirstName = user?.FirstName;
vm.LastName = user.LastName;
vm.UserName = user?.UserName;
return(View("OwnerAccount", vm));
}
public void MyAccountViewModel_CustomFields_ShouldBePopulated()
{
// Given
var delegateUser = UserTestHelper.GetDefaultDelegateUser();
var customPrompts = PromptsTestHelper.GetDefaultCentreRegistrationPromptsWithAnswers(
new List <CentreRegistrationPromptWithAnswer>
{
PromptsTestHelper.GetDefaultCentreRegistrationPromptWithAnswer(1),
PromptsTestHelper.GetDefaultCentreRegistrationPromptWithAnswer(2),
}
);
// When
var returnedModel = new MyAccountViewModel(null, delegateUser, customPrompts, DlsSubApplication.Default);
// Then
using (new AssertionScope())
{
returnedModel.DelegateRegistrationPrompts.Should().NotBeNullOrEmpty();
returnedModel.DelegateRegistrationPrompts[0].PromptNumber.Should().Be(1);
returnedModel.DelegateRegistrationPrompts[0].Prompt.Should()
.BeEquivalentTo(customPrompts.CustomPrompts[0].PromptText);
returnedModel.DelegateRegistrationPrompts[0].Answer.Should().BeEquivalentTo(delegateUser.Answer1);
returnedModel.DelegateRegistrationPrompts[0].Mandatory.Should().BeFalse();
returnedModel.DelegateRegistrationPrompts[1].PromptNumber.Should().Be(2);
returnedModel.DelegateRegistrationPrompts[1].Prompt.Should()
.BeEquivalentTo(customPrompts.CustomPrompts[1].PromptText);
returnedModel.DelegateRegistrationPrompts[1].Answer.Should().BeEquivalentTo(delegateUser.Answer1);
returnedModel.DelegateRegistrationPrompts[1].Mandatory.Should().BeFalse();
}
}
public void MyAccountViewModel_DelegateUser_no_AdminUser_populates_expected_values()
{
// Given
var delegateUser = UserTestHelper.GetDefaultDelegateUser();
var customPrompts = PromptsTestHelper.GetDefaultCentreRegistrationPromptsWithAnswers(
new List <CentreRegistrationPromptWithAnswer>
{
PromptsTestHelper.GetDefaultCentreRegistrationPromptWithAnswer(1),
}
);
// When
var returnedModel = new MyAccountViewModel(null, delegateUser, customPrompts, DlsSubApplication.Default);
// Then
using (new AssertionScope())
{
returnedModel.FirstName.Should().BeEquivalentTo(delegateUser.FirstName);
returnedModel.Centre.Should().BeEquivalentTo(delegateUser.CentreName);
returnedModel.Surname.Should().BeEquivalentTo(delegateUser.LastName);
returnedModel.ProfilePicture.Should().BeEquivalentTo(delegateUser.ProfileImage);
returnedModel.DelegateNumber.Should().BeEquivalentTo(delegateUser.CandidateNumber);
returnedModel.User.Should().BeEquivalentTo(delegateUser.EmailAddress);
returnedModel.JobGroup.Should().BeEquivalentTo(delegateUser.JobGroupName);
returnedModel.DelegateRegistrationPrompts.Should().NotBeNullOrEmpty();
}
}
public async Task <ActionResult> Login(MyAccountViewModel myAccountViewModel, string returnUrl)
{
LoginViewModel model = myAccountViewModel.LoginViewModel;
if (!ModelState.IsValid)
{
return(View(model));
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.RequiresVerification:
return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
private static MyAccountViewModel BuildTenantViewModel(IEnumerable <TenantModel> tenants)
{
// Set default
var viewModel = new MyAccountViewModel();
// Build the viewmodel
if (tenants != null)
{
viewModel = new MyAccountViewModel()
{
UserAccounts = tenants.GroupBy(u => u.Username).Select(u => new UserAccountViewModel()
{
Username = u.Key,
Tenants = u.Select(t => new TenantViewModel()
{
Id = t.TenantId,
Plan = t.ProvisioningOption,
Theme = t.Theme,
Status = t.AzureServicesProvisioned
? ProvisioningStatus.Deployed
: ProvisioningStatus.NotDeployed,
AzureServicesProvisioned = t.AzureServicesProvisioned,
}).ToList()
}).ToList()
};
}
return(viewModel);
}
public IActionResult ChangePicture(List <IFormFile> uploadedFiles)
{
var model = new MyAccountViewModel();
string imageS3Name = null;
if (uploadedFiles.Count == 0)
{
ModelState.AddModelError("Picture", "Please choose a picture!");
return(View("MyAccount", model));
}
var formFile = uploadedFiles[0];
if (!(formFile.ContentType.Equals("image/png") || formFile.ContentType.Equals("image/jpeg") || formFile.ContentType.Equals("image/jpeg")))
{
ModelState.AddModelError("Picture", formFile.ContentType + " extension is not allowed. You can only upload jpg, jpeg or png.");
return(View("MyAccount", model));
}
if (formFile.Length > MBoxConstants.MaximumImageSizeAllowed)
{
//Error Message
ModelState.AddModelError("Picture", "Maximum 3MB picture size allowed!");
return(View("MyAccount", model));
}
imageS3Name = _s3Manager.UploadFile(formFile);
var currentUser = _userManager.FindByIdAsync(CurrentLoggedUserId.ToString()).Result;
currentUser.Picture = imageS3Name;
_userManager.UpdateAsync(currentUser).Wait();
return(RedirectToAction("MyAccount"));
}
public async Task <IActionResult> MyAccount()
{
var userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
var user = await this.userManager.GetUserAsync(this.User);
var myCars = await this.myAccountService.GetMyCarsAsync(userId);
var result = new MyAccountViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
MyCars = myCars.Select(x => new MyCarsViewModel
{
Id = x.Id,
Model = x.Model,
Make = x.Make,
CreatedOn = x.CreatedOn,
IsApproved = x.IsApproved,
ModelToString = this.adService.EnumParser(x.Make.ToString(), x.Model),
Modification = x.Modification,
Price = x.Price,
}),
};
return(this.View(result));
}
public IActionResult EditName(string artistName, int artistlId)
{
var model = new MyAccountViewModel();
var artist = _artistManager.GetOne(x => x.Id == artistlId, includeProperties: $"{ nameof(Artist.User)}");
if (string.IsNullOrWhiteSpace(artistName))
{
ModelState.AddModelError("Name", "The Name must contain at least 2 characters");
return(View("MyAccount", model));
}
artistName = artistName.Trim();
if (artistName.Length < 2)
{
ModelState.AddModelError("Name", "The Name must contain at least 2 characters");
return(View("MyAccount", model));
}
if (artistName.Length > 50)
{
ModelState.AddModelError("Name", "The Name cannot contain more than 50 characters");
return(View("MyAccount", model));
}
artist.User.Name = artistName;
_artistManager.Update(artist, artistlId);
_artistManager.Save();
return(RedirectToAction("MyAccount"));
}
public ActionResult MyAccount(MyAccountViewModel info, HttpPostedFileBase imgFile)
{
UserStore <Person> store = new UserStore <Person>(UnitOfWork.Create());
UserManager <Person> manager = new UserManager <Person>(store);
string uId = User.Identity.GetUserId();
Person person = manager.FindById(uId);
person.Email = info.Email;
person.PhoneNumber = info.PhoneNumber;
if (imgFile != null)
{
string path = Server.MapPath("/Uploads/Members/");
string old = path + person.Id + ".jpg";
if (System.IO.File.Exists(old))
{
System.IO.File.Delete(old);
}
string _new = path + person.Id + ".jpg";
imgFile.SaveAs(_new);
person.HasPhoto = true;
}
manager.Update(person);
if (person.HasPhoto)
{
ViewBag.Photo = "/Uploads/Members/" + uId + ".jpg";
}
return(View(info));
}
public async Task <IActionResult> ChangePassword(MyAccountViewModel model)
{
if (ModelState.IsValid)
{
AppUser user = await _userManager.FindByIdAsync(model.Id);
if (user != null)
{
IdentityResult result =
await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Пользователь не найден");
}
}
return(View(model));
}
public async Task <IActionResult> Index([Bind("UserDetail,UserDetail.Aim,UserDetail.Somatotyp,UserDetail.Age,UserDetail.Sex,UserDetail.Activity,UserDetail.Calculator_Type,UserDetail.Authomatic_calculate,UserDetail.Calories_after_BMR_multiply_activity,UserDetail.Calories_for_calculators," +
"Sizes,Sizes.Weight,Sizes.Biceps,Sizes.Waist,Sizes.Height,Sizes.Chest,Sizes.Thigh,Sizes.Forearm,Sizes.Hips,Sizes.Fat,Sizes.Muscle_Mass")] MyAccountViewModel myModel, short new_BMR, bool save_new_BMR)
{
if (ModelState.IsValid)
{
try
{
if (save_new_BMR == true)
{
myModel.UserDetail.Calories_after_BMR_multiply_activity = new_BMR;
}
string userId = User.getUserId();
myModel.Sizes.UserId = userId;
myModel.UserDetail.Id = userId;
_context_Sizes.SaveActualSizes(myModel.Sizes);
await _context_Sizes.SaveChangesAsync();
_context_UserDetail.UpdateUserDetail(myModel.UserDetail);
await _context_UserDetail.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
return(View(myModel));
}
public IActionResult Change(MyAccountViewModel myAccountVM)
{
UserProfile userProfile = _userProfileDatabase.Find(s => s.UserName == User.Identity.Name && s.IsDeleted == false).FirstOrDefault();
UserProfile isValidEmail = _userProfileDatabase.Find(s => s.Email == myAccountVM.Email && s.IsDeleted == false).FirstOrDefault();
if (myAccountVM.OldPassword != userProfile.Password)
{
return(RedirectToAction("MyAccount", "Account", new { mess = "Wrong Old Password" }));
}
else if (isValidEmail != null)
{
return(RedirectToAction("MyAccount", "Account", new { mess = "Invalid Email" }));
}
else
{
userProfile.PhoneNumber = myAccountVM.PhoneNumber;
userProfile.FullName = myAccountVM.FullName;
userProfile.Email = myAccountVM.Email;
userProfile.Password = myAccountVM.NewPassword;
_userProfileDatabase.Update(userProfile);
}
return(RedirectToAction("Index", "Product", new { Areas = "Admin" }));
}
public async Task <ActionResult> Register(MyAccountViewModel myAccountViewModel)
{
RegisterViewModel model = myAccountViewModel.RegisterViewModel;
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public void NavigateToMyAccount()
{
if (_core.TryGetUiManager(out IUiManager ui))
{
var vm = new MyAccountViewModel(_core, this);
ui.Navigate(vm);
}
}
public ActionResult Index()
{
var model = new MyAccountViewModel();
var person = personProvider.GetPerson(User.Identity.Name);
model.PersonInfo = person;
return(View(model));
}
public ActionResult MyAccount()
{
DbManager mgr = new DbManager(Properties.Settings.Default.ConStr);
MyAccountViewModel vm = new MyAccountViewModel();
vm.User = mgr.GetByEmail(User.Identity.Name);
vm.Images = mgr.GetImgaesForUser(vm.User.Id);
return(View(vm));
}
public IActionResult Index(MyAccountViewModel model)
{
if (!_cookieService.checkUserLogin())
{
return(Redirect("~/giris"));
}
_myAccountService.updatePersonnelInformation(model);
return(Redirect("~/hesabim/bilgilerimi-guncelle"));
}
public IActionResult Index()
{
if (!_cookieService.checkUserLogin())
{
return(Redirect("~/giris"));
}
MyAccountViewModel model = _myAccountService.getPersonnelInformation(_cookieService.getSessionEmail());
return(View(model));
}
// GET: MyAccount
public ActionResult Index()
{
string uid = User.Identity.GetUserId();
Customer customer = _uw.db.Users.Find(uid);
MyAccountViewModel model = new MyAccountViewModel();
model.Email = customer.Email;
model.PhoneNumber = customer.PhoneNumber;
return(View(customer));
}
public ActionResult MyAccount()
{
var user = _userService.Get(User.Identity.GetUserId());
var result = new MyAccountViewModel()
{
User = _mapper.Map <ApplicationUserViewModel>(user)
};
return(View(result));
}
public IActionResult MyAccount()
{
var artist = _artistManager.GetOne(filter: x => x.Id == CurrentLoggedUserId, includeProperties: $"{nameof(Artist.User)},{nameof(Artist.Follows)}.{nameof(Follow.Follower)}");
var model = new MyAccountViewModel();
model.ArtistBio = artist.Bio;
model.Name = artist.User.Name;
model.Picture = artist.PictureName;
model.FollowingCount = _userManager.Users.Where(x => x.Id == CurrentLoggedUserId).Include($"{nameof(Artist.Follows)}.{nameof(Follow.Artist)}").FirstOrDefault().Follows.Select(x => x.Artist == artist).ToList().Count;
model.FollowersCount = artist.Follows.Select(x => x.Follower).ToList().Count;
return(View(model));
}
private void SetupViewBag(MyAccountViewModel viewModel, bool pipelineRunning, string process)
{
// Build up the ViewBag
var tenants = viewModel.UserAccounts[0].Tenants;
ViewBag.ShowOpen = tenants.All(t => t.AzureServicesProvisioned);
ViewBag.ShowStart = tenants.Any(t => !t.AzureServicesProvisioned) && !pipelineRunning;
ViewBag.ShowDelete = !pipelineRunning;
ViewBag.PipelineRunning = pipelineRunning;
ViewBag.Process = process;
}
public ActionResult MyAccount()
{
var user = UserManager.FindById(User.Identity.GetUserId <long>());
var model = new MyAccountViewModel
{
FullName = user.FirstName + " " + user.LastName,
ProfileImageUrl = ConfigurationManager.AppSettings["BlobUrl"] + user.ProfileImageUrl,
HasPassword = user.PasswordHash != null
};
return(View(model));
}
public IActionResult MyAccount()
{
var db = new Db(_connectionString);
var ads = db.GetAllAds();
var userId = db.GetByEmail(User.Identity.Name).Id;
var vm = new MyAccountViewModel()
{
Ads = ads.Where(ad => ad.UserId == userId).ToList()
};
return(View(vm));
}
public IActionResult MyAccount()
{
var adDb = new AdDbMgr(_connection);
var pwDb = new PasswordDbMgr(_connection);
string email = User.Identity.Name;
var user = pwDb.GetUserByEmail(email);
var vm = new MyAccountViewModel
{
Ads = adDb.GetAdsForUser(user.Id)
};
return(View(vm));
}
/// <summary>
/// 设置当前用户到tempData
/// </summary>
protected void SetMyAccount()
{
if (CurrentUser != null)
{
MyAccountViewModel myAccountViewModel = new MyAccountViewModel
{
User = CurrentUser,
MyNewInvoteCount = CurrentUser.MyRecommends.Where(ru => ru.CreatedTime > DateTime.Now.AddDays(-7)).Select(us => us.Id).ToList().Count
};
ViewBag.MyAccount = myAccountViewModel;
}
}
public async Task <IActionResult> MyAccount()
{
var currentUser = await userManager.GetUserAsync(HttpContext.User);
var advs = unitOfWork.AdvertismentRepository.GetUserAdvertisements(currentUser.UserName);
var advUser = new MyAccountViewModel
{
CurrentUser = currentUser,
CurrentAdvertisements = advs
};
return(View(advUser));
}
public ActionResult MyAccount()
{
MyAccountViewModel vm = new MyAccountViewModel();
if (User.Identity.IsAuthenticated)
{
User user = mgr.GetUserByEmail(User.Identity.Name);
vm.User = user;
vm.Images = mgr.GetImageForUser(user.Id);
}
return(View(vm));
}
public async Task <IActionResult> MyAccount(string email)
{
AppUser user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(NotFound());
}
MyAccountViewModel model = new MyAccountViewModel {
Name = user.UserName, Id = user.Id, Email = user.Email
};
return(View(model));
}
public ActionResult MyAccount()
{
string uId = User.Identity.GetUserId();
Person person = _uw.db.Users.Find(uId);
MyAccountViewModel vm = new MyAccountViewModel();
vm.Email = person.Email;
vm.PhoneNumber = person.PhoneNumber;
if (person.HasPhoto)
{
ViewBag.Photo = "/Uploads/Members/" + uId + ".jpg";
}
return(View(vm));
}
private async Task<MyAccountViewModel> GetMyAccountVm(MyAccountRequest request, IMyMentorRepository repository)
{
var model = new MyAccountViewModel {MyAccountRequest = request};
var isAdmin = Session.GetLoggedInUserRoleName() == RoleNames.ADMINISTRATORS || !string.IsNullOrEmpty(Session.GetImpersonatingUserName());
var currentUser = Session.GetLoggedInUser();
var isFirstTimeInPage = Request.QueryString.AllKeys.All(x => x.ToLower() != "uid" && x.ToLower() != "pn");
var userManager = new MyMentorUserManager(repository, Session, HttpContext);
if (isAdmin && currentUser.Username != request.Uid && !isFirstTimeInPage)
{
if (!string.IsNullOrEmpty(request.Uid))
{
var user = await repository.FindUserByUserName(request.Uid);
if (user != null)
{
model.ErrorMessage = string.Empty;
model.UserName = user.UserName;
model.UserDispalyName =string.Concat(user.GetLocalizedField("FirstName") ," ", user.GetLocalizedField("LastName"));
model.MyAccountRequest.Uid = user.ObjectId;
if (Session.GetImpersonatingUserName() != model.UserName)
await userManager.ImpersonateUser(user.UserName);
else
userManager.StopImpersonation();
}
else
{
model.ErrorMessage = MyMentorResources.userNameDoesNotExist;
}
}
else
{
userManager.StopImpersonation();
}
}
else
{
model.UserName = currentUser.Username;
model.UserDispalyName = currentUser.GetFullName(Language.CurrentLanguageCode);
model.MyAccountRequest.Uid = currentUser.ObjectId;
}
return model;
}
private static void SetDates(MyAccountViewModel model)
{
if (string.IsNullOrEmpty(model.MyAccountRequest.Sd) && string.IsNullOrEmpty(model.MyAccountRequest.Ed))
{
model.MyAccountRequest.Sd = DateTime.Now.AddDays(-7).ToString("dd/MM/yyyy");
model.MyAccountRequest.Ed = DateTime.Now.ToString("dd/MM/yyyy");
}
}
