feat: Replace AcademicYear with automatic course scheduling system

README.md

@@ -174,12 +174,16 @@ This setup has not been fully tested on Windows, so some adjustment is probably
 ### Clean install
 If you don't want to migrate data from an old instance, then you will have to create new the all new data from scratch. 
 New super users can be created in django by running this command `python manage.py createsuperuser`
-After this navigate to the admin interface. Here we will have to add entries like "akademiska år", "institutioner" "Nivåer", "Spår" and "Tidsperioder". 
-- Akademiska år : The study year (You probably want a few courses here)
+After this navigate to the admin interface. Here we will have to add entries like "institutioner" "Nivåer" and "Spår".
 - Institutioner : The institution / faculty where the course can be / is taken
 - Nivåer : If it's an advanced course or not (grundläggande / avancerad)
 - Spår : The different tracks that can be choosen. Make a profile before on the main site
-- Tidsperioder : This is when during the year a course starts. For example week 0 for "läsperiod 1", week 10 for "läsperiod 2" Week 0 is the beginning of time academic year. If a course starts 3 weeks into period 2, then specify week 13.
+Course periods are now entered directly as start week values in forms
+(LP1=0, LP2=10, LP3=20, LP4=30, LP5=40). If a course starts 3 weeks into
+period 2, set start week to 13.
+
+Academic years (e.g. "20/21") are computed automatically — no database setup
+needed. Year dropdowns in forms show the current year ± 10.
 
 After after creating these, new courses can be added to the default site
 

rodatraden/admin.py

@@ -10,8 +10,6 @@
     Department,
     Level,
     Track,
-    AcademicYear,
-    TimePeriod,
     ISPTemplate,
     CourseScheduleSegment,
     Exam,

rodatraden/filters.py

@@ -1,8 +1,21 @@
+import datetime
 import django_filters
 from .models import (
-    Course, Category, Level, Department, Track, AcademicYear, TimePeriod
+    Course, Category, Level, Department, Profile, Track,
+    CourseOccasion, academic_year_title, YEAR_RANGE_OFFSET
 )
 
+
+def _courseoccasion_year_choices(extra_years=YEAR_RANGE_OFFSET):
+    """Build year choices from dynamic range + existing database values."""
+    current = datetime.date.today().year
+    years = set(range(current - extra_years, current + extra_years + 1))
+    years.update(
+        CourseOccasion.objects.exclude(year__isnull=True).values_list('year', flat=True)
+    )
+
+    return [('', 'Läsår')] + [(y, academic_year_title(y)) for y in sorted(years)]
+
 class CourseFilter(django_filters.FilterSet):
     """Filter settings for the list of courses.
 
@@ -37,40 +50,58 @@ def filter_by_course(self, queryset, name, value):
         queryset=Track.objects.all().order_by('title'),
         empty_label='Profil', field_name='tracks'
     )
-    academic_year = django_filters.ModelChoiceFilter(
-        queryset=AcademicYear.objects.all().order_by('-year'),
-        empty_label='Läsår', method='filter_by_academic_year'
-    )
-    time_period = django_filters.ModelChoiceFilter(
-        queryset=TimePeriod.objects.all().order_by('week'),
-        empty_label='Läsperiod', method='filter_by_time_period'
-    )
-
-    def filter_by_academic_year(self, queryset, name, value):
-        """Filter courses that have an official occasion in the given academic year."""
-        if value:
-            return queryset.filter(
-                courseoccasion__academic_year=value,
-                courseoccasion__official=True
-            ).distinct()
-        return queryset
-
-    def filter_by_time_period(self, queryset, name, value):
-        """Filter courses that have an official occasion in the given time period."""
-        if value:
-            return queryset.filter(
-                courseoccasion__time_period=value,
-                courseoccasion__official=True
-            ).distinct()
-        return queryset
 
     class Meta:
         model = Course
-        fields = ['title', 'categories', 'profile', 'level', 'department',
-                  'academic_year', 'time_period']
+        fields = ['title', 'categories', 'profile', 'level', 'department']
 
     @property
     def qs(self):
         # Sort by title in ascending order if no sort order is specified.
         sort_order = self.data.get('sort_order', 'title')
         return super().qs.order_by(sort_order)
+
+
+class CourseOccasionFilter(django_filters.FilterSet):
+    """Filter settings for the list of course occasions."""
+
+    # A lot of the filters refer to the course that the courseoccasion is
+    # connected to, hence the 'field_name' argument
+    title = django_filters.ModelChoiceFilter(
+            queryset=Course.objects.all().order_by('title'),
+            empty_label='Kursnamn', to_field_name='id', field_name='course'
+    )
+    # Year is now a plain IntegerField — use ChoiceFilter with dynamic choices.
+    year = django_filters.ChoiceFilter(
+            choices=_courseoccasion_year_choices,
+            empty_label=None,  # we include the empty option in choices above
+            field_name='year'
+    )
+    time_period = django_filters.ChoiceFilter(
+            choices=lambda: [('', 'Läsperiod')] + [
+                (i * 10, f'LP{i}') for i in range(1, 6)
+            ],
+            empty_label=None,
+            field_name='start',
+            label='Läsperiod',
+    )
+    categories = django_filters.ModelChoiceFilter(
+            queryset=Category.objects.all().order_by('title'), 
+            field_name='course__categories',
+            empty_label='Kategori'
+    )
+    department = django_filters.ModelChoiceFilter(
+            queryset=Department.objects.all().order_by('title'), 
+            field_name='course__department',
+            empty_label='Institution'
+    )
+    official = django_filters.ChoiceFilter(
+            choices=((True, 'Godkänd'), (False, 'Ej godkänd')), 
+            empty_label='Status'
+    )
+
+    class Meta:
+        model = CourseOccasion
+        fields = ['title', 'year', 'categories', 'department',
+            'official'
+        ]

rodatraden/forms.py

@@ -5,8 +5,8 @@
 from .models import (
     Course, Block, CourseOccasion, CourseScheduleSegment, Category,
     CategoryCourse, Prerequisite, Profile,
-    AcademicYear, TimePeriod, CategoryExam, Exam, Report, PrivateCourse,
-    PrivateCourseCategory, User
+    CategoryExam, Exam, Report, PrivateCourse,
+    PrivateCourseCategory, User, academic_year_title, YEAR_RANGE_OFFSET
 )
 from .rodatraden_modules.mixins import (
     CategoryFormMixin, PrerequisiteFormMixin, SaveAndImportBlockMixin
@@ -16,6 +16,24 @@
 from bootstrap_modal_forms.forms import BSModalForm, BSModalModelForm
 
 
+def _dynamic_year_choices(extra_years=YEAR_RANGE_OFFSET, include_years=None):
+    """Build (value, label) tuples for current year ± extra_years.
+
+    The range is wide enough to cover both historical and future course
+    occasions without needing pre-allocated database rows.
+    """
+    current = datetime.date.today().year
+    years = set(range(current - extra_years, current + extra_years + 1))
+    for y in include_years or []:
+        if y is not None:
+            years.add(int(y))
+
+    return [
+        (y, academic_year_title(y))
+        for y in sorted(years)
+    ]
+
+
 class UpdateUserForm(forms.ModelForm):
     """Form for updating user"""
 
@@ -111,8 +129,10 @@ def __init__(self, *args, **kwargs):
         # Build the fields from these categories
         self._build_category_fields(categories)
 
-        # Get choices given from academic years
-        year_choices = [(x.year, x.title) for x in AcademicYear.objects.all().order_by('year')]
+        # Year choices computed dynamically — no database query needed.
+        year_choices = _dynamic_year_choices(
+            include_years=[self.instance.year] if self.instance.pk else None
+        )
         self.fields['year'] = forms.ChoiceField(choices=year_choices,
                 initial=datetime.datetime.now().year)
         # Always save to current user
@@ -150,8 +170,6 @@ class Meta:
 class CourseScheduleSegmentForm(BSModalModelForm):
     """Form for course schedule segments."""
 
-    start_week = StartWeekField(label='Start')
-
     blacklisted_years = forms.MultipleChoiceField(
         choices=[],
         required=False,
@@ -166,10 +184,11 @@ def __init__(self, *args, **kwargs):
         if 'course' in self.request.GET:
             self.initial['course'] = self.request.GET['course']
 
-        # Year choices from AcademicYear (str keys for ChoiceField compat)
+        # Year choices computed dynamically (str keys for ChoiceField compat).
+        include_years = [self.instance.start_year, self.instance.end_year] if self.instance.pk else None
         year_choices = [
-            (str(x.year), x.title)
-            for x in AcademicYear.objects.all().order_by('year')
+            (str(y), label)
+            for y, label in _dynamic_year_choices(include_years=include_years)
         ]
         self.fields['start_year'] = forms.ChoiceField(
             choices=year_choices,
@@ -183,6 +202,9 @@ def __init__(self, *args, **kwargs):
 
         # Blacklisted years: same year choices as multi-select
         self.fields['blacklisted_years'].choices = year_choices
+
+        self.fields['start'] = StartWeekField(label='Läsperiod')
+
         # Pre-fill for existing instances
         if self.instance.pk:
             self.initial['start_year'] = str(self.instance.start_year)
@@ -192,12 +214,10 @@ def __init__(self, *args, **kwargs):
                 self.initial['blacklisted_years'] = [
                     str(y) for y in self.instance.blacklisted_years
                 ]
-            self.fields['start_week'].initial = (
-                self.instance.time_period.week + (self.instance.start_offset or 0)
-            )
+            self.initial['start'] = self.instance.start
 
         self.order_fields([
-            'start_week',
+            'start',
             'frequency',
             'start_year',
             'end_year',
@@ -215,35 +235,10 @@ def clean_end_year(self):
     def clean_blacklisted_years(self):
         return [int(y) for y in self.cleaned_data.get('blacklisted_years', [])]
 
-    def save(self, commit=True):
-        segment = super().save(commit=False)
-        start_week = self.cleaned_data['start_week']
-
-        weeks_in_period = 10
-        period_number = start_week // weeks_in_period + 1
-        base_period_week = (period_number - 1) * weeks_in_period
-        start_offset = start_week % weeks_in_period
-
-        time_period = TimePeriod.objects.filter(week=base_period_week).first()
-        if time_period is None:
-            time_period = TimePeriod.objects.create(
-                week=base_period_week,
-                title=f'LP{period_number}',
-            )
-
-        segment.time_period = time_period
-        segment.start_offset = start_offset
-
-        if commit:
-            segment.save()
-            self.save_m2m()
-
-        return segment
-
     class Meta:
         model = CourseScheduleSegment
-        fields = ['course', 'frequency',
-                  'start_year', 'end_year', 'weeks', 'blacklisted_years']
+        fields = ['course', 'start', 'frequency', 'start_year',
+                  'end_year', 'weeks', 'blacklisted_years']
         widgets = {
             'course': forms.HiddenInput(),
         }
@@ -252,80 +247,48 @@ class Meta:
 class CourseOccasionForm(BSModalModelForm):
     """Form for course occasions."""
 
-    start_week = StartWeekField(label='Start')
-
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-        # Keep academic year options in chronological order.
-        self.fields['academic_year'].queryset = AcademicYear.objects.all().order_by('year')
+        # Year is now a plain IntegerField — present as a dropdown with
+        # dynamically computed year choices (current year ± 10).
+        year_choices = _dynamic_year_choices(
+            include_years=[self.instance.year] if self.instance.pk else None
+        )
+        self.fields['year'] = forms.ChoiceField(
+            choices=year_choices,
+            initial=datetime.datetime.now().year,
+            label='År',
+        )
 
         # If a courseoccasion is copied
         if 'courseocc' in self.request.GET:
             courseocc_cpy = CourseOccasion.objects.get(slug=self.request.GET['courseocc'])
             # This hard-coding might be avoidable. Not sure...
             self.fields['course'].initial = courseocc_cpy.course
-            self.fields['academic_year'].initial = courseocc_cpy.academic_year
-            self.fields['start_week'].initial = courseocc_cpy.time_period.week
+            self.fields['year'].initial = courseocc_cpy.year
+            self.fields['start'].initial = courseocc_cpy.start
             self.fields['weeks'].initial = courseocc_cpy.weeks
             self.fields['note'].initial = courseocc_cpy.note
             self.fields['contact_name'].initial = courseocc_cpy.contact_name
             self.fields['contact_email'].initial = courseocc_cpy.contact_email
             self.fields['official'].initial = courseocc_cpy.official
 
-        # Populate start week when editing an existing occasion.
-        if self.instance.pk:
-            self.fields['start_week'].initial = self.instance.time_period.week
-
         self.fields['course'].widget.attrs['class'] = \
             'course-list-filter-courseocc-create'
 
-        self.order_fields([
-            'course',
-            'academic_year',
-            'start_week',
-            'weeks',
-            'note',
-            'contact_name',
-            'contact_email',
-            'official',
-        ])
-
-    @staticmethod
-    def _format_time_period_title(start_week: int) -> str:
-        weeks_in_period = 10
-        period_number = start_week // weeks_in_period + 1
-        period_start_offset = start_week % weeks_in_period
-
-        result = f'LP{period_number}'
-        if period_start_offset:
-            postfix = 'vecka' if period_start_offset == 1 else 'veckor'
-            result += f' - {period_start_offset} {postfix} in'
-        return result
-
-    def save(self, commit=True):
-        courseoccasion = super().save(commit=False)
-        start_week = self.cleaned_data['start_week']
-
-        # Resolve existing period by week, or create one if it is missing.
-        time_period = TimePeriod.objects.filter(week=start_week).first()
-        if time_period is None:
-            time_period = TimePeriod.objects.create(
-                week=start_week,
-                title=self._format_time_period_title(start_week),
-            )
+        self.fields['start'] = StartWeekField(label='Läsperiod')
 
-        courseoccasion.time_period = time_period
-
-        if commit:
-            courseoccasion.save()
-            self.save_m2m()
-
-        return courseoccasion
+    def clean_year(self):
+        """Coerce the ChoiceField string back to int for the IntegerField."""
+        try:
+            return int(self.cleaned_data['year'])
+        except (ValueError, TypeError):
+            raise forms.ValidationError('Ogiltigt år.')
 
     class Meta:
         model = CourseOccasion
-        fields = ['course', 'academic_year', 'weeks',
+        fields = ['course', 'year', 'start', 'weeks',
         'note', 'contact_name', 'contact_email', 'official']
 
 
@@ -344,9 +307,10 @@ class BlockForm(SaveAndImportBlockMixin, BSModalModelForm):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        # Get choices given from academic years and sort
-        years = [(x.year, x.year) for x in AcademicYear.objects.all()]
-        years.sort()
+        # Year choices computed dynamically — no database query needed.
+        years = _dynamic_year_choices(
+            include_years=[self.instance.start_year] if self.instance.pk else None
+        )
 
         # Use can import form all public blocks published in a track and all
         # their own blocks.