private bool ValidateUser(EditViewModel userToSave)
{
//Change the validateUser to the DBContext, this validation must be done in that layer.
//and what about the Validateuser on the Edit section, this always will be return a duplicated username!! IMPORTANT!!
var isValid = usersRepository.FindUser(userToSave.Username) == null? true : false;
if (!isValid) { ModelState.AddModelError("Username", "Duplicated Username"); }
return isValid;
}
public ActionResult Save(EditViewModel userToSave)
{
if (ModelState.IsValid && ValidateUser(userToSave))
{
usersRepository.SaveUser(userToSave.ConvertEditViewModelToUser(rolesRepository));
return RedirectToAction("List");
}
else
{
return View("Edit");
}
}
public async Task <ActionResult> EditUser(EditViewModel model, string redirectUrl)
{
if (!ModelState.IsValid)
{
RedirectToLocal(Url.Action("EditUser", "User", new { id = model.Id }));
}
var result = await userService.UpdateUserAsync(model);
if (!result)
{
ModelState.AddModelError(string.Empty, "The user cannot be Update");
model.listCountries = await userService.GetCountriesAsync(string.Empty);
model.listCities = await userService.GetCitiesAsync(1, string.Empty);
return(View(model));
}
return(RedirectToLocal(redirectUrl));
}
public async Task <IActionResult> Edit()
{
if (_session.GetInt32("CustomerId") == null)
{
return(RedirectToAction("Login", "Account", new { returnUrl = "/Account/Edit" }));
}
var CustomerId = _session.GetInt32("CustomerId").Value;
var customer = await _customerService.GetCustomerById(CustomerId);
var model = new EditViewModel
{
CustomerAddress = customer.CustomerAddress,
CustomerFullname = customer.CustomerFullname,
CustomerPassword = customer.CustomerPassword,
CustomerPhone = customer.CustomerPhone,
CustomerEmail = customer.CustomerEmail
};
return(View(model));
}
public async Task <IActionResult> Edit(EditViewModel model)
{
var currentOsiguranje = _db.Osiguranje.SingleOrDefault(o => o.IdOsiguranja == model.Osiguranje.IdOsiguranja);
if (ModelState.IsValid)
{
Osiguranje osiguranje;
if (model.Osiguranje.IdOsiguranja > 0)
{
osiguranje = _db.Osiguranje.SingleOrDefault(o => o.IdOsiguranja == model.Osiguranje.IdOsiguranja);
if (osiguranje == null)
{
return(BadRequest());
}
}
else
{
osiguranje = new Osiguranje();
}
osiguranje.IdOsiguranja = model.Osiguranje.IdOsiguranja;
osiguranje.Tip = model.Osiguranje.Tip;
osiguranje.Trajanje = model.Osiguranje.Trajanje;
await _db.SaveChangesAsync();
ModelState.Clear();
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(new EditViewModel()
{
Osiguranje = currentOsiguranje
}));
}
}
public async Task <IActionResult> Edit(EditViewModel model)
{
var currentUser = _db.User.SingleOrDefault(u => u.Id == model.User.Id);
if (ModelState.IsValid)
{
User user;
if (model.User.Id != "")
{
user = _db.User.SingleOrDefault(u => u.Id == model.User.Id);
if (user == null)
{
return(BadRequest());
}
}
else
{
user = new User();
}
user.UserName = model.User.UserName;
user.PhoneNumber = model.User.PhoneNumber;
user.Email = model.User.Email;
await _db.SaveChangesAsync();
ModelState.Clear();
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(new EditViewModel()
{
User = currentUser
}));
}
}
public async Task <IActionResult> Edit(string @class, string student, string teacher)
{
TimetableKind kind = TimetableKind.Class;
string element = "";
if (!string.IsNullOrWhiteSpace(@class))
{
kind = TimetableKind.Class;
element = @class;
}
else if (!string.IsNullOrWhiteSpace(teacher))
{
kind = TimetableKind.Teacher;
element = teacher;
}
else if (!string.IsNullOrWhiteSpace(student))
{
kind = TimetableKind.Student;
element = student;
}
TimetableLoader timetable = new TimetableLoader(kind, element);
var lessons = await timetable.LoadAsync();
var lessonVMs = new List <LessonViewModel>();
foreach (var lesson in lessons)
{
var classVMs = new List <ClassViewModel>();
foreach (var _class in lesson.Classes)
{
classVMs.Add(new ClassViewModel(_class.Name, _class.Teacher, _class.Room));
}
lessonVMs.Add(new LessonViewModel(lesson.DayOfWeek, lesson.Period, lesson.Duration, lesson.Name, kind == TimetableKind.Teacher ? lesson.SchoolClass : lesson.Teacher, lesson.Room, lesson.Color, lesson.Week, classVMs));
}
var viewModel = new EditViewModel(kind, element, lessonVMs);
return(View(viewModel));
}
public IActionResult Edit([FromBody] EditViewModel userEditView)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
string id = User.FindFirstValue(ClaimTypes.NameIdentifier);
string role = User.FindFirstValue(ClaimTypes.Role);
if (userEditView == null || (userEditView.Id.ToString() != id && role != "Admin"))
{
return(BadRequest("Editing data is incorrect"));
}
IEnumerable <User> users = _repoWrapper.User
.FindByCondition(u => u.Id == userEditView.Id || u.Email == userEditView.Email)
.ToList();
if (users == null)
{
return(NotFound());
}
if (users.Count() != 1)
{
return(BadRequest("Email alredy exist!"));
}
User user = users.First();
var mapper = new Mapper(new MapperConfiguration(cfg =>
cfg.CreateMap <EditViewModel, User>()));
User userEdit = mapper.Map <EditViewModel, User>(userEditView);
userEdit.Password = user.Password;
userEdit.Role = user.Role;
_repoWrapper.User.Update(userEdit);
_repoWrapper.Save();
return(Ok(new { Success = true }));
}
public async Task Edit_Get()
{
var branch = new Branch
{
Id = 1,
Name = "name",
Address = "address"
};
var returnUrl = "/";
var expectedVm = new EditViewModel
{
EditorMode = EditorMode.Update,
Id = branch.Id,
Name = branch.Name,
Address = branch.Address,
ReturnUrl = returnUrl
};
var context = MakeContext();
await context.BranchesDao.CreateAsync(branch);
var controller = new BranchesController(context.BranchesDao)
{
TempData = context.TempDataDictionary,
ControllerContext = context.ControllerContext
};
var r = await controller.Edit(branch.Id, returnUrl) as ViewResult;
Assert.NotNull(r);
Assert.Null(r.ViewName);
var vm = r.Model as EditViewModel;
Assert.NotNull(vm);
Assert.Equal(expectedVm.EditorMode, vm.EditorMode);
Assert.Equal(expectedVm.Id, vm.Id);
Assert.Equal(expectedVm.Name, vm.Name);
Assert.Equal(expectedVm.Address, vm.Address);
Assert.Equal(expectedVm.ReturnUrl, vm.ReturnUrl);
}
public ActionResult Edit(EditViewModel vmEdit)
{
try
{
if (!ModelState.IsValid)
{
TempData["ErrorMessage"] = "Problem editing record. Try again.";
return(RedirectToAction("Index", "AccountTransaction"));
}
// transfer vm to bm
var bmAssetTransaction = new Business.Models.AccountTransaction()
{
AssetTransactionId = vmEdit.Id,
AssetId = vmEdit.AssetId,
TransactionTypeId = DataTypeUtility.GetIntegerFromString(vmEdit.SelectedTransactionTypeId),
TransactionCategoryId = DataTypeUtility.GetIntegerFromString(vmEdit.SelectedTransactionCategoryId),
CheckNumber = vmEdit.CheckNumber,
DueDate = Convert.ToDateTime(vmEdit.DueDate),
ClearDate = Convert.ToDateTime(vmEdit.ClearDate),
Amount = vmEdit.Amount,
Note = vmEdit.Note,
};
// update db
if (!_businessService.AccountTransactionService.UpdateTransaction(bmAssetTransaction))
{
ViewData["ErrorMessage"] = "Problem updating record";
return(View("Edit", vmEdit));
}
TempData["SuccessMessage"] = "Record updated";
return(RedirectToAction("Details", "Account", new { id = vmEdit.AssetId }));
}
catch (Exception)
{
TempData["ErrorMessage"] = "Encountered Problem";
return(RedirectToAction("Index", "AccountTransaction"));
}
}
public IActionResult CreateNewTimeCard(EditViewModel editModel)
{
TblTempTimecards tempTableTimeCard = new TblTempTimecards();
// Get current time id
var tempLastId = context.TblTempTimecards.Select(x => x.TimeId).LastOrDefault();
var liveLastId = context.TblTimecards.Select(x => x.TimeId).LastOrDefault();
int currentTimeId = Math.Max(tempLastId, liveLastId) + 1;
// Get current pay period id
var activePayPeriod = context.TblTimecardHeader.Where(x => x.Validated == false).Select(x => x.TimePeriodId).FirstOrDefault();
// Create tempTimeCard
tempTableTimeCard.EmployeeId = (int)HttpContext.Session.GetInt32("EmpID");
tempTableTimeCard.TimeId = currentTimeId;
tempTableTimeCard.TimePeriodId = activePayPeriod;
tempTableTimeCard.TimeDate = editModel.TimeCard.TimeDate;
tempTableTimeCard.ProjectId = editModel.TimeCard.ProjectId;
tempTableTimeCard.SpecId = editModel.TimeCard.SpecId;
tempTableTimeCard.HourType = editModel.TimeCard.HourType;
tempTableTimeCard.HourTime = editModel.TimeCard.HourTime;
tempTableTimeCard.CreatedDate = DateTime.UtcNow;
tempTableTimeCard.Add = true;
tempTableTimeCard.Edit = false;
tempTableTimeCard.Delete = false;
// Add tempTimeCard to database
try
{
context.TblTempTimecards.Add(tempTableTimeCard);
context.SaveChanges();
}
catch (Exception ex)
{
}
// Return to Index view, with add confirmation box
return(RedirectToAction("Index", new { actionDone = "add" }));
}
public async Task <IActionResult> Edit(string id, EditViewModel vm)
{
if (!ModelState.IsValid)
{
return(View());
}
var employee = await _applicationUser.GetEmployeeById(id);
if (employee == null)
{
return(View());
}
employee.FirstName = vm.FirstName;
employee.LastName = vm.LastName;
employee.Email = vm.Email;
employee.PhoneNumber = vm.PhoneNumber;
employee.Address = vm.Address;
employee.BirthDate = vm.BirthDate;
employee.Gender = vm.Gender;
employee.MaritalStatus = vm.MaritalStatus;
employee.NumberOfChildren = vm.NumberOfChildren;
employee.Active = vm.Active;
employee.Department = vm.Department;
employee.Position = vm.Position;
employee.LastSchoolAttended = vm.LastSchoolAttended;
employee.HighestQualification = vm.HighestQualification;
employee.DateJoined = vm.DateJoined;
employee.ContractExpirationDate = vm.ContractExpirationDate;
employee.YearsOfService = vm.YearsOfService;
employee.MonthsOfService = vm.MonthsOfService;
employee.DaysOfService = vm.DaysOfService;
employee.LastDateOfPromotion = vm.LastDateOfPromotion;
employee.AnnualSalary = vm.AnnualSalary;
await _applicationUser.UpdateEmployee(employee);
return(RedirectToAction("Detail", new { id = employee.Id }));
}
public async Task <ActionResult <EditViewModel> > UpdatePost(EditViewModel editViewModel, ClaimsPrincipal claimsPrincipal)
{
var post = postService.GetPost(editViewModel.Post.Id);
if (post is null)
{
return(new NotFoundResult());
}
var authorizationResult = await authorizationService.AuthorizeAsync(claimsPrincipal, post, Operations.Update);
if (!authorizationResult.Succeeded)
{
return(DetermineActionResult(claimsPrincipal));
}
post.Published = editViewModel.Post.Published;
post.Title = editViewModel.Post.Title;
post.Description = editViewModel.Post.Description;
post.Content = editViewModel.Post.Content;
post.UpdatedOn = DateTime.Now;
if (editViewModel.HeaderImage != null)
{
string webRootPath = webHostEnvironment.WebRootPath;
string pathToImage = $@"{webRootPath}\UserFiles\Posts\{post.Id}\HeaderImage.jpg";
EnsureFolder(pathToImage);
using (var fileStream = new FileStream(pathToImage, FileMode.Create))
{
await editViewModel.HeaderImage.CopyToAsync(fileStream);
}
}
return(new EditViewModel
{
Post = await postService.Update(post)
});
}
public ActionResult EditProfil(EditViewModel edit)
{
var UserId = User.Identity.GetUserId();
var current = db.Users.Where(a => a.Id == UserId).SingleOrDefault();
if (!UserManager.CheckPassword(current, edit.EncienPassword))
{
ViewBag.Message = "Mot de passe Incorrect";
}
else
{
var newp = UserManager.PasswordHasher.HashPassword(edit.NewPassword);
current.UserName = edit.UserName;
current.Email = edit.Email;
current.PasswordHash = newp;
db.Entry(current).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
ViewBag.Message = "L'operation reusit";
}
return(View());
}
public IActionResult Edit(EditViewModel model)
{
if (ModelState.IsValid)
{
var user = _context.Users
.Include(u => u.Department)
.Single(u => u.Id == _userManager.GetUserId(User));
if (user.DepartmentId != model.DepartmentId)
{
var prevDepartment = user.Department; // remove user from this
prevDepartment.Users.Remove(user);
var newDepartment = _context.Department.Single(d => d.DepartmentId == model.DepartmentId);
user.DepartmentId = model.DepartmentId;
user.Department = newDepartment;
if (newDepartment.Users == null)
{
newDepartment.Users = new List <ApplicationUser>();
}
newDepartment.Users.Add(user);
_context.Update(prevDepartment);
_context.Update(newDepartment);
}
// update the FullName for both Teachers and Printers
user.FullName = model.FullName;
_context.Update(user);
_context.SaveChanges();
return(RedirectToAction("Index", new { Message = ManageMessageId.EditSuccess }));
}
// If we got this far, something failed, redisplay form
return(RedirectToAction("Edit"));
}
public IActionResult Delete(EditViewModel editViewModel)
{
int numId = CommonUtil.ConvAcceptId(editViewModel.Id);
if (numId == -1)
{
return(View(ErrorPath, new ErrorViewModel {
RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier
}));
}
var ret = _service.DeleteDiary(numId);
if (!ret)
{
TempData["notification"] = DeleteFailMessage;
return(RedirectToAction("Index", "Menu"));
}
TempData["notification"] = DeleteOkMessage;
return(RedirectToAction("Index", "Menu"));
}
public override void EstablishContext()
{
base.EstablishContext();
viewModel = new EditViewModel() {
FirstName = "first",
LastName = "last",
Username = "******",
Email = "*****@*****.**",
IsLocked = !isLocked,
IsApproved = !isApproved,
Id = user.Id,
Roles = new int[] { adminRole.Id, officerRole.Id },
Version = DomainModelHelper.ConvertIntVersionToString(1),
Password = "******",
ConfirmPassword = "******"
};
user.IsLocked = isLocked;
user.IsApproved = isApproved;
membershipService.Setup(s => s.EncodePassword(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((password, salt) => password);
}
public EditViewModel<TaskPriority> GetTaskPriority(int id)
{
var result = new EditViewModel<TaskPriority>();
result.Item = _adminRepo.FindTaskPriority(id) ?? new TaskPriority();
return result;
}
public EditViewModel<TaskType> GetTaskType(int taskTypeID)
{
var result = new EditViewModel<TaskType>();
result.Item = _adminRepo.FindTaskType(taskTypeID) ?? new TaskType();
return result;
}
public static EditViewModel ConvertToEditViewModel(this User users)
{
EditViewModel vmodel = new EditViewModel { UserID = users.UserID, Username = users.Username, Password = users.Password, Name = users.Name, Role = users.Role.RoleName, Email = users.Email };
if (users.Role.RoleName == "Pricer") { vmodel.PPCredentials = users.PPCredentials; }
return vmodel;
}
public ActionResult New()
{
EditViewModel vmodel = new EditViewModel();
ViewBag.Title = "Create New User";
return View("Edit", vmodel);
}
private EditViewModel BuildEditViewModel(User user, ClubPoolPrincipal currentPrincipal)
{
var model = new EditViewModel {
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
IsApproved = user.IsApproved,
IsLocked = user.IsLocked,
Username = user.Username,
Version = user.EncodedVersion,
Roles = user.Roles.Select(r => r.Id).ToArray()
};
model.ShowStatus = CanEditUserStatus(currentPrincipal, user);
model.ShowRoles = CanEditUserRoles(currentPrincipal, user);
if (model.ShowRoles) {
model.AvailableRoles = repository.All<Role>().Select(r => new RoleViewModel { Id = r.Id, Name = r.Name }).ToList();
}
model.ShowPassword = CanEditUserPassword(currentPrincipal, user);
return model;
}
public ActionResult Edit(EditViewModel viewModel)
{
var authTicketChanged = false;
var previousUsername = "";
try {
var user = repository.Get<User>(viewModel.Id);
if (null == user) {
return ErrorView("The user you were editing was deleted by another user");
}
if (viewModel.Version != user.EncodedVersion) {
return EditRedirectForConcurrency(viewModel.Id);
}
var currentPrincipal = authenticationService.GetCurrentPrincipal();
if (!CanEditUser(currentPrincipal, user)) {
return ErrorView("You are not authorized to edit this user");
}
if (!ModelState.IsValid) {
return View(viewModel);
}
var canEditStatus = CanEditUserStatus(currentPrincipal, user);
var canEditRoles = CanEditUserRoles(currentPrincipal, user);
var canEditPassword = CanEditUserPassword(currentPrincipal, user);
previousUsername = user.Username;
if (!TryUpdateUser(user, viewModel, canEditStatus, canEditRoles, canEditPassword)) {
viewModel.ShowStatus = canEditStatus;
viewModel.ShowRoles = canEditRoles;
if (canEditRoles) {
viewModel.AvailableRoles = repository.All<Role>().Select(r => new RoleViewModel { Id = r.Id, Name = r.Name }).ToList();
}
viewModel.ShowPassword = canEditPassword;
return View(viewModel);
}
try {
repository.SaveChanges();
}
catch (UpdateConcurrencyException) {
return EditRedirectForConcurrency(viewModel.Id);
}
TempData[GlobalViewDataProperty.PageNotificationMessage] = "The user was updated successfully";
if (currentPrincipal.UserId == user.Id && previousUsername != user.Username) {
// if editing self and updating the username, we must update the auth ticket
// using LogIn to do this will reset the persistent cookie
// setting to false, which is not ideal but the other way
// would be more complicated than its worth
authenticationService.LogIn(user.Username, false);
authTicketChanged = true;
}
return RedirectToAction("Edit", new { id = viewModel.Id });
}
catch (Exception) {
// revert new auth ticket, if set
if (authTicketChanged) {
authenticationService.LogIn(previousUsername, false);
}
throw;
}
}
private bool TryUpdateUser(User user, EditViewModel viewModel, bool canEditStatus, bool canEditRoles, bool canEditPassword)
{
if (!user.Username.Equals(viewModel.Username)) {
// verify that the new username is not in use
if (membershipService.UsernameIsInUse(viewModel.Username)) {
ModelState.AddModelErrorFor<EditViewModel>(m => m.Username, "The username is already in use");
return false;
}
user.Username = viewModel.Username;
}
if (!user.Email.Equals(viewModel.Email)) {
// verify that the new email is not in use
if (membershipService.EmailIsInUse(viewModel.Email)) {
ModelState.AddModelErrorFor<EditViewModel>(m => m.Email, "The email address is already in use");
return false;
}
user.Email = viewModel.Email;
}
user.FirstName = viewModel.FirstName;
user.LastName = viewModel.LastName;
if (canEditStatus) {
user.IsApproved = viewModel.IsApproved;
user.IsLocked = viewModel.IsLocked;
}
if (canEditRoles) {
user.RemoveAllRoles();
if (null != viewModel.Roles && viewModel.Roles.Length > 0) {
foreach (int roleId in viewModel.Roles) {
user.AddRole(repository.Get<Role>(roleId));
}
}
}
if (canEditPassword && null != viewModel.Password && !string.IsNullOrEmpty(viewModel.Password.Trim())) {
user.Password = membershipService.EncodePassword(viewModel.Password, user.PasswordSalt);
}
return true;
}
public ActionResult Edit(EditViewModel editViewModel)
{
if (editViewModel == null)
{
throw new HttpException(400, "Bad Request");
}
var contact = ContactService.FindById(editViewModel.ContactId);
if (contact == null)
{
throw new HttpException(404, "Not Found");
}
var selectedPartner = PartnerService.FindById(editViewModel.DropDownList_Partner_Property.SelectedPartner);
contact.Name = editViewModel.Name;
contact.Position = editViewModel.Position;
contact.Email = editViewModel.Email;
contact.Phone = editViewModel.Phone;
contact.Note = editViewModel.Note;
contact.IsMale = editViewModel.IsMale;
contact.IsBooker = editViewModel.IsBooker;
contact.Partner = selectedPartner;
contact.PartnerId = editViewModel.DropDownList_Partner_Property.SelectedPartner != -1 ? (int?)editViewModel.DropDownList_Partner_Property.SelectedPartner : null;
contact.Birthday = !String.IsNullOrEmpty(editViewModel.Birthday) ? (DateTime?)DateTime.ParseExact(editViewModel.Birthday,"dd/MM/yyyy",CultureInfo.InvariantCulture) : null;
ContactService.UpdateContact(contact);
TempData["ContactId"] = contact.ContactId;
TempData["ContactName"] = contact.Name;
TempData["Message"] = ContactsMessage.EditSuccess;
return RedirectToAction("index", "contacts");
}
public ActionResult Edit(int? id)
{
if (id == null)
{
throw new HttpException(400, "Bad Request");
}
var contact = ContactService.FindById(id.Value);
if (contact == null)
{
throw new HttpException(404, "Not Found");
}
var dropdownlist_Partner_Property = new EditViewModel.DropDownList_Partner()
{
Partners = PartnerService.GetPartners().ToList(),
SelectedPartner = contact.Partner != null ? contact.Partner.PartnerId : -1
};
var editViewModel = new EditViewModel()
{
ContactId = contact.ContactId,
Name = contact.Name,
Email = contact.Email,
Phone = contact.Phone,
Position = contact.Position,
Note = contact.Note,
IsMale = contact.IsMale,
IsBooker = contact.IsBooker,
DropDownList_Partner_Property = dropdownlist_Partner_Property
};
return View(editViewModel);
}
public async Task<IActionResult> Edit(EditViewModel model)
{
try
{
if (ModelState.IsValid)
{
context.Update(new Contact {
ContactId = model.ContactId,
FirstName = model.FirstName,
LastName = model.LastName,
Company = model.Company,
Title = model.Title,
Trade = model.Trade,
Phone = model.Phone,
Email = model.Email,
Chat = model.Chat,
Website = model.Website,
UserId = model.UserId
});
await context.SaveChangesAsync();
return RedirectToAction(nameof(ContactsController.Details), new { id = model.ContactId });
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return View(model);
}
public ActionResult Edit(int? id, string sortOrder, int? page, int? size)
{
if (id == null)
{
throw new HttpException(400, "Bad Request");
}
var group = GroupService.FindById(id.Value);
if (group == null)
{
throw new HttpException(404, "Not Found");
}
Session["GroupName"] = group.Name;
var groupRoles = group.ApplicationRoles.AsQueryable().
Select(gr => new { gr.Id }).
AsEnumerable().
Select(gr => new ApplicationRole() { Id = gr.Id });
ViewBag.IdSortParm = String.IsNullOrEmpty(sortOrder) ? "id_desc" : "";
ViewBag.NameSortParm = sortOrder == "name_asc" ? "name_desc" : "name_asc";
ViewBag.DescriptionSortParm = sortOrder == "description_asc" ? "description_desc" : "description_asc";
ViewBag.SortOrder = sortOrder;
switch (sortOrder)
{
case "id_desc":
groupRoles = groupRoles.OrderByDescending(gr => gr.Id);
break;
case "name_asc":
groupRoles = groupRoles.OrderBy(gr => gr.Name);
break;
case "name_desc":
groupRoles = groupRoles.OrderByDescending(g => g.Name);
break;
case "description_asc":
groupRoles = groupRoles.OrderBy(g => g.Description);
break;
case "description_desc":
groupRoles = groupRoles.OrderByDescending(g => g.Description);
break;
}
var roles = RoleManager.Roles.ToArray();
var checkBoxRoleViewModelList = new List<edit.CheckBoxRoleViewModel>();
for (var i = 0; i < roles.Count(); i++)
{
var role = roles[i];
var checkBoxRoleViewModel = new edit.CheckBoxRoleViewModel()
{
Id = role.Id,
Name = role.Name,
Description = role.Description,
Selected = groupRoles.Any(gr => gr.Id == role.Id)
};
checkBoxRoleViewModelList.Add(checkBoxRoleViewModel);
}
int pageNumber = (page ?? 1);
int pageSize = (size ?? 10);
ViewBag.PageSize = pageSize;
ViewBag.PageNumber = pageNumber;
ViewBag.Next = pageNumber + 1;
ViewBag.Previous = pageNumber - 1;
var editViewModel = new EditViewModel()
{
Id = group.GroupId,
Name = !String.IsNullOrEmpty((string)TempData["Name"]) ? (string)TempData["Name"] : group.Name,
Description = !String.IsNullOrEmpty((string)TempData["Description"]) ? (string)TempData["Description"] : group.Description,
CheckBoxRoleViewModelPagedList = new PagedList<edit.CheckBoxRoleViewModel>(checkBoxRoleViewModelList,pageNumber,pageSize),
CheckBoxRoleViewModelList = new PagedList<edit.CheckBoxRoleViewModel>(checkBoxRoleViewModelList, pageNumber, pageSize).ToList()
};
ViewBag.FromEntry = (editViewModel.CheckBoxRoleViewModelPagedList.PageNumber - 1) * editViewModel.CheckBoxRoleViewModelPagedList.PageSize + 1;
ViewBag.ToEntry = (editViewModel.CheckBoxRoleViewModelPagedList.PageNumber - 1) * editViewModel.CheckBoxRoleViewModelPagedList.PageSize + editViewModel.CheckBoxRoleViewModelPagedList.Count;
ViewBag.First = 1;
ViewBag.Last = editViewModel.CheckBoxRoleViewModelPagedList.PageCount;
return View(editViewModel);
}
