//private GroupRepository groupRepository;
//public GroupService()
//{
// //groupRepository = new GroupRepository();
//}
public static List<GroupViewModel> GetAllGroups()
{
IEnumerable<Group> groups = GroupRepository.FindAll();
List<GroupViewModel> result = new List<GroupViewModel>();
foreach (Group g in groups)
{
GroupViewModel groupview = new GroupViewModel();
//groupview.Key = g.Key.ToString();
//groupview.Name = g.Name;
//groupview.Description = g.Description;
groupview.Profile = new ServicesViewModels.CompleteProfileViewModel { BasicProfile = new BasicProfileViewModel { ReferenceKey=g.Key.ToString(), AccountType= AccountType.Group }, FullName=g.Name, Description1=g.Description };
List<CompleteProfileViewModel> members = new List<ServicesViewModels.CompleteProfileViewModel>();
foreach (GroupMembershipStateInfo membership in g.GroupMemberships)
{
members.Add(new CompleteProfileViewModel{ BasicProfile=new ServicesViewModels.BasicProfileViewModel{ ReferenceKey= membership.RequestorAccount.Key.ToString(), AccountType=AccountType.UserAccount}, FullName=membership.RequestorAccount.User.FirstName + " " + membership.RequestorAccount.User.LastName });
}
groupview.Members = members;
result.Add(groupview);
}
return result;
}
public GroupControl(IPlatformGroup group)
{
InitializeComponent();
_group = group;
this.MouseLeftButtonDown += OnMouseLeftButtonDown;
DataContext = new GroupViewModel(group);
}
// GET: /User/
public ActionResult Index(int? page = 1)
{
log4net.Config.XmlConfigurator.Configure();
ILog log = LogManager.GetLogger("Inside Group Controller- Index");
try
{
if (Session["OrganizationGUID"] != null)
{
DropdownValues();
var groupList = new GroupViewModel();
groupList.Group = new List<GroupModel>();
var appGroup = _IGroupRepository.GetGroupByOrganizationGUID(new Guid(Session["OrganizationGUID"].ToString())).ToList();
foreach (var group in appGroup.ToList())
{
groupList.Group.Add(new GroupModel { Name = group.Name, GroupGUID = group.GroupGUID.ToString(), Description = group.Description, OrganizationGUID = group.OrganizationGUID.ToString() });
}
int pageSize = 10;
int pageNumber = (page ?? 1);
return View(groupList.Group.ToPagedList(pageNumber, pageSize).AsEnumerable());
}
else
{
TempData["msg"] = "<script>ModalPopupsAlert('Workers-In-Motion','Session Expired');</script>";
return RedirectToAction("../User/Login");
}
}
catch (Exception ex)
{
log.Debug(ex.Message);
return null;
}
}
public ActionResult Edit(GroupViewModel viewModel)
{
if (!ModelState.IsValid)
return View("Create", viewModel);
var group = Map<GroupViewModel, Group>(viewModel);
Site.GroupManager.Update(group);
return RedirectToAction("List");
}
protected void Page_Load(object sender, EventArgs e)
{
_environmentParametersViewModel =
new EnvironmentParametersFactory(AppSettings.ConnectionStringName).GetEnvironmentParameters();
_rolePortalId =
(RolePortal)
SessionObject.LoggedInUser.Roles.Where(w => w.RolePortalSelection != 0).Min(m => m.RolePortalSelection);
_groupViewModel = GetGroupViewModel();
}
public static GroupViewModel GetGroupByKey(string groupKey)
{
Group group = GroupRepository.FindBy(new Guid(groupKey));
GroupViewModel groupView = new GroupViewModel();
//groupView.Key = group.Key.ToString();
//groupView.Name = group.Name;
//groupView.Description = group.Description;
//Dictionary<string, string> members = new Dictionary<string, string>();
//groupView.Members = members;
groupView.Profile = new ServicesViewModels.CompleteProfileViewModel { BasicProfile = new BasicProfileViewModel { ReferenceKey = group.Key.ToString(), AccountType = AccountType.Group }, FullName = group.Name, Description1 = group.Description };
List<CompleteProfileViewModel> members = new List<ServicesViewModels.CompleteProfileViewModel>();
//groupView.Wall = new ContentStreamViewModel();
//groupView.Wall.Posts = new List<PostViewModel>();
foreach (GroupMembershipStateInfo membership in group.GroupMemberships)
{
members.Add(new CompleteProfileViewModel { BasicProfile = new ServicesViewModels.BasicProfileViewModel { ReferenceKey = membership.RequestorAccount.Key.ToString(), AccountType = AccountType.UserAccount }, FullName = membership.RequestorAccount.User.FirstName + " " + membership.RequestorAccount.User.LastName });
}
groupView.Members = members;
//foreach (var post in group.Wall.Posts)
//{
// PostViewModel thisPost = new PostViewModel();
// thisPost.Key = post.Key.ToString();
// //postView.AuthorKey = post.Author.ReferenceKey.ToString();
// //postView.AuthorName = SecurityRepository.GetCompleteProfile(post.Author.ReferenceKey);
// var postAuthorProfile = SecurityRepository.GetCompleteProfile(post.Author);
// thisPost.Author = new CompleteProfileViewModel { BasicProfile = new BasicProfileViewModel { ReferenceKey = postAuthorProfile.BasicProfile.ReferenceKey.ToString(), AccountType = post.Author.ReferenceType }, FullName = postAuthorProfile.FullName, Description1 = postAuthorProfile.Description1, Description2 = postAuthorProfile.Description2 };
// thisPost.Text = post.Text;
// thisPost.TimeStamp = post.PublishDateTime;
// thisPost.Comments = new List<CommentViewModel>();
// foreach (var comment in post.Comments)
// {
// CommentViewModel thisComment = new CommentViewModel();
// thisComment.Key = comment.Key.ToString();
// thisComment.TimeStamp = comment.PublishDateTime;
// var commentAuthorProfile = SecurityRepository.GetCompleteProfile(comment.Author);
// thisComment.Author = new CompleteProfileViewModel { BasicProfile = new BasicProfileViewModel { ReferenceKey = commentAuthorProfile.BasicProfile.ReferenceKey.ToString(), AccountType = commentAuthorProfile.BasicProfile.ReferenceType }, FullName = commentAuthorProfile.FullName, Description1 = commentAuthorProfile.Description1, Description2 = commentAuthorProfile.Description2 };
// thisComment.Text = comment.Text;
// thisPost.Comments.Add(thisComment);
// }
// groupView.Wall.Posts.Add(thisPost);
//}
return groupView;
}
public void CreateGroupFromT()
{
var newGroupMap = new GroupViewModel()
{
Name = "Test Group"
};
var group = groupService.CreateGroup<GroupViewModel>(newGroupMap);
Assert.IsNotNull(group);
Assert.IsNotNull(group.Id);
Assert.AreEqual(newGroupMap.Name, group.Name);
}
public IActionResult Post([FromBody] GroupViewModel group)
{
try
{
if (ModelState.IsValid)
{
var newGroup = _mapper.Map <GroupViewModel, Group>(group);
if (newGroup.CreationTime == DateTime.MinValue)
{
newGroup.CreationTime = DateTime.UtcNow;
}
var user = _repository.GetUser(User.Identity.Name);
var admin = new GroupMember()
{
Group = newGroup,
GroupId = newGroup.Id,
Member = user,
MemberId = user.Id,
IsAdmin = true
};
newGroup.Members = new List <GroupMember>()
{
admin
};
user.Memberships.Add(admin);
_repository.AddEntity(newGroup);
if (_repository.SaveAll())
{
var vm = _mapper.Map <Group, GroupViewModel>(newGroup);
return(Created($"api/groups/{vm.GroupId}", vm));
}
}
else
{
return(BadRequest(ModelState));
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save group. [ex={ex}]");
throw;
}
return(BadRequest("Failed to save new group."));
}
public async Task <IActionResult> AddGroup(GroupViewModel model)
{
if (ModelState.IsValid)
{
GroupEntity entity = await _converter.ToGroupEntityAsync(model, true);
_context.Add(entity);
await _context.SaveChangesAsync();
return(RedirectToAction($"{ nameof(Details)}/{ model.TournamentId}"));
}
return(View(model));
}
public async Task <IActionResult> EditGroup(GroupViewModel model)
{
if (ModelState.IsValid)
{
var groupEntity = await _converterHelper.ToGroupEntityAsync(model, false);
_context.Update(groupEntity);
await _context.SaveChangesAsync();
return(RedirectToAction($"{nameof(Details)}/{model.TournamentId}"));
}
return(View(model));
}
private GroupViewModels()
{
if (WpfUtil.IsInDesignMode)
{
return;
}
this.Add = new DelegateCommand(() => {
new GroupViewModel(Guid.NewGuid())
{
SortNumber = Count + 1
}.Edit.Execute(FormType.Add);
});
VirtualRoot.BuildEventPath <ServerContextReInitedEvent>("刷新VM内存", LogEnum.DevConsole,
path: message => {
_dicById.Clear();
Init();
}, location: this.GetType());
VirtualRoot.BuildEventPath <ServerContextReInitedEventHandledEvent>("刷新视图界面", LogEnum.DevConsole,
path: message => {
OnPropertyChangeds();
}, location: this.GetType());
BuildEventPath <GroupAddedEvent>("调整VM内存", LogEnum.DevConsole,
path: (message) => {
if (!_dicById.ContainsKey(message.Source.GetId()))
{
GroupViewModel groupVm = new GroupViewModel(message.Source);
_dicById.Add(message.Source.GetId(), groupVm);
OnPropertyChangeds();
}
}, location: this.GetType());
BuildEventPath <GroupUpdatedEvent>("调整VM内存", LogEnum.DevConsole,
path: (message) => {
if (_dicById.TryGetValue(message.Source.GetId(), out GroupViewModel vm))
{
int sortNumber = vm.SortNumber;
vm.Update(message.Source);
if (sortNumber != vm.SortNumber)
{
this.OnPropertyChanged(nameof(List));
OnPropertyChanged(nameof(SelectionOptions));
}
}
}, location: this.GetType());
BuildEventPath <GroupRemovedEvent>("调整VM内存", LogEnum.DevConsole,
path: (message) => {
_dicById.Remove(message.Source.GetId());
OnPropertyChangeds();
}, location: this.GetType());
Init();
}
public bool EditGroup(GroupViewModel model)
{
var data = new GroupViewModel();
if (data != null)
{
var conn = db.ConnStrg();
string sqlQuery = "update groupes set group_name='" + model.group_name + "',group_code='" + model.group_code + "' where group_id=" + model.group_id;
int rowsAffected = conn.Execute(sqlQuery);
}
return(true);
}
public void TestBindingModes()
{
var group = new GroupViewModel();
var stack = new StackLayout
{
BindingContext = group
};
string oldName = group.Person1.FullName;
var label1W = GenerateNameLabel(nameof(group.Person1), BindingMode.OneWay);
stack.Children.Add(label1W);
Assert.AreEqual(group.Person1.FullName, label1W.Text);
label1W.SetValueCore(Label.TextProperty, "don't change source", Internals.SetValueFlags.None);
Assert.AreEqual("don't change source", label1W.Text);
Assert.AreEqual(oldName, group.Person1.FullName);
var label2W = GenerateNameLabel(nameof(group.Person2), BindingMode.TwoWay);
stack.Children.Add(label2W);
Assert.AreEqual(group.Person2.FullName, label2W.Text);
label2W.Text = group.Person2.FullName.ToUpper();
Assert.AreEqual(group.Person2.FullName.ToUpper(), label2W.Text);
oldName = group.Person3.FullName;
var label1WTS = GenerateNameLabel(nameof(group.Person3), BindingMode.OneWayToSource);
stack.Children.Add(label1WTS);
// Initial value is target fallback
Assert.AreEqual(c_Fallback, label1WTS.Text);
Assert.AreEqual(c_Fallback, group.Person3.FullName);
label1WTS.Text = oldName;
Assert.AreEqual(oldName, label1WTS.Text);
Assert.AreEqual(oldName, group.Person3.FullName);
oldName = group.Person4.FullName;
var label1T = GenerateNameLabel(nameof(group.Person4), BindingMode.OneTime);
stack.Children.Add(label1T);
Assert.AreEqual(group.Person4.FullName, label1T.Text);
group.Person4.FirstName = "Do";
group.Person4.MiddleName = "Not";
group.Person4.LastName = "Update";
// changing source values should not trigger update
Assert.AreEqual(oldName, label1T.Text);
Assert.AreEqual("Do Not Update", group.Person4.FullName);
group.Person4 = group.Person1;
// changing the bctx should trigger update
Assert.AreEqual(group.Person1.FullName, label1T.Text);
}
public async Task <IActionResult> Delete(int id)
{
var group = await this._groupService
.GetGroupAsync(id);
var viewModel = new GroupViewModel
{
GroupId = group.GroupId,
Title = group.Title,
Description = group.Description
};
return(View(viewModel));
}
public ActionResult Create(GroupViewModel groupViewModel)
{
if (ModelState.IsValid)
{
var group = new GroupDTO
{
NameOfGroup = groupViewModel.NameOfGroup,
SpecialityId = _specialityManager.GetAll().Where(t => t.NameOfSpeciality.Equals(groupViewModel.Speciality)).ToList().First().Id
};
_groupManager.Create(group);
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public async Task <HttpResponseMessage> Update(HttpRequestMessage request, GroupViewModel groupViewModel)
{
if (ModelState.IsValid)
{
var oldGroup = this.groupService.GetById(groupViewModel.Id);
try
{
oldGroup.Name = groupViewModel.Name;
oldGroup.Description = groupViewModel.Description;
this.groupService.Update(oldGroup);
this.groupService.Save();
//save role group
var listRoleGroup = new List <RoleGroup>();
foreach (var role in groupViewModel.Roles)
{
listRoleGroup.Add(new RoleGroup()
{
GroupId = oldGroup.Id,
RoleId = role.Id
});
}
this.roleService.AddRolesToGroup(listRoleGroup, oldGroup.Id);
this.roleService.Save();
//add role to user
var listRole = this.roleService.GetListRoleByGroupId(oldGroup.Id);
var listUserInGroup = this.groupService.GetListUserByGroupId(oldGroup.Id);
foreach (var user in listUserInGroup)
{
var listRoleName = listRole.Select(x => x.Name).ToArray();
foreach (var roleName in listRoleName)
{
await this.userManager.RemoveFromRoleAsync(user.Id, roleName);
await this.userManager.AddToRoleAsync(user.Id, roleName);
}
}
return(request.CreateResponse(HttpStatusCode.OK, groupViewModel));
}
catch (DuplicatedException dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public void ScrumMasterUpdateProject_NotNull()
{
var scrumMasterId = _context.Groups
.Where(t => t.Project.Status == ProjectStatus.WaitingForDescription)
.Select(g => g.ScrumMasterId.Value)
.First();
var controller = CreateControllerWithFakeUser(scrumMasterId);
string teamPurpose = "testTeam";
string fullDescription = "testFull";
string shortDescription = "testShort";
string teamworkDesciption = "testTeamDesc";
var dbGroupId = _context.ScrumMasters.Where(sm => sm.Id == scrumMasterId).Select(sm => sm.GroupId.Value).Single();
var dbProjectId = _context.Projects.Where(p => p.Groups.Any(g => g.Id == dbGroupId)).Select(p => p.Id).Single();
var group = new GroupViewModel
{
Id = dbGroupId,
TeamPurpose = teamPurpose,
TeamWorkDescription = teamworkDesciption,
ScrumMasterId = scrumMasterId,
ProjectId = dbProjectId
};
var model = new ScrumProjectViewModel
{
Group = group,
Project = new ProjectViewModel
{
Id = dbProjectId,
FullDescription = fullDescription,
ShortDescription = shortDescription
}
};
RedirectToRouteResult result = controller.Project(model) as RedirectToRouteResult;
Assert.IsNotNull(result, "RedirectResult is null");
Assert.AreEqual("Project", result.RouteValues["controller"], "Controller is not equal");
Assert.AreEqual("View", result.RouteValues["action"], "Action is not equal");
Assert.AreEqual(model.Project.Id, result.RouteValues["id"], "Id is not equal");
var dbProject = _context.Projects.Single(p => p.Id == dbProjectId);
var dbGroup = _context.Groups.Single(g => g.Id == group.Id);
Assert.AreEqual(teamPurpose, dbGroup.TeamPurpose, "Group TeamPurpose is not equal");
Assert.AreEqual(fullDescription, dbProject.FullDescription, "Project FullDescription is not equal");
Assert.AreEqual(shortDescription, dbProject.ShortDescription, "Group ShortDescription is not equal");
Assert.AreEqual(teamworkDesciption, dbGroup.TeamworkDescription, "Project TeamworkDesciption is not equal");
}
//
// GET: /Forums/Groups
public async Task <ActionResult> Groups()
{
//ICollection<GroupSetViewModel> model = new List<GroupSetViewModel>();
IDictionary <string, ICollection <GroupViewModel> > model = new Dictionary <string, ICollection <GroupViewModel> >();
IEnumerable <Group> groups = await GroupManager.GetGroupsAsync();
// Getting the group sets
foreach (Group group in groups)
{
int groupId = group.Id;
GroupViewModel subModel = new GroupViewModel
{
Id = groupId,
Name = group.Name,
Description = group.Description,
Image = group.Image ?? "string", // TODO: This needs to be checked if its null there has to be a defualt image
ThreadCount = group.Threads.Any() ? group.Threads.Count() : 0,
PostCount = await GroupManager.GetPostsCount(groupId)
};
// Check if there are any threads
if (group.Threads.Any())
{
Thread lastThread = GroupManager.GetLastActiveThreadByGroupIdAsync(groupId);
subModel.LastPostedThreadName = lastThread.Name;
subModel.LastPostedThreadUserName = lastThread.User.UserName;
}
else
{
subModel.LastPostedThreadName = "None";
subModel.LastPostedThreadUserName = "******";
}
// Seperating based on the category
if (model.ContainsKey(group.Category))
{
model[group.Category].Add(subModel);
}
else
{
model.Add(group.Category, new List <GroupViewModel>());
model[group.Category].Add(subModel);
}
}
return(View(model));
}
public IActionResult RemoveUserFromGroup(int userId, [FromBody] GroupViewModel group)
{
if (group == null)
{
return(BadRequest("Group cannot be null."));
}
if (group.GroupId < 1)
{
return(BadRequest("Group does not exist."));
}
if (userId < 1)
{
return(BadRequest("User does not exist"));
}
var categories = categoryService.GetAllCategories();
group.CategoryName = categories.FirstOrDefault(c => c.CategoryId == group.CategoryId).CategoryName;
var user = group.GroupMembers.FirstOrDefault(gm => gm.UserId == userId);
if (user == null)
{
return(NotFound("User could not be found"));
}
var activityId = groupService.RemoveUserFromGroup(userId, group.GroupId);
if (activityId != 0)
{
group.GroupActivity.Insert(0, new GroupActivity
{
ActivityId = activityId,
UserId = user.UserId,
FirstName = user.FirstName,
LastName = user.LastName,
Date = "Just Now",
Type = "LEAVE"
});
}
group.GroupMembers.Remove(user);
group.MemberCount = group.MemberCount - 1;
return(Ok(group));
}
public IActionResult Update([FromBody] GroupViewModel groupViewModel, int id)
{
try
{
Group group = serviceGroup.GetGroupById(id);
group.Name = groupViewModel.Name;
serviceGroup.UpdateGroup(group);
return(Ok(ToOutputModel(group)));
}
catch
{
return(BadRequest());
}
}
/// <summary>
/// Throw an exception if name is exist.
/// </summary>
/// <param name="model">Group view model</param>
public void ThrowExceptionIfExist(GroupViewModel model)
{
ConditionFilter <Group, long> condition = new ConditionFilter <Group, long>
{
Query = (entity =>
entity.Code == model.Code &&
entity.Id != model.Id)
};
var existEntity = this._GroupsRepository.Get(condition).FirstOrDefault();
if (existEntity != null)
{
throw new ItemAlreadyExistException((int)ErrorCodeEnum.CodeAlreadyExist);
}
}
public async Task <GroupViewModel> UpdateAsync(GroupViewModel model)
{
var team = await _repository.GetByIdAsync(model.Id);
if (team == null)
{
throw new ClientFriendlyException($"Invalid Group: {model.Id}");
}
var data = _mapper.Map <Group>(model);
var result = await _repository.UpdateAsync(data);
_logger.LogInformation($"Updated team {model.Id} {model.Name}");
return(_mapper.Map <GroupViewModel>(result));
}
public IActionResult ManageGroup(GroupViewModel model)
{
if (ModelState.IsValid)
{
var group = _mapper.Map <GroupViewModel, Group>(model);
var updateToGroup = _settingRepository.GetGroupById(model.Id);
_settingRepository.UpdateGroup(group, updateToGroup);
return(RedirectToAction("managegroup"));
}
return(Ok(model));
}
public ActionResult GroupInfo()
{
var res = _context.Users.Find(User.Identity.GetUserId()).Student;
var group = _context.Groups.Find(res.GroupId);
GroupViewModel g = new GroupViewModel()
{
Name = group.Name,
CountOfStudents = group.CountOfStudents,
Year = group.Year
};
ViewBag.Students = _context.Students.Where(el => el.GroupId == group.Id);
return(View(g));
}
private void TextBlock_MouseDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
{//событие по нажатию мышью по надписи
GroupViewModel groupViewModel = new GroupViewModel();
groupViewModel.Commence = new DateTime(1990, 01, 01);
EditGroup dialog = new EditGroup(groupViewModel);
var result = dialog.ShowDialog();
if (result == true)
{
groupService.CreateGroup(groupViewModel);
}
groups = groupService.GetAll();
cBoxGroup.DataContext = groups;
}
public async Task <IActionResult> UpdateGroupAsync(int groupId, [FromBody] GroupViewModel group)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ValidationError(ModelState)));
}
var groupDto = _mapper.Map <GroupDto>(group);
groupDto.Id = groupId;
await _groupsService.UpdateGroupAsync(groupDto);
return(NoContent());
}
public async Task <IActionResult> Create([Bind("Id,Name, UserIds")] GroupViewModel groupViewModel)
{
if (ModelState.IsValid)
{
Group group = _mapper.Map <Group>(groupViewModel);
PopulateModelWithSelectedValues(groupViewModel.UserIds, group);
_context.Add(@group);
await _context.SaveChangesAsync();
TempData["Msg"] = groupViewModel.Name + " sucessfully added";
return(RedirectToAction(nameof(Index)));
}
LoadFieldsViewModel(groupViewModel);
return(View(groupViewModel));
}
public async Task <GroupViewModel> CreateAsync(GroupViewModel model)
{
var contactExists = await GroupExistsByNameAsync(model.Name);
if (contactExists)
{
throw new ClientFriendlyException($"Group: {model.Name} already exists");
}
var data = _mapper.Map <Group>(model);
var result = await _repository.CreateAsync(data);
_logger.LogInformation($"Created new team {model.Id} {model.Name}");
return(_mapper.Map <GroupViewModel>(result));
}
public void RenderMessages_Should_CallMethod_GetAllGroups()
{
var groupServiceMocked = new Mock <IGroupService>();
var groupViewModel = new GroupViewModel();
groupServiceMocked.Setup(m => m.GetAll())
.Returns(new List <Group>());
var controller = new ForumController(groupServiceMocked.Object);
controller.RenderMessages("testGroup");
groupServiceMocked.Verify(m => m.GetAll(), Times.Once);
}
public void Update(GroupViewModel model)
{
var group = _groupRepository.FindById(model.ID); //_groupRepository.FindByMultipleId(model.ID, model.AcademyProgramId);
if (group == null)
{
throw new Exception();
}
group.Name = model.Name;
group.AcademyProgramId = model.AcademyProgramId;
group.AcademyProgram = _academyProgramrepository.FindById(model.AcademyProgramId);
_groupRepository.Update(group);
}
public GroupViewModel AddGroup(GroupViewModel group)
{
var groupToRepository = new Group
{
Number = group.Number,
EndDate = group.EndDate,
StartDate = group.StartDate,
HalfGroup = group.HalfGroup,
CourseId = group.CourseId
};
var groupAdded = Mapper.Map <GroupViewModel>(_eJContext.Groups.Add(groupToRepository));
_eJContext.SaveChanges();
return(groupAdded);
}
public async Task <IActionResult> AddGroup([FromBody] GroupViewModel group)
{
try
{
await SetAuthenticatedUser();
var groups = await _groupFacade.AddGroupAsync(group);
return(new JsonResult(groups));
}
catch (Exception e)
{
return(StatusCode(500, e));
}
}
/// <summary>
/// Method for inserting new group to db
/// </summary>
/// <param name="item">ViewModel of group</param>
public bool Insert(GroupViewModel item)
{
ApplicationGroup group = mapper.Map <GroupViewModel, ApplicationGroup>(item);
try
{
unitOfWork.ApplicationGroups.Insert(group);
unitOfWork.Save();
}
catch (Exception)
{
return(false);
}
return(true);
}
public async Task <IActionResult> CreateGroup(GroupViewModel model)
{
if (ModelState.IsValid)
{
var userName = User.Identity.Name;
if (!(await groupRepository.CreateGroup(model.GroupName)))
{
ModelState.AddModelError("", "Group name already exist");
return(View(model));
}
string currentGroupId = groupRepository.GetGroupId(model.GroupName);
await groupRepository.AddRoleOfGroupMember(userName, currentGroupId, "SuperAdmin");
}
return(RedirectToAction("AllGroups"));
}
private async Task <int> AddRolesToGroup(List <int> RolesId, int GroupId)
{
var role = _db.Roles.Where(a => RolesId.Any(x => x == a.Id)).ToList();
var grp = _db.Groups.Where(g => g.Id == GroupId).Include(r => r.Roles).FirstOrDefault();
//role.ForEach(grp.Roles.Add);
grp.Roles = role;
var changes = await _db.SaveChangesAsync();
Mapper.CreateMap <Group, CreateGroupViewModel>().ReverseMap();
GroupViewModel groupVm = Mapper.Map <GroupViewModel>(grp);
return(changes > 0 ? 1 : 0);
}
public dynamic CreateGroup(GroupViewModel GVM)
{
string baseURL = HttpContext.Current.Request.Url.Authority;
baseURL += (WebConfigurationManager.AppSettings["groupimagepath"]).Replace("~", "");
GroupViewModel data = new GroupViewModel();
Group G = new Group();
using (LystenEntities db = new LystenEntities())
{
int CreatorId = Convert.ToInt32(GVM.CreatorId);
int CategoryId = Convert.ToInt32(GVM.CategoryId);
G = new Group()
{
Name = GVM.Name,
IsActive = true,
CreatedDate = System.DateTime.Now,
CreatorId = CreatorId,
GroupTypeId = Convert.ToInt32(GVM.GroupTypeId),
CategoryId = CategoryId
};
db.Groups.Add(G);
db.SaveChanges();
data = AutoMapper.Mapper.Map <Group, GroupViewModel>(G);
if (G.Image == null || G.Image == "")
{
data.Image = "";
}
else
{
data.Image = baseURL + GVM.Image;
}
if (!db.UserCategoryMappings.Any(x => x.UserId == CreatorId && x.CategoryId == CategoryId))
{
UserCategoryMapping uc = new UserCategoryMapping()
{
CategoryId = CategoryId,
UserId = CreatorId
};
db.UserCategoryMappings.Add(uc);
db.SaveChanges();
}
}
return(data);
}
public async Task <IList <GroupViewModel> > GetGroups([FromQuery] string id)
{
IList <StudentViewModel> studentsToSend = new List <StudentViewModel>();
var students = await applicationDbContext.Students.ToListAsync();
foreach (Student student in students)
{
var user = await applicationDbContext.Users.FirstOrDefaultAsync(x => x.Id == student.IdentityId);
StudentViewModel studentToSend = new StudentViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
NrIndex = student.NrIndex,
ProjectId = student.ProjectId,
Confirmed = student.Confirmed,
GroupId = student.GroupId,
Id = student.Id
};
studentsToSend.Add(studentToSend);
}
var worker = await applicationDbContext.Workers.FirstOrDefaultAsync(x => x.IdentityId == id);
var groups = await applicationDbContext.Groups.Where(x => x.WorkerId == worker.Id).ToListAsync();
IList <GroupViewModel> groupsWithStudents = new List <GroupViewModel>();
foreach (Group group in groups)
{
GroupViewModel groupWithStudents = new GroupViewModel
{
Id = group.Id,
Name = group.Name,
WorkerId = group.WorkerId,
Students = new List <StudentViewModel>()
};
foreach (StudentViewModel student in studentsToSend)
{
if (student.GroupId == group.Id)
{
groupWithStudents.Students.Add(student);
}
}
groupsWithStudents.Add(groupWithStudents);
}
return(groupsWithStudents);
}
protected void Save(object sender, EventArgs e)
{
if (!Page.IsValid) return;
_groupViewModel = GetGroupViewModel();
var groupViewModel = new GroupViewModel
{
DisplayName = txtName.Text,
Description = txtDescription.Text,
VisibilityType = _groupViewModel.VisibilityType
};
var grouping = new Grouping(_environmentParametersViewModel);
Guid roleId = grouping.CopyGroup(groupViewModel, SessionObject.LoggedInUser.School, RoleId, _rolePortalId);
string script = string.Format("CloseDialog('{0}');", roleId.ToString());
ScriptManager.RegisterStartupScript(Page, typeof(Page), "closeScript", script, true);
}
// GET: Groups/Edit/5
public ActionResult Edit(int id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Group group = _groupRepo.GetGroupByID(id);
if (group == null)
{
return HttpNotFound();
}
GroupViewModel groupViewModel = new GroupViewModel(group, _groupRepo.GetMemberDetails(group.ID,User.Identity.GetUserId()));
return View(groupViewModel);
}
public ActionResult Edit(GroupViewModel model)
{
int userId = WebSecurity.GetUserId(WebSecurity.CurrentUserName);
var userProfile = _userContext.UserProfiles.First(x => x.UserId == userId);
model.group.isContactGroup = false;
UserData userData = new UserData();
userData.PublicKey = userProfile.PublicKey;
userData.Timestamp = DateTime.Now;
userData.GenerateAuthenticationHash(userProfile.PrivateKey + userProfile.PublicKey + "POST/contact/" + model.group._id + userData.Timestamp + userProfile.PrivateKey);
GroupEndpoint g = new GroupEndpoint();
string message = g.UpdateGroup(model.group, userData);
TempData["Notification"] = new Notification("Group details has been saved" + message, Nature.success);
Thread.Sleep(2500);
return RedirectToAction("Index");
}
// GET: /Group/Details/5
public async Task<ActionResult> Details(int? id)
{
if (id != null)
{
Group group = await appContext.Groups.FindAsync(id);
if (group != null)
{
Dictionary<ApplicationUser, Boolean> learners = new Dictionary<ApplicationUser, Boolean>();
Dictionary<ApplicationUser, Boolean> teachers = new Dictionary<ApplicationUser, Boolean>();
(await cMa.GetUsersFromMainGroupAsync(appContext, group, CourseUsers.Student, true))
.ToList()
.ForEach(u => learners.Add(u, cMa.CheckUserForRoleInMainGroup(u, group, "Student")));
(await cMa.GetUsersFromMainGroupAsync(appContext, group, CourseUsers.Teacher, true))
.ToList()
.ForEach(u => teachers.Add(u, cMa.CheckUserForRoleInMainGroup(u, group, "Teacher")));
GroupViewModel gVm = new GroupViewModel
{
GroupData = group,
Learners = learners,
Teachers = teachers
};
return View(gVm);
}
}
return new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Can't find requested group");
}
public MainPage()
{
this.InitializeComponent();
DataContext = new GroupViewModel();
}
public ActionResult Create( )
{
var group = new GroupViewModel();
return View(group);
}
