public async Task <ActionResult> ManageProfile(ManageProfileViewModel model)
{
if (ModelState.IsValid)
{
var user = UserManager.FindById(User.Identity.GetUserId());
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.Birthday = model.Birthday;
user.City = model.City;
user.State = model.State;
user.IsPrivate = model.Private;
user.AllowsEmails = model.AllowEmails;
user.UserName = model.UserName;
user.Email = model.Email;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Manage"));
}
AddErrors(result);
}
return(View(model));
}
public async Task<ActionResult> Manage(ManageProfileViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
try
{
var user = await _userManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
user.UserName = model.UserName;
user.PhoneNumber = model.Phone;
uow.userRepository.Update(user);
uow.Save();
var result = await _userManager.ChangePasswordAsync(User.Identity.GetUserId(), model.OldPassword, model.NewPassword);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
return RedirectToAction("Index");
}
}
}
catch (Exception ex)
{
FileLogger.LogError(ex);
return View(model);
}
return View(model);
}
public async Task UpdateProfileAsync_ReturnsNotFound_WithUserManagerReturnsNull()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
mockUserManager.Setup(repo => repo.FindByNameAsync(It.IsAny <string>()))
.Returns(Task.FromResult <ApplicationUser>(null));
var controller = new ManageController(_mapper, _emailSender.Object, _urlService.Object, _logger.Object, mockUserManager.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = SharedFunctions.GetTestClaimsPrincipal("example name")
}
};
var model = new ManageProfileViewModel()
{
UserName = "", IsEmailConfirmed = true
};
// Act
var result = await controller.UpdateProfileAsync(model);
// Assert
var objectResult = Assert.IsType <NotFoundObjectResult>(result);
Assert.IsType <String>(objectResult.Value);
Assert.Equal("User not found", objectResult.Value);
}
public async Task UpdateProfileAsync_ReturnsBadRequestWithStringObject_WhenExceptionIsRaised()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
mockUserManager.Setup(repo => repo.FindByNameAsync(It.IsAny <string>()))
.ThrowsAsync(new InvalidOperationException());
var controller = new ManageController(_mapper, _emailSender.Object, _urlService.Object, _logger.Object, mockUserManager.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = SharedFunctions.GetTestClaimsPrincipal("example name")
}
};
var model = new ManageProfileViewModel()
{
UserName = "", IsEmailConfirmed = true
};
// Act
var result = await controller.UpdateProfileAsync(model);
// Assert
Assert.IsType <BadRequestObjectResult>(result);
var objectResult = result as ObjectResult;
Assert.Equal("There was an error updating the user", objectResult.Value);
}
public ActionResult Add()
{
// do not display the add page, if you're already registered
string name = User.Identity.Name;
if (SignedInUser.WindowsIdentity == name)
return RedirectToRoute(new {Controller = "Profile", Action = "edit"});
ViewBag.DisplayOption = "Add";
// Help with prefilling some fields....
name = name.Replace("\\", ","); // hack to change backslash to comma so that it can be split easily.
string fname = name.Split(',')[1].Split('.')[0];
string lname = name.Split(',')[1].Split('.')[1];
ManageProfileViewModel profileModel = new ManageProfileViewModel
{
FirstName = fname,
LastName = lname,
Emailaddress = name.Split(',')[1] + "@reedonline.co.uk"
};
ProfileViewModel seatingplanModel = employeeRepository.GetEmployeesByFloor();
ManageProfileSeatingPlanViewModel viewModel = new ManageProfileSeatingPlanViewModel
{
employeesByFloorModel = seatingplanModel,
manageProfileModel = profileModel
};
return View(PopulateDropdowns(viewModel));
}
// GET: Profile
public ActionResult Index()
{
ManageProfileViewModel currentUser = new ManageProfileViewModel {
currentUser = accountHelper.getCurrentUser(Session["User"].ToString())
};
account user = accountHelper.getCurrentUser(Session["User"].ToString());
int userId = user.id;
ViewBag.userName = user.name;
ViewBag.imagePath = user.imagePath;
return(View(currentUser));
}
public async Task<ActionResult> Manage()
{
var user = await _userManager.FindByIdAsync(User.Identity.GetUserId());
ManageProfileViewModel model = new ManageProfileViewModel
{
Email = user.Email,
UserName = user.UserName,
Phone = user.PhoneNumber
};
ViewBag.UserName = user.UserName;
ViewBag.ProfileImgUri = user.Resume?.ProfileImageUri;
ViewBag.NoOfAppliedJobs = user.jobApplications.Count();
ViewBag.NoOfFavourites = user.FavouriteJobs.Count();
return View(model);
}
public async Task UpdateProfileAsync_ReturnsBadRequestWithModelState_WhenSetEmailAysncResultNotSucceeded()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
var user = GetValidTestUser();
mockUserManager.Setup(repo => repo.FindByNameAsync(It.IsAny <string>()))
.ReturnsAsync(user);
//.Returns(Task.FromResult<ApplicationUser>(null));
mockUserManager.Setup(repo => repo.SetEmailAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.Returns(Task.FromResult(IdentityResult.Failed()));
var controller = new ManageController(_mapper, _emailSender.Object, _urlService.Object, _logger.Object, mockUserManager.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = SharedFunctions.GetTestClaimsPrincipal("example name")
}
};
var model = new ManageProfileViewModel()
{
UserName = "******", Email = "", IsEmailConfirmed = true
};
// Act
var result = await controller.UpdateProfileAsync(model);
// Assert
Assert.IsType <BadRequestObjectResult>(result);
var objectResult = result as ObjectResult;
Assert.NotNull(objectResult);
Assert.True(objectResult is BadRequestObjectResult);
Assert.Equal(StatusCodes.Status400BadRequest, objectResult.StatusCode);
var returnError = Assert.IsType <SerializableError>(objectResult.Value);
Assert.Single(returnError); //Assert.Equal(2, returnError.Count);
Assert.True(returnError.ContainsKey("Email"));
var values = returnError["Email"] as String[];
Assert.True(values[0] == $"Unexpected error occurred setting email for user with ID '{user.Id}'.");
}
public async Task UpdateProfileAsync_ReturnsBadRequestWithModelState_WhenUsernameIsAlreadyInUse()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
mockUserManager.Setup(repo => repo.FindByNameAsync(It.IsAny <string>()))
.ReturnsAsync(GetValidTestUser());
var controller = new ManageController(_mapper, _emailSender.Object, _urlService.Object, _logger.Object, mockUserManager.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = SharedFunctions.GetTestClaimsPrincipal("example name")
}
};
// model username IS the same as GetValidTestUser username
var model = new ManageProfileViewModel()
{
UserName = "******", IsEmailConfirmed = true
};
// Act
var result = await controller.UpdateProfileAsync(model);
// Assert
Assert.IsType <BadRequestObjectResult>(result);
var objectResult = result as ObjectResult;
Assert.NotNull(objectResult);
Assert.True(objectResult is BadRequestObjectResult);
Assert.Equal(StatusCodes.Status400BadRequest, objectResult.StatusCode);
//Assert.IsType<String>(objectResult.Value);
// Assert
var returnError = Assert.IsType <SerializableError>(objectResult.Value);
Assert.Single(returnError); //Assert.Equal(2, returnError.Count);
Assert.True(returnError.ContainsKey("Username"));
var values = returnError["Username"] as String[];
Assert.True(values[0] == $"Username '{model.UserName}' is already taken.");
}
public async Task UpdateProfileAsync_ReturnsOkObject_WhenSuccessful()
{
// Arrange
var mockUserManager = SharedFunctions.InitialiseMockUserManager();
mockUserManager.SetupSequence(repo => repo.FindByNameAsync(It.IsAny <string>()))
.ReturnsAsync(GetValidTestUser)
.Returns(Task.FromResult <ApplicationUser>(null));
mockUserManager.Setup(repo => repo.SetUserNameAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.Returns(Task.FromResult(IdentityResult.Success));
mockUserManager.Setup(repo => repo.SetEmailAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.Returns(Task.FromResult(IdentityResult.Success));
mockUserManager.Setup(repo => repo.GenerateEmailConfirmationTokenAsync(It.IsAny <ApplicationUser>()))
.Returns(Task.FromResult(It.IsAny <string>()));
mockUserManager.Setup(repo => repo.UpdateAsync(It.IsAny <ApplicationUser>()))
.Returns(Task.FromResult(IdentityResult.Success));
var controller = new ManageController(_mapper, _emailSender.Object, _urlService.Object, _logger.Object, mockUserManager.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = SharedFunctions.GetTestClaimsPrincipal("example name")
}
};
var model = new ManageProfileViewModel()
{
UserName = "******", Email = "", IsEmailConfirmed = true
};
// Act
var result = await controller.UpdateProfileAsync(model);
// Assert
var objectResult = Assert.IsType <OkObjectResult>(result);
Assert.NotNull(objectResult);
Assert.True(objectResult is OkObjectResult);
Assert.Equal(StatusCodes.Status200OK, objectResult.StatusCode);
var returnObject = Assert.IsType <ManageProfileViewModel>(objectResult.Value);
Assert.Equal(model, returnObject);
}
public ActionResult ManageProfile()
{
ManageProfileViewModel model = new ManageProfileViewModel();
model.Member = new Member(Members.GetCurrentMember());
DataManager dm = new DataManager();
try
{
model.IsSubscribedToMailingList = Task.Run(() => dm.IsUserSubscribedToMailChimpList(MailChimpListIds.MailingList, model.Member.Email)).Result;
model.IsSubscribedToMemberList = Task.Run(() => dm.IsUserSubscribedToMailChimpList(MailChimpListIds.Membership, model.Member.Email)).Result;
}
catch (Exception ex)
{
_log.Error("Error fetching mailchimp subscription information", ex);
}
return(PartialView("ManageProfile", model));
}
public SettingsController(ISettingsService settingsService,
ICalendarController calendarController,
SettingsViewModel settingsViewModel,
Lazy <CalendarViewModel> calendarViewModelLazy,
Lazy <ManageProfileViewModel> manageProfileViewModelLazy,
Lazy <TaskViewModel> taskViewModelLazy,
Lazy <AppSettingsViewModel> appSettingsViewModelLazy)
{
_calendarController = calendarController;
_settingsViewModel = settingsViewModel;
_calendarViewModel = calendarViewModelLazy.Value;
_taskViewModel = taskViewModelLazy.Value;
_manageProfileViewModel = manageProfileViewModelLazy.Value;
_appSettingsViewModel = appSettingsViewModelLazy.Value;
settingsService.TaskView = _taskViewModel.View;
settingsService.CalendarView = _calendarViewModel.View;
settingsService.ManageProfilesView = _manageProfileViewModel.View;
settingsService.AppSettingsView = _appSettingsViewModel.View;
}
public async Task <ActionResult> ManageProfile()
{
var userId = User.Identity.GetUserId();
var um = UserManager.FindById(userId);
var model = new ManageProfileViewModel
{
Email = await UserManager.GetEmailAsync(userId),
UserName = User.Identity.GetUserName(),
FirstName = um.FirstName,
LastName = um.LastName,
Birthday = um.Birthday,
City = um.City,
State = um.State,
Private = um.IsPrivate,
AllowEmails = um.AllowsEmails
};
return(View(model));
}
public async Task <ActionResult> ManageProfile()
{
// get current user details
var user = await UserManager.FindByNameAsync(User.Identity.Name);
if (user == null) // user not found
{
return(HttpNotFound());
}
// get user to edit
var editUser = new ManageProfileViewModel()
{
Id = user.Id,
Initials = user.Intials,
Title = user.Title,
Surname = user.Surname,
HasPicture = user.Picture == null ? false : true
};
editUser.TitleSelectList = new SelectList(GetTitles(), "TitleID", "TitleID", (user.Title == null ? "0" : user.Title.TitleID));
return(View(editUser));
}
public IActionResult ManageProfile()
{
var user = _userService.GetByMail(User.Claims.SingleOrDefault(c => c.Type == ClaimTypes.Email).Value);
var model = new ManageProfileViewModel
{
User = user.Data,
GenderNamesSelectItems = new List <SelectListItem>()
};
foreach (var gender in _genderDal.GetList())
{
model.GenderNamesSelectItems.Add(new SelectListItem
{
Text = gender.GenderName,
Value = gender.GenderId.ToString()
});
}
model.GenderNamesSelectItems.SingleOrDefault(g => g.Value.Equals(user.Data.GenderId.ToString())).Selected = true;
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync()
{
ManageProfileViewModel model = new ManageProfileViewModel();
ApplicationUser user = await _UserManager.GetUserAsync(UserClaimsPrincipal);
model.User = new ManageUserProfileViewModel()
{
UserID = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
PictureUrl = user.PictureUrl,
PhoneNumber = user.PhoneNumber,
Address = user.Address,
Email = user.Email,
Suburb = user.Suburb,
ZipCode = user.ZipCode,
Unit = user.Unit,
};
model.ChangePasswordViewModel = new ChangePasswordViewModel();
return(View(model));
}
public async Task <IActionResult> UpdateProfileAsync(ManageProfileViewModel model)
{
try
{
var user = await _userManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
_logger.LogError(LoggingEvents.GetItemNotFound, "GetUserProfileAsync");
return(NotFound("User not found"));
}
var userName = user.UserName;
if (model.UserName != userName)
{
if (await _userManager.FindByNameAsync(model.UserName) != null)
{
ModelState.AddModelError("Username", $"Username '{model.UserName}' is already taken.");
return(BadRequest(ModelState));
}
var setUserNameResult = await _userManager.SetUserNameAsync(user, model.UserName);
if (!setUserNameResult.Succeeded)
{
ModelState.AddModelError("Username", $"Unexpected error occurred setting username for user with ID '{user.Id}'.");
return(BadRequest(ModelState));
}
// Save Avatar with new username ========> use user id instead
//
//var file = await _fileClient.GetFile(StorageContainers.Avatar, userName);
//if (file != null)
//{
// await _fileClient.SaveFile(StorageContainers.Avatar, model.UserName, file);
// await file.DisposeAsync();
// await _fileClient.DeleteFile(StorageContainers.Avatar, userName);
//}
//var avatarUrl = await _fileClient.GetFileUrl(StorageContainers.Avatar, model.UserName);
//if (string.IsNullOrEmpty(avatarUrl))
//{
// avatarUrl = "https://img.icons8.com/color/96/000000/user.png";
//}
//user.Avatar = avatarUrl;
}
var email = user.Email;
if (model.Email != email)
{
var setEmailResult = await _userManager.SetEmailAsync(user, model.Email);
if (!setEmailResult.Succeeded)
{
ModelState.AddModelError("Email", $"Unexpected error occurred setting email for user with ID '{user.Id}'.");
return(BadRequest(ModelState));
}
else
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var url = _urlService.GetConfirmEmailUrl(model.UserName, code);
var templateData = new { username = user.UserName, url = url };
await _emailSender.SendTemplateEmail("d-fc1571171e23463bb311870984664506", model.Email, templateData);
}
}
var update = await _userManager.UpdateAsync(user);
if (!update.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting the location for user with ID '{user.Id}'.");
}
return(Ok(model));
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.UpdateItemNotFound, ex, "GetUserProfileAsync");
return(BadRequest("There was an error updating the user"));
}
}
public async Task <ActionResult> ManageProfile([Bind(Include = "ProfileImage,Id,Initials,Title,Surname,HasPicture")] ManageProfileViewModel model)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(model.Id);
// user not found
if (user == null)
{
return(HttpNotFound());
}
if (User.Identity.Name.Equals(user.UserName)) // the rightful user
{
#region get profile image
// fill in the product image
if (model.ProfileImage != null)
{
// get image
byte[] thumbnailImage = null;
try
{
System.Drawing.Image originalImage = System.Drawing.Image.FromStream(model.ProfileImage.InputStream);
System.Drawing.Image.GetThumbnailImageAbort callback = new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallBack);
System.Drawing.Image thumbNailImg = originalImage.GetThumbnailImage(100, 100, callback, IntPtr.Zero);
// get small image
MemoryStream ms2 = new MemoryStream();
thumbNailImg.Save(ms2, ImageFormat.Png);
thumbnailImage = ms2.ToArray();
ms2.Dispose();
// free memory
thumbNailImg.Dispose();
originalImage.Dispose();
}
catch (Exception e)
{
Trace.WriteLine(e.Message, "Profile Image Creation");
}
user.Picture = thumbnailImage;
}
#endregion
#region edit user
// set text info to be able to capitalize the product name
TextInfo ti = CultureInfo.CurrentCulture.TextInfo;
// get title
var title = await db.Titles.FindAsync(model.Title.TitleID);
// modify user details
user.Surname = ti.ToTitleCase(model.Surname);
user.Title = title;
user.Intials = ti.ToUpper(model.Initials);
// save changes
IdentityResult result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
// set users session info
SetCurrentUserSessionInfo(Request, Session);
return(RedirectToAction("Manage", new { Message = ManageMessageId.ProfileSaved }));
}
else
{
AddErrors(result);
}
#endregion
}
else // not actual user
{
return(new HttpStatusCodeResult(HttpStatusCode.Forbidden));
}
}
model.TitleSelectList = new SelectList(GetTitles(), "TitleID", "TitleID", (model.Title == null ? "0" : model.Title.TitleID));
return(View(model)); // something went wrong, redisplay the edit form
}
public async Task <IActionResult> ManageProfile(ManageProfileViewModel manageProfileViewModel)
{
var user = _userService.GetByMail(User.Claims.SingleOrDefault(c => c.Type == ClaimTypes.Email).Value);
var model = new ManageProfileViewModel
{
User = user.Data,
GenderNamesSelectItems = new List <SelectListItem>()
};
foreach (var gender in _genderDal.GetList())
{
model.GenderNamesSelectItems.Add(new SelectListItem
{
Text = gender.GenderName,
Value = gender.GenderId.ToString()
});
}
model.GenderNamesSelectItems.SingleOrDefault(g => g.Value.Equals(user.Data.GenderId.ToString())).Selected = true;
if (!ModelState.IsValid)
{
return(View(model));
}
user.Data.FirstName = manageProfileViewModel.User.FirstName;
user.Data.LastName = manageProfileViewModel.User.LastName;
user.Data.PhoneNumber = manageProfileViewModel.User.PhoneNumber;
user.Data.GenderId = manageProfileViewModel.User.GenderId;
var result = _userService.Update(user.Data);
if (!result.Success)
{
TempData.Add(TempDataTypes.ManageUpdateError, result.Message);
return(View(model));
}
await HttpContext.SignOutAsync();
var roles = _userService.GetRoles(user.Data);
var claims = new List <Claim>
{
new Claim(ClaimTypes.Email, user.Data.Email),
new Claim(ClaimTypes.Name, user.Data.FirstName + " " + user.Data.LastName)
};
foreach (var role in roles.Data)
{
claims.Add(new Claim(ClaimTypes.Role, role.RoleName));
}
var userIdentity = new ClaimsIdentity(claims, "login");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
await HttpContext.SignInAsync(principal);
TempData.Add(TempDataTypes.ManageInfo, Messages.UserUpdatedSuccessfully);
return(RedirectToAction("Manage", "Account"));
}
public ActionResult SubmitManageProfileForm(ManageProfileViewModel model)
{
if (ModelState.IsValid)
{
//No user id was passed in
if (model.Member.Id == 0)
{
_log.Error("No user id we submitted to the SubmitManageProfileForm on the Membership surface controller");
ModelState.AddModelError("", "We could not find a user with that id to update");
return(CurrentUmbracoPage());
}
var memberService = Services.MemberService;
var member = memberService.GetById(model.Member.Id);
//couldnt find member
if (member == null)
{
_log.Warn("There was a post to the SubmitManageProfileForm function but we cuold not find the member associated with this post");
ModelState.AddModelError("", "We could not find a user with that id to update");
return(CurrentUmbracoPage());
}
//update email if email is different
if (model.Member.Email != member.Email)
{
//check if the new email already exists in the system
if (memberService.GetByEmail(model.Member.Email) != null)
{
ModelState.AddModelError("Email", "This email address already exists in the system and emails must be unique.");
return(CurrentUmbracoPage());
}
}
try
{
DataManager dm = new DataManager();
dm.AddOrUpdateMember(model.Member);
//mailing list subscribe
if (model.IsSubscribedToMailingList)
{
Task.Run(
() =>
dm.AddOrUpdateUserToMailChimpList(MailChimpListIds.MailingList, model.Member.Email,
model.Member.FirstName, model.Member.LastName));
}
else
{
var mailingListMember = Task.Run(() => dm.IsUserSubscribedToMailChimpList(MailChimpListIds.MailingList, model.Member.Email)).Result;
if (mailingListMember)
{
Task.Run(
() =>
dm.AddOrUpdateUserToMailChimpList(MailChimpListIds.MailingList, model.Member.Email,
model.Member.FirstName, model.Member.LastName, true));
}
}
//members mailing list subscribe
if (model.IsSubscribedToMailingList)
{
Task.Run(
() =>
dm.AddOrUpdateUserToMailChimpList(MailChimpListIds.Membership, model.Member.Email,
model.Member.FirstName, model.Member.LastName));
}
else
{
var memberListMember = Task.Run(() => dm.IsUserSubscribedToMailChimpList(MailChimpListIds.Membership, model.Member.Email)).Result;
if (memberListMember)
{
Task.Run(
() =>
dm.AddOrUpdateUserToMailChimpList(MailChimpListIds.Membership, model.Member.Email,
model.Member.FirstName, model.Member.LastName, true));
}
}
}
catch (Exception ex)
{
_log.Error("There was an error updating a profile with the exception as follows", ex);
ModelState.AddModelError("", "There was an error updating your profile. Give us a shout if this keeps happening and we will find out whats going on");
}
if (ModelState.IsValid)
{
TempData["Message"] = "You have successfully updated your profile. Woohooo!";
return(RedirectToCurrentUmbracoPage());
}
}
return(CurrentUmbracoPage());
}
public ActionResult Edit()
{
var model = new ManageProfileViewModel();
var windowsIdentity = System.Web.HttpContext.Current.User.Identity.Name;
var profile = GetProfileByWindowsIdentity(windowsIdentity);
if (profile == null)
{
TempData["Message"] = "User does not exist";
RedirectToAction("index", "home");
}
else
{
model.ToModel(profile);
ViewBag.DisplayOption = "Edit";
}
ProfileViewModel seatingplanModel = employeeRepository.GetEmployeesByFloor();
ManageProfileSeatingPlanViewModel viewModel = new ManageProfileSeatingPlanViewModel
{
employeesByFloorModel = seatingplanModel,
manageProfileModel = model
};
return View("Add", PopulateDropdowns(viewModel));
}
public ActionResult View(int profileId)
{
EmployeeProfile profile = employeeRepository.GetProfile(profileId);
if (profile == null)
{
TempData["Message"] = "User does not exist";
RedirectToAction("index", "home");
}
var model = new ManageProfileViewModel();
model.ToModel(profile);
ViewBag.Id = Session["SignedInUser"];
return View(model);
}
