public ActionResult Edit(int id, EditUserProfileViewModel vm)
{
int getUser = GetCurrentUserId();
int adminCount = _userProfileRepository.getAdminCount();
if (adminCount <= 1 && getUser == id)
{
vm.UserProfile.UserTypeId = 1;
try
{
_userProfileRepository.UpdateUserProfile(id, vm.UserProfile);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View(vm));
}
}
else
{
try
{
_userProfileRepository.UpdateUserProfile(id, vm.UserProfile);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View(vm));
}
}
}
public async Task <IActionResult> EditUserProfile()
{
var user = await userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
ViewBag.ErrorMessage = $"User cannot be found";
return(View("NotFound"));
}
List <UserSubscriptions> userSubscriptions = _dbContext.UserSubscriptions.Where(x => x.UserId == user.Id && x.SubscriptionId != null).ToList();
var model = new EditUserProfileViewModel
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
UserName = user.UserName,
City = user.City,
SendEmails = user.SendEmails,
UserSubscriptions = userSubscriptions
};
return(View(model));
}
public async Task <IActionResult> EditUserProfile(EditUserProfileViewModel model)
{
var user = await userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
ViewBag.ErrorMessage = $"User cannot be found";
return(View("NotFound"));
}
else
{
List <UserSubscriptions> userSubscriptions = _dbContext.UserSubscriptions.Where(x => x.UserId == user.Id && x.SubscriptionId != null).ToList();
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.UserName = model.UserName;
user.City = model.City;
user.SendEmails = model.SendEmails;
user.Subscriptions = userSubscriptions;
var result = await userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("EditUserProfile"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <ActionResult> SetupProfile(EditUserProfileViewModel viewModel)
{
try
{
await
_userService.UpdateProfile(CurrentUserId, viewModel.UserId, viewModel.SurName, viewModel.FatherName,
viewModel.BornName, viewModel.PrefferedName, viewModel.Gender, viewModel.PhoneNumber, viewModel.Nicknames,
viewModel.GroupNames, viewModel.Skype, viewModel.Vk, viewModel.Livejournal);
if (viewModel.LastClaimId == null || viewModel.LastClaimProjectId == null)
{
return(RedirectToAction("SetupProfile"));
}
else
{
return(RedirectToAction("Edit", "Claim",
new { ClaimId = viewModel.LastClaimId, ProjectId = viewModel.LastClaimProjectId }));
}
}
catch (Exception e)
{
ModelState.AddModelError("", $"Ошибка при сохранении: {e.Message}");
return(View(viewModel));
}
}
public void EditProfile(string email, EditUserProfileViewModel profile)
{
if (profile.UserAvatar != null)
{
string ImagePath = "";
if (profile.AvatarName != "default.png")
{
ImagePath = Path.Combine(_environment.WebRootPath, "Images/UserAvatar", profile.AvatarName);
if (File.Exists(ImagePath))
{
File.Delete(ImagePath);
}
}
profile.AvatarName = GeneratorName.GenerateGUID() + Path.GetExtension(profile.UserAvatar.FileName);
ImagePath = Path.Combine(_environment.WebRootPath, "Images/UserAvatar", profile.AvatarName);
using (var stream = new FileStream(ImagePath, FileMode.Create))
{
profile.UserAvatar.CopyTo(stream);
}
}
var user = GetUserByEmail(email);
user.FirstName = profile.FirstName;
user.LastName = profile.LastName;
user.Mobile = profile.Mobile;
user.UserAvatar = profile.AvatarName;
UpdateUser(user);
}
public async Task <ActionResult> SetupProfile(EditUserProfileViewModel viewModel)
{
try
{
await
_userService.UpdateProfile(viewModel.UserId, viewModel.SurName, viewModel.FatherName,
viewModel.BornName, viewModel.PrefferedName, viewModel.Gender, viewModel.PhoneNumber, viewModel.Nicknames,
viewModel.GroupNames, viewModel.Skype, viewModel.Vk, viewModel.Livejournal, viewModel.Telegram);
var userId = CurrentUserAccessor.UserId;
var user = await UserManager.FindByIdAsync(userId.ToString());
await UserManager.UpdateSecurityStampAsync(user);
if (viewModel.LastClaimId == null || viewModel.LastClaimProjectId == null)
{
return(RedirectToAction("SetupProfile"));
}
else
{
return(RedirectToAction("Edit", "Claim",
new { ClaimId = viewModel.LastClaimId, ProjectId = viewModel.LastClaimProjectId }));
}
}
catch
{
//ModelState.AddException(e);
return(View(viewModel));
}
}
public async Task <IActionResult> Edit(string id)
{
var user = await this.userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var employees = await this.userManager
.Users
.Select(r => new SelectListItem
{
Text = r.UserName,
Value = r.Id
})
.ToListAsync();
var model = new EditUserProfileViewModel
{
Id = user.Id,
Username = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Birthdate = user.Birthdate,
Gender = user.Gender,
HireDate = user.HireDate,
Salary = user.Salary,
Status = user.Status,
Managers = employees
};
return(View(model));
}
public ActionResult EditUserProfile(EditUserProfileViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
Image image = null;
if (model.Picture != null)
{
using (var memory = new MemoryStream())
{
model.Picture.InputStream.CopyTo(memory);
var content = memory.GetBuffer();
image = new Image
{
Content = content,
Extension = model.Picture.FileName.Split(new[] { '.' }).Last()
};
}
}
var dataModel = AutoMapper.Mapper.Map<EditUserProfileViewModel, PetCare.Models.User>(model);
string username = this.User.Identity.Name;
User user = this.users.GetByUsername(username).FirstOrDefault();
this.users.UpdateUser(dataModel, user.Id);
return RedirectToAction("Index", "Home");
}
public async Task <IActionResult> ViewProfile(string id)
{
Profile profile = matrimonyRepository.GetProfileById(id);
ApplicationUser userData = await userManager.FindByIdAsync(profile.UserId);
EditUserProfileViewModel userProfileViewModel = EditUserProfileViewModel(profile);
userProfileViewModel.Email = userData.Email;
userProfileViewModel.EndDate = userData.EndDate;
userProfileViewModel.ExistingPhotoPath1 = userProfileViewModel.Photo1;
userProfileViewModel.ExistingPhotoPath2 = userProfileViewModel.Photo2;
userProfileViewModel.ExistingPhotoPath3 = userProfileViewModel.Photo3;
userProfileViewModel.profileImages = new List <string>();
if (userProfileViewModel.Photo1 != null)
{
userProfileViewModel.profileImages.Add(userProfileViewModel.Photo1);
}
if (userProfileViewModel.Photo2 != null)
{
userProfileViewModel.profileImages.Add(userProfileViewModel.Photo2);
}
if (userProfileViewModel.Photo3 != null)
{
userProfileViewModel.profileImages.Add(userProfileViewModel.Photo3);
}
return(View(userProfileViewModel));
}
public async Task <IActionResult> EditUserProfile()
{
var user = await GetCurrentUserAsync();
if (user == null)
{
return(View("Error"));
}
UserProfile profile = _context.UserProfiles.FirstOrDefault(x => x.UserId == user.Id);
if (profile == null)
{
profile = new UserProfile();
profile.UserId = user.Id;
_context.UserProfiles.Add(profile);
await _context.SaveChangesAsync();
}
var model = new EditUserProfileViewModel();
model.Location = profile.Location;
model.Gender = profile.Gender;
model.DateOfBirth = profile.DateOfBirth;
return(View(model));
}
public async Task <IActionResult> EditUserProfile(EditUserProfileViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await GetCurrentUserAsync();
if (user == null)
{
return(View("Error"));
}
UserProfile profile = _context.UserProfiles.FirstOrDefault(x => x.UserId == user.Id);
if (profile != null)
{
profile.Location = model.Location;
profile.Gender = model.Gender;
_context.SaveChanges();
}
return(View());
}
public void InsertEditedUserProfile(EditUserProfileViewModel viewModel)
{
IUserProfileRepository repo = new UserProfileRepository();
UserProfile user = new UserProfile();
if (viewModel.ProfilePhoto != null)
{
var fileName = Path.GetFileNameWithoutExtension(viewModel.ProfilePhoto.FileName);
fileName += DateTime.Now.Ticks + Path.GetExtension(viewModel.ProfilePhoto.FileName);
var basePath = "~/Content/Users/" + viewModel.UserID + "/Profile/Images/";
var path = Path.Combine(HttpContext.Current.Server.MapPath(basePath), fileName);
Directory.CreateDirectory(HttpContext.Current.Server.MapPath("~/Content/Users/" + viewModel.UserID + "/Profile/Images/"));
viewModel.ProfilePhoto.SaveAs(path);
user.ProfilePicPath = basePath + fileName;
}
else
{
user.ProfilePicPath = viewModel.ProfilePicPath;
}
user.OrganizationID = viewModel.OrganizationID;
user.UserID = viewModel.UserID;
user.FirstName = viewModel.FirstName;
user.LastName = viewModel.LastName;
user.Address = viewModel.Address;
user.Gender = viewModel.Gender;
user.CityID = viewModel.CityID;
user.PhoneNo = viewModel.MobileNO;
user.DOB = viewModel.DOB;
repo.Update(user);
}
public EditUserProfileViewModel EditUserProfile(string userID, int?orgID)
{
IUserProfileRepository profileRepo = new UserProfileRepository();
ICountryRepository countryRepo = new CountryRepository();
IStateRepository stateRepo = new StateRepository();
ICityRepository cityRepo = new CityRepository();
var yourProfile = profileRepo.Get().Where(s => s.UserID == userID && s.OrganizationID == orgID).FirstOrDefault();
//var city = cityRepo.Get().Where(s => s.CityID == yourProfile.CityID).FirstOrDefault();
//var state = stateRepo.Get().Where(s => s.StateID == city.StateID).FirstOrDefault();
//var country = countryRepo.Get().Where(s => s.CountryID == state.CountryID).FirstOrDefault();
EditUserProfileViewModel viewModel = new EditUserProfileViewModel();
viewModel.UserID = userID;
viewModel.OrganizationID = orgID;
viewModel.FirstName = yourProfile.FirstName;
viewModel.LastName = yourProfile.LastName;
viewModel.Address = yourProfile.Address;
viewModel.Gender = yourProfile.Gender;
viewModel.MobileNO = yourProfile.PhoneNo;
viewModel.ProfilePicPath = yourProfile.ProfilePicPath;
viewModel.DOB = yourProfile.DOB;
//viewModel.City = city.CityName;
//viewModel.State = state.StateName;
//viewModel.Country = country.CoutnryName;
return(viewModel);
}
private bool IsValid(EditUserProfileViewModel model, out IList <string> errorMessages, User user)
{
bool isValid = true;
var errors = new List <string>();
if (_userManager.FindByIdAsync(model.Id).Result == null)
{
errors.Add("User not found.");
isValid = false;
}
if (string.IsNullOrEmpty(model.Username))
{
errors.Add("Username required.");
isValid = false;
}
if (!model.Username.Equals(user.UserName)) // username was changed
{
if (_dbContext.Users.FirstOrDefault(u => u.UserName.Equals(model.Username)) != null)
{
errors.Add("User with the same username already exists.");
isValid = false;
}
}
errorMessages = errors;
return(isValid);
}
public async Task <IActionResult> Edit(string id, EditUserProfileViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await this.userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
user.Name = model.Name;
user.Birthdate = model.Birthdate;
var result = await this.userManager.UpdateAsync(user);
if (result.Succeeded)
{
TempData.AddSuccessMessage($"User {user.UserName} successfully updated.");
return(RedirectToAction(nameof(Index)));
}
else
{
AddModelErrors(result);
return(View(model));
}
}
public void UpdateUserDetails(EditUserProfileViewModel uvm)
{
var Config = new MapperConfiguration(cfg => { cfg.CreateMap <EditUserProfileViewModel, Users>(); });
IMapper mapper = Config.CreateMapper();
Users users = mapper.Map <EditUserProfileViewModel, Users>(uvm);
ur.UpdateUserDetails(users);
}
public IActionResult EditUserProfile()
{
var currUser = this.UserAccountService.GetCurrentUser(HttpContext);
EditUserProfileViewModel viewModel = mapper.Map <EditUserProfileViewModel>(currUser);
return(this.View(viewModel));
}
public void UpdateUser(EditUserProfileViewModel input, string name)
{
User userFromIndex = this.GetUser(name);
User user = this.ravenSession.Load <User>(userFromIndex.Id);
Mapper.Map(input, user);
}
public ActionResult ChangeProfile(EditUserProfileViewModel euvm)
{
this.us.UpdateUserDetails(euvm);
Session["CurrentUserName"] = euvm.UserName;
Session["CurrentUserPhone"] = euvm.Phone;
Session["CurrentUserGender"] = euvm.Gender;
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> Edit(EditUserProfileViewModel model)
{
var user = await _userManager.FindByIdAsync(model.Id);
if (user == null)
{
return(NotFound());
}
IList <string> errorMessages = new List <string>();
if (!IsValid(model, out errorMessages, user))
{
var viewModel = new ErrorsViewModel
{
Title = "User profile validation error",
Text = "Validation errors occurred while editing user profile",
Errors = errorMessages,
GoBackUrl = Url.Action("Edit", "Users", new { userId = model.Id })
};
return(View("Errors", viewModel));
}
user.UserName = model.Username;
user.About = model.About;
if (model.NewProfilePicture != null)
{
var userSettings = _serviceProvider.GetRequiredService <IOptions <UserSettings> >();
var defaultProfilePicture = userSettings.Value.DefaultProfilePicture;
var imagesManager = _serviceProvider.GetRequiredService <ImagesManager>();
var newImage = imagesManager.CreateAsync(model.NewProfilePicture).Result;
newImage = _dbContext.Images.Add(newImage).Entity;
_dbContext.SaveChanges();
user.ProfilePicture = newImage;
if (!user.ProfilePicture.Filename.Equals(defaultProfilePicture))
{
if (_dbContext.Images.FirstOrDefault(i => i.Id.Equals(user.ProfilePicture.Id)) == null)
{
_dbContext.Images.Remove(user.ProfilePicture);
_dbContext.SaveChanges();
}
imagesManager.RemoveAsync(user.ProfilePicture);
}
}
_dbContext.SaveChangesAsync();
ViewData["Message"] = "Changes saved successfully.";
return(View("Success"));
}
public ActionResult EditUserProfile(EditUserProfileViewModel viewModel)
{
UserProfileBL profileBL = new UserProfileBL();
profileBL.InsertEditedUserProfile(viewModel);
int?orgID = viewModel.OrganizationID;
return(RedirectToAction("Profile", new { UserId = viewModel.UserID, orgID }));
}
public ActionResult ChangeProfile()
{
int UserID = Convert.ToInt32(Session["CurrentUserID"]);
UserViewModel user = this.us.GetUsersByUserID(UserID);
EditUserProfileViewModel eupm = new EditUserProfileViewModel {
Email = user.Email, UserName = user.UserName, Phone = user.Phone, Gender = user.Gender, UserID = user.UserID
};
return(View(eupm));
}
public async Task <IActionResult> EditProfile(EditUserProfileViewModel model)
{
var user = _userProfileService.GetUserByName(User.Identity.Name);
var userProfileDTO = _mapper.Map <EditUserProfileViewModel, UserProfileDTO>(model);
userProfileDTO.UserId = user.Id;
await _userProfileService.EditProfile(userProfileDTO);
return(RedirectToAction("UserProfile", "UserProfile"));
}
public async Task <IActionResult> EditUserProfile(EditUserProfileViewModel model)
{
AppUser currentUser = _userManager.GetUserAsync(User).Result;
Guid userGuidId = currentUser.Id;
string userStringId = userGuidId.ToString();
AppUser user = await _userManager.FindByIdAsync(userStringId);
if (ModelState.IsValid)
{
if (!string.IsNullOrEmpty(model.MemberName))
{
user.MemberName = model.MemberName;
}
if (!string.IsNullOrEmpty(model.UserName))
{
user.UserName = model.UserName;
}
if (!string.IsNullOrEmpty(model.FirstName))
{
user.FirstName = model.FirstName;
}
if (!string.IsNullOrEmpty(model.LastName))
{
user.LastName = model.LastName;
}
if (!string.IsNullOrEmpty(model.Location))
{
user.Location = model.Location;
}
if (!string.IsNullOrEmpty(model.Position))
{
user.Position = model.Position;
}
if (!string.IsNullOrEmpty(model.Notes))
{
user.Notes = model.Notes;
}
if (!string.IsNullOrEmpty(model.PhoneNumber))
{
user.PhoneNumber = model.PhoneNumber;
}
if (Request.Form.Files.Count > 0)
{
IFormFile file = Request.Form.Files.FirstOrDefault();
MemoryStream dataStream = new MemoryStream();
await file.CopyToAsync(dataStream);
user.ProfilePicture = dataStream.ToArray();
}
await _userManager.UpdateAsync(user);
return(RedirectToAction("Profile", "Member"));
}
return(View(model));
}
public IActionResult EditProfile(EditUserProfileViewModel userProfile)
{
if (!ModelState.IsValid)
{
return(View(userProfile));
}
_userService.EditProfile(User.Identity.GetEmail(), userProfile);
HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
return(Redirect("/Login?EditProfile=true"));
}
public async Task <ResponseMessage> EditUserProfile([FromBody] EditUserProfileViewModel model)
{
//get current user from jwt token
var userName = HttpContext?.User.Claims.FirstOrDefault(c => c.Type == System.Security.Claims.ClaimTypes.NameIdentifier).Value;
var user = await _userManager.FindByNameAsync(userName);
_appUserService.UpdateUserProfile(user.Id, model, user.Photo);
return(new ResponseMessage {
IsSuccess = true
});
}
public ActionResult SaveUserProfile(EditUserProfileViewModel model)
{
if (ModelState.IsValid)
{
var success = GetCommand <SaveUserProfileCommand>().ExecuteCommand(model);
return(WireJson(success));
}
return(WireJson(false));
}
public override async Task <IDisplayResult> UpdateAsync(UserProfile profile, BuildEditorContext context)
{
var model = new EditUserProfileViewModel();
if (await context.Updater.TryUpdateModelAsync(model, Prefix))
{
profile.Age = model.Age;
profile.Name = model.Name;
}
return(Edit(profile, context));
}
public IActionResult MyProfile(EditUserProfileViewModel editUser)
{
if (ModelState.IsValid)
{
var userprofile =
_userMasterQueries.GetProfileForEditByUserId(
Convert.ToInt64(HttpContext.Session.GetString(AllSessionKeys.UserId)));
if (!string.Equals(userprofile.EmailId, editUser.EmailId, StringComparison.OrdinalIgnoreCase))
{
if (_userMasterQueries.CheckEmailExists(editUser.EmailId))
{
ModelState.AddModelError("", "Entered EmailId Already Exists");
return(View(editUser));
}
}
if (!string.Equals(userprofile.MobileNo, editUser.MobileNo, StringComparison.OrdinalIgnoreCase))
{
if (_userMasterQueries.CheckMobileNoExists(editUser.MobileNo))
{
ModelState.AddModelError("", "Entered MobileNo Already Exists");
return(View(editUser));
}
}
var userMaster = _userMasterQueries.GetUserDetailsbyUserId(editUser.UserId);
userMaster.ModifiedOn = DateTime.Now;
userMaster.ModifiedBy = Convert.ToInt32(HttpContext.Session.GetString(AllSessionKeys.UserId));
userMaster.LastName = editUser.LastName;
userMaster.FirstName = editUser.FirstName;
userMaster.MobileNo = editUser.MobileNo;
userMaster.EmailId = editUser.EmailId;
userMaster.Gender = editUser.Gender;
_unitOfWorkEntityFramework.UserMasterCommand.Update(userMaster);
var result = _unitOfWorkEntityFramework.Commit();
if (result)
{
_notificationService.SuccessNotification("Message", "User Details Updated Successfully !");
return(RedirectToAction("MyProfile"));
}
else
{
_notificationService.DangerNotification("Message", "Something went wrong Please Try Once Again !");
return(View(editUser));
}
}
return(View(editUser));
}
public void UpdateUserProfile(EditUserProfileViewModel userProfile)
{
User user = new User()
{
FirstName = userProfile.FirstName,
LastName = userProfile.LastName,
Mobile = userProfile.Mobile,
UserAvatar = userProfile.AvatarName
};
_context.Update(user);
_context.SaveChanges();
}
public IActionResult EditUserProfile(EditUserProfileViewModel editUserProfileViewModel)
{
var currUser = this.UserAccountService.GetCurrentUser(HttpContext);
editUserProfileViewModel.FirstName = currUser.FirstName;
editUserProfileViewModel.LastName = currUser.LastName;
editUserProfileViewModel.City = currUser.City;
editUserProfileViewModel.Address = currUser.Address;
editUserProfileViewModel.Email = currUser.Email;
editUserProfileViewModel.PhoneNumber = currUser.PhoneNumber;
return(this.View(editUserProfileViewModel));
}
