move from current and next term to all active terms (#408)

* move from current and next term to all active terms

* Fix/369/terms take2 (#431)

* hi

* fix codespace

* apply jasper's suggestions

---------

Signed-off-by: Daniel Miretsky <miretskyd@wit.edu>

* Fix/369/terms take2 (#433)

* hi

* fix codespace

* apply jasper's suggestions

* fix misc spec

* fix misc spec

* fix term start and end dates

---------

Signed-off-by: Daniel Miretsky <miretskyd@wit.edu>

* fix misc spec

* apply fixes from jasper's review

---------

Signed-off-by: Daniel Miretsky <miretskyd@wit.edu>

Author: miretskydatwit

app/controllers/api/misc_controller.rb

@@ -2,16 +2,14 @@
 
 module Api
   class MiscController < ApiController
-    skip_before_action :authenticate_user_from_token!, only: [:get_current_terms]
-    skip_before_action :check_beta_access, only: [:get_current_terms]
+    skip_before_action :authenticate_user_from_token!, only: [:get_active_terms]
+    skip_before_action :check_beta_access, only: [:get_active_terms]
 
-    def get_current_terms
-      current_term = Term.current
-      next_term = Term.next
+    def get_active_terms
+      active_terms = Term.active
 
       render json: {
-        current_term: TermSerializer.new(current_term).as_json,
-        next_term: TermSerializer.new(next_term).as_json
+        active_terms: active_terms.map { |term| TermSerializer.new(term).as_json }
       }, status: :ok
     end
 

app/jobs/course_data_sync_job.rb

@@ -8,7 +8,7 @@ class CourseDataSyncJob < ApplicationJob
   # Run with low concurrency to avoid overwhelming LeopardWeb API
   limits_concurrency to: 1, key: -> { "course_data_sync" }
 
-  # Sync course data for current and next term by default
+  # Sync course data for all active terms by default
   def perform(term_uids: nil)
     term_uids ||= default_term_uids
 
@@ -26,10 +26,7 @@ def perform(term_uids: nil)
   private
 
   def default_term_uids
-    uids = []
-    uids << Term.current_uid if Term.current_uid
-    uids << Term.next_uid if Term.next_uid
-    uids.compact.uniq
+    Term.active_uids.uniq
   end
 
   def sync_term_courses(term_uid)

app/jobs/university_calendar_sync_job.rb

@@ -81,8 +81,12 @@ def trigger_sync_for_opted_in_users
 
   # Attempt to update term dates from university calendar events
   def update_term_dates_from_events
-    # Only update terms that don't have dates set
-    Term.where(start_date: nil).or(Term.where(end_date: nil)).find_each do |term|
+    # Only check recent and future terms — no need to re-evaluate historical terms
+    # from years ago. Include the prior year in case we're early in the calendar
+    # year and a recently ended term needs a correction.
+    current_year = Time.zone.today.year
+
+    Term.where(year: (current_year - 1)..).find_each do |term|
       dates = UniversityCalendarEvent.detect_term_dates(term.year, term.season)
 
       updates = {}

app/models/term.rb

@@ -51,6 +51,47 @@ def self.with_deferred_date_updates
     summer: 3
   }
 
+  # Returns active term UIDs from LeopardWeb
+  # @return [Array<Integer>] UIDs of terms LeopardWeb considers active, empty array on failure
+  def self.active_uids
+    result = LeopardWebService.get_active_terms
+    return [] unless result[:success]
+
+    result[:terms].map { |t| t[:code].to_i }
+  end
+
+  # Returns the registration start date for this term.
+  # Queries LeopardWeb to determine if registration is open for this term.
+  # Once the term first appears as active, that date is considered the open date.
+  # Falls back to start_date when LeopardWeb is unavailable or does not list the term.
+  # @return [Date, nil] the registration start date
+  def registration_start
+    result = LeopardWebService.get_active_terms
+    if result[:success]
+      active_codes = result[:terms].map { |t| (t[:code] || t["code"]).to_i }
+      if active_codes.include?(uid)
+        return start_date if start_date.present? && start_date <= Time.zone.today
+
+        return Time.zone.today
+      end
+    end
+
+    start_date
+  rescue => e
+    Rails.logger.warn("LeopardWebService unavailable for registration_start on #{name}: #{e.message}")
+    start_date
+  end
+
+  # Scope for active terms (classes have started and term hasn't ended)
+  # Returns up to 3 terms if 3 are active, otherwise returns 2
+  scope :active, -> {
+    today = Time.zone.today
+
+    where(start_date: ..today)
+      .where(end_date: today..)
+      .order(year: :desc, season: :desc)
+  }
+
   # Scope for current and future terms (for finals schedule uploads)
   scope :current_and_future, -> {
     current_term = Term.current

app/models/university_calendar_event.rb

@@ -95,36 +95,174 @@ def self.no_class_days_between(start_date, end_date)
     where(category: %w[holiday finals]).in_date_range(start_date, end_date).order(:start_time)
   end
 
-  # Detect term dates from university calendar events
-  # Looks for "Classes Begin" and "Classes End"/"Final Exam" patterns
+  # Detect term dates for a term.
+  #
+  # Date rules:
+  # - start_date: The day LeopardWeb reports registration open for the term.
+  #               Once captured, keep the stored past start_date stable across
+  #               later syncs.
+  # - end_date:   Last day of finals period for the term.
+  #               Falls back to latest imported course end_date for the term
+  #               when finals period events are unavailable.
+  #
   # @param year [Integer] The academic year
   # @param season [Symbol] The season (:fall, :spring, :summer)
   # @return [Hash] Hash with :start_date and :end_date keys
   def self.detect_term_dates(year, season)
-    term_name = "#{season.to_s.capitalize} #{year}"
-    term_name_alt = season.to_s.capitalize.to_s
-
-    # Find "Classes Begin" events (now in term_dates category)
-    classes_begin = term_dates.where("summary ILIKE ?", "%classes begin%")
-                              .where("academic_term ILIKE ? OR summary ILIKE ?", "%#{term_name_alt}%", "%#{year}%")
-                              .where(start_time: Date.new(year - 1, 7, 1)..Date.new(year + 1, 2, 1))
-                              .order(:start_time)
-                              .first
-
-    # Find term end indicators - check both term_dates and finals categories
-    term_end = where(category: %w[term_dates finals])
-               .where("summary ILIKE ? OR summary ILIKE ?", "%final exam%", "%classes end%")
-               .where("academic_term ILIKE ? OR summary ILIKE ?", "%#{term_name_alt}%", "%#{year}%")
-               .where(start_time: Date.new(year - 1, 7, 1)..Date.new(year + 1, 7, 1))
-               .order(start_time: :desc)
-               .first
+    term = Term.find_by(year: year, season: season)
+
+    candidate_events = where(start_time: Date.new(year - 1, 1, 1).beginning_of_day..Date.new(year + 1, 12, 31).end_of_day)
+    matching_events = candidate_events.select { |event| event_matches_term_for_date_detection?(event, year, season, term) }
+
+    leopard_web_start_date = leopard_web_registration_open_date(year, season, term)
+
+    # Prefer explicit schedule-available events when LeopardWeb does not expose
+    # the term as currently open for registration.
+    schedule_available_event = matching_events
+                               .select { |event| schedule_available_summary?(event.summary) }
+                               .min_by(&:start_time)
+
+
+    estimated_schedule_available_date = registration_event&.start_time&.to_date&.-(14)
+
+    finals_period_event = matching_events
+                          .select { |event| event.category == "finals" && finals_period_summary?(event.summary) }
+                          .max_by { |event| event.end_time || event.start_time }
+
+    finals_end_date = finals_period_event&.end_time&.to_date || finals_period_event&.start_time&.to_date
+    course_end_fallback = fallback_end_date_from_courses(term)
 
     {
-      start_date: classes_begin&.start_time&.to_date,
-      end_date: term_end&.end_time&.to_date || term_end&.start_time&.to_date
+      start_date: leopard_web_start_date || schedule_available_event&.start_time&.to_date || estimated_schedule_available_date,
+      end_date: finals_end_date || course_end_fallback
     }
   end
 
+  def self.leopard_web_registration_open_date(year, season, term)
+    result = LeopardWebService.get_active_terms
+    return nil unless result[:success]
+
+    target_uid = term&.uid || generated_term_uid(year, season)
+    return nil unless target_uid
+
+    active_term_found = Array(result[:terms]).any? do |active_term|
+      (active_term[:code] || active_term["code"]).to_i == target_uid
+    end
+    return nil unless active_term_found
+
+    existing_start_date = term&.start_date
+    return existing_start_date if existing_start_date.present? && existing_start_date <= Time.zone.today
+
+    Time.zone.today
+  rescue => e
+    Rails.logger.warn("Failed to determine LeopardWeb registration-open date for #{season} #{year}: #{e.message}")
+    nil
+  end
+
+  def self.generated_term_uid(year, season)
+    case season.to_sym
+    when :fall
+      ((year + 1) * 100) + 10
+    when :spring
+      (year * 100) + 20
+    when :summer
+      (year * 100) + 30
+    end
+  end
+
+  # Returns true when an event can be considered part of the target term for
+  # date detection purposes.
+  def self.event_matches_term_for_date_detection?(event, year, season, term)
+    season_name = season.to_s.capitalize
+    summary = event.summary.to_s
+    academic_term = event.academic_term.to_s
+
+    # If summary explicitly names a term, trust that first.
+    explicit_summary_term = extract_explicit_term_from_summary(summary)
+    if explicit_summary_term
+      return explicit_summary_term[:season] == season.to_sym && explicit_summary_term[:year] == year
+    end
+
+    # Strongest signal: explicit DB term linkage from sync processing.
+    return true if term && event.term_id == term.id
+
+    # Next strongest signal: summary explicitly mentions season + year.
+    return true if summary.match?(/\b#{Regexp.escape(season_name)}\b/i) && summary.match?(/\b#{year}\b/)
+
+    # Weak signal: academic term only. Restrict with season-specific date windows
+    # to avoid cross-year contamination.
+    return false unless academic_term.match?(/\b#{Regexp.escape(season_name)}\b/i)
+
+    event_date = event.start_time&.to_date
+    return false unless event_date
+
+    event_date.in?(term_detection_date_window(year, season))
+  end
+
+  # Extract explicit term mention like "Fall 2026" from summary text.
+  # Returns nil when no explicit term/year is present.
+  def self.extract_explicit_term_from_summary(summary)
+    match = summary.to_s.match(/\b(Fall|Spring|Summer)\s+(\d{4})\b/i)
+    return nil unless match
+
+    season = case match[1].downcase
+             when "fall" then :fall
+             when "spring" then :spring
+             when "summer" then :summer
+             end
+
+    return nil unless season
+
+    { season: season, year: match[2].to_i }
+  end
+
+  # Date windows tuned for academic term event timing (including preregistration).
+  def self.term_detection_date_window(year, season)
+    case season.to_sym
+    when :spring
+      Date.new(year - 1, 8, 1)..Date.new(year, 6, 30)
+    when :summer
+      Date.new(year, 1, 1)..Date.new(year, 8, 31)
+    when :fall
+      Date.new(year, 1, 1)..Date.new(year, 12, 31)
+    else
+      Date.new(year - 1, 1, 1)..Date.new(year + 1, 12, 31)
+    end
+  end
+
+  def self.schedule_available_summary?(summary)
+    normalized = summary.to_s
+    return false if registration_summary?(normalized)
+
+    normalized.match?(/course\s+schedule/i) ||
+      normalized.match?(/schedule\s+(available|release|released|posted|opens|open|begins|begin)/i)
+  end
+
+  def self.registration_summary?(summary)
+    summary.to_s.match?(/registration\s+(opens|open|begins|begin)|registration/i)
+  end
+
+  # Finals period events should represent actual exam days, not announcement-only
+  # "schedule available" events.
+  def self.finals_period_summary?(summary)
+    normalized = summary.to_s
+    return false if normalized.match?(/schedule\s+(available|online|release|released|posted)/i)
+
+    normalized.match?(/final\s+exam\s+period|final\s+exams?|finals\s+week|examination\s+period|study\s+day/i)
+  end
+
+  # Fallback end date from imported course data for the same term.
+  # This is used only when finals period events are not available yet.
+  def self.fallback_end_date_from_courses(term)
+    return nil unless term
+
+    term.courses.where.not(start_date: nil)
+        .where.not(end_date: nil)
+        .where("EXTRACT(YEAR FROM start_date) >= ? AND EXTRACT(YEAR FROM start_date) <= ?", term.year - 1, term.year)
+        .where("EXTRACT(YEAR FROM end_date) >= ? AND EXTRACT(YEAR FROM end_date) <= ?", term.year, term.year + 1)
+        .maximum(:end_date)
+  end
+
   # Infer category from event summary and raw event type
   # @param summary [String] The event summary/title
   # @param event_type_raw [String] The raw event type from ICS

app/services/leopard_web_service.rb

@@ -26,8 +26,8 @@ def call
       get_faculty_meeting_times
     when :get_course_catalog
       get_course_catalog
-    when :get_available_terms
-      get_available_terms
+    when :get_active_terms
+      get_active_terms
     else
       raise ArgumentError, "Unknown action: #{action}"
     end
@@ -65,8 +65,8 @@ def self.get_course_catalog(term:)
     ).call
   end
 
-  def self.get_available_terms
-    new(action: :get_available_terms).call
+  def self.get_active_terms
+    new(action: :get_active_terms).call
   end
 
   private
@@ -256,11 +256,11 @@ def handle_error(response)
     raise "Request failed with status #{response.status}: #{response.body}"
   end
 
-  def get_available_terms
-    response = terms_connection.get("classSearch/getTerms", {
+  def get_active_terms
+    response = terms_connection.get("classRegistration/getTerms", {
                                       searchTerm: "",
                                       offset: 1,
-                                      max: 50
+                                      max: 10
                                     })
 
     if response.success?

config/routes.rb

@@ -388,7 +388,7 @@
 
     get "faculty/by_rmp", to: "faculty#get_info_by_rmp_id"
 
-    get "terms/current_and_next", to: "misc#get_current_terms"
+    get "terms/active", to: "misc#get_active_terms"
 
     # Course events
     post "process_courses", to: "courses#process_courses"