public async Task <IActionResult> Post([FromBody] UpdateProfileViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
if (!string.IsNullOrEmpty(model.Image))
{
user.ImageId = await _imageManager.Save(FileConverter.FromBase64String(model.Image), Folder.Profile);
}
else
{
user.ImageId = null;
}
user.UserName = model.UserName;
user.Email = model.Email;
user.PhoneNumber = model.PhoneNumber;
await _userManager.UpdateAsync(user);
return(Ok());
}
return(BadRequest(model));
}
/// <summary>
/// Update the profile info on the server.
/// </summary>
/// <param name="profile">The (new) profile of the current person to set.</param>
/// <returns>The response of the server on the updating process, formatted as a string.</returns>
public async Task <string> UpdateProfile(Profile profile)
{
var viewModel = new UpdateProfileViewModel(profile);
var reply = await connection.PostData <Response>(viewModel, "api/Profile/UpdateProfile");
return(reply.Test);
}
public async Task <ActionResult> UpdateProfile(UpdateProfileViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var loggedInUserEmail = Convert.ToString(Session["Email"]);
if (string.IsNullOrEmpty(loggedInUserEmail))
{
return(Logout());
}
var existingUser = await _context.Users.FirstOrDefaultAsync(
m => m.UserName.ToLower() == model.UserName.ToLower() && model.Id != m.Id);
if (existingUser != null)
{
TempData["ErrorMessage"] = "User already exists!";
return(View(model));
}
var updatingUser = await _context.Users.FirstOrDefaultAsync(m => m.Email.ToLower() == loggedInUserEmail.ToLower());
updatingUser.UserName = model.UserName;
updatingUser.FullName = model.FullName;
updatingUser.City = model.City;
updatingUser.Phone = model.Phone;
await _context.SaveChangesAsync();
TempData["SuccessMessage"] = "User updated!";
return(RedirectToAction("UpdateProfile", "Login"));
}
public async Task <IActionResult> UpdateProfile(UpdateProfileViewModel model, string Id)
{
var user = await _userManager.FindByIdAsync(Id);
if (!ModelState.IsValid)
{
model.UserPhotoPath = user.UserPhotoPath;
return(View(model));
}
_mapper.Map(model, user);
var photoPath = (await _photoService.AddImage(model.ImageInfo));
if (photoPath != null)
{
user.UserPhotoPath = photoPath;
}
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
AddErrors(error.Description);
}
return(View(model));
}
return(RedirectToAction(nameof(ProfileController.ProfileInfo), new { Id }));
}
public ActionResult Me(HttpPostedFileBase avatarFile, UpdateProfileViewModel input)
{
int staffId = ((Staff)Session["Staff"]).Id;
if (staffId != input.Id)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
else
{
var staff = db.Staffs.Where(q => q.Id == staffId).FirstOrDefault();
staff.Id = input.Id;
staff.Name = input.Name;
staff.Address = input.Address;
staff.Phone = input.Phone;
if (avatarFile != null)
{
staff.Avatar = SaveImages.SaveAvatarFile(avatarFile, staff.Email);
}
Session["Avatar"] = "/" + ConfigurationManager.AppSettings["CusAvatar"] + staff.Avatar;
db.Entry(staff).State = EntityState.Modified;
db.SaveChanges();
}
return(RedirectToAction("Me"));
}
/// <summary>
/// Updates <see cref="MacroNewtUser"/> account with details necessary for BMR calculation
/// </summary>
/// <param name="form">An <see cref="UpdateProfileViewModel"/> object populated with required user details</param>
/// <returns>The BMRCalculator ViewComponent</returns>
public IActionResult UpdateProfileStats([Bind("Gender,HeightFeet,HeightInches,Weight")] UpdateProfileViewModel form)
{
if (!ModelState.IsValid)
{
return(ViewComponent("UpdateProfile", form));
}
string userID = User.FindFirstValue(ClaimTypes.NameIdentifier);
var user = _context.Users
.Where(u => u.Id == userID)
.FirstOrDefault();
user.Gender = form.Gender;
user.HeightFeet = form.HeightFeet;
user.HeightInches = form.HeightInches;
user.Weight = form.Weight;
_context.Users.Update(user);
_context.SaveChanges();
int height = (user.HeightFeet * 12) + (user.HeightInches);
BMRCalculatorViewModel bmrc = new BMRCalculatorViewModel(
user.Weight,
height,
user.Age,
user.Gender
);
return(ViewComponent("BMRCalculator", bmrc));
}
public async Task <IActionResult> EditUser(string id)
{
AppUser user = await userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
UpdateProfileViewModel viewModel = new UpdateProfileViewModel
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PhoneNumber = user.PhoneNumber,
Photo = user.Photo,
Country = user.Country,
City = user.City,
Address = user.Address,
AboutMe = user.AboutMe,
SecurityStamp = user.SecurityStamp
};
return(View(viewModel));
}
public UpdateProfilePage()
{
InitializeComponent();
_network = App.Container.Resolve <INetwork>();
_viewModel = new UpdateProfileViewModel();
BindingContext = _viewModel;
}
public ActionResult UpdateProfile(UpdateProfileViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = db.Users.Find(User.Identity.GetUserId());
if (user.LastName == "Demo")
{
ViewBag.StatusMessage = "'Demo' accounts cannot update their Profiles";
return(View());
}
if (user != null)
{
user.FirstName = model.NewFirstName;
user.LastName = model.NewLastName;
user.DisplayName = model.NewDisplayName;
db.SaveChanges();
ViewBag.StatusMessage = "Your Profile has been updated.";
return(View());
}
return(View(model));
}
public IActionResult UpdateProfile(UpdateProfileViewModel model)
{
if (!ModelState.IsValid)
{
TempData["Error-Notification"] = "Greška prilikom ažuriranja profila.";
return(View("Settings"));
}
Users updateUser = new Users()
{
Id = model.KorisnikId,
IdentUserId = model.UserId,
Name = model.Name,
LastName = model.LegalPerson == true ? "" : model.LastName,
LegalPerson = model.LegalPerson,
PhoneNumber = model.Phone,
ContactAddress = model.ContactAddress,
Email = model.Email,
UserName = model.Username,
};
_user.UpdateUser(updateUser);
TempData["Notification"] = "Ažurirali ste profil.";
if (model.AdminAction)
{
return(RedirectToAction("UserSettingsAdmin", "Auth", new { identUserId = model.UserId }));
}
return(RedirectToAction("Settings", "Auth"));
}
public ActionResult UpdateUserProfile(UpdateProfileViewModel vm)
{
using (var client = new UserProfileServiceReference.UserProfileServiceClient())
{
int.TryParse(Session["UserId"].ToString(), out int userid);
var Userinfo = client.GetUserByUserId(userid);
var updateUser = new UserProfileServiceReference.User()
{
Address = vm.userAddress,
City = vm.userCity,
PersonalCodeNumber = vm.personalnumber,
Phonenumber = vm.userPhoneNumber,
Picture = vm.userProfilePicture,
ZipCode = vm.userZipCode,
Id = userid,
Email = Userinfo.Email,
Name = Userinfo.Name,
Surname = Userinfo.Surname,
Username = Userinfo.Username,
};
var user = client.UpdateUser(updateUser);
}
return(View());
}
public ActionResult ChangeProfile(UpdateProfileViewModel model, HttpPostedFileBase avatar)
{
var user = db.Accounts.Where(m => m.Username == User.Identity.Name).FirstOrDefault();
if (ModelState.IsValid)
{
user.Name = model.Name;
user.DOB = model.DOB;
user.Tel = model.Tel;
//change avatar in profile
if (avatar != null)
{
var img = Path.GetFileName(avatar.FileName);
var pathImg = Path.Combine(Server.MapPath("~/Files/Avatar/"), img);
avatar.SaveAs(pathImg);
user.Avatar = img;
}
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(Redirect("Profile"));
}
user.Avatar = model.Avatar;
user.Name = model.Name;
return(View("ChangeProfile", model));
}
public async Task <IActionResult> _UpdateProfile(String identUserId)
{
IdentityUser user;
if (identUserId == null)
{
user = await _userManager.GetUserAsync(User);
}
else
{
user = await _userManager.FindByIdAsync(identUserId.ToString());
}
if (user == null)
{
return(NotFound($"Nemoguće je pronaći korisnika koji ima ID '{_userManager.GetUserId(User)}'."));
}
var current_user = _user.GetUser(user.Id);
UpdateProfileViewModel model = new UpdateProfileViewModel()
{
KorisnikId = current_user.Id,
UserId = current_user.IdentUserId,
Username = current_user.UserName,
Name = current_user.Name,
LegalPerson = current_user.LegalPerson,
LastName = current_user.LastName,
Email = current_user.Email,
ContactAddress = current_user.ContactAddress,
Phone = current_user.PhoneNumber,
AdminAction = identUserId == null ? false : true,
};
return(View(model));
}
public OperationResult UpdateUserProfile(Guid userId, UpdateProfileViewModel profile)
{
return(InvokeOperations.InvokeOperation(() =>
{
if (context.Profiles.Any(x => x.UserName == profile.UserName && x.UserId != userId))
{
throw new Exception("Username already exists");
}
var user = context.Profiles.First(x => x.UserId == userId);
user.UserName = profile.UserName;
user.Avatar = profile.Avatar;
user.Address = profile.Address;
if (profile.Birthday.HasValue)
{
user.Birthday = profile.Birthday.Value;
}
user.City = profile.City;
user.Country = profile.Country;
user.DocumentNumber = profile.DocumentNumber;
user.DocumentType = profile.DocumentType;
user.FirstName = profile.FirstName;
if (profile.Gender.HasValue)
{
user.Gender = profile.Gender.Value;
}
user.LastName = profile.LastName;
user.MiddleName = profile.MiddleName;
user.Phone = profile.Phone;
context.SaveChanges();
}));
}
public async Task <IActionResult> EditUser(UpdateProfileViewModel viewModel)
{
if (ModelState.IsValid)
{
AppUser user = await userManager.FindByIdAsync(viewModel.Id);
if (user != null)
{
string role = userManager.GetRolesAsync(user).Result.FirstOrDefault();
user.FirstName = viewModel.FirstName;
user.LastName = viewModel.LastName;
user.Email = viewModel.Email;
user.PhoneNumber = viewModel.PhoneNumber;
if (!string.IsNullOrEmpty(viewModel.Photo))
{
user.Photo = viewModel.Photo;
}
user.Country = viewModel.Country;
user.City = viewModel.City;
user.Address = viewModel.Address;
user.AboutMe = viewModel.AboutMe;
await userManager.UpdateAsync(user);
if (!string.IsNullOrEmpty(role) && role != "Admin")
{
return(Redirect("/Home"));
}
return(RedirectToAction(nameof(Index)));
}
}
return(View(viewModel));
}
public IActionResult UpdateProfile(UpdateProfileViewModel model)
{
if (ModelState.IsValid)
{
var error = _userService.UpdateProfile(new UpdateProfileRequest
{
UserId = CurrentUserId,
FirstName = model.FirstName,
LastName = model.LastName,
Address = model.Address,
PhoneNumber = model.PhoneNumber,
Email = model.Email
});
switch (error)
{
case null:
return(RedirectToAction("Index"));
case ResponseErrorEnum.EmailAlreadyUsed:
ModelState.AddModelError(nameof(model.Email), "This email is already used");
break;
default:
return(this.InternalServerError());
}
}
var indexModel = new ProfileViewModel();
FillProfileViewModel(indexModel);
indexModel.UpdateProfileViewModel = model;
indexModel.OpenUpdateProfileModal = true;
return(View("Index", indexModel));
}
public async Task <ActionResult> UpdateProfile()
{
var loggedInUserEmail = Convert.ToString(Session["Email"]);
if (string.IsNullOrEmpty(loggedInUserEmail))
{
return(Logout());
}
var loggedInUser = await _context.Users.FirstOrDefaultAsync(m => m.Email.ToLower() == loggedInUserEmail.ToLower());
if (loggedInUser == null)
{
return(Logout());
}
UpdateProfileViewModel model = new UpdateProfileViewModel
{
Id = loggedInUser.Id,
UserName = loggedInUser.UserName,
FullName = loggedInUser.FullName,
City = loggedInUser.City,
Phone = loggedInUser.Phone
};
return(View(model));
}
public ActionResult UpdateProfile(UpdateProfileViewModel model)
{
ViewData["Form"] = new UpdateProfileForm().Init(model, User);
if (ModelState.IsValid)
{
var user = UserManager.FindById(User.Identity.GetUserId());
System.Diagnostics.Debug.WriteLine(user);
if (user != null)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Title = model.Title;
user.TimeZone = model.TimeZone;
IdentityResult result = UserManager.Update(user);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Could not update your profile.");
}
else
{
this.TempData["Success"] = "Saved!";
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
//
// GET: /Account/Manage/UpdateProfile
public ActionResult UpdateProfile()
{
var user = UserManager.FindById(User.Identity.GetUserId());
UpdateProfileViewModel model = new UpdateProfileViewModel();
model.Email = user.Email;
model.FirstName = user.FirstName;
model.LastName = user.LastName;
model.Title = user.Title;
model.TimeZone = user.TimeZone;
model.Avatar = user.Avatar;
model.Roles = new List <string>();
foreach (var role in RoleManager.Roles.ToList())
{
foreach (var u in role.Users)
{
if (u.UserId == user.Id)
{
model.Roles.Add(role.Name);
}
}
}
ViewData["Form"] = new UpdateProfileForm().Init(model, User);
return(View(model));
}
public IActionResult UserUpdateProfile(UpdateProfileViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = this._context.Users.FirstOrDefault(u => u.Id == model.UserId);
if (user != null)
{
user.PhoneNumber = model.PhoneNumber;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Gender = model.Gender;
user.UserName = model.FirstName + "" + model.LastName;
this._context.Users.Update(user);
this._context.SaveChanges();
return(RedirectToAction("Profile", new { UserId = model.UserId }));
}
return(View());
}
public ActionResult UpdateProfile()
{
User user = _usersService.GetByUsername(User.Identity.Name);
UpdateProfileViewModel viewModel = Mapper.Map <UpdateProfileViewModel>(user);
return(UpdateProfilePartial(viewModel));
}
public IActionResult UpdateProfile([Bind("Name,Phone,Email,AvatarUrl")] UpdateProfileViewModel model)
{
if (ModelState.IsValid)
{
// upload file
string fileName = "";
string folderName = "wwwroot\\Media\\";
string webRootPath = _hostEnvironment.ContentRootPath;
string newPath = Path.Combine(webRootPath, folderName);
if (!Directory.Exists(newPath))
{
Directory.CreateDirectory(newPath);
}
if (model.AvatarUrl != null)
{
fileName = ContentDispositionHeaderValue.Parse(model.AvatarUrl.ContentDisposition).FileName.Trim('"');
string fullPath = Path.Combine(newPath, fileName);
using (var stream = new FileStream(fullPath, FileMode.Create))
{
model.AvatarUrl.CopyTo(stream);
}
}
var user = HttpContext.Session.Get <User>(SD.CurrentUser);
user.AvatarUrl = fileName;
user.Name = model.Name;
user.PhoneNumber = model.Phone;
user.Email = model.Email;
_unitOfWork.User.Update(user);
_unitOfWork.Save();
UpdateCurrentUserSession(user);
return(RedirectToAction(nameof(Index)));
}
return(View("Index"));
}
public async Task <ActionResult> Index()
{
var _user = await UserManager.FindByEmailAsync(User.Identity.Name);
UpdateProfileViewModel model = new UpdateProfileViewModel()
{
Email = _user.Email,
Title = _user.Title,
Gender = _user.Gender,
FirstName = _user.FirstName,
LastName = _user.LastName,
Mobile = _user.PhoneNumber,
Bio = _user.Bio,
Hobbies = _user.Hobbies,
StudentGrade = _user.StudentGrade,
StudentSchool = _user.StudentSchool,
ProfileImage = _user.ProfileImage,
Address = _user.Address,
City = _user.City,
TimeZone = _user.TimeZone,
Country = _user.Country,
Zip = _user.Zip,
//DOB = _user.DOB,
CreatedDate = DateTime.Now,
//UpdatedDate = DateTime.Now
UserId = _user.Id,
//Concerns = _tutor.Concerns,
};
return(View(model));
}
/// <summary>
/// Determines if user account includes required details for finding BMR. Returns view component
/// for providing those details if not present, otherwise returns BMR calculator view component
/// </summary>
/// <returns>The UpdateProfile ViewComponent if necessary, otherwise the BMRCalculator ViewComponent</returns>
public IActionResult CheckProfileComplete()
{
string userID = User.FindFirstValue(ClaimTypes.NameIdentifier);
var user = _context.Users
.Where(u => u.Id == userID)
.FirstOrDefault();
if ((user.HeightFeet == -1) || (user.HeightInches == -1) || (user.Weight == 0) || (user.Gender == null))
{
UpdateProfileViewModel upvm = new UpdateProfileViewModel
{
Gender = user.Gender,
HeightFeet = user.HeightFeet,
HeightInches = user.HeightInches,
Weight = user.Weight
};
return(ViewComponent("UpdateProfile", upvm));
}
int height = (user.HeightFeet * 12) + (user.HeightInches);
BMRCalculatorViewModel bmrc = new BMRCalculatorViewModel(
user.Weight,
height,
user.Age,
user.Gender
);
return(ViewComponent("BMRCalculator", bmrc));
}
public ActionResult UpdateProfile(UpdateProfileViewModel model)
{
this.TempData["Success"] = "Profile updated";
return(this.IndependentActionResult(() =>
this.ownProfileService.ChangeUserPicture(User.Identity.GetUserId(), model.File.InputStream, model.File.ContentType),
this.RedirectToAction <SettingsController>((c) => c.General())));
}
public IActionResult UpdateProfile(UpdateProfileViewModel vm, IFormFile DisplayPhotoPath)
{
var user = GetCurrentUserAsync().Result;
var profile = _profileRepo.GetSingle(p => p.UserId == user.Id);
profile.DisplayName = vm.DisplayName;
profile.Firstname = vm.Firstname;
profile.Lastname = vm.Lastname;
profile.Phone = vm.Phone;
if (DisplayPhotoPath != null)
{
string uploadPath = Path.Combine(_hostingEnviro.WebRootPath, "Media\\User");
//uploadPath = Path.Combine(uploadPath, User.Identity.Name);
//Directory.CreateDirectory(Path.Combine(uploadPath, tp.PackageName));
string filename = User.Identity.Name + "-" + User.Identity.Name + "-1" + Path.GetExtension(DisplayPhotoPath.FileName);
uploadPath = Path.Combine(uploadPath, filename);
using (FileStream fs = new FileStream(uploadPath, FileMode.Create))
{
DisplayPhotoPath.CopyTo(fs);
}
string SaveFilename = Path.Combine("Media\\User", filename);
profile.DisplayPhotoPath = SaveFilename;
}
else
{
profile.DisplayPhotoPath = profile.DisplayPhotoPath;
}
_profileRepo.Update(profile);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Edit(UpdateProfileViewModel model, HttpPostedFileBase file)
{
if (ModelState.IsValid)
{
var _user = await UserManager.FindByIdAsync(model.UserId);
if (_user == null)
{
ViewBag.success = "<ul><li><p style='color:red'>Error. Something went wrong, please try again.</p></li></ul>";
return(View(model));
}
//profile upload
if (file != null)
{
var supportedTypes = new[] { "jpg", "jpeg", "png", "gif" };
var fileExt = System.IO.Path.GetExtension(file.FileName).Substring(1);
if ((file.ContentLength / 1024 > 1024) || (!supportedTypes.Contains(fileExt)))
{
ViewBag.success = "<ul><li><p style='color:red'>Error: Only JPEG/PNG image smaller than 1MB is allowed.</p></li></ul>";
return(View(model));
}
else
{
var profileImage = Guid.NewGuid() + Path.GetExtension(file.FileName);
file.SaveAs(HttpContext.Server.MapPath("~/Content/images/tutor/") + profileImage);
_user.ProfileImage = profileImage;
}
}
_user.Title = model.Title;
_user.Gender = model.Gender;
_user.FirstName = model.FirstName;
_user.LastName = model.LastName;
_user.PhoneNumber = model.Mobile;
_user.Bio = model.Bio;
_user.Hobbies = model.Hobbies;
_user.Address = model.Address;
_user.City = model.City;
//_user.TimeZone = model.TimeZone;
_user.Country = model.Country;
_user.Zip = model.Zip;
//_user.DOB = DateTime.Now.AddYears(-29),
_user.UpdatedDate = DateTime.Now;
await UserManager.UpdateAsync(_user);
await this._tutorService.UpdateTutorAsync(new Tutors
{
Id = model.TutorId,
Experience = model.Experience,
NameOfSchool = model.GradeLevel,
PreviousSubjects = model.GradeLevel
});
ModelState.Clear();
ViewBag.success = "<ul><li><p style='color:green'>Profile has been updated successfully!! </p></li></ul>";
return(View(model));
}
return(View(model));
}
public async Task <IActionResult> UpdateUser(string username, UpdateProfileViewModel data)
{
var requestingUser = _tokenReaderService.GetTokenUsername(HttpContext.Request.Headers["Authorization"]);
var result = await _identityService.UpdateUserProfile(username, data, requestingUser);
return(Ok(result));
}
public async Task <IActionResult> UpdateSelfProfile(UpdateProfileViewModel data)
{
var username = _tokenReaderService.GetTokenUsername(HttpContext.Request.Headers["Authorization"]);
var response = await _identityService.UpdateUserProfile(username, data);
return(Ok(response));
}
public ActionResult UpdateProfile(UpdateProfileViewModel vm)
{
var UpdateProfile = new UpdateProfileViewModel();
return(View(UpdateProfile));
}
