public async Task <IActionResult> RemoveStudentFromGroup([FromRoute] int studentId, [FromQuery][Required] int?groupId)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            Student student = await _studentService.GetByIdAsync(studentId);

            Group group = await _groupService.GetByIdAsync(groupId ?? 0);

            if (student == null || group == null)
            {
                return(BadRequest("Group or Student not found"));
            }
            if (!group.Students.Any(s => s.Id == student.Id))
            {
                return(BadRequest("Student is not in this group"));
            }
            if (student.GroupAdmin)
            {
                if (group.Students.Count > 1)
                {
                    return(BadRequest("Group Admin not allowed to exit, make a student group admin before leaving."));
                }
                student.GroupAdmin = false;
                await _groupService.DeleteAsync(group, Int32.Parse(User.Identity.Name));

                return(Ok());
            }
            await _studentService.RemoveStudentFromGroupAsync(student, groupId ?? 0, Int32.Parse(User.Identity.Name));

            return(Ok());
        }
        public async Task <IActionResult> DeleteGroup([FromRoute] int groupId)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            Group group = await _groupService.GetByIdAsync(groupId);

            if (group == null)
            {
                return(BadRequest("Group not found"));
            }
            Student groupAdmin = group.Students.Where(s => s.GroupAdmin == true).FirstOrDefault();

            if (!User.IsInRole("Admin"))
            {
                Student student = await _studentService.GetByIdAsync(Int32.Parse(User.Identity.Name));

                if (!student.Group.Equals(groupAdmin))
                {
                    return(BadRequest("Action not allowed"));
                }
            }
            groupAdmin.GroupAdmin = false;
            await _studentService.UpdateAsync(groupAdmin);

            await _groupService.DeleteAsync(group, Int32.Parse(User.Identity.Name));

            return(Ok());
        }
Ejemplo n.º 3
0
        public async Task <IActionResult> DeleteConfirmed(long id)
        {
            var group = await _groupRepository.FindByIdAsync(id);

            await _groupRepository.DeleteAsync(group);

            return(RedirectToAction(nameof(Index)));
        }
Ejemplo n.º 4
0
        public async Task <ActionResult> Delete(Group group)
        {
            try {
                ActiveDirectoryClient client = AuthenticationHelper.GetActiveDirectoryClient();
                IGroup toDelete = await client.Groups.GetByObjectId(@group.ObjectId).ExecuteAsync();

                await toDelete.DeleteAsync();

                return(RedirectToAction("Index"));
            }
            catch (Exception exception) {
                ModelState.AddModelError("", exception.Message);
                return(View(group));
            }
        }
Ejemplo n.º 5
0
        public async Task <ActionResult <Group> > DeleteGroup(long id)
        {
            long   userId    = UserId;
            string didDelete = await repository.DeleteAsync(id, userId);

            if (didDelete == "null")
            {
                return(NotFound());
            }
            else if (didDelete == "false")
            {
                return(Unauthorized("You must be the owner of this group to delete it."));
            }
            else
            {
                return(await repository.GetGroup(id));
            }
        }
Ejemplo n.º 6
0
 public Task RemoveGroup(IGroup group)
 {
     return(group.DeleteAsync());
 }