예제 #1
0
        /// <summary>
        /// Gets list of all assignment categories of classes attached to studentid
        /// </summary>
        /// <param name="studentid">ID of student to get assignment categories for</param>
        /// <returns>List(AssignmentCategory) of all assignment categories attached to studentid</returns>
        public List <AssignmentCategory> GetAssignmentCategoriesInStudentSchedule(int studentid)
        {
            var categoriesQuery = (from assignmentcategories in _context.AssignmentCategories
                                   join studentclasses in _context.StudentsClasses on assignmentcategories.ClassId equals studentclasses.ClassId
                                   join classes in _context.Classes on assignmentcategories.ClassId equals classes.ClassId
                                   select new
            {
                assignmentcategories.CategoryId,
                assignmentcategories.ClassId,
                assignmentcategories.CategoryName,
                assignmentcategories.CategoryWeight,
                classes.Period,
                studentclasses.StudentId
            }).Where(c => c.StudentId == studentid).OrderBy(c => c.Period);

            List <AssignmentCategory> categories = new List <AssignmentCategory>();

            foreach (var c in categoriesQuery)
            {
                AssignmentCategory newCategory = new AssignmentCategory()
                {
                    CategoryId     = c.CategoryId,
                    ClassId        = c.ClassId,
                    CategoryName   = c.CategoryName,
                    CategoryWeight = c.CategoryWeight
                };

                categories.Add(newCategory);
            }

            return(categories);
        }
예제 #2
0
        /// <summary>
        /// Creates a new assignment category for the specified class.
        /// A class can not have two categories with the same name.
        /// If a category of the given class with the given name already exists, return success = false.
        /// </summary>
        /// <param name="subject">The course subject abbreviation</param>
        /// <param name="num">The course number</param>
        /// <param name="season">The season part of the semester for the class the assignment belongs to</param>
        /// <param name="year">The year part of the semester for the class the assignment belongs to</param>
        /// <param name="category">The new category name</param>
        /// <param name="catweight">The new category weight</param>
        /// <returns>A JSON object containing {success = true/false} </returns>
        public IActionResult CreateAssignmentCategory(string subject, int num, string season, int year, string category, int catweight)
        {
            int classId = lookupClassId(subject, num, season, year);
            var query   = from co in db.Course
                          join cl in db.Class
                          on co.CourseId equals cl.CourseId into Courses
                          from c in Courses.DefaultIfEmpty()
                          join cat in db.AssignmentCategory
                          on c.ClassId equals cat.ClassId
                          select new
            {
                name   = cat.Name,
                weight = cat.Weight
            };

            if (query.Any())
            {
                foreach (var result in query)
                {
                    if (result.name.Equals(category))
                    {
                        return(Json(new { success = false }));
                    }
                }
            }
            AssignmentCategory ac = new AssignmentCategory();

            ac.Name    = category;
            ac.Weight  = catweight;
            ac.ClassId = classId;
            db.AssignmentCategory.Add(ac);
            db.SaveChanges();
            return(Json(new { success = true }));
        }
예제 #3
0
        /// <summary>
        /// Deletes all assignment categories attached to classid.
        /// </summary>
        /// <param name="classid">ID of class to delete assignment categories of</param>
        public async Task DeleteClassAssignmentCategories(int classid)
        {
            var assignmentCategoriesQuery = (from assignmentcategories in _context.AssignmentCategories
                                             select new
            {
                assignmentcategories.CategoryId,
                assignmentcategories.ClassId
            }).Where(ac => ac.ClassId == classid);

            List <AssignmentCategory> categoriesToDelete = new List <AssignmentCategory>();

            foreach (var ac in assignmentCategoriesQuery)
            {
                AssignmentCategory category = new AssignmentCategory()
                {
                    CategoryId = ac.CategoryId,
                    ClassId    = ac.ClassId
                };

                categoriesToDelete.Add(category);
            }

            _context.AssignmentCategories.RemoveRange(categoriesToDelete);
            await _context.SaveChangesAsync();
        }
예제 #4
0
        private static Assignment AddAssignment(AssignmentsDbContext db, AssignmentCategory category, string title, string body, int dayTillDue)
        {
            var assignment = new Assignment()
            {
                Id               = (title + "-" + category.OwnerId).ToUpper().Replace(' ', '-'),
                OwnerId          = category.OwnerId,
                OwnerLevel       = OwnerLevel.User,
                CreatedUTC       = DateTime.UtcNow,
                Status           = AssignmentStatus.Draft,
                Title            = title,
                AssignmentBody   = body,
                AllowComments    = false,
                DueUTC           = DateTime.Now.AddDays(dayTillDue),
                TimeZoneId       = TimeZoneHelper.DefaultTimeZoneId,
                SendNotification = false,
                CreatedBy        = category.OwnerId
            };

            if (!db.Assignments.Any(a => a.Id == assignment.Id))
            {
                db.Assignments.Add(assignment);
            }
            if (!db.AssignmentCategoryLinks.Any(l => l.AssignmentId == assignment.Id && l.CategoryId == category.Id))
            {
                db.AssignmentCategoryLinks.Add(new AssignmentCategoryLink()
                {
                    AssignmentId = assignment.Id, CategoryId = category.Id
                });
            }
            return(assignment);
        }
예제 #5
0
        /// <summary>
        /// Creates a new assignment category for the specified class.
        /// If a category of the given class with the given name already exists, return success = false.
        /// </summary>
        /// <param name="subject">The course subject abbreviation</param>
        /// <param name="num">The course number</param>
        /// <param name="season">The season part of the semester for the class the assignment belongs to</param>
        /// <param name="year">The year part of the semester for the class the assignment belongs to</param>
        /// <param name="category">The new category name</param>
        /// <param name="catweight">The new category weight</param>
        /// <returns>A JSON object containing {success = true/false} </returns>
        public IActionResult CreateAssignmentCategory(string subject, int num, string season, int year, string category, int catweight)
        {
            var classID = getClassID(subject, num, season, year);

            // To see if the category of the given class already exists
            var query1 =
                from ac in db.AssignmentCategory
                where ac.ClassId == classID && ac.Name == category
                select ac;

            if (query1.Count() > 0)
            {
                return(Json(new { success = false }));
            }

            AssignmentCategory a = new AssignmentCategory();

            a.ClassId = classID;
            a.Weight  = catweight;
            a.Name    = category;
            db.AssignmentCategory.Add(a);
            db.SaveChanges();

            return(Json(new { success = true }));
        }
예제 #6
0
        public async Task DeleteAssignmentCategory(int categoryid)
        {
            AssignmentCategory category = _context.AssignmentCategories.FirstOrDefault(ac => ac.CategoryId == categoryid);

            _context.AssignmentCategories.Remove(category);
            await _context.SaveChangesAsync();
        }
예제 #7
0
        /// <summary>
        /// Gets list of AssignmentCategories attached to classid
        /// </summary>
        /// <param name="classid">ID of class to get AssignmentCategories for</param>
        /// <returns>List(AssignmentCategory) of categories attached to classid</returns>
        public List <AssignmentCategory> GetAssignmentCategories(int classid)
        {
            List <AssignmentCategory> assignmentCategories = new List <AssignmentCategory>();

            var assignmentCategoriesQuery = (from assignmentcategories in _context.AssignmentCategories
                                             select new
            {
                assignmentcategories.CategoryId,
                assignmentcategories.ClassId,
                assignmentcategories.CategoryName,
                assignmentcategories.CategoryWeight
            }).Where(a => a.ClassId == classid).ToList();

            foreach (var category in assignmentCategoriesQuery)
            {
                AssignmentCategory newCategory = new AssignmentCategory
                {
                    CategoryId     = category.CategoryId,
                    ClassId        = category.ClassId,
                    CategoryName   = category.CategoryName,
                    CategoryWeight = category.CategoryWeight
                };

                assignmentCategories.Add(newCategory);
            }

            return(assignmentCategories);
        }
예제 #8
0
        /// <summary>
        /// Deletes all assignment categories of classes attached to teacherid
        /// </summary>
        /// <param name="teacherid">ID of teacher to delete assignment categories from classes</param>
        public async Task DeleteClassesAssignmentCategories(int teacherid)
        {
            var categoriesQuery = (from categories in _context.AssignmentCategories
                                   join classes in _context.Classes on categories.ClassId equals classes.ClassId
                                   select new
            {
                categories.CategoryId,
                classes.ClassId,
                classes.TeacherId
            }).Where(c => c.TeacherId == teacherid);

            List <AssignmentCategory> categoriesToDelete = new List <AssignmentCategory>();

            foreach (var c in categoriesQuery)
            {
                AssignmentCategory ac = new AssignmentCategory()
                {
                    CategoryId = c.CategoryId,
                    ClassId    = c.ClassId,
                };

                categoriesToDelete.Add(ac);
            }

            _context.AssignmentCategories.AttachRange(categoriesToDelete);
            _context.AssignmentCategories.RemoveRange(categoriesToDelete);
            await _context.SaveChangesAsync();
        }
예제 #9
0
 public async Task InsertCategoryAsync(AssignmentCategory category)
 {
     if (string.IsNullOrEmpty(category.Id))
     {
         category.Id = Guid.NewGuid().ToString("N");
     }
     _assignmentsDb.AssignmentCategories.Add(category);
     await _assignmentsDb.SaveChangesAsync();
 }
예제 #10
0
        /// <summary>
        /// Adds assignment category to class.
        /// </summary>
        /// <param name="classid">ID of class to add category to</param>
        /// <param name="categoryname">Name of new category</param>
        /// <param name="categoryweight">Weight percent of new category</param>
        /// <returns></returns>
        public async Task AddAssignmentCategory(int classid, string categoryname, int categoryweight)
        {
            AssignmentCategory categoryToAdd = new AssignmentCategory()
            {
                ClassId        = classid,
                CategoryName   = categoryname,
                CategoryWeight = categoryweight
            };

            _context.AssignmentCategories.Add(categoryToAdd);
            await _context.SaveChangesAsync();
        }
예제 #11
0
        public async Task UpdateCategoryAsync(AssignmentCategory category)
        {
            var oldCategory = await _assignmentsDb.AssignmentCategories.Where(x => x.Id == category.Id).FirstOrDefaultAsync();

            if (oldCategory == null)
            {
                throw new Exception($"Unable to find Assignment Category (Id: {category.Id}).");
            }
            oldCategory.OwnerLevel = category.OwnerLevel;
            oldCategory.OwnerId    = category.OwnerId ?? oldCategory.OwnerId;
            oldCategory.Title      = category.Title;
            await _assignmentsDb.SaveChangesAsync();
        }
예제 #12
0
        /// <summary>
        /// Creates a new assignment category for the specified class.
        /// </summary>
        /// <param name="subject">The course subject abbreviation</param>
        /// <param name="num">The course number</param>
        /// <param name="season">The season part of the semester for the class the assignment belongs to</param>
        /// <param name="year">The year part of the semester for the class the assignment belongs to</param>
        /// <param name="category">The new category name</param>
        /// <param name="catweight">The new category weight</param>
        /// <returns>A JSON object containing {success = true/false},
        ///	false if an assignment category with the same name already exists in the same class.</returns>
        public IActionResult CreateAssignmentCategory(string subject, int num, string season, int year, string category, int catweight)
        {
            // Query table to check if assignment category with the same name already exists in the same class.
            var query =
                from cl in db.Class
                join cr in db.Course on cl.CourseId equals cr.CourseId
                join ac in db.AssignmentCategory on cl.ClassId equals ac.ClassId
                join sm in db.Semester on cl.SemesterId equals sm.SemesterId
                where cr.DeptAbbr == subject && cr.Number == num && sm.Season == season && sm.Year == year && ac.Name == category
                select ac.Name;

            // If the above query found any results, then there already exists an AssignmentCategory
            // with the same name in the same class.
            if (query.ToArray().Length > 0)
            {
                return(Json(new { success = false }));
            }

            // Grab the class ID for the class specified by the input parameters.
            var queryForClassID =
                from cl in db.Class
                join cr in db.Course on cl.CourseId equals cr.CourseId
                join sm in db.Semester on cl.SemesterId equals sm.SemesterId
                where cr.DeptAbbr == subject && cr.Number == num && sm.Season == season && sm.Year == year
                select cl.ClassId;

            uint classID = queryForClassID.First();

            // Create the new Assignment category with the specified name/weight and the ClassID from above.
            AssignmentCategory newAssnCat = new AssignmentCategory();

            newAssnCat.Name    = category;
            newAssnCat.Weight  = (uint)catweight;
            newAssnCat.ClassId = classID;

            // only return true if the addition saves successfully.
            try
            {
                db.AssignmentCategory.Add(newAssnCat);
                db.SaveChanges();

                return(Json(new { success = true }));
            }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine(e.Message);
            }

            // return false if the try failed. Changes were not saved successfully to db.
            return(Json(new { success = false }));
        }
예제 #13
0
        /// <summary>
        /// Creates a new assignment category for the specified class.
        /// A class can not have two categories with the same name.
        /// If a category of the given class with the given name already exists, return success = false.
        /// </summary>
        /// <param name="subject">The course subject abbreviation</param>
        /// <param name="num">The course number</param>
        /// <param name="season">The season part of the semester for the class the assignment belongs to</param>
        /// <param name="year">The year part of the semester for the class the assignment belongs to</param>
        /// <param name="category">The new category name</param>
        /// <param name="catweight">The new category weight</param>
        /// <returns>A JSON object containing {success = true/false} </returns>
        public IActionResult CreateAssignmentCategory(string subject, int num, string season, int year, string category, int catweight)
        {
            using (Team9Context db = new Team9Context())
            {
                var queryCatagory =
                    from cr in db.Course
                    join cl in db.Class on cr.CatId equals cl.CatId into join1
                    from j1 in join1.DefaultIfEmpty()

                    join ac in db.AssignmentCategory on j1.ClassId equals ac.ClassId into join2
                    from j2 in join2.DefaultIfEmpty()

                    where cr.CourseNum == num && j1.Season == season && j1.Year == year && cr.DId == subject
                    select new { catName = j2.Name ?? null, classID = j1.ClassId };

                bool categoryAdded = false;

                for (int i = 0; i < queryCatagory.Count(); i++)
                {
                    if (queryCatagory.ToArray()[i].catName != null && queryCatagory.ToArray()[i].catName.Equals(category))
                    {
                        categoryAdded = true;
                    }
                }

                if (!categoryAdded)
                {
                    //insert into enroll, grade, uid, classID
                    AssignmentCategory catToAdd = new AssignmentCategory();
                    catToAdd.Name    = category;
                    catToAdd.Weight  = catweight;
                    catToAdd.ClassId = queryCatagory.ToArray()[0].classID;

                    db.AssignmentCategory.Add(catToAdd);
                    try { db.SaveChanges(); }
                    catch (Exception e) {
                        System.Diagnostics.Debug.WriteLine("Problem saving changes: " + e);
                    }


                    return(Json(new { success = true }));
                }
                else
                {
                    return(Json(new { success = false }));
                }
            }
        }
예제 #14
0
        private static AssignmentCategory AddAssignmentCategory(AssignmentsDbContext db, string title, string userId)
        {
            var ac = new AssignmentCategory()
            {
                Id         = (title + "-" + userId).ToUpper().Replace(' ', '-'),
                OwnerLevel = OwnerLevel.User,
                OwnerId    = userId,
                Title      = title
            };

            if (!db.AssignmentCategories.Any(c => c.Id == ac.Id))
            {
                db.AssignmentCategories.Add(ac);
            }
            return(ac);
        }
예제 #15
0
        /// <summary>
        /// Creates a new assignment category for the specified class.
        /// If a category of the given class with the given name already exists, return success = false.
        /// </summary>
        /// <param name="subject">The course subject abbreviation</param>
        /// <param name="num">The course number</param>
        /// <param name="season">The season part of the semester for the class the assignment belongs to</param>
        /// <param name="year">The year part of the semester for the class the assignment belongs to</param>
        /// <param name="category">The new category name</param>
        /// <param name="catweight">The new category weight</param>
        /// <returns>A JSON object containing {success = true/false} </returns>
        public IActionResult CreateAssignmentCategory(string subject, int num, string season, int year, string category, int catweight)
        {
            // grab the class id
            var query =
                from d in db.Department
                where d.Abbrv == subject
                join co in db.Course on d.DepartmentId equals co.DepartmentId
                where co.Number == num
                join cl in db.Class on co.CourseId equals cl.CourseId
                where cl.Season == season && cl.Year == year
                select new
            {
                cl.ClassId
            };

            uint theID = 0;

            // parse the id
            foreach (var item in query)
            {
                theID = item.ClassId;
                break;
            }

            // make sure the category doesn't already exist
            if (db.AssignmentCategory.Any(checkCat => checkCat.Name == category && checkCat.ClassId == theID))
            {
                return(Json(new { success = false }));
            }

            // make our new category and save it
            AssignmentCategory newCat = new AssignmentCategory();

            newCat.Name    = category;
            newCat.Weight  = (sbyte)catweight;
            newCat.ClassId = theID;

            db.AssignmentCategory.Add(newCat);
            db.SaveChanges();


            return(Json(new { success = true }));
        }
예제 #16
0
        public async Task<ActionResult> SaveAssignmentCategory(AssignmentCategoryViewModel model)
        {
            //ModelState.AddModelError("EmailSubject", "Test Error.");

            if (ModelState.IsValid)
            {
                var category = new AssignmentCategory()
                {
                    Id = model.Id,
                    OwnerLevel = model.OwnerLevel,
                    OwnerId = model.OwnerId,
                    Title = model.Title
                };

                if (string.IsNullOrEmpty(model.Id))
                    await _assignmentManager.InsertCategoryAsync(category);
                else
                    await _assignmentManager.UpdateCategoryAsync(category);

                return Ok(category);
            }
            return BadRequest(ModelState);
        }
예제 #17
0
        /// <summary>
        /// Creates a new assignment category for the specified class.
        /// </summary>
        /// <param name="subject">The course subject abbreviation</param>
        /// <param name="num">The course number</param>
        /// <param name="season">The season part of the semester for the class the assignment belongs to</param>
        /// <param name="year">The year part of the semester for the class the assignment belongs to</param>
        /// <param name="category">The new category name</param>
        /// <param name="catweight">The new category weight</param>
        /// <returns>A JSON object containing {success = true/false},
        ///	false if an assignment category with the same name already exists in the same class.</returns>
        public IActionResult CreateAssignmentCategory(string subject, int num, string season, int year, string category, int catweight)
        {
            var query1 = from p in db.Department
                         join g in db.Courses on p.DId equals g.DId
                         join h in db.Classes on g.CId equals h.CId
                         join w in db.AssignmentCategory on h.ClassId equals w.ClassId
                         where h.SemesterSeason.Equals(season) && h.SemesterYear == year && g.Number.Equals(num) &&
                         p.Subject.Equals(subject) && w.Name.Equals(category)
                         select h.ClassId;

            if (query1.Count() == 1)
            {
                return(Json(new { success = false }));
            }

            var query = from p in db.Department
                        join g in db.Courses on p.DId equals g.DId
                        join h in db.Classes on g.CId equals h.CId
                        where h.SemesterSeason.Equals(season) && h.SemesterYear == year && g.Number.Equals(num) &&
                        p.Subject.Equals(subject)
                        select h.ClassId;

            if (query.Count() == 1)
            {
                AssignmentCategory assignCat = new AssignmentCategory();
                assignCat.ClassId = query.ToArray()[0];
                assignCat.Name    = category;
                assignCat.Weight  = (uint?)catweight;

                db.AssignmentCategory.Add(assignCat);
                int success = db.SaveChanges();
                return(Json(new { success = true }));
            }

            return(Json(new { success = false }));
        }