예제 #1
0
        public ScheduleBoard Calculating(Guid semesterId)
        {
            ScheduleBoard board = new ScheduleBoard();

            Logger.Debug($"Calculating semester: {semesterId}");
            // Get Class Groups
            List <ClassGroup> classGroups = this.UnitOfWork.ClassGroupRepository.GetSemesterClassGroups(semesterId).ToList();

            var mapper = config.CreateMapper();

            List <ClassGroupSchedule> cgs = mapper.Map <List <ClassGroup>, List <ClassGroupSchedule> >(classGroups);

            Logger.Debug($"Calculating semester - Total group: {cgs.Count}");

            foreach (ClassGroupSchedule cg in cgs)
            {
                Logger.Debug($"Calculating group: {cg.Name}");
                board.ClassGroups.Add(cg);
                this.CalculateClassGroupSchedule(cg);
                this.CalculateSchedule(cg, board);
                Logger.Debug($"Complete calculating group: {cg.Name}");
            }

            Logger.Debug($"Complete calculating semester: {semesterId}");

            return(board);
        }
예제 #2
0
        public ScheduleBoard GenerateScheduleBoard(Guid scheduleId)
        {
            Logger.Debug($"Start generating schedule board: {scheduleId}");

            if (scheduleId == null || scheduleId == Guid.Empty)
            {
                Logger.Error($"ScheduleId is empty.");
                throw new ArgumentNullException("scheduleId");
            }

            Schedule.Models.SchedulingTable schedule = this.UnitOfWork.SchedulingTableRepository.GetById(scheduleId);

            if (schedule == null)
            {
                Logger.Error($"Schedule ({scheduleId}) does not exist.");
                throw new InvalidOperationException($"Schedule ({scheduleId}) does not exist.");
            }

            Guid semesterId = schedule.SemesterId;

            if (semesterId == null || semesterId == Guid.Empty)
            {
                Logger.Error($"Schedule ({scheduleId}) does not content SemesterId.");
                throw new InvalidOperationException($"Schedule ({scheduleId}) does not content SemesterId.");
            }

            ScheduleBoard board = new ScheduleBoard();

            board.Id = scheduleId;

            Logger.Debug($"Start calculating schedule-board for semester: {semesterId}");

            // Get Class Groups
            List <ClassGroup> classGroups = this.UnitOfWork.ClassGroupRepository.GetSemesterClassGroups(semesterId).ToList();

            Logger.Debug($"Found {classGroups.Count} class-groups");

            var mapper = config.CreateMapper();

            List <ClassGroupSchedule> cgs = mapper.Map <List <ClassGroup>, List <ClassGroupSchedule> >(classGroups);

            Logger.Debug($"Start calculating schedule for {cgs.Count} class-group.");

            foreach (ClassGroupSchedule cg in cgs)
            {
                Logger.Debug($"Calculating group: {cg.Name}");
                board.ClassGroups.Add(cg);
                this.CalculateClassGroupSchedule(cg);
                this.CalculateSchedule(cg, board);
                Logger.Debug($"Complete calculating group: {cg.Name}");
            }

            this.UnitOfWork.SaveChanges();

            Logger.Debug($"Complete calculating semester: {semesterId}");

            return(board);
        }
예제 #3
0
 private void CalculateSchedule(ClassGroupSchedule classGroup, ScheduleBoard board)
 {
     foreach (ClassRoomSchedule classRoom in classGroup.ClassRooms)
     {
         //foreach (CourseSubjectSchedule courseSubject in classGroup.TrainingProgram.CourseSubjects)
         foreach (ClassCourseSchedule course in classRoom.Courses)
         {
             StoneCastle.Scheduler.Models.TimetableModel tt = classRoom.Timetable;
             this.CalculateTimetable(tt, course, board);
         }
         Logger.Debug($"Calculated class: {classRoom.Name}");
     }
 }
예제 #4
0
        public ScheduleBoard Processing(Guid semesterId)
        {
            /*StoneCastle.Scheduler.Models.ClassGroupSchedule cg1 = this.GetRandomScheduleGroup("10", this.workingShiftInDay);
             * StoneCastle.Scheduler.Models.ClassGroupSchedule cg2 = this.GetRandomScheduleGroup("11", this.workingShiftInDay);
             * StoneCastle.Scheduler.Models.ClassGroupSchedule cg3 = this.GetRandomScheduleGroup("12", this.workingShiftInDay);
             * this.ScheduleBoard.ScheduleGroups.Add(cg1);
             * this.ScheduleBoard.ScheduleGroups.Add(cg2);
             * this.ScheduleBoard.ScheduleGroups.Add(cg3);
             *
             * this.CalculateSchedule(cg1);
             * this.CalculateSchedule(cg2);
             * this.CalculateSchedule(cg3);
             *
             * return this.ScheduleBoard;*/

            ScheduleBoard board = this.Calculating(semesterId);

            return(board);
        }
예제 #5
0
        public ScheduleBoard ProceedGeneratingScheduleBoard(Guid scheduleId)
        {
            this.UnitOfWork.SchedulingTableRepository.ChangeGeneratingStarted(scheduleId);
            Logger.Debug($"Changed status of schedule to GENERATING: {scheduleId}");
            this.UnitOfWork.SaveChanges();

            this.ClearScheduleBoard(scheduleId);
            Logger.Debug($"Cleared/Reset schedule-board: {scheduleId}");

            ScheduleBoard board = this.GenerateScheduleBoard(scheduleId);

            this.SaveScheduleBoard(board);

            this.UnitOfWork.SchedulingTableRepository.ChangeGeneratingCompleted(scheduleId);
            Logger.Debug($"Changed status of schedule to GENERATED: {scheduleId}");

            this.UnitOfWork.SaveChanges();

            return(board);
        }
예제 #6
0
        public ScheduleMan(IUnitOfWork unitOfWork, ITimetableService timetableService) : base(unitOfWork)
        {
            this.timetableService = timetableService;

            this.ScheduleBoard = new ScheduleBoard();

            config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap <Organization.Models.ClassGroup, ClassGroupSchedule>(); //.ForMember(x => x.TrainingProgram, y => y.Ignore());
                cfg.CreateMap <TrainingProgram.Models.TrainingProgram, TrainingProgramSchedule>();
                cfg.CreateMap <Organization.Models.ClassRoom, ClassRoomSchedule>();
                cfg.CreateMap <TrainingProgram.Models.Course, CourseSchedule>().ForMember(x => x.TrainingProgram, y => y.Ignore());
                cfg.CreateMap <Schedule.Models.Timetable, TimetableModel>();
                cfg.CreateMap <ClassCourse, ClassCourseSchedule>();
                cfg.CreateMap <CourseSection, CourseSectionSchedule>();
                cfg.CreateMap <Account.Models.Teacher, TeacherScheduleModel>();
                cfg.CreateMap <Account.Models.Account, Account.Models.AccountModel>();
                cfg.CreateMap <Account.Models.Profile, Account.Models.ProfileModel>();
                cfg.CreateMap <Application.Models.User, Application.Models.UserView>();
            });
        }
예제 #7
0
        public ScheduleStageInfo CalculateSemesterScheduleBoard(Guid semesterId)
        {
            Schedule.Models.SchedulingTable scheduleTable = this.UnitOfWork.SchedulingTableRepository.GetSemesterDefaultSchedule(semesterId);

            Guid scheduleId = Guid.Empty;

            if (scheduleTable == null)
            {
                scheduleTable = this.UnitOfWork.SchedulingTableRepository.CreateSchedule(semesterId);
                this.UnitOfWork.SaveChanges();
            }

            scheduleId = scheduleTable.Id;

            this.UnitOfWork.SchedulingTableRepository.ChangedValidated(scheduleId);
            Logger.Debug($"Changed status of schedule to VALIDATED: {scheduleId}");
            this.UnitOfWork.SaveChanges();

            this.UnitOfWork.SchedulingTableRepository.ChangeGeneratingStarted(scheduleId);
            Logger.Debug($"Changed status of schedule to GENERATING: {scheduleId}");
            this.UnitOfWork.SaveChanges();

            this.ClearScheduleBoard(scheduleId);
            Logger.Debug($"Cleared/Reset schedule-board: {scheduleId}");

            ScheduleBoard board = this.GenerateScheduleBoard(scheduleId);

            this.SaveScheduleBoard(board);

            this.UnitOfWork.SchedulingTableRepository.ChangeGeneratingCompleted(scheduleId);
            Logger.Debug($"Changed status of schedule to GENERATED: {scheduleId}");

            this.UnitOfWork.SaveChanges();

            SchedulingTable schedule = this.UnitOfWork.SchedulingTableRepository.GetById(scheduleId);

            ScheduleStageInfo scheduleStageInfo = Mapper.Map <Schedule.Models.SchedulingTable, Schedule.Models.ScheduleStageInfo>(schedule);

            return(scheduleStageInfo);
        }
예제 #8
0
        public KatinaSchedulingService(IUnitOfWork unitOfWork, ITimetableService timetableService) : base(unitOfWork)
        {
            this.timetableService = timetableService;

            this.ScheduleBoard = new ScheduleBoard();

            config = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap <Organization.Models.ClassGroup, ClassGroupSchedule>(); //.ForMember(x => x.TrainingProgram, y => y.Ignore());
                cfg.CreateMap <TrainingProgram.Models.TrainingProgram, TrainingProgramSchedule>();
                cfg.CreateMap <Organization.Models.ClassRoom, ClassRoomSchedule>().ForMember(x => x.Courses, y => y.Ignore());;
                cfg.CreateMap <TrainingProgram.Models.Course, CourseSchedule>().ForMember(x => x.TrainingProgram, y => y.Ignore());
                cfg.CreateMap <Schedule.Models.Timetable, TimetableModel>();
                cfg.CreateMap <ClassCourse, ClassCourseSchedule>(); //.ForMember(x => x.ClassRoom, y => y.Ignore()); ;
                cfg.CreateMap <CourseSection, CourseSectionSchedule>().ForMember(x => x.Timetable, y => y.Ignore());
                cfg.CreateMap <Schedule.Models.ScheduleEvent, StoneCastle.Schedule.Models.ScheduleEventModel>().ForMember(x => x.SchedulingTable, y => y.Ignore());
                cfg.CreateMap <Account.Models.Teacher, StoneCastle.Scheduler.Models.TeacherScheduleModel>().ForMember(dest => dest.FullName, opt => opt.MapFrom(src => $"{src.Account.Profile.FirstName} {src.Account.Profile.LastName}"));
                cfg.CreateMap <Account.Models.Account, Account.Models.AccountModel>();
                cfg.CreateMap <Account.Models.Profile, Account.Models.ProfileModel>();
                cfg.CreateMap <Application.Models.User, Application.Models.UserView>();
            });
        }
예제 #9
0
        private bool CanBeBookedForTeacher(TeacherScheduleModel teacher, TimeShift tf, ScheduleBoard board)
        {
            foreach (ClassGroupSchedule cg in board.ClassGroups)
            {
                foreach (ClassRoomSchedule cr in cg.ClassRooms)
                {
                    StoneCastle.Scheduler.Models.TimetableModel tt = cr.Timetable;

                    if (this.IsTeacherAlreadyBooked(teacher, tf, tt))
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
예제 #10
0
        private void CalculateTimetable(StoneCastle.Scheduler.Models.TimetableModel tt, ClassCourseSchedule course, ScheduleBoard board)
        {
            if (course.Course.SectionPerWeek == 0)
            {
                return;
            }

            bool canSchedule = false;

            // Check tt has open-shifts for courses
            int openSlotCount = 0;

            for (int i = 0; i < tt.ShiftPerDay * tt.SlotPerShift; i++)
            {
                for (int j = 0; j < Commons.Constants.DAY_OF_WEEK; j++)
                {
                    CourseSectionSchedule cs = tt.TimeTableMatrix[i, j];
                    if (cs.Stage == COURSE_SECTION_STAGE.OPEN)
                    {
                        openSlotCount++;
                    }
                }
            }

            if (openSlotCount >= course.Course.SectionPerWeek)
            {
                canSchedule = true;
            }

            if (canSchedule)
            {
                List <TimeShift> checklist = new List <TimeShift>();

                int bookedCount = 0;
                do
                {
                    int i = rand.Next(tt.ShiftPerDay);
                    int j = rand.Next(Commons.Constants.DAY_OF_WEEK);
                    int k = rand.Next(tt.SlotPerShift);

                    CourseSectionSchedule cs = tt.TimeTableMatrix[i * tt.SlotPerShift + k, j];
                    if (cs.Stage == COURSE_SECTION_STAGE.OPEN)
                    {
                        TimeShift tf = new TimeShift()
                        {
                            Day   = (DayOfWeek)j,
                            Shift = i,
                            Slot  = k
                        };

                        if (!this.IsTimeShiftExistInList(tf, checklist))
                        {
                            checklist.Add(tf);

                            // Check exiting teacher section booked
                            if (this.CanBeBookedForTeacher(course.Teacher, tf, board))
                            {
                                cs.ClassCourse = course;
                                cs.Stage       = COURSE_SECTION_STAGE.BOOKED;
                                bookedCount++;
                            }
                        }
                    }
                } while (bookedCount < course.Course.SectionPerWeek && checklist.Count < openSlotCount);
            }
        }
예제 #11
0
        public void SaveScheduleBoard(ScheduleBoard scheduleBoard)
        {
            if (scheduleBoard == null)
            {
                Logger.Error($"scheduleBoard is empty.");
                throw new ArgumentNullException("scheduleBoard");
            }

            Logger.Debug($"Start saving schedule board: {scheduleBoard.Id}");

            Schedule.Models.SchedulingTable schedule = this.UnitOfWork.SchedulingTableRepository.GetById(scheduleBoard.Id);

            if (schedule == null)
            {
                Logger.Error($"Schedule ({scheduleBoard.Id}) does not exist.");
                throw new InvalidOperationException($"Schedule ({scheduleBoard.Id}) does not exist.");
            }

            var mapper = config.CreateMapper();

            foreach (ClassGroupSchedule cg in scheduleBoard.ClassGroups)
            {
                foreach (ClassRoomSchedule crs in cg.ClassRooms)
                {
                    Timetable tt = new Timetable()
                    {
                        Id           = Guid.NewGuid(),
                        Name         = crs.Name,
                        ShiftPerDay  = crs.Timetable.ShiftPerDay,
                        SlotPerShift = crs.Timetable.SlotPerShift,
                    };

                    this.UnitOfWork.ClassTimetableRepository.Create(scheduleBoard.Id, crs.Id, tt);

                    for (int i = 0; i < crs.Timetable.ShiftPerDay * crs.Timetable.SlotPerShift; i++)
                    {
                        for (int j = 0; j < Commons.Constants.DAY_OF_WEEK; j++)
                        {
                            CourseSectionSchedule cs = crs.Timetable.TimeTableMatrix[i, j];

                            if (cs != null && (cs.Id != null && cs.Id != Guid.Empty) && (cs.ClassCourse != null && (cs.ClassCourse.Id != null && cs.ClassCourse.Id != Guid.Empty)))
                            {// Added
                                //CourseSection courseSection = mapper.Map<CourseSectionSchedule, CourseSection>(cs);
                                CourseSection courseSection = new CourseSection();
                                courseSection.Day           = (DayOfWeek)j;
                                courseSection.Id            = Guid.NewGuid();
                                courseSection.TimetableId   = tt.Id;
                                courseSection.ClassCourseId = cs.ClassCourse.Id;
                                courseSection.Stage         = cs.Stage;
                                courseSection.Shift         = cs.Shift;
                                courseSection.Slot          = cs.Slot;

                                this.UnitOfWork.CourseSectionRepository.Insert(courseSection);
                            }
                        }
                    }
                }
            }

            this.UnitOfWork.SaveChanges();

            Logger.Debug($"Complete saving schedule board: {scheduleBoard.Id}");
        }
예제 #12
0
        public ScheduleBoard LoadScheduleBoard(Guid scheduleId)
        {
            Logger.Debug($"Start loading schedule board: {scheduleId}");

            if (scheduleId == null || scheduleId == Guid.Empty)
            {
                Logger.Error($"ScheduleId is empty.");
                throw new ArgumentNullException("scheduleId");
            }

            Schedule.Models.SchedulingTable schedule = this.UnitOfWork.SchedulingTableRepository.GetById(scheduleId);

            if (schedule == null)
            {
                Logger.Error($"Schedule ({scheduleId}) does not exist.");
                throw new InvalidOperationException($"Schedule ({scheduleId}) does not exist.");
            }

            Guid semesterId = schedule.SemesterId;

            if (semesterId == null || semesterId == Guid.Empty)
            {
                Logger.Error($"Schedule ({scheduleId}) does not content SemesterId.");
                throw new InvalidOperationException($"Schedule ({scheduleId}) does not content SemesterId.");
            }

            ScheduleBoard board = new ScheduleBoard();

            board.Id = scheduleId;

            Logger.Debug($"Start loading schedule-board for semester: {semesterId}");

            // Get Class Groups
            List <ClassGroup> classGroups = this.UnitOfWork.ClassGroupRepository.GetSemesterClassGroups(semesterId).ToList();

            Logger.Debug($"Found {classGroups.Count} class-groups");

            var mapper = config.CreateMapper();

            List <ClassGroupSchedule> cgs = mapper.Map <List <ClassGroup>, List <ClassGroupSchedule> >(classGroups);

            foreach (ClassGroupSchedule cg in cgs)
            {
                Logger.Debug($"Loading group: {cg.Name}");
                board.ClassGroups.Add(cg);

                foreach (ClassRoomSchedule cr in cg.ClassRooms)
                {
                    Timetable tt = this.UnitOfWork.ClassTimetableRepository.GetTimetable(board.Id, cr.Id);
                    if (tt != null)
                    {
                        TimetableModel ttm = mapper.Map <Timetable, TimetableModel>(tt);

                        cr.Timetable = ttm;
                        cr.Timetable.TimeTableMatrix = ttm.GenerateTimeTableMatrix();
                    }

                    List <ClassCourse> courses = this.UnitOfWork.ClassCourseRepository.GetCoursesByClassRoom(cr.Id).ToList();
                    cr.Courses = mapper.Map <List <ClassCourse>, List <ClassCourseSchedule> >(courses);
                }

                Logger.Debug($"Complete loading group: {cg.Name}");
            }

            Logger.Debug($"Complete loading semester: {semesterId}");

            return(board);
        }