public void DeleteCourse(Course course)
        {
            Contract.Requires<ArgumentNullException>(course != null, "The course must be non-null!");

            using (var context = new SchoolContext())
            {
                context.Courses.Attach(course);
                context.Courses.Remove(course);

                if (context.SaveChanges() != 0)
                {
                    /*
                    if (Logger.IsLoggingEnabled())
                    {
                        Logger.Write("The course " + course + " was successfully removed!", "General", 2, 2,
                            TraceEventType.Information);
                    }*/
                }/*
                else
                {

                    if (Logger.IsLoggingEnabled())
                    {
                        Logger.Write("The course " + course + " was not removed!", "Important", 1, 1,
                            TraceEventType.Error);
                    }
                }*/
            }
        }
 public void AddCorequisiteToCourse(Course course1, Course course2)
 {
     if (course1 == null || course2 == null)
         throw new ArgumentNullException();
     course1.Corequisites.Add(course2);
     course2.Corequisites.Add(course1);
 }
        public void AddCourse(Course course)
        {
            Contract.Requires<ArgumentNullException>(course != null, "The course must be non-null!");

            using (var context = new SchoolContext())
            {
                context.Courses.Add(course);

                if (context.SaveChanges() != 0)
                {

                    if (Logger.IsLoggingEnabled())
                    {
                        Logger.Write("The course: " + course + " was successfully inserted!", "General", 2, 2,
                            TraceEventType.Information);
                    }
                }

                else
                {
                    if (Logger.IsLoggingEnabled())
                    {
                        Logger.Write("The course: " + course + " was not inserted!", "Important", 1, 1,
                            TraceEventType.Error);
                    }
                }
            }
        }
 public IList<Catalog> GetAllStudentCatalogsForCourse(Student student, Course course)
 {
     using (var context = new MyApplicationContext())
     {
         return context.Catalogs.Where(catalog => catalog.Student == student && catalog.Exam.Course == course).ToList();
     }
 }
 /// <summary>
 /// Adds the course.
 /// </summary>
 /// <param name="course">The course.</param>
 public void AddCourse(Course course)
 {
     using (var context = new MyApplicationContext())
     {
         context.Courses.Add(course);
         context.SaveChanges();
     }
 }
 public void AddPrerequisiteToCourse(Course course, Course prereq)
 {
     if (course == null || prereq == null)
         throw new ArgumentNullException();
     if (IsCoursePrerequisiteForCourse(course, prereq) || IsCoursePrerequisiteForCourse(prereq, course))
         throw new InvalidOperationException();
     course.Prerequisites.Add(prereq);
 }
 public bool StudentHasPrerequisites(Student student, Course course)
 {
     if (course.Prerequisites.Count == 0)
         return true;
     foreach (var prereq in course.Prerequisites)
         if (HasStudentCourse(student, prereq) && StudentPassedCourse(student, prereq))
             return true;
     return false;
 }
 /// <summary>
 /// Deletes the course.
 /// </summary>
 /// <param name="course">The course.</param>
 public void DeleteCourse(Course course)
 {
     using (var context = new MyApplicationContext())
     {
         var newProd = new Course { Id = course.Id };
         context.Courses.Attach(newProd);
         context.Courses.Remove(newProd);
         context.SaveChanges();
     }
 }
        public void TestCourseDelete()
        {
            Course course = new Course() { Id = 15 };

            courseDataService.Expect(dao => dao.DeleteCourse(course));

            courseService.DeleteCourse(course);

            courseDataService.VerifyAllExpectations();
        }
 public bool StudentPassedCoursePacket(Student student, Course course)
 {
     if (StudentPassedCourse(student, course))
     {
         foreach (var coreqCourse in course.Corequisites)
             if (!StudentPassedCourse(student, coreqCourse))
                 return false;
         return true;
     }
     return false;
 }
 public bool IsCoursePrerequisiteForCourse(Course course, Course course2)
 {
     if (course == null || course2 == null)
         throw new ArgumentNullException();
     foreach (var prereq in course2.Prerequisites)
         if (prereq.Id == course.Id)
             return true;
         else if (IsCoursePrerequisiteForCourse(course, prereq))
             return true;
     return false;
 }
 public void SetUp()
 {
     // a valid course
     course = new Course()
     {
         Name = "Grafica",
         Credit = 6,
         MinThreshold = 100,
         MaxThreshold = 200,
         Cost = 900
     };
 }
 /// <summary>
 /// Updates the course.
 /// </summary>
 /// <param name="course">The course.</param>
 /// <exception cref="System.Collections.Generic.KeyNotFoundException"></exception>
 public void UpdateCourse(Course course)
 {
     using (var context = new MyApplicationContext())
     {
         Course courseRef = context.Courses.Where(c => c.Id == course.Id).SingleOrDefault();
         if (courseRef != null)
         {
             courseRef = course;
             context.SaveChanges();
         }
         else
             throw new KeyNotFoundException();
     }
 }
        public void ValidateCircularPreRequisites(Course course, ValidationResults results)
        {
            // verificarea de prerequisites
            if (!course.CoursePreRequisites.Any()) return;

            // Verificarea faptului ca nu exista cicluri intre cursuri (A1 prerequisite pentru A2, A2 pentru A3, ... AN pentru A1)
            if (CourseHasCircularRequisite(course, null, "CoursePreRequisites"))
            {
                results.AddResult(new ValidationResult
                    (
                    "The course cannot have a circular pre-requisite", results, "ValidationMethod", "error", null)
                    );
            }
        }
        public void TestCourseGetById()
        {
            int id = 15;
            Course course = new Course()
            {
                Id = id,
                Name = "Baze de date"
            };

            courseDataService.Stub(dao => dao.GetCourseById(id)).Return(course);

            Course result = courseService.GetCourseById(id);

            Assert.AreEqual(id, result.Id);
        }
        // Create
        public bool AddCourse(Course course)
        {
            if (!ValidateCourse(course))
            {
                var sb = new StringBuilder();
                foreach (var error in Errors)
                {
                    sb.Append(error);
                }

                throw new ValidationException(sb.ToString());
            }

            DataMapperFactory.GetMapperFactory().CourseMapper.AddCourse(course);

            return true;
        }
        public void TestAddCourseAlreadyPrerequisiteCourse()
        {
            Course course3 = new Course();
            Course course2 = new Course();
            Course course1 = new Course() { Prerequisites = { course2, course3 } };

            courseService.AddPrerequisiteToCourse(course1, course2);
        }
        public void TestIsCoursePrereqNullToObj()
        {
            Course course1 = null;
            Course course2 = new Course();

            courseService.IsCoursePrerequisiteForCourse(course1, course2);
        }
        public void TestAddCourseIsPrereqIndirectTree()
        {
            Course course1 = new Course();
            Course course5 = new Course();
            Course course4 = new Course() { Prerequisites = { course5, course1 } };
            Course course3 = new Course();
            Course course2 = new Course() { Prerequisites = { course3, course4 } };

            Assert.IsTrue(courseService.IsCoursePrerequisiteForCourse(course1, course2));
        }
        public void TestAddCourseIsPrereqIndirect()
        {
            Course course3 = new Course();
            Course course2 = new Course() { Prerequisites = { course3 } };
            Course course1 = new Course() { Prerequisites = { course2 } };

            Assert.IsTrue(courseService.IsCoursePrerequisiteForCourse(course3, course1));
        }
        public void TestAddCourseIsNotPrereqEmptyPrereq()
        {
            Course course2 = new Course();
            Course course1 = new Course();

            Assert.IsFalse(courseService.IsCoursePrerequisiteForCourse(course2, course1));
        }
        public void TestAddTwoPrerequisite()
        {
            Course course1 = new Course() { Id = 1 };
            Course course2 = new Course() { Id = 2 };
            Course course3 = new Course() { Id = 3 };

            courseService.AddPrerequisiteToCourse(course1, course2);
            courseService.AddPrerequisiteToCourse(course1, course3);

            Assert.AreEqual(2, course1.Prerequisites.Count);
        }
 // Update
 public Course UpdateCourse(int courseId, Course course)
 {
     if (ValidateCourse(course))
         return DataMapperFactory.GetMapperFactory().CourseMapper.UpdateCourse(courseId, course);
     return null;
 }
        public void TestCourseGetListOfCourses()
        {
            Course course1 = new Course()
            {
                Id = 11,
                Name = "Baze de date"
            };
            Course course2 = new Course()
            {
                Id = 12,
                Name = "Grafica"
            };
            IList<Course> courses = new List<Course>() { course1, course2 };

            courseDataService.Stub(dao => dao.GetAllCourses()).Return(courses);

            var result = courseService.GetListOfCourses();

            Assert.AreEqual(result.Count, courses.Count);
        }
        private bool ValidateCourse(Course course)
        {
            // Se va impune din logica aplicatiei ca pentru cursurile din semesterul 1 sa nu existe prerequisites
            var semesters = DataMapperFactory.GetMapperFactory().SemesterMapper.GetAllSemesters();

            bool flag = true;
            string message = null;

            if (semesters.Any() && course.Semesters.Contains(semesters.OrderBy(s => s.StartDate).First()) &&
                course.CoursePreRequisites.Any())
            {
                flag = false;
                message = "Courses in the first semester cannot have prerequisites!";
            }
            if (course.Semesters.Count > 0 && course.CoursePreRequisites.Any())
            {
                flag = false;
                message = "Courses in the first semester cannot have prerequisites!";
            }
            if (!flag)
                Errors.Add(message);

            var result = Validation.Validate(course);
            if (!result.IsValid)
            {
                var firstOrDefault = result.FirstOrDefault();
                if (firstOrDefault != null) Errors.Add(firstOrDefault.Message);
            }
            return flag && result.IsValid;
        }
        public void TestAddNullCorequisite()
        {
            Course course1 = new Course();
            Course course2 = null;

            courseService.AddCorequisiteToCourse(course1, course2);
        }
 public void DeleteCourse(Course course)
 {
     DataMapperFactory.GetMapperFactory().CourseMapper.DeleteCourse(course);
 }
        public void TestAddToNullPrerequisite()
        {
            Course course1 = null;
            Course course2 = new Course();

            courseService.AddPrerequisiteToCourse(course1, course2);
        }
        public Course UpdateCourse(int courseId, string name, string description, short credits, decimal cost,
            string currency, int lowerBound, int upperBound)
        {
            var course = new Course
            {
                CourseId = courseId,
                Name = name,
                Description = description,
                Credits = credits,
                Cost = cost,
                Currency = currency,
                LowerBound =  lowerBound,
                UpperBound =  upperBound
            };

            if(ValidateCourse(course))
                return DataMapperFactory.GetMapperFactory()
                    .CourseMapper.UpdateCourse(courseId, name, description, credits, cost, currency);
            return null;
        }
        public void TestAddPrerequisiteCrossCheck()
        {
            Course course1 = new Course();
            Course course2 = new Course();

            courseService.AddPrerequisiteToCourse(course1, course2);

            Assert.AreEqual(0, course2.Prerequisites.Count);
        }