public ActionResult EditInfo()
{
if (!User.Identity.IsAuthenticated)
{
return(Redirect("/login"));
}
string cellNum = User.Identity.Name;
if (cellNum == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
User user = db.Users.FirstOrDefault(current =>
current.IsActive && !current.IsDeleted && current.CellNum == cellNum);
if (user == null)
{
return(HttpNotFound());
}
UserProfileEditViewModel userProfile = new UserProfileEditViewModel()
{
CellNumber = user.CellNum,
FullName = user.FullName,
Email = user.Email,
Id = user.Id
};
return(View(userProfile));
}
public async Task <IActionResult> ProfileBackgroundSettingsPartial(UserProfileEditViewModel viewModel)
{
UserProfile userProfile = await userProfileService.GetByIDAsync(viewModel.UserProfile.ID);
if (userProfile == null)
{
return(NotFound());
}
string uniqueFileName = null;
string profileBackgroundImageFolder = Path.Combine(webHostEnvironment.WebRootPath, "images\\UserProfile\\Background");
if (viewModel.UserProfile.AvatarImage != null)
{
uniqueFileName = Guid.NewGuid().ToString() + "_" + viewModel.UserProfile.ProfileBackgroundImage.FileName;
string filePath = Path.Combine(profileBackgroundImageFolder, uniqueFileName);
await viewModel.UserProfile.ProfileBackgroundImage.CopyToAsync(new FileStream(filePath, FileMode.Create));
userProfile.ProfileBackgroundImageFilePath = uniqueFileName;
userProfile.ProfileBackgroundImage = viewModel.UserProfile.ProfileBackgroundImage;
await userProfileService.UpdateAsync(userProfile);
}
return(RedirectToAction("Profile", new { id = userProfile.UserID }));
}
public ResultViewModel <UserProfileEditViewModel> UpdateProfile(UserProfileEditViewModel User)
{
ResultViewModel <UserProfileEditViewModel> result
= new ResultViewModel <UserProfileEditViewModel>();
try
{
if (!ModelState.IsValid)
{
result.Message = "In Valid Model State";
}
else
{
UserEditViewModel selectedEmp
= userService.Update(User.ToUserEditViewModel());
result.Successed = true;
result.Data = selectedEmp.ToUserProfileEditViewModel();
}
}
catch (Exception ex)
{
result.Successed = false;
result.Message = "Semething Went Wrong";
}
return(result);
}
public virtual async Task <IActionResult> EditProfilePartial(Guid userId)
{
if (userId == Guid.Empty)
{
return(NotFound());
}
var currentUser = await _userManager.UserManager.Users.FirstOrDefaultAsync(x => x.Id.Equals(userId));
if (currentUser == null)
{
return(NotFound());
}
var model = new UserProfileEditViewModel
{
FirstName = currentUser.FirstName,
LastName = currentUser.LastName,
Birthday = currentUser.Birthday,
AboutMe = currentUser.AboutMe,
PhoneNumber = currentUser.PhoneNumber,
Email = currentUser.Email
};
return(PartialView("Partial/_EditProfilePartial", model));
}
public async Task <object> Get(object obj)
{
KeyValuePair <string, object> requestData = (KeyValuePair <string, object>)obj;
switch (requestData.Key)
{
case "getUserProfile":
string userId = (string)requestData.Value;
ApplicationUser user = await GetUserById(userId);
UserProfileViewModel userProfileViewModel = BuildUserProfileViewModel(user);
return(userProfileViewModel);
case "editProfile":
userId = (string)requestData.Value;
user = await GetUserById(userId);
UserProfileEditViewModel userProfileEditViewModel = await BuildProfileEditViewModel(user);
return(userProfileEditViewModel);
default:
return(null);
}
}
public async Task <IActionResult> EditProfile(string userId)
{
KeyValuePair <string, object> editUserProfileKeyValuePair = new KeyValuePair <string, object>("editProfile", userId);
UserProfileEditViewModel userProfileEditViewModel = (UserProfileEditViewModel)await _profileRepository.Get(editUserProfileKeyValuePair);
return(View(userProfileEditViewModel));
}
public async Task <IActionResult> EditProfile(UserProfileEditViewModel userProfileEditViewModel)
{
if (ModelState.IsValid)
{
if (userProfileEditViewModel.ProfilePhoto != null)
{
if (!Path.GetExtension(userProfileEditViewModel.ProfilePhoto.FileName).Equals(".png", StringComparison.InvariantCultureIgnoreCase) && !Path.GetExtension(userProfileEditViewModel.ProfilePhoto.FileName).Equals(".jpg", StringComparison.InvariantCultureIgnoreCase))
{
TempData["errormessage"] = "Incorrect Image File Type. Please try again!";
return(View(userProfileEditViewModel));
}
}
KeyValuePair <string, object> editUserProfileKeyValuePair = new KeyValuePair <string, object>("editProfile", userProfileEditViewModel);
int profileUpdateResult = (int)await _profileRepository.Update(editUserProfileKeyValuePair);
if (profileUpdateResult > 0)
{
TempData["successmessage"] = "Updated successfully!";
return(RedirectToAction("Index", "Home"));
}
else
{
TempData["errormessage"] = "Failed to Update. Please try again.";
return(View(userProfileEditViewModel));
}
}
return(View(userProfileEditViewModel));
}
public ActionResult UserProfileEdit(UserProfileEditViewModel model)
{
if (ModelState.IsValid)
{
var userId = User.Identity.GetUserId();
var user = _userManager.Find(userId);
user.Name = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(model.Name).Trim();
user.Surname = CultureInfo.CurrentCulture.TextInfo.ToUpper(model.Surname).Trim();
user.Email = CultureInfo.CurrentCulture.TextInfo.ToLower(model.Email).Trim();
user.CityId = model.CityId;
BusinessLayerResult <ApplicationUser> res = _userManager.Update(user);
if (res.Errors.Count() > 0)
{
res.Errors.ForEach(x => ModelState.AddModelError("", x.Message));
}
else
{
return(RedirectToAction("UserProfile"));
}
}
ViewBag.CityId = new SelectList(CacheHelper.GetCitiesFromCache(), "Id", "Name", model.CityId);
return(View(model));
}
public ViewResult Edit()
{
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
var userProfile = userProfileRepository.UserProfiles.FirstOrDefault(p => p.AppUserId == userId);
UserProfileEditViewModel userProfileViewModel = mapper.Map<UserProfileEditViewModel>(userProfile);
return View(userProfileViewModel);
}
public virtual async Task <JsonResult> EditProfile(UserProfileEditViewModel model)
{
if (!ModelState.IsValid)
{
return(JsonModelStateErrors());
}
return(await JsonAsync(_profileService.UpdateBaseUserProfileAsync(model)));
}
public async Task <IActionResult> AccountSettingsPartial(UserProfileEditViewModel viewModel)
{
User user = await userService.GetByIDAsync(viewModel.User.Id);
user.FirstName = viewModel.User.FirstName;
user.LastName = viewModel.User.LastName;
user.Age = viewModel.User.Age;
user.Location = viewModel.User.Location;
await userService.UpdateAsync(user);
return(RedirectToAction("Profile", new { id = user.Id }));
}
public IActionResult Edit(IFormFile file, UserProfileEditViewModel userProfileViewModel)
{
if (ModelState.IsValid)
{
userProfileRepository.EditUserProfile(file, userProfileViewModel);
flashMessage.Confirmation("Profil został zedytowany");
return RedirectToAction(nameof(UserProfileController.Details), nameof(UserProfileController).Replace("Controller", ""));
}
else
{
return View(userProfileViewModel);
}
}
public async Task <IActionResult> GeneralSettingsPartial(UserProfileEditViewModel viewModel)
{
UserProfile userProfile = await userProfileService.GetByIDAsync(viewModel.UserProfile.ID);
if (userProfile == null)
{
return(NotFound());
}
userProfile.Biography = viewModel.UserProfile.Biography;
await userProfileService.UpdateAsync(userProfile);
return(RedirectToAction("Profile", new { id = userProfile.UserID }));
}
public ActionResult <UserProfileEditViewModel> Save(UserProfileSaveViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
User user = userRepository.GetById(model.Id);
mapper.Map(model, user);
userRepository.Save(user);
UserProfileEditViewModel result = mapper.Map <UserProfileEditViewModel>(user);
return(Ok(result));
}
public void EditUserProfile(IFormFile file, UserProfileEditViewModel userProfileViewModel)
{
UserProfile userProfile = context.UserProfiles.FirstOrDefault(p => p.UserProfileId == userProfileViewModel.UserProfileId);
if (userProfile != null)
{
mapper.Map(userProfileViewModel, userProfile);
if (file != null)
{
userProfile.ImagePath = file.FileName;
}
}
context.SaveChanges();
}
public async Task <IActionResult> PrivacySettingsPartial(UserProfileEditViewModel viewModel)
{
UserProfile userProfile = await userProfileService.GetByIDAsync(viewModel.UserProfile.ID);
if (userProfile == null)
{
return(NotFound());
}
userProfile.UserProfileVisibility = viewModel.UserProfile.UserProfileVisibility;
userProfile.UserProfileCommentPermission = viewModel.UserProfile.UserProfileCommentPermission;
await userProfileService.UpdateAsync(userProfile);
return(RedirectToAction("Profile", new { id = userProfile.UserID }));
}
// GET: UserProfileController/Edit/5
public ActionResult Edit(int id)
{
UserProfile user = _userProfileRepository.GetById(id);
List <UserType> types = _userTypeRepository.GetAll();
UserProfileEditViewModel vm = new UserProfileEditViewModel()
{
UserProfile = user,
UserTypes = types
};
if (vm.UserProfile == null)
{
return(NotFound());
}
return(View(vm));
}
public ActionResult UserProfileEdit()
{
var userId = User.Identity.GetUserId();
var user = _userManager.Find(userId);
UserProfileEditViewModel model = new UserProfileEditViewModel()
{
Name = user.Name,
Surname = user.Surname,
Email = user.Email,
CityId = user.CityId
};
ViewBag.CityId = new SelectList(CacheHelper.GetCitiesFromCache(), "Id", "Name", model.CityId);
return(View(model));
}
public async Task <UserProfileEditViewModel> BuildProfileEditViewModel(ApplicationUser user)
{
UserProfileEditViewModel userProfileEditViewModel = new UserProfileEditViewModel();
userProfileEditViewModel.UserId = user.Id;
userProfileEditViewModel.Description = user.Description;
userProfileEditViewModel.Carer = user.Carer;
if (user.Carer)
{
List <ServiceRateViewModel> serviceRateViewModelList = new List <ServiceRateViewModel>();
List <ServiceType> serviceTypes = (List <ServiceType>) await CommandFactory.CreateCommand(CommandFactory.GET_SERVICE_TYPES, _dbContext).Execute();
foreach (ServiceType service in serviceTypes)
{
ServiceTypeViewModel serviceTypeViewModel = new ServiceTypeViewModel();
ServiceRateViewModel serviceRateViewModel = new ServiceRateViewModel();
ServiceRate serviceRate = user.ServiceRates.FirstOrDefault(rate => rate.ServiceType.Id == service.Id);
//if (!user.ServiceRates.Any(rate => rate.ServiceType == service))
if (serviceRate == null)
{
serviceTypeViewModel.Id = service.Id;
serviceTypeViewModel.Name = service.Name;
serviceRateViewModel.ServiceType = serviceTypeViewModel;
serviceRateViewModel.Rate = 0;
}
else
{
serviceTypeViewModel.Id = service.Id;
serviceTypeViewModel.Name = service.Name;
serviceRateViewModel.ServiceType = serviceTypeViewModel;
serviceRateViewModel.Rate = serviceRate.Rate;
}
serviceRateViewModelList.Add(serviceRateViewModel);
}
userProfileEditViewModel.ServiceRates = serviceRateViewModelList;
}
return(userProfileEditViewModel);
}
public async Task <object> Update(object obj)
{
KeyValuePair <string, object> requestData = (KeyValuePair <string, object>)obj;
switch (requestData.Key)
{
case "editProfile":
UserProfileEditViewModel userProfileEditViewModel = (UserProfileEditViewModel)requestData.Value;
ApplicationUser uneditedUser = await GetUserById(userProfileEditViewModel.UserId);
int updateResult = await UpdateUserProfile(userProfileEditViewModel, uneditedUser);
return(updateResult);
default:
return(null);
}
}
public ActionResult EditInfo(UserProfileEditViewModel userProfile)
{
User user = db.Users.FirstOrDefault(current =>
current.IsActive && !current.IsDeleted && current.Id == userProfile.Id);
if (user == null)
{
return(HttpNotFound());
}
user.CellNum = userProfile.CellNumber;
user.Email = userProfile.Email;
user.FullName = userProfile.FullName;
user.LastModifiedDate = DateTime.Now;
db.SaveChanges();
return(RedirectToAction("Details"));
}
public async Task <IActionResult> EmailSettingsPartial(UserProfileEditViewModel viewModel)
{
if (ModelState.IsValid)
{
User user = await userService.GetByIDAsync(viewModel.User.Id);
if (user == null)
{
return(NotFound());
}
user.Email = viewModel.EmailAddress;
await userService.UpdateAsync(user);
return(RedirectToAction("Profile", new { id = user.Id }));
}
return(PartialView(accountSettingsPath + "_EmailSettings.cshtml", viewModel));
}
public async Task <IActionResult> AccountSettingsPartial(int id)
{
if (id == 0)
{
return(NotFound());
}
User user = await userService.GetByIDAsync(id);
if (user == null)
{
return(NotFound());
}
UserProfileEditViewModel viewModel = new UserProfileEditViewModel
{
User = user
};
return(PartialView(accountSettingsPath + "_AccountSettings.cshtml", viewModel));
}
public ActionResult Edit(int id, UserProfileEditViewModel user)
{
try
{
_userProfileRepository.UpdateUser(user.UserProfile);
return(RedirectToAction("Index"));
}
catch
{
user.UserProfile = _userProfileRepository.GetById(id);
user.UserProfile.Error = true;
List <UserType> types = _userTypeRepository.GetAll();
user.UserTypes = types;
if (user.UserProfile == null)
{
return(NotFound());
}
return(View(user));
}
}
public async Task <IActionResult> ProfileBackgroundSettingsPartial(int id)
{
if (id == 0)
{
return(NotFound());
}
UserProfile userProfile = await userProfileService.GetByIDAsync(id);
if (userProfile == null)
{
return(NotFound());
}
UserProfileEditViewModel viewModel = new UserProfileEditViewModel
{
UserProfile = userProfile
};
return(PartialView(profileSettingsPath + "_ProfileBackgroundSettings.cshtml", viewModel));
}
public async Task <IActionResult> ProfileSettings(int id)
{
//First check for User
if (id == 0)
{
return(NotFound());
}
UserProfile userProfile = await userProfileService.GetByUserIDAsync(id);
if (userProfile == null)
{
return(NotFound());
}
UserProfileEditViewModel viewModel = new UserProfileEditViewModel
{
UserProfile = userProfile
};
return(View(profileSettingsPath + "ProfileSettings.cshtml", viewModel));
}
public async Task <IActionResult> PrivacySettingsPartial(int id)
{
if (id == 0)
{
return(NotFound());
}
UserProfile userProfile = await userProfileService.GetByIDAsync(id);
if (userProfile == null)
{
return(NotFound());
}
var visibilityList = await userProfileVisibilityService.GetAllAsync();
var visibilitySelectList = visibilityList.Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList();
var commentPermissionList = await userProfileCommentPermissionService.GetAllAsync();
var commentPermissionSelectList = commentPermissionList.Select(x => new SelectListItem()
{
Text = x.Name,
Value = x.ID.ToString()
}).ToList();
UserProfileEditViewModel viewModel = new UserProfileEditViewModel
{
UserProfile = userProfile,
UserProfileVisibilityList = visibilitySelectList,
UserProfileCommentPermissionList = commentPermissionSelectList
};
return(PartialView(profileSettingsPath + "_PrivacySettings.cshtml", viewModel));
}
public ActionResult <UserProfileEditViewModel> GetById(int id)
{
var user = userRepository.GetById(id);
if (user == null)
{
return(NotFound());
}
#region left-right code
/*
* UserProfileEditViewModel model = new UserProfileEditViewModel {
* Id = user.Id,
* FirstName = user.FirstName,
* ...
* }
*/
#endregion
UserProfileEditViewModel model = mapper.Map <UserProfileEditViewModel>(user);
return(Ok(model));
}
public ActionResult Edit(UserProfileEditViewModel userProfileEdit)
{
if (userProfileEdit.ID != Convert.ToDecimal(UserHelper.GetUserId()))
{
TempData["message"] = ToasterMessage.Message(ToastType.warning, "Unauthorized Access");
return(RedirectToAction("Index"));
}
User_Profile user_Profile = db.User_Profile.Find(userProfileEdit.ID);
try
{
ViewBag.CountryID = new SelectList(db.Country_Master.OrderBy(m => m.Name), "ID", "Name", user_Profile.CountryID);
ViewBag.Role_id = new SelectList(db.Role_Master, "Id", "Name", user_Profile.Role_id);
ViewBag.StateID = new SelectList(db.State_Master.OrderBy(m => m.Name), "ID", "Name", user_Profile.StateID);
ViewBag.StateEnrolled = new SelectList(db.State_Master.OrderBy(m => m.Name), "ID", "Name", user_Profile.StateEnrolled);
user_Profile.UserName = userProfileEdit.EmailAddress;
user_Profile.FirstName = userProfileEdit.FirstName;
user_Profile.LastName = userProfileEdit.LastName;
user_Profile.OtherName = userProfileEdit.OtherName;
user_Profile.StateID = userProfileEdit.StateID;
user_Profile.StreetName = userProfileEdit.StreetName;
user_Profile.StreetNumber = userProfileEdit.StreetNumber;
user_Profile.PostCode = userProfileEdit.PostCode;
user_Profile.Suburb = userProfileEdit.Suburb;
user_Profile.LawSocietyNumber = userProfileEdit.LawSocietyNumber;
user_Profile.PhoneNumber = userProfileEdit.PhoneNumber;
user_Profile.Date = userProfileEdit.Date;
user_Profile.Address = userProfileEdit.Address;
db.Entry(user_Profile).State = EntityState.Modified;
db.SaveChanges();
TempData["message"] = ToasterMessage.Message(ToastType.success, "Updated Successfully");
}
catch (DbEntityValidationException e)
{
string errorMessage = string.Empty;
foreach (DbEntityValidationResult eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (DbValidationError ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
errorMessage = ve.ErrorMessage;
ViewBag.message = ViewBag.message + ToasterMessage.Message(ToastType.error, errorMessage);
}
}
return(View());
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Update base user profile
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel> UpdateBaseUserProfileAsync(UserProfileEditViewModel model)
{
var modelState = ModelValidator.IsValid(model);
if (!modelState.IsSuccess)
{
return(modelState);
}
var resultModel = new ResultModel();
var currentUserRequest = await _userManager.GetCurrentUserAsync();
if (!currentUserRequest.IsSuccess)
{
resultModel.Errors.Add(new ErrorModel(string.Empty, "User not found!"));
return(resultModel);
}
var currentUser = currentUserRequest.Result;
var isUsed = await _userManager.UserManager
.Users.AnyAsync(x => !x.Id.Equals(currentUser.Id) &&
!x.Email.IsNullOrEmpty() &&
x.Email.ToLowerInvariant()
.Equals(model.Email.ToLowerInvariant()));
if (isUsed)
{
resultModel.AddError("Email is used by another user");
return(resultModel);
}
currentUser.FirstName = model.FirstName;
currentUser.LastName = model.LastName;
currentUser.Birthday = model.Birthday;
currentUser.AboutMe = model.AboutMe;
currentUser.PhoneNumber = model.PhoneNumber;
currentUser.EmailConfirmed = currentUser.EmailConfirmed && model.Email.Equals(currentUser.Email);
currentUser.Email = model.Email;
if (!currentUser.EmailConfirmed)
{
EmailEvents.Events.TriggerSendConfirmEmail(new SendConfirmEmailEventArgs
{
HttpContext = _accessor.HttpContext,
Email = model.Email
});
}
var result = await _userManager.UserManager.UpdateAsync(currentUser);
if (result.Succeeded)
{
resultModel.IsSuccess = true;
return(resultModel);
}
resultModel.AppendIdentityErrors(result.Errors);
return(resultModel);
}
