/// <summary>
/// Maps a Group to the edit view model
/// </summary>
/// <param name="Group"></param>
/// <param name="allGroupSelectListItems"></param>
/// <param name="sections"></param>
/// <returns></returns>
public static GroupEditViewModel ToEditViewModel(this Group Group, List <SelectListItem> allGroupSelectListItems, IEnumerable <SelectListItem> sections)
{
var GroupViewModel = new GroupEditViewModel
{
Name = Group.Name,
Description = Group.Description,
Subtitle = Group.Subtitle,
Introduction = Group.Introduction,
IsLocked = Group.IsLocked,
ModeratePosts = Group.ModerateComments == true,
ModerateTopics = Group.ModerateDiscussions == true,
SortOrder = Group.SortOrder,
Id = Group.Id,
PageTitle = Group.PageTitle,
MetaDesc = Group.MetaDescription,
Image = Group.Image,
GroupColour = Group.Colour,
ParentGroup = Group.Parent_GroupId?.Id ?? Guid.Empty,
Section = Group.Section?.Id ?? Guid.Empty,
AllGroups = allGroupSelectListItems,
AllSections = sections,
GroupOwner = Group.GroupOwner?.Id,
GroupAdministrators = Group.GroupUsers.Where(x => x.Role.RoleName == Constants.AdminRoleName).Select(x => x.User.Id),
Public = Group.PublicGroup
};
return(GroupViewModel);
}
public GroupEditViewModel Update(GroupEditViewModel P)
{
Group PP = GroupRepo.Update(P.ToModel());
unitOfWork.Commit();
return(PP.ToEditableViewModel());
}
public GroupEditViewModel Update(GroupEditViewModel GroupEditViewModel)
{
Group Group = GroupRepo.Update(GroupEditViewModel.ToModel());
unitOfWork.commit();
return(Group.ToEditableViewModel());
}
public ResultViewModel <GroupEditViewModel> Update(GroupEditViewModel emp)
{
ResultViewModel <GroupEditViewModel> result
= new ResultViewModel <GroupEditViewModel>();
try
{
if (!ModelState.IsValid)
{
result.Message = "In Valid Model State";
}
else
{
GroupEditViewModel selectedEmp
= groupService.Update(emp);
result.Successed = true;
result.Data = selectedEmp;
}
}
catch (Exception ex)
{
result.Successed = false;
result.Message = "Semething Went Wrong";
}
return(result);
}
public async Task <GroupEditViewModel> CreateGroup()
{
var group = new GroupEditViewModel()
{
Faculties = await GetFaculties(),
Departments = GetDepartments()
};
return(group);
}
public async Task <IActionResult> ModifyAsync([FromBody] GroupEditViewModel groupVM)
{
GenericResult result = null;
try
{
if (ModelState.IsValid)
{
var group = await groupRepository.GetSingleByIdAsync(groupVM.Id);
if (group != null)
{
group.Name = groupVM.Groupname;
groupRepository.Modify(group);
await groupRepository.CommitAsync();
result = new GenericResult
{
Succeeded = true,
Message = Localizer["Group modified"]
};
}
else
{
result = new GenericResult
{
Succeeded = false,
Message = Localizer["Group not found (Id: {0})", groupVM.Id]
};
}
}
else
{
result = new GenericResult
{
Succeeded = false,
Message = Localizer["Invalid fields"]
};
}
}
catch (Exception ex)
{
result = new GenericResult
{
Succeeded = false,
Message = ex.Message
};
Logger.Error(ex, ex.Message);
}
return(new ObjectResult(result));
}
public ActionResult CreateGroup()
{
var GroupViewModel = new GroupEditViewModel
{
AllGroups = _groupService.GetBaseSelectListGroups(_groupService.GetAll(LoggedOnReadOnlyUser?.Id), LoggedOnReadOnlyUser?.Id),
AllSections = _groupService.GetAllSections().ToSelectList(),
Users = MembershipService.GetAll().ToSelectList(),
Public = true
};
return(View(GroupViewModel));
}
public async Task <ActionResult> EditGroupAsync(GroupEditViewModel GroupViewModel)
{
if (ModelState.IsValid)
{
var administrators = GroupViewModel.GroupAdministrators;
//_groupService.getg
// Reset the select list
GroupViewModel.AllGroups = _groupService.GetBaseSelectListGroups(_groupService.GetAll(LoggedOnReadOnlyUser?.Id)
.Where(x => x.Id != GroupViewModel.Id)
.ToList(), LoggedOnReadOnlyUser?.Id);
var groupToEdit = _groupService.Get(GroupViewModel.Id);
var group = GroupViewModel.ToGroup(groupToEdit);
group.RowVersion = GroupViewModel.RowVersion;
var groupResult = await _groupService.Edit(group, GroupViewModel.Files,
GroupViewModel.ParentGroup, GroupViewModel.Section);
if (!groupResult.Successful)
{
ModelState.AddModelError("", groupResult.ProcessLog.FirstOrDefault());
}
else
{
// We use temp data because we are doing a redirect
TempData[Constants.MessageViewBagName] = new GenericMessageViewModel
{
Message = "Group Edited",
MessageType = GenericMessages.success
};
// Set the view model
GroupViewModel = groupResult.EntityToProcess.ToEditViewModel(
_groupService.GetBaseSelectListGroups(_groupService.GetAll(LoggedOnReadOnlyUser?.Id)
.Where(x => x.Id != GroupViewModel.Id)
.ToList(), LoggedOnReadOnlyUser?.Id), _groupService.GetAllSections().ToSelectList());
if (administrators != null && administrators.Any())
{
_groupService.AddGroupAdministrators(group.Slug, administrators.Where(x => x != Guid.Empty).ToList(), LoggedOnReadOnlyUser.Id);
}
else
{
_groupService.AddGroupAdministrators(group.Slug, new List <Guid>(), LoggedOnReadOnlyUser.Id);
}
return(RedirectToAction("Index"));
}
}
GroupViewModel.Users = MembershipService.GetAll().ToSelectList();
return(View(GroupViewModel));
}
public JsonResult AddOrEditGroup(GroupEditViewModel model)
{
SyncContext.Lock();
try
{
using (var masterPassword = SessionContext.GetMasterPassword())
{
if (ModelState.IsValid)
{
var currentVaultName = SessionContext.GetCurrentVaultName();
var vaultRepository = VaultRepositoryFactory.CreateInstance();
var vault = vaultRepository.GetVault(currentVaultName, masterPassword);
var vaultManipulator = this.VaultManipulatorFactory.CreateInstance(vault);
var group = vaultManipulator.GetGroupById(Guid.Parse(model.Id));
bool isNew = false;
if (group == null)
{
group = new Model.Group();
group.Id = Guid.Parse(model.Id);
isNew = true;
}
group.Name = model.Name;
if (isNew)
{
Guid?parentId = model.ParentId == "#" ? null : (Guid?)Guid.Parse(model.ParentId);
vaultManipulator.AddGroup(parentId, group);
}
else
{
vaultManipulator.UpdateGroup(group);
}
vaultRepository.SaveVault(vault, masterPassword);
return(Json(new { success = true }));
}
else
{
return(Json(new { success = false }));
}
}
}
finally
{
SyncContext.Release();
}
}
public ActionResult Edit(GroupEditViewModel model, UserToGroup userToGroup, int?id)
{
if (ModelState.IsValid)
{
var groupToUpdate = db.Groups.Find(db.UserToGroups.Find(userToGroup.Id).GroupId);
var userToGroupToUpdate = db.UserToGroups.Find(userToGroup.Id);
userToGroupToUpdate.GroupId = groupToUpdate.Id;
groupToUpdate.Name = model.Name;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.GroupId = new SelectList(db.Groups, "Id", "Name", userToGroup.GroupId);
ViewBag.UserId = new SelectList(db.Users, "Id", "Email", userToGroup.UserId);
return(View(userToGroup));
}
public async Task <bool> UpdateGroup(GroupEditViewModel groupToUpdate)
{
if (groupToUpdate != null)
{
var group = new AcademicGroup()
{
Id = Guid.Parse(groupToUpdate.GroupId),
Name = groupToUpdate.GroupName,
DepartmentId = Guid.Parse(groupToUpdate.SelectedDepartment)
};
var response = await _requestSender.SendPostRequestAsync("https://localhost:44389/api/AcademicGroups/update", group);
return(true);
}
return(false);
}
/// <summary>
/// Maps changed data to a Group
/// </summary>
/// <param name="GroupViewModel"></param>
/// <param name="Group"></param>
/// <returns></returns>
public static Group ToGroup(this GroupEditViewModel GroupViewModel, Group Group)
{
Group.Description = GroupViewModel.Description;
Group.Subtitle = GroupViewModel.Subtitle;
Group.Introduction = GroupViewModel.Introduction;
Group.IsLocked = GroupViewModel.IsLocked;
Group.ModerateComments = GroupViewModel.ModeratePosts;
Group.ModerateDiscussions = GroupViewModel.ModerateTopics;
Group.Name = GroupViewModel.Name;
Group.SortOrder = GroupViewModel.SortOrder;
Group.PageTitle = GroupViewModel.PageTitle;
Group.MetaDescription = GroupViewModel.MetaDesc;
Group.Colour = GroupViewModel.GroupColour;
Group.PublicGroup = GroupViewModel.Public;
return(Group);
}
public async Task <IActionResult> SaveGroup([FromBody] GroupEditViewModel vm)
{
var userId = _caller.Claims.Single(c => c.Type == "id");
var user = await _userManager.FindByIdAsync(userId.Value);
if (user == null)
{
return(BadRequest("Not logged in"));
}
var group = _context.Groups.FirstOrDefault(x => x.id == vm.id);
if (group == null)
{
group = new Group()
{
dateCreated = DateTime.Now,
owner = user,
guid = Guid.NewGuid().ToString()
};
}
group.name = vm.name;
group.description = vm.description;
group.slug = vm.slug;
var slugCount = _context.Groups.Where(x => x.slug == group.slug && group.id != group.id).Count();
if (slugCount > 0)
{
group.slug += $"-{slugCount}";
}
if (group.id > 0)
{
_context.Groups.Update(group);
}
else
{
await _context.Groups.AddAsync(group);
}
await _context.SaveChangesAsync();
return(Ok(group));
}
public async Task <GroupEditViewModel> CreateGroupEditViewModel(AcademicGroup group)
{
var groupEditViewModel = new GroupEditViewModel()
{
GroupName = group.Name,
GroupId = group.Id.ToString(),
Faculties = await GetFaculties(),
SelectedDepartment = group.DepartmentId.ToString()
};
if (group.Department != null && group.Department.FacultyId != null)
{
groupEditViewModel.Departments = await GetDepartments(group.Department.FacultyId);
groupEditViewModel.SelectedFaculty = group.Department.FacultyId.ToString();
}
return(groupEditViewModel);
}
public ActionResult Edit(GroupEditViewModel model)
{
if (ModelState.IsValid)
{
try
{
Group group = _groupManager.GetGroupById(new ObjectId(model.Id));
group.Name = model.Name;
group.Description = model.Description;
_groupManager.UpdateGroup(group);
return(RedirectToAction("Index", "Group", new { id = model.Id }));
}
catch (Exception)
{
return(View(model));
}
}
return(View(model));
}
public async Task <ActionResult> CreateGroupAsync(GroupEditViewModel GroupViewModel)
{
if (ModelState.IsValid)
{
var Group = GroupViewModel.ToGroup();
Group.GroupOwner = MembershipService.GetUser(GroupViewModel.GroupOwner);
var GroupResult = await _groupService.Create(Group, GroupViewModel.Files,
GroupViewModel.ParentGroup, GroupViewModel.Section);
if (!GroupResult.Successful)
{
ModelState.AddModelError("", GroupResult.ProcessLog.FirstOrDefault());
}
else
{
if (GroupViewModel.GroupAdministrators != null && GroupViewModel.GroupAdministrators.Any())
{
_groupService.AddGroupAdministrators(Group.Slug, GroupViewModel.GroupAdministrators.ToList(), LoggedOnReadOnlyUser.Id);
}
// We use temp data because we are doing a redirect
TempData[Constants.MessageViewBagName] = new GenericMessageViewModel
{
Message = "Group Created",
MessageType =
GenericMessages.success
};
return(RedirectToAction("Index"));
}
}
else
{
ModelState.AddModelError("", "There was an error creating the Group");
}
GroupViewModel.AllGroups = _groupService.GetBaseSelectListGroups(_groupService.GetAll(LoggedOnReadOnlyUser?.Id), LoggedOnReadOnlyUser?.Id);
GroupViewModel.AllSections = _groupService.GetAllSections().ToSelectList();
GroupViewModel.Users = MembershipService.GetAll().ToSelectList();
return(View(GroupViewModel));
}
public async Task <IActionResult> OnGetAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
var group = await _requestSender.GetContetFromRequestAsyncAs <AcademicGroup>(
await _requestSender.SendGetRequestAsync("https://localhost:44389/api/AcademicGroups/one?id=" + id)
);
GroupEditViewModel = await _dropDownService.CreateGroupEditViewModel(group);
return(Page());
if (GroupEditViewModel == null)
{
return(NotFound());
}
return(Page());
}
public IActionResult EditGroup(int id, GroupEditViewModel input)
{
var context = new OnlineWebPortalDbContext();
var group = context.ChurchGroups.FirstOrDefault(e => e.ID == id);
if (group != null && ModelState.IsValid)
{
group.GroupName = input.GroupName;
group.GroupDescription = input.GroupDescription;
group.MeetingDay = input.MeetingDay;
group.StartTime = input.StartTime;
group.EndTime = input.EndTime;
group.Location = input.Location;
group.LeaderName = input.LeaderName;
group.LeaderProfile = input.LeaderProfile;
context.SaveChanges();
return(RedirectToAction("FindGroup", "Group"));
}
return(View(group));
}
/// <summary>
/// Turns a Edit view model into a Group
/// </summary>
/// <param name="GroupViewModel"></param>
/// <returns></returns>
public static Group ToGroup(this GroupEditViewModel GroupViewModel)
{
var Group = new Group {
Name = GroupViewModel.Name,
Description = GroupViewModel.Description,
Subtitle = GroupViewModel.Subtitle,
Introduction = GroupViewModel.Introduction,
IsLocked = GroupViewModel.IsLocked,
ModerateComments = GroupViewModel.ModeratePosts,
ModerateDiscussions = GroupViewModel.ModerateTopics,
SortOrder = GroupViewModel.SortOrder,
PageTitle = GroupViewModel.PageTitle,
MetaDescription = GroupViewModel.MetaDesc,
Colour = GroupViewModel.GroupColour,
CreatedAtUtc = DateTime.UtcNow,
PublicGroup = GroupViewModel.Public
};
return(Group);
}
public async Task <IActionResult> NewAsync([FromBody] GroupEditViewModel groupVM)
{
GenericResult result = null;
try
{
if (ModelState.IsValid)
{
var group = Mapper.Map <GroupEditViewModel, Group>(groupVM);
groupRepository.Add(group);
await groupRepository.CommitAsync();
result = new GenericResult
{
Succeeded = true,
Message = Localizer["Group created"]
};
}
else
{
result = new GenericResult
{
Succeeded = false,
Message = Localizer["Invalid fields"]
};
}
}
catch (Exception ex)
{
result = new GenericResult
{
Succeeded = false,
Message = ex.Message
};
Logger.Error(ex, ex.Message);
}
return(new ObjectResult(result));
}
public async Task <bool> SaveGroup(GroupEditViewModel groupToSave)
{
if (groupToSave != null)
{
var group = new AcademicGroup()
{
Name = groupToSave.GroupName,
DepartmentId = Guid.Parse(groupToSave.SelectedDepartment)
};
// group.Faculty = await _requestSender.GetContetFromRequestAsyncAs<Faculty>(
//await _requestSender.SendGetRequestAsync("https://localhost:44389/api/Faculties/one?id=" + Guid.Parse(groupToSave.SelectedFaculty))
//);
// group.Department = await _requestSender.GetContetFromRequestAsyncAs<Department>(
//await _requestSender.SendGetRequestAsync("https://localhost:44389/api/Departments/one?id=" + Guid.Parse(groupToSave.SelectedDepartment))
//);
var response = await _requestSender.SendPostRequestAsync("https://localhost:44389/api/AcademicGroups/create", group);
return(true);
}
return(false);
}
//
// GET: /Group/Edit
public ActionResult Edit(int id)
{
var group = groupService.GetDetails(id);
if (group != null)
{
var model = new GroupEditViewModel
{
Id = group.Id,
Name = group.Name,
Description = group.Description
};
return(View(model));
}
else
{
return(RedirectToAction("Index", "Group"));
}
}
// GET: Group/Edit/5
public ActionResult Edit(string id)
{
try
{
if (IsValidId(id))
{
var group = _groupManager.GetGroupById(new ObjectId(id));
if (IsValidGroup(group) && _groupManager.IsGroupOwner(group.Id.ToString(), User.Identity.GetUserId()))
{
GroupEditViewModel gevm = new GroupEditViewModel {
Id = group.Id.ToString(), Description = group.Description, Name = group.Name
};
return(View(gevm));
}
}
}
catch (Exception)
{
return(RedirectToAction("Index", "Home"));
}
return(RedirectToAction("Index", "Home"));
}
public ActionResult Edit(GroupEditViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index", "Error"));
}
var entity = new Group
{
SpecialtyId = model.SpecialtyId,
GroupId = model.GroupId,
GroupNumber = Convert.ToInt32(model.GroupNumber),
};
if (entity.GroupId != 0)
{
_groupService.Update(entity);
_historyService.Insert(new History
{
Email = AuthHelper.GetUser(HttpContext).Email,
Action = Action.Update,
DateTime = DateTime.Now,
Entity = EntityEnum.Group
});
}
else
{
_groupService.Insert(entity);
_historyService.Insert(new History
{
Email = AuthHelper.GetUser(HttpContext).Email,
Action = Action.Create,
DateTime = DateTime.Now,
Entity = EntityEnum.Group
});
}
_unitOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(long id)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Index", "Error"));
}
var entity = _groupService.Find(id);
if (entity == null)
{
return(RedirectToAction("Index", "Error"));
}
var specialties = _specialtyService.Queryable().ToList();
var model = new GroupEditViewModel
{
Specialties = new SelectList(specialties, "SpecialtyId", "Name"),
GroupId = entity.GroupId,
SpecialtyId = entity.SpecialtyId,
GroupNumber = entity.GroupNumber.ToString()
};
return(View(model));
}
public ActionResult Edit(GroupEditViewModel model)
{
if (ModelState.IsValid)
{
var result = groupService.Edit(new GroupModel
{
Id = model.Id,
Name = model.Name,
Description = model.Description,
});
if (result)
{
return(RedirectToAction("Index", "Group"));
}
else
{
ModelState.AddModelError("", "Group creation failed");
}
}
return(View(model));
}
public async Task <IActionResult> OnGet()
{
GroupEditViewModel = await _dropDownService.CreateGroup();
return(Page());
}
public GroupEditPageView()
{
Group = null;
}
public ActionResult Edit(GroupEditViewModel model)
{
// ...
}
public GroupEditPageView(GroupEditViewModel group)
: base()
{
Group = group;
}
