Implement planning of timetable slots with specified weeks

Co-Authored-By: Jakub Jirutka <[email protected]>

Author: pidekjunior

app/roles/planned_semester_period.rb

@@ -9,7 +9,7 @@ class PlannedSemesterPeriod < RolePlaying::Role
 
   def plan(teaching_time)
     scheduling_start = combine_date_with_time(
-      schedule_start_day(teaching_time.parity),
+      schedule_start_day(teaching_time),
       teaching_time.start_time
     )
 
@@ -33,8 +33,11 @@ def combine_date_with_time(date, time)
     Time.new(date.year, date.month, date.day, time.hour, time.min, time.sec)
   end
 
-  def schedule_start_day(teaching_time_parity)
-    if teaching_time_parity == 'both' || teaching_time_parity == first_week_parity
+  def schedule_start_day(teaching_time)
+    if teaching_time.start_date
+      # Teaching time is defined only in some time interval.
+      [starts_at, teaching_time.start_date].max
+    elsif teaching_time.parity == 'both' || teaching_time.parity == first_week_parity
       starts_at
     else
       starts_at.next_week(:monday)

app/roles/planned_timetable_slot.rb

@@ -8,9 +8,12 @@ def initialize(obj, time_converter)
     @time_converter = time_converter
   end
 
-  def generate_events(faculty_semester, semester_period)
-    teaching_time = generate_teaching_time
-    event_periods = semester_period.plan(teaching_time)
+  def generate_events(faculty_semester, semester_period, weeks_dates)
+    teaching_times = generate_teaching_times(weeks_dates)
+    # Count event periods in current semester period in all week intervals.
+    event_periods = teaching_times.flat_map do |teaching_time|
+      semester_period.plan(teaching_time)
+    end
     create_events(event_periods, faculty_semester).tap do |events|
       events.map { |e| e.deleted = !!deleted_at }
     end
@@ -32,21 +35,41 @@ def day
   end
 
   private
+
   attr_reader :time_converter
 
   def filter_extra_events(all_events, planned_events)
     planned_event_ids = planned_events.map(&:id)
     all_events.find_all { |evt| !planned_event_ids.include?(evt.id) }
   end
 
-  def generate_teaching_time
-    teaching_period = if start_time && end_time
-        # Timetable slot has start time and end time already specified.
-        Period.new(start_time, end_time)
-      else
-        time_converter.convert_time(first_hour, duration)
+  def generate_teaching_times(weeks_dates)
+    teaching_period = generate_teaching_period
+
+    if weeks.blank?
+      # Timetable slot with even/odd week parity.
+      [Sirius::TeachingTime.new(teaching_period: teaching_period, day: day, parity: parity)]
+    else
+      # Timetable slot with specified weeks.
+      weeks_intervals.map do |first, last|
+        start_date = weeks_dates[first - 1].first
+        end_date = weeks_dates[last - 1].last
+        Sirius::TeachingTime.new(teaching_period: teaching_period, day: day, start_date: start_date, end_date: end_date)
       end
-    Sirius::TeachingTime.new(teaching_period: teaching_period, day: day, parity: parity)
+    end
+  end
+
+  def generate_teaching_period
+    if start_time && end_time
+      # Timetable slot has start time and end time already specified.
+      Period.new(start_time, end_time)
+    else
+      time_converter.convert_time(first_hour, duration)
+    end
+  end
+
+  def weeks_intervals
+    weeks.slice_when { |i, j| i + 1 != j }.map(&:minmax)
   end
 
   def create_events(event_periods, faculty_semester)

lib/actors/teacher_timetable_slot_transformer.rb

@@ -4,6 +4,7 @@
 require 'sirius/time_converter'
 require 'roles/planned_timetable_slot'
 require 'day'
+require 'sirius/faculty_semester_weeks_generator'
 
 # A convertor which receives TeacherTimetableSlots loaded from KOSapi and plans them into
 # Events according to semester parameters and semester periods.
@@ -16,6 +17,7 @@ def initialize(input, output, semester)
     self.input = input
     self.output = output
     @semester = semester
+    @semester_weeks_dates = Sirius::FacultySemesterWeeksGenerator.generate_semester_weeks_dates(@semester)
     @events = nil
   end
 
@@ -58,7 +60,7 @@ def plan_events(slot, teacher)
     end
 
     events = periods.flat_map do |period|
-      PlannedTimetableSlot.new(slot, time_converter).generate_events(@semester, period)
+      PlannedTimetableSlot.new(slot, time_converter).generate_events(@semester, period, @semester_weeks_dates)
     end
 
     events.each_with_index do |e, i|

lib/sirius/event_planner.rb

@@ -3,6 +3,7 @@
 require 'models/parallel'
 require 'sirius/time_converter'
 require 'roles/planned_semester_period'
+require 'sirius/faculty_semester_weeks_generator'
 
 module Sirius
   class EventPlanner
@@ -14,10 +15,13 @@ def initialize
 
     def plan_semester(semester)
       time_converter, semester_periods = create_converters(semester)
+
+      weeks_dates = Sirius::FacultySemesterWeeksGenerator.generate_semester_weeks_dates(semester)
+
       slots_dataset(semester).flat_map do |sl|
         slot = PlannedTimetableSlot.new(sl, time_converter)
         events = semester_periods.flat_map do |semester_period|
-          slot.generate_events(semester, semester_period)
+          slot.generate_events(semester, semester_period, weeks_dates)
         end
         number_events(events)
         apply_exceptions(events)

lib/sirius/faculty_semester_weeks_generator.rb

@@ -0,0 +1,15 @@
+require 'sirius_api/semester_week'
+
+module Sirius
+  module FacultySemesterWeeksGenerator
+
+    module_function
+
+    def generate_semester_weeks_dates(semester)
+      SiriusApi::SemesterWeek
+        .resolve_weeks(semester, from: semester.starts_at, to: semester.teaching_ends_at)
+        .select(&:teaching_week)
+        .map { |week| [week.start_date, week.end_date]}
+    end
+  end
+end

lib/sirius/teaching_time.rb

@@ -3,13 +3,15 @@
 module Sirius
   class TeachingTime
 
-    attr_reader :teaching_period, :day
+    attr_reader :teaching_period, :day, :start_date, :end_date
     attr_accessor :parity
 
-    def initialize(teaching_period:, day:, parity:)
+    def initialize(teaching_period:, day:, parity: nil, start_date: nil, end_date: nil)
       @teaching_period = teaching_period
       @day = day
       @parity = parity
+      @start_date = start_date
+      @end_date = end_date
     end
 
     def start_time
@@ -25,7 +27,11 @@ def duration
     end
 
     def ==(other)
-      @teaching_period == other.teaching_period && @day == other.day && @parity == other.parity
+      @teaching_period == other.teaching_period &&
+        @day == other.day &&
+        @parity == other.parity &&
+        @start_date == other.start_date &&
+        @end_date == other.end_date
     end
 
     def numeric_day
@@ -34,7 +40,15 @@ def numeric_day
 
     def to_recurrence_rule(day_offset, schedule_ends_at)
       teaching_day = (numeric_day + day_offset) % 7
-      IceCube::Rule.weekly(week_frequency, :monday).day(teaching_day).until(schedule_ends_at)
+      until_date = if @end_date && @end_date < schedule_ends_at
+          # The current teaching time is defined in some time interval.
+          @end_date
+        else
+          # The current teaching time is defined in whole semester -> whole scheduling period.
+          schedule_ends_at
+        end
+
+      IceCube::Rule.weekly(week_frequency, :monday).day(teaching_day).until(until_date)
     end
 
     def week_frequency

spec/fabricators/timetable_slot_fabricator.rb

@@ -17,3 +17,8 @@
   room
   parallel
 end
+
+Fabricator(:timetable_slot_with_weeks, from: :timetable_slot_with_times) do
+  parity nil
+  weeks [1, 3]
+end

spec/lib/sirius/teaching_time_spec.rb

@@ -8,10 +8,12 @@
 
   subject(:teaching_time) do
     described_class.new(teaching_period: Period.parse('14:30', '16:00'),
-                        parity: parity, day: input_day)
+                        parity: parity, day: input_day, start_date: start_date, end_date: end_date)
   end
   let(:parity) { 'odd' }
   let(:input_day) { :tuesday }
+  let(:start_date) { nil }
+  let(:end_date) { nil }
 
   describe '#week_frequency' do
     where :parity, :week_frequency do
@@ -34,7 +36,7 @@
   end
 
   describe '#to_recurrence_rule' do
-    let(:ends_at) { DateTime.parse('2015-11-11') }
+    let(:ends_at) { DateTime.parse('2020-03-11') }
 
     it 'returns weekly recurrence rule' do
       expect(subject.to_recurrence_rule(0, ends_at)).to be_an_instance_of IceCube::WeeklyRule
@@ -61,5 +63,25 @@
         expect(rule.validations[:day].first.day).to eq result_day
       end
     end
+
+    context 'when start/end dates were not provided' do
+      it 'returns recurrence rule ending at the given ends_at date' do
+        expect(
+          subject.to_recurrence_rule(0, ends_at).until_time.strftime("%F")
+        ).to eq ends_at.strftime("%F")
+      end
+    end
+
+    context 'when start/end dates were provided' do
+      let(:period) { nil }
+      let(:start_date) { Date.parse('2020-02-20') }
+      let(:end_date) { Date.parse('2020-02-26') }
+
+      it 'returns recurrence rule ending at the end_date' do
+        expect(
+          subject.to_recurrence_rule(0, ends_at).until_time.strftime("%F")
+        ).to eq end_date.strftime("%F")
+      end
+    end
   end
 end

spec/roles/planned_timetable_slot_spec.rb

@@ -10,27 +10,32 @@
   let(:converter) { Sirius::TimeConverter.new(hour_starts: faculty_semester.hour_starts, hour_length: faculty_semester.hour_duration) }
   let(:semester_calendar) { PlannedSemesterPeriod.new(Fabricate(:teaching_semester_period)) }
   let(:faculty_semester) { Fabricate.build(:faculty_semester) }
+  let(:weeks_dates) {[
+    [Date.parse('2014-09-22'), Date.parse('2014-09-28')],
+    [Date.parse('2014-09-29'), Date.parse('2014-10-05')],
+    [Date.parse('2014-10-06'), Date.parse('2014-10-12')],
+  ]}
   subject(:planned_slot) { described_class.new(slot, converter) }
 
   describe '#generate_events' do
 
     it 'converts TimetableSlot to events' do
-      events = planned_slot.generate_events(faculty_semester, semester_calendar)
+      events = planned_slot.generate_events(faculty_semester, semester_calendar, weeks_dates)
       expect(events.size).to eq 13
       expect(events.first).to be_an_instance_of(Event)
     end
 
     it 'sets deleted flag for deleted timetable slots' do
       slot.deleted_at = Time.now
-      events = planned_slot.generate_events(faculty_semester, semester_calendar)
+      events = planned_slot.generate_events(faculty_semester, semester_calendar, weeks_dates)
       expect(events.first.deleted).to be_truthy
     end
 
     context 'TimetableSlot with start_time and end_time' do
       let(:slot) { Fabricate(:timetable_slot_with_times, parity: 'even') }
 
       it 'converts TimetableSlot to events with the specified times' do
-        events = planned_slot.generate_events(faculty_semester, semester_calendar)
+        events = planned_slot.generate_events(faculty_semester, semester_calendar, weeks_dates)
 
         expect(events.size).to eq 6
         expect(events.first).to be_an_instance_of(Event)
@@ -39,6 +44,23 @@
       end
     end
 
+    context 'TimetableSlot with weeks' do
+      let(:slot) { Fabricate(:timetable_slot_with_weeks, weeks: weeks) }
+      let(:weeks) { [1, 3] }
+
+      it 'converts TimetableSlot to events in the specified weeks only' do
+        events = planned_slot.generate_events(faculty_semester, semester_calendar, weeks_dates)
+
+        expect(events.size).to eq weeks.size
+        expect(events[0]).to be_an_instance_of(Event)
+
+        events.each_with_index do |event, i|
+          expect(event.starts_at.strftime('%F')).to eq weeks_dates[weeks[i] - 1].first.strftime('%F')
+          expect(event.starts_at.strftime('%H:%M')).to eq slot.start_time.strftime('%H:%M')
+        end
+      end
+    end
+
   end
 
   describe '#clear_extra_events' do