From 21bfd1c07509e12189ccf33b576506a5be324bee Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 10:57:48 +0000
Subject: [PATCH 1/9] feat: add ensure_academic_years command and fix
 year-title sort order

Agent-Logs-Url: https://github.com/it-amanuens/rodatraden/sessions/a6e01129-76ef-4f7e-9b95-aafef4f01b75

Co-authored-by: SpiderQubit <25958778+SpiderQubit@users.noreply.github.com>
---
 MIGRATION_GUIDE.md                            |  23 ++-
 README.md                                     |   2 +-
 .../commands/ensure_academic_years.py         | 135 ++++++++++++++++++
 rodatraden/views.py                           |  14 +-
 4 files changed, 170 insertions(+), 4 deletions(-)
 create mode 100644 rodatraden/management/commands/ensure_academic_years.py

diff --git a/MIGRATION_GUIDE.md b/MIGRATION_GUIDE.md
index 9ab4860..263fae8 100644
--- a/MIGRATION_GUIDE.md
+++ b/MIGRATION_GUIDE.md
@@ -117,7 +117,28 @@ Kontrollera att segmenten matchar befintliga kurstillfällen:
 python manage.py validate_course_schedule_parity
 ```
 
-### 11. Starta om servern
+### 11. Säkerställ akademiska år
+
+Kör kommandot som automatiskt skapar `AcademicYear`-poster för alla år från
+startåret (standard 2011) till och med innevarande år + 10.  Kommandot är
+idempotent och kan köras hur många gånger som helst utan att befintliga poster
+påverkas.
+
+```bash
+# Förhandsvisning (ingen data ändras)
+python manage.py ensure_academic_years
+
+# Skapa saknade poster
+python manage.py ensure_academic_years --apply
+
+# Justera antalet framtida år (standard: 10)
+python manage.py ensure_academic_years --apply --future-years 5
+```
+
+Lägg med fördel in kommandot i ett återkommande jobb (t.ex. cron eller ett
+driftsättningsskript) så att nya år läggs till automatiskt varje år.
+
+### 12. Starta om servern
 
 Starta om webbservern (t.ex. IIS, gunicorn, eller liknande).
 
diff --git a/README.md b/README.md
index 682283c..8ccd15b 100644
--- a/README.md
+++ b/README.md
@@ -175,7 +175,7 @@ This setup has not been fully tested on Windows, so some adjustment is probably
 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)
+- Akademiska år : The study year (run `python manage.py ensure_academic_years --apply` to auto-populate years from 2011 to current year + 10, instead of adding them manually)
 - 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
diff --git a/rodatraden/management/commands/ensure_academic_years.py b/rodatraden/management/commands/ensure_academic_years.py
new file mode 100644
index 0000000..fe1cff3
--- /dev/null
+++ b/rodatraden/management/commands/ensure_academic_years.py
@@ -0,0 +1,135 @@
+"""
+Ensure AcademicYear rows exist for every year from a base year up to
+current year + a configurable future buffer.
+
+The command is idempotent: it only creates rows that are missing and never
+modifies existing ones.  Run it once during initial setup and then once per
+year (e.g. from a cron job or a deployment script) so that new years are
+added automatically.
+
+Title format: year 2011 → "11/12", year 2020 → "20/21" (same convention
+as the AcademicYear model docstring: "year 2018 is associated to period 18/19").
+
+Usage:
+    python manage.py ensure_academic_years              # dry-run
+    python manage.py ensure_academic_years --apply      # create missing rows
+    python manage.py ensure_academic_years --apply --future-years 5
+    python manage.py ensure_academic_years --apply --base-year 2012
+"""
+
+import datetime
+
+from django.core.management.base import BaseCommand
+
+from rodatraden.models import AcademicYear
+
+# Default starting year.  The first AcademicYear in production is around 2011.
+DEFAULT_BASE_YEAR = 2011
+
+# How many years beyond the current calendar year to pre-create.
+DEFAULT_FUTURE_BUFFER = 10
+
+
+def _year_title(year: int) -> str:
+    """Return the conventional title string for an academic year.
+
+    Example: 2011 → "11/12", 2020 → "20/21".
+    """
+    return f"{str(year)[2:]}/{str(year + 1)[2:]}"
+
+
+class Command(BaseCommand):
+    help = (
+        "Ensure AcademicYear rows exist from a base year up to "
+        "current year + future buffer.  Safe to re-run at any time."
+    )
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--apply",
+            action="store_true",
+            help="Actually create missing rows (default is dry-run).",
+        )
+        parser.add_argument(
+            "--base-year",
+            type=int,
+            default=None,
+            help=(
+                f"First year to ensure exists.  Defaults to the minimum year "
+                f"already in the database, or {DEFAULT_BASE_YEAR} if the "
+                f"table is empty."
+            ),
+        )
+        parser.add_argument(
+            "--future-years",
+            type=int,
+            default=DEFAULT_FUTURE_BUFFER,
+            help=(
+                f"Number of years beyond the current year to pre-create "
+                f"(default: {DEFAULT_FUTURE_BUFFER})."
+            ),
+        )
+
+    def handle(self, *args, **options):
+        apply = options["apply"]
+        future_buffer = options["future_years"]
+
+        if not apply:
+            self.stdout.write(
+                self.style.WARNING(
+                    "DRY-RUN MODE — no rows will be created. "
+                    "Use --apply to write.\n"
+                )
+            )
+
+        # Determine base year: explicit arg → min existing DB year → hardcoded default.
+        if options["base_year"] is not None:
+            base_year = options["base_year"]
+        else:
+            existing_min = AcademicYear.objects.order_by("year").values_list(
+                "year", flat=True
+            ).first()
+            base_year = existing_min if existing_min is not None else DEFAULT_BASE_YEAR
+
+        current_year = datetime.date.today().year
+        end_year = current_year + future_buffer
+
+        self.stdout.write(
+            f"Ensuring AcademicYear rows for {base_year} – {end_year} "
+            f"(current year: {current_year}, buffer: +{future_buffer})\n"
+        )
+
+        created_count = 0
+        skipped_count = 0
+
+        for year in range(base_year, end_year + 1):
+            title = _year_title(year)
+            if apply:
+                _, created = AcademicYear.objects.get_or_create(
+                    year=year,
+                    defaults={"title": title},
+                )
+            else:
+                created = not AcademicYear.objects.filter(year=year).exists()
+
+            if created:
+                created_count += 1
+                self.stdout.write(
+                    f"  {'CREATE' if apply else 'WOULD CREATE'}  {year}  ({title})"
+                )
+            else:
+                skipped_count += 1
+
+        self.stdout.write("\n" + "=" * 60)
+        self.stdout.write(
+            f"Range:    {base_year} – {end_year}\n"
+            f"Created:  {created_count}\n"
+            f"Skipped (already exist): {skipped_count}"
+        )
+
+        if not apply:
+            self.stdout.write(
+                self.style.WARNING("\nNo rows created. Run with --apply to write.")
+            )
+        else:
+            self.stdout.write(self.style.SUCCESS("\nDone."))
diff --git a/rodatraden/views.py b/rodatraden/views.py
index 2defe19..3d4eafe 100644
--- a/rodatraden/views.py
+++ b/rodatraden/views.py
@@ -260,9 +260,19 @@ def _generate_occasions_all_years(request):
         if not dry_run:
             co.delete()
 
-    # Convert to list sorted by year title
+    # Build a lookup so results are ordered by the numeric year, not the title
+    # string.  This is important because title strings like "11/12" sort
+    # correctly for 2000-2099, but the mapping makes it robust to any title
+    # format that was manually entered in the database.
+    title_to_year = {
+        ay.title: ay.year
+        for ay in AcademicYear.objects.only('title', 'year')
+    }
+
+    # Convert to list sorted by numeric year (unknown titles fall back to their
+    # string representation so they still appear rather than causing an error).
     results = []
-    for yr in sorted(year_results.keys()):
+    for yr in sorted(year_results.keys(), key=lambda t: title_to_year.get(t, t)):
         data = year_results[yr]
         if data['created'] or data['skipped_exists'] or data['removed']:
             results.append({

From 925079387f5ef1a2ff77a988777b2e3ec6aa6d33 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 10:59:20 +0000
Subject: [PATCH 2/9] fix: use float('inf') sentinel and document year-title
 century boundary

Agent-Logs-Url: https://github.com/it-amanuens/rodatraden/sessions/a6e01129-76ef-4f7e-9b95-aafef4f01b75

Co-authored-by: SpiderQubit <25958778+SpiderQubit@users.noreply.github.com>
---
 rodatraden/management/commands/ensure_academic_years.py | 5 +++++
 rodatraden/views.py                                     | 8 +++++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/rodatraden/management/commands/ensure_academic_years.py b/rodatraden/management/commands/ensure_academic_years.py
index fe1cff3..b8f0133 100644
--- a/rodatraden/management/commands/ensure_academic_years.py
+++ b/rodatraden/management/commands/ensure_academic_years.py
@@ -34,6 +34,11 @@ def _year_title(year: int) -> str:
     """Return the conventional title string for an academic year.
 
     Example: 2011 → "11/12", 2020 → "20/21".
+
+    Note: this format uses only the last two digits of each calendar year and
+    is only meaningful for years in the range 2000–2099.  The base year
+    (DEFAULT_BASE_YEAR = 2011) and the ten-year future buffer keep all
+    generated titles well within that range.
     """
     return f"{str(year)[2:]}/{str(year + 1)[2:]}"
 
diff --git a/rodatraden/views.py b/rodatraden/views.py
index 3d4eafe..0fbbb1a 100644
--- a/rodatraden/views.py
+++ b/rodatraden/views.py
@@ -269,10 +269,12 @@ def _generate_occasions_all_years(request):
         for ay in AcademicYear.objects.only('title', 'year')
     }
 
-    # Convert to list sorted by numeric year (unknown titles fall back to their
-    # string representation so they still appear rather than causing an error).
+    # Convert to list sorted by numeric year.  Titles not found in the lookup
+    # (e.g. manually entered with a non-standard format) are placed at the end
+    # using a sentinel so the sort key is always an integer.
     results = []
-    for yr in sorted(year_results.keys(), key=lambda t: title_to_year.get(t, t)):
+    for yr in sorted(year_results.keys(),
+                     key=lambda t: title_to_year.get(t, float('inf'))):
         data = year_results[yr]
         if data['created'] or data['skipped_exists'] or data['removed']:
             results.append({

From 2f87ed9d5b6c8489a355d572bf47feb66b92cb3f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 12:18:35 +0000
Subject: [PATCH 3/9] refactor: replace AcademicYear FK with plain IntegerField
 on CourseOccasion
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the AcademicYear model entirely. CourseOccasion.year is now a
plain IntegerField (matching PrivateCourse.year). Display titles like
"20/21" are computed by academic_year_title(). All year dropdowns in
forms now populate dynamically (current year ± 10) with no database
rows needed.

Files changed: models.py, forms.py, filters.py, views.py, tables.py,
admin.py, functions.py, 5 templates, 3 management commands.
Deleted: ensure_academic_years management command.

Agent-Logs-Url: https://github.com/it-amanuens/rodatraden/sessions/b816d356-cc25-4262-a918-9016ea81368b

Co-authored-by: SpiderQubit <25958778+SpiderQubit@users.noreply.github.com>
---
 rodatraden/admin.py                           |   1 -
 rodatraden/filters.py                         |  19 ++-
 rodatraden/forms.py                           |  50 +++++--
 .../commands/ensure_academic_years.py         | 140 ------------------
 .../commands/generate_course_occasions.py     |  17 +--
 .../commands/infer_course_scheduling.py       |   4 +-
 .../validate_course_schedule_parity.py        |   4 +-
 rodatraden/models.py                          |  45 +++---
 rodatraden/rodatraden_modules/functions.py    |   6 +-
 rodatraden/tables.py                          |   8 +-
 .../courseoccasion_confirm_delete.html        |   2 +-
 .../courseoccasion/courseoccasion_detail.html |   6 +-
 .../courseoccasion/courseoccasion_info.html   |   2 +-
 .../rt_modal/course_list_table_row.html       |   2 +-
 .../tables/courseoccasion_edit.html           |   4 +-
 rodatraden/templates/rodatraden/tools.html    |   4 +-
 rodatraden/views.py                           | 106 +++++++------
 17 files changed, 155 insertions(+), 265 deletions(-)
 delete mode 100644 rodatraden/management/commands/ensure_academic_years.py

diff --git a/rodatraden/admin.py b/rodatraden/admin.py
index 17c68b6..f96933b 100644
--- a/rodatraden/admin.py
+++ b/rodatraden/admin.py
@@ -10,7 +10,6 @@
     Department,
     Level,
     Track,
-    AcademicYear,
     TimePeriod,
     ISPTemplate,
     CourseScheduleSegment,
diff --git a/rodatraden/filters.py b/rodatraden/filters.py
index 70022b1..29260e5 100644
--- a/rodatraden/filters.py
+++ b/rodatraden/filters.py
@@ -1,7 +1,8 @@
+import datetime
 import django_filters
 from .models import (
-    Course, Category, Level, Department, Profile, Track, AcademicYear,
-    CourseOccasion, TimePeriod
+    Course, Category, Level, Department, Profile, Track,
+    CourseOccasion, TimePeriod, academic_year_title
 )
 
 class CourseFilter(django_filters.FilterSet):
@@ -60,9 +61,17 @@ class CourseOccasionFilter(django_filters.FilterSet):
             queryset=Course.objects.all().order_by('title'),
             empty_label='Kursnamn', to_field_name='id', field_name='course'
     )
-    year = django_filters.ModelChoiceFilter(
-            queryset=AcademicYear.objects.all().order_by('year'),
-            empty_label='Läsår', field_name='academic_year'
+    # Year is now a plain IntegerField — use ChoiceFilter with dynamic choices.
+    year = django_filters.ChoiceFilter(
+            choices=lambda: [('', 'Läsår')] + [
+                (y, academic_year_title(y))
+                for y in range(
+                    datetime.date.today().year - 10,
+                    datetime.date.today().year + 11,
+                )
+            ],
+            empty_label=None,  # we include the empty option in choices above
+            field_name='year'
     )
     time_period = django_filters.ModelChoiceFilter(
             queryset=TimePeriod.objects.all().order_by('week'),
diff --git a/rodatraden/forms.py b/rodatraden/forms.py
index 0666631..754a23f 100644
--- a/rodatraden/forms.py
+++ b/rodatraden/forms.py
@@ -5,8 +5,8 @@
 from .models import (
     Course, Block, CourseOccasion, CourseScheduleSegment, Category,
     CategoryCourse, Prerequisite, Profile,
-    AcademicYear, CategoryExam, Exam, Report, PrivateCourse,
-    PrivateCourseCategory, User
+    CategoryExam, Exam, Report, PrivateCourse,
+    PrivateCourseCategory, User, academic_year_title
 )
 from .rodatraden_modules.mixins import (
     CategoryFormMixin, PrerequisiteFormMixin, SaveAndImportBlockMixin
@@ -16,6 +16,19 @@
 from bootstrap_modal_forms.forms import BSModalForm, BSModalModelForm
 
 
+def _dynamic_year_choices(extra_years=10):
+    """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
+    return [
+        (y, academic_year_title(y))
+        for y in range(current - extra_years, current + extra_years + 1)
+    ]
+
+
 class UpdateUserForm(forms.ModelForm):
     """Form for updating user"""
 
@@ -111,8 +124,8 @@ 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()
         self.fields['year'] = forms.ChoiceField(choices=year_choices,
                 initial=datetime.datetime.now().year)
         # Always save to current user
@@ -164,10 +177,10 @@ 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).
         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()
         ]
         self.fields['start_year'] = forms.ChoiceField(
             choices=year_choices,
@@ -217,15 +230,21 @@ class CourseOccasionForm(BSModalModelForm):
     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()
+        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['year'].initial = courseocc_cpy.year
             self.fields['time_period'].initial = courseocc_cpy.time_period
             self.fields['weeks'].initial = courseocc_cpy.weeks
             self.fields['note'].initial = courseocc_cpy.note
@@ -236,9 +255,13 @@ def __init__(self, *args, **kwargs):
         self.fields['course'].widget.attrs['class'] = \
             'course-list-filter-courseocc-create'
 
+    def clean_year(self):
+        """Coerce the ChoiceField string back to int for the IntegerField."""
+        return int(self.cleaned_data['year'])
+
     class Meta:
         model = CourseOccasion
-        fields = ['course', 'academic_year', 'time_period', 'weeks',
+        fields = ['course', 'year', 'time_period', 'weeks',
         'note', 'contact_name', 'contact_email', 'official']
 
 
@@ -257,9 +280,8 @@ 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()
         
         # Use can import form all public blocks published in a track and all
         # their own blocks.
diff --git a/rodatraden/management/commands/ensure_academic_years.py b/rodatraden/management/commands/ensure_academic_years.py
deleted file mode 100644
index b8f0133..0000000
--- a/rodatraden/management/commands/ensure_academic_years.py
+++ /dev/null
@@ -1,140 +0,0 @@
-"""
-Ensure AcademicYear rows exist for every year from a base year up to
-current year + a configurable future buffer.
-
-The command is idempotent: it only creates rows that are missing and never
-modifies existing ones.  Run it once during initial setup and then once per
-year (e.g. from a cron job or a deployment script) so that new years are
-added automatically.
-
-Title format: year 2011 → "11/12", year 2020 → "20/21" (same convention
-as the AcademicYear model docstring: "year 2018 is associated to period 18/19").
-
-Usage:
-    python manage.py ensure_academic_years              # dry-run
-    python manage.py ensure_academic_years --apply      # create missing rows
-    python manage.py ensure_academic_years --apply --future-years 5
-    python manage.py ensure_academic_years --apply --base-year 2012
-"""
-
-import datetime
-
-from django.core.management.base import BaseCommand
-
-from rodatraden.models import AcademicYear
-
-# Default starting year.  The first AcademicYear in production is around 2011.
-DEFAULT_BASE_YEAR = 2011
-
-# How many years beyond the current calendar year to pre-create.
-DEFAULT_FUTURE_BUFFER = 10
-
-
-def _year_title(year: int) -> str:
-    """Return the conventional title string for an academic year.
-
-    Example: 2011 → "11/12", 2020 → "20/21".
-
-    Note: this format uses only the last two digits of each calendar year and
-    is only meaningful for years in the range 2000–2099.  The base year
-    (DEFAULT_BASE_YEAR = 2011) and the ten-year future buffer keep all
-    generated titles well within that range.
-    """
-    return f"{str(year)[2:]}/{str(year + 1)[2:]}"
-
-
-class Command(BaseCommand):
-    help = (
-        "Ensure AcademicYear rows exist from a base year up to "
-        "current year + future buffer.  Safe to re-run at any time."
-    )
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "--apply",
-            action="store_true",
-            help="Actually create missing rows (default is dry-run).",
-        )
-        parser.add_argument(
-            "--base-year",
-            type=int,
-            default=None,
-            help=(
-                f"First year to ensure exists.  Defaults to the minimum year "
-                f"already in the database, or {DEFAULT_BASE_YEAR} if the "
-                f"table is empty."
-            ),
-        )
-        parser.add_argument(
-            "--future-years",
-            type=int,
-            default=DEFAULT_FUTURE_BUFFER,
-            help=(
-                f"Number of years beyond the current year to pre-create "
-                f"(default: {DEFAULT_FUTURE_BUFFER})."
-            ),
-        )
-
-    def handle(self, *args, **options):
-        apply = options["apply"]
-        future_buffer = options["future_years"]
-
-        if not apply:
-            self.stdout.write(
-                self.style.WARNING(
-                    "DRY-RUN MODE — no rows will be created. "
-                    "Use --apply to write.\n"
-                )
-            )
-
-        # Determine base year: explicit arg → min existing DB year → hardcoded default.
-        if options["base_year"] is not None:
-            base_year = options["base_year"]
-        else:
-            existing_min = AcademicYear.objects.order_by("year").values_list(
-                "year", flat=True
-            ).first()
-            base_year = existing_min if existing_min is not None else DEFAULT_BASE_YEAR
-
-        current_year = datetime.date.today().year
-        end_year = current_year + future_buffer
-
-        self.stdout.write(
-            f"Ensuring AcademicYear rows for {base_year} – {end_year} "
-            f"(current year: {current_year}, buffer: +{future_buffer})\n"
-        )
-
-        created_count = 0
-        skipped_count = 0
-
-        for year in range(base_year, end_year + 1):
-            title = _year_title(year)
-            if apply:
-                _, created = AcademicYear.objects.get_or_create(
-                    year=year,
-                    defaults={"title": title},
-                )
-            else:
-                created = not AcademicYear.objects.filter(year=year).exists()
-
-            if created:
-                created_count += 1
-                self.stdout.write(
-                    f"  {'CREATE' if apply else 'WOULD CREATE'}  {year}  ({title})"
-                )
-            else:
-                skipped_count += 1
-
-        self.stdout.write("\n" + "=" * 60)
-        self.stdout.write(
-            f"Range:    {base_year} – {end_year}\n"
-            f"Created:  {created_count}\n"
-            f"Skipped (already exist): {skipped_count}"
-        )
-
-        if not apply:
-            self.stdout.write(
-                self.style.WARNING("\nNo rows created. Run with --apply to write.")
-            )
-        else:
-            self.stdout.write(self.style.SUCCESS("\nDone."))
diff --git a/rodatraden/management/commands/generate_course_occasions.py b/rodatraden/management/commands/generate_course_occasions.py
index af53de1..37b7364 100644
--- a/rodatraden/management/commands/generate_course_occasions.py
+++ b/rodatraden/management/commands/generate_course_occasions.py
@@ -12,7 +12,7 @@
 
 from django.core.management.base import BaseCommand
 
-from rodatraden.models import AcademicYear, Course, CourseOccasion
+from rodatraden.models import Course, CourseOccasion, academic_year_title
 
 
 class Command(BaseCommand):
@@ -47,14 +47,7 @@ def handle(self, *args, **options):
                 'Use --apply to write.\n'
             ))
 
-        try:
-            academic_year = AcademicYear.objects.get(year=year)
-        except AcademicYear.DoesNotExist:
-            self.stdout.write(self.style.ERROR(
-                f'AcademicYear with year={year} does not exist. '
-                f'Create it first in the admin.'
-            ))
-            return
+        title = academic_year_title(year)
 
         courses = Course.objects.all().order_by('title')
         if course_id:
@@ -73,7 +66,7 @@ def handle(self, *args, **options):
             for segment in segments:
                 exists = CourseOccasion.objects.filter(
                     course=course,
-                    academic_year=academic_year,
+                    year=year,
                     time_period=segment.time_period,
                 ).exists()
 
@@ -83,7 +76,7 @@ def handle(self, *args, **options):
 
                 self.stdout.write(
                     f'  {"CREATE" if apply else "WOULD CREATE"}  '
-                    f'{course.title} — {academic_year.title} '
+                    f'{course.title} — {title} '
                     f'{segment.time_period.title} '
                     f'({segment.weeks} weeks)'
                 )
@@ -91,7 +84,7 @@ def handle(self, *args, **options):
                 if apply:
                     CourseOccasion.objects.create(
                         course=course,
-                        academic_year=academic_year,
+                        year=year,
                         time_period=segment.time_period,
                         weeks=segment.weeks,
                         official=True,
diff --git a/rodatraden/management/commands/infer_course_scheduling.py b/rodatraden/management/commands/infer_course_scheduling.py
index 3ca4bfc..081d8b5 100644
--- a/rodatraden/management/commands/infer_course_scheduling.py
+++ b/rodatraden/management/commands/infer_course_scheduling.py
@@ -75,7 +75,7 @@ def handle(self, *args, **options):
 
             occasions = CourseOccasion.objects.filter(
                 course=course
-            ).select_related('academic_year', 'time_period')
+            ).select_related('time_period')
 
             if not occasions.exists():
                 stats['skipped_no_occasions'] += 1
@@ -120,7 +120,7 @@ def _infer_segments(self, course, occasions):
                     'years': [],
                     'weeks': [],
                 }
-            by_period[pid]['years'].append(occ.academic_year.year)
+            by_period[pid]['years'].append(occ.year)
             by_period[pid]['weeks'].append(occ.weeks)
 
         segments = []
diff --git a/rodatraden/management/commands/validate_course_schedule_parity.py b/rodatraden/management/commands/validate_course_schedule_parity.py
index 8ff67e0..ba9db73 100644
--- a/rodatraden/management/commands/validate_course_schedule_parity.py
+++ b/rodatraden/management/commands/validate_course_schedule_parity.py
@@ -103,9 +103,9 @@ def _get_existing_tuples(self, course):
         """Return set of (year, period_title) from actual CourseOccasion rows."""
         occasions = CourseOccasion.objects.filter(
             course=course
-        ).select_related('academic_year', 'time_period')
+        ).select_related('time_period')
         return {
-            (occ.academic_year.year, occ.time_period.title)
+            (occ.year, occ.time_period.title)
             for occ in occasions
         }
 
diff --git a/rodatraden/models.py b/rodatraden/models.py
index e8527a4..29b8242 100644
--- a/rodatraden/models.py
+++ b/rodatraden/models.py
@@ -10,6 +10,14 @@
 User = get_user_model()
 
 
+def academic_year_title(year: int) -> str:
+    """Return the conventional title string for an academic year.
+
+    Example: 2011 → "11/12", 2020 → "20/21".
+    """
+    return f"{str(year)[2:]}/{str(year + 1)[2:]}"
+
+
 def get_unique_slug(to_slug, model):
     """Generate unique slug for insert in model.
 
@@ -172,26 +180,8 @@ class Meta:
         verbose_name_plural = 'Nivåer'
 
 
-class AcademicYear(models.Model):
-    """'Akademiska perioder' to which all courses is associated with. 
-
-    For example, year 2018 is associated to period 18/19.
-    """
-
-    title = models.CharField(max_length=250)
-    year = models.IntegerField()
-
-    created_at = models.DateTimeField(auto_now_add=True, editable=False,
-            null=False, blank=False)
-    updated_at = models.DateTimeField(auto_now=True, editable=False, null=False,
-            blank=False)
-
-    def __str__(self):
-        return self.title
-
-    class Meta:
-        verbose_name = 'Akademiskt år'
-        verbose_name_plural = 'Akademiska år'
+# AcademicYear model removed — CourseOccasion.year is now a plain IntegerField
+# and the display title (e.g. "20/21") is computed by academic_year_title().
 
 
 class TimePeriod(models.Model):
@@ -654,8 +644,8 @@ class CourseOccasion(models.Model):
             verbose_name='Kontaktadress')
     course = models.ForeignKey(Course, on_delete=models.CASCADE,
             verbose_name='Kurs')
-    academic_year = models.ForeignKey(AcademicYear, on_delete=models.CASCADE,
-            verbose_name='År')
+    # Plain integer — no FK lookup needed. Title derived via academic_year_title().
+    year = models.IntegerField(verbose_name='År')
     time_period = models.ForeignKey(TimePeriod, on_delete=models.CASCADE,
             verbose_name='Läsperiod')
     slug = models.SlugField(max_length=100, unique=True, editable=False)
@@ -672,7 +662,7 @@ class CourseOccasion(models.Model):
 
 
     def __str__(self):
-        return self.course.title + ' - ' + str(self.academic_year.year)
+        return self.course.title + ' - ' + str(self.year)
 
 
     def save(self, *args, **kwargs):
@@ -699,7 +689,7 @@ def save(self, *args, **kwargs):
 
     def get_absolute_url(self):
         return reverse('courseoccasion-detail', kwargs={'year':
-            self.academic_year.year, 'slug': self.slug})
+            self.year, 'slug': self.slug})
 
 
     def as_json(self):
@@ -710,7 +700,7 @@ def as_json(self):
         prerequisites_json = [prerequisite.as_json() for prerequisite in prerequisites]
 
         return dict(
-            year=self.academic_year.year,
+            year=self.year,
             start=self.time_period.week,
             title=self.course.title,
             ects=self.course.ects,
@@ -739,6 +729,11 @@ def start_weeks_into_period(self):
         
         return get_start_weeks_into_period(self.time_period.week)
 
+    @property
+    def year_title(self):
+        """Computed display title, e.g. 2020 → '20/21'."""
+        return academic_year_title(self.year)
+
 
     def category_ects(self, category_sum):
         """Pass through.
diff --git a/rodatraden/rodatraden_modules/functions.py b/rodatraden/rodatraden_modules/functions.py
index 726acfe..e7351ec 100644
--- a/rodatraden/rodatraden_modules/functions.py
+++ b/rodatraden/rodatraden_modules/functions.py
@@ -26,7 +26,7 @@ def import_course_occasions(start_year: int, imported_block: Block):
 
     # Get all courseoccasions from selected block
     course_occasions = imported_block.courseoccasions.all().order_by(
-        'academic_year__year', 'time_period__week'
+        'year', 'time_period__week'
     )
 
     # Difference in years from new block to the import block
@@ -35,13 +35,13 @@ def import_course_occasions(start_year: int, imported_block: Block):
     # Create new courseoccasions
     new_course_occasions: list[CourseOccasion] = []
     for course_occasion in course_occasions:
-        new_year = course_occasion.academic_year.year + year_diff
+        new_year = course_occasion.year + year_diff
         # Get the new course occasion. Just skip if something bad happens,
         # like if it doesn't exist for the new year.
         try:
             new_course_occasion = CourseOccasion.objects.get(
                 course = course_occasion.course,
-                academic_year__year = new_year,
+                year = new_year,
                 time_period__week = course_occasion.time_period.week
             )
             new_course_occasions.append(new_course_occasion)
diff --git a/rodatraden/tables.py b/rodatraden/tables.py
index e660e6c..9afb1cc 100644
--- a/rodatraden/tables.py
+++ b/rodatraden/tables.py
@@ -41,8 +41,8 @@ class CourseOccasionTable(tables.Table):
 
     # Need to fetch url from courseoccasion model
     course = tables.Column(linkify=lambda record: record.get_absolute_url())
-    academic_year = tables.Column(accessor="academic_year__year",
-            verbose_name="År")
+    # Year is now a direct IntegerField on CourseOccasion.
+    year = tables.Column(accessor="year", verbose_name="År")
     time_period = tables.Column(accessor="time_period__title",
             verbose_name="Läsperiod")
 
@@ -72,9 +72,9 @@ class Meta:
         model = CourseOccasion
         # Style template
         template_name = 'django_tables2/bootstrap4.html'
-        fields = ('official', 'course', 'academic_year', 'time_period', 'weeks',
+        fields = ('official', 'course', 'year', 'time_period', 'weeks',
                 'course__ects', 'categories')
-        order_by = ('course', '-academic_year', )
+        order_by = ('course', '-year', )
 
 
 class ExamTable(tables.Table):
diff --git a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_confirm_delete.html b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_confirm_delete.html
index 6546c80..4c38839 100644
--- a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_confirm_delete.html
+++ b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_confirm_delete.html
@@ -12,7 +12,7 @@ <h3 class="modal-title">Radera kurstillfälle</h3>
 
   <div class="modal-body">
     <p class="delete-text">Är du säker på att du vill radera kurstillfället 
-    <strong>{{ courseoccasion.course.title }} - {{ courseoccasion.academic_year.year }}</strong>?</p>
+    <strong>{{ courseoccasion.course.title }} - {{ courseoccasion.year }}</strong>?</p>
   </div>
 
   <div class="modal-footer">
diff --git a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_detail.html b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_detail.html
index 1491d65..5393852 100644
--- a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_detail.html
+++ b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_detail.html
@@ -12,19 +12,19 @@
 </a>
 {% if user.is_staff %}
 <a class="btn btn-gone update-item" 
-  data-id="{% url 'courseoccasion-update' courseoccasion.academic_year.year courseoccasion.slug %}"
+  data-id="{% url 'courseoccasion-update' courseoccasion.year courseoccasion.slug %}"
   data-toggle="tooltip" title="Ändra">
   <span class="fa fa-edit"></span>
 </a>
 <a class="btn btn-gone delete-item"
-  data-id="{% url 'courseoccasion-delete' courseoccasion.academic_year.year courseoccasion.slug %}"
+  data-id="{% url 'courseoccasion-delete' courseoccasion.year courseoccasion.slug %}"
   data-toggle="tooltip" title="Radera">
   <span class="fa fa-trash"></span>
 </a> 
 {% endif %}
 {% endblock %}
 
-{% block page_title %}{{ courseoccasion.course.title }} ({{ courseoccasion.academic_year.year }}){% endblock %}
+{% block page_title %}{{ courseoccasion.course.title }} ({{ courseoccasion.year }}){% endblock %}
 
 {% block content %}
 
diff --git a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
index ee07d09..34939f5 100644
--- a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
+++ b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
@@ -84,7 +84,7 @@ <h5 class="card-header">Kursinfo</h5>
       <div class="card">
         <h5 class="card-header">Kurstillfälle</h5>
         <div class="card-body">
-          <p class="lead"><a target="_blank" href="{% url 'courseoccasion-detail' courseoccasion.academic_year.year courseoccasion.slug %}">
+          <p class="lead"><a target="_blank" href="{% url 'courseoccasion-detail' courseoccasion.year courseoccasion.slug %}">
             {{ course.title }}, {{courseoccasion.year }}
           </a></p>
 
diff --git a/rodatraden/templates/rodatraden/rt_modal/course_list_table_row.html b/rodatraden/templates/rodatraden/rt_modal/course_list_table_row.html
index 58b8844..a30f97d 100644
--- a/rodatraden/templates/rodatraden/rt_modal/course_list_table_row.html
+++ b/rodatraden/templates/rodatraden/rt_modal/course_list_table_row.html
@@ -32,7 +32,7 @@
         {% if is_private %}
         href="{% url 'privatecourse-detail' courseoccasion.user.username courseoccasion.slug %}"
         {% else %}
-        href="{% url 'courseoccasion-detail' courseoccasion.academic_year.year courseoccasion.slug %}"
+        href="{% url 'courseoccasion-detail' courseoccasion.year courseoccasion.slug %}"
         {% endif %}
         aria-label="Läs mer om {{ course.title }} {{ course.ects }} högskolepoäng">
       Läs mer
diff --git a/rodatraden/templates/rodatraden/tables/courseoccasion_edit.html b/rodatraden/templates/rodatraden/tables/courseoccasion_edit.html
index ccb0f93..6a2f1b5 100644
--- a/rodatraden/templates/rodatraden/tables/courseoccasion_edit.html
+++ b/rodatraden/templates/rodatraden/tables/courseoccasion_edit.html
@@ -1,9 +1,9 @@
 <button type='button' class='delete-item btn btn-gone' 
-  data-id="{% url 'courseoccasion-delete' record.academic_year.year record.slug %}">
+  data-id="{% url 'courseoccasion-delete' record.year record.slug %}">
   <span class='fa fa-trash' data-toggle='tooltip' title='Radera'></span>
 </button>
 <button type='button' class='update-item btn btn-gone' 
-  data-id="{% url 'courseoccasion-update' record.academic_year.year record.slug %}">
+  data-id="{% url 'courseoccasion-update' record.year record.slug %}">
   <span class='fa fa-pen' data-toggle='tooltip' title='Ändra'></span>
 </button>
 <button type='button' class='add-item btn btn-gone' 
diff --git a/rodatraden/templates/rodatraden/tools.html b/rodatraden/templates/rodatraden/tools.html
index 73c99c5..c819c1a 100644
--- a/rodatraden/templates/rodatraden/tools.html
+++ b/rodatraden/templates/rodatraden/tools.html
@@ -23,13 +23,13 @@ <h2>Kopiera kurstillfällen till nytt år (äldre verktyg)</h2>
     <span class='px-3'>Ta från år</span>
     <select name='from' id='from'>
       {% for acyear in acyears %}
-      <option value='{{ acyear.id }}'>{{ acyear.title }}</option>
+      <option value='{{ acyear.year }}'>{{ acyear.title }}</option>
       {% endfor %}
     </select>
     <span class='px-3'>till år</span>
     <select name='to' id='to'>
       {% for acyear in acyears %}
-      <option value='{{ acyear.id }}'>{{ acyear.title }}</option>
+      <option value='{{ acyear.year }}'>{{ acyear.title }}</option>
       {% endfor %}
     </select>
     <input class='mx-3' type='submit' value='Skicka' name='courseocc_copy'>
diff --git a/rodatraden/views.py b/rodatraden/views.py
index 0fbbb1a..a2e00f2 100644
--- a/rodatraden/views.py
+++ b/rodatraden/views.py
@@ -21,8 +21,8 @@
 from .models import (
     Category, Course, CourseOccasion, CourseScheduleSegment, Block,
     Prerequisite, User, Profile,
-    CategoryExam, CategoryCourse, AcademicYear, Exam, Report,
-    PrivateCourse, ISPTemplate
+    CategoryExam, CategoryCourse, Exam, Report,
+    PrivateCourse, ISPTemplate, academic_year_title
 )
 from .tables import (
     CourseOccasionTable, ExamTable, ReportTable
@@ -37,6 +37,7 @@
 from .rodatraden_modules.mixins import CorrectUserPermissionMixin
 from .rodatraden_modules.functions import import_course_occasions, is_ajax
 
+import datetime
 import openpyxl
 import os
 import math
@@ -62,12 +63,12 @@ def get_public_elective_course_occasions(block: Block):
     fourth_period_start_week = 30
 
     third_year_elective_course_occasions = block.courseoccasions.filter(
-        academic_year__year=third_year,
+        year=third_year,
         time_period__week__gte=fourth_period_start_week
     )
 
     course_occasions_last_two_years = block.courseoccasions.filter(
-        academic_year__year__gt=third_year
+        year__gt=third_year
     )
 
     elective_course_occasions = (third_year_elective_course_occasions
@@ -108,30 +109,30 @@ def tools(request: HttpRequest):
     if request.method == 'POST':
         # Copying courseoccasions tool (legacy)
         if 'courseocc_copy' in request.POST:
-            from_acyear = AcademicYear.objects.get(id=request.POST['from'])
-            to_acyear = AcademicYear.objects.get(id=request.POST['to'])
-            # Make sure that the years exist
-            if from_acyear and to_acyear:
-                # From all the current courseoccasions
-                for courseocc in CourseOccasion.objects.filter(
-                        academic_year=from_acyear
-                        ):
-                    # Only create a new for the new year if it does not already
-                    # exist
-                    if not CourseOccasion.objects.filter(
-                            academic_year=to_acyear,
-                            course=courseocc.course):
-                        courseocc.pk = None
-                        courseocc.academic_year = to_acyear
-                        courseocc.slug = ''
-                        courseocc.save()
+            from_year = int(request.POST['from'])
+            to_year = int(request.POST['to'])
+            # From all the current courseoccasions
+            for courseocc in CourseOccasion.objects.filter(year=from_year):
+                # Only create a new for the new year if it does not already
+                # exist
+                if not CourseOccasion.objects.filter(
+                        year=to_year,
+                        course=courseocc.course):
+                    courseocc.pk = None
+                    courseocc.year = to_year
+                    courseocc.slug = ''
+                    courseocc.save()
 
         # Generate course occasions from scheduling rules
         if 'generate_occasions' in request.POST:
             generate_results = _generate_occasions_all_years(request)
 
-    # Get all academic years
-    acyears = AcademicYear.objects.all().order_by('year')
+    # Build year choices dynamically for the copy tool dropdown.
+    current = datetime.date.today().year
+    acyears = [
+        {'year': y, 'title': academic_year_title(y)}
+        for y in range(current - 10, current + 11)
+    ]
 
     context = {
             'acyears': acyears,
@@ -152,25 +153,41 @@ def sync_course_occasions(course, dry_run=True):
         - skipped_exists: list of dicts {year_title, period_title}
         - removed: list of dicts {year_title, period_title}
     """
-    academic_years = AcademicYear.objects.all().order_by('year')
+    # Determine the year range to check: cover all segment ranges plus any
+    # existing occasions, and extend up to current year + 10 for future gen.
+    segments_all = course.schedule_segments.all()
+    segment_years = set()
+    for seg in segments_all:
+        end = seg.end_year or seg.start_year
+        segment_years.update(range(seg.start_year, end + 1))
+
+    existing_years = set(
+        CourseOccasion.objects.filter(course=course)
+        .values_list('year', flat=True)
+    )
+    current = datetime.date.today().year
+    all_years = segment_years | existing_years | set(range(current, current + 11))
+    # Fall back gracefully if no years found at all.
+    if not all_years:
+        return {'created': [], 'skipped_exists': [], 'removed': []}
+
     created = []
     skipped_exists = []
     removed = []
 
-    for academic_year in academic_years:
-        year = academic_year.year
+    for year in sorted(all_years):
         segments = course.get_segments_for_year(year)
 
         # --- Create missing CourseOccasions ---
         for segment in segments:
             exists = CourseOccasion.objects.filter(
                 course=course,
-                academic_year=academic_year,
+                year=year,
                 time_period=segment.time_period,
             ).exists()
 
             entry = {
-                'year_title': academic_year.title,
+                'year_title': academic_year_title(year),
                 'period_title': segment.time_period.title,
             }
 
@@ -181,7 +198,7 @@ def sync_course_occasions(course, dry_run=True):
             if not dry_run:
                 CourseOccasion.objects.create(
                     course=course,
-                    academic_year=academic_year,
+                    year=year,
                     time_period=segment.time_period,
                     weeks=segment.weeks,
                     official=True,
@@ -192,7 +209,7 @@ def sync_course_occasions(course, dry_run=True):
         # --- Remove orphaned auto-generated CourseOccasions ---
         for co in CourseOccasion.objects.filter(
             course=course,
-            academic_year=academic_year,
+            year=year,
             auto_generated=True,
         ).select_related('time_period'):
             covered = any(
@@ -201,7 +218,7 @@ def sync_course_occasions(course, dry_run=True):
             )
             if not covered:
                 removed.append({
-                    'year_title': academic_year.title,
+                    'year_title': academic_year_title(year),
                     'period_title': co.time_period.title,
                 })
                 if not dry_run:
@@ -252,26 +269,22 @@ def _generate_occasions_all_years(request):
         auto_generated=True,
     ).exclude(
         course__schedule_segments__isnull=False,
-    ).select_related('course', 'time_period', 'academic_year'):
-        yr = co.academic_year.title
+    ).select_related('course', 'time_period'):
+        yr = academic_year_title(co.year)
         year_results.setdefault(yr, {'created': [], 'skipped_exists': [], 'removed': []})
         year_results[yr]['removed'].append(
             f'{co.course.title} — {co.time_period.title}')
         if not dry_run:
             co.delete()
 
-    # Build a lookup so results are ordered by the numeric year, not the title
-    # string.  This is important because title strings like "11/12" sort
-    # correctly for 2000-2099, but the mapping makes it robust to any title
-    # format that was manually entered in the database.
-    title_to_year = {
-        ay.title: ay.year
-        for ay in AcademicYear.objects.only('title', 'year')
-    }
+    # Sort by the numeric year embedded in the title string.
+    # academic_year_title() always produces "XX/YY", so we can reverse-map
+    # back to the integer for a robust sort.
+    title_to_year = {}
+    for y in range(1900, 2200):
+        title_to_year[academic_year_title(y)] = y
 
-    # Convert to list sorted by numeric year.  Titles not found in the lookup
-    # (e.g. manually entered with a non-standard format) are placed at the end
-    # using a sentinel so the sort key is always an integer.
+    # Convert to list sorted by numeric year.
     results = []
     for yr in sorted(year_results.keys(),
                      key=lambda t: title_to_year.get(t, float('inf'))):
@@ -799,8 +812,7 @@ def get_queryset(self):
 
         self.qs = super().get_queryset()
 
-        return self.qs.filter(
-                academic_year__year=self.kwargs['year'])
+        return self.qs.filter(year=self.kwargs['year'])
 
     def get_context_data(self, **kwargs):
         """Extend get_context_data to return courses that is required for the
@@ -836,7 +848,7 @@ def courseoccasion_info(request: HttpRequest):
 
     unmet_prerequisites = Prerequisite.objects.filter(id__in=unmet_prerequisite_ids)
 
-    courseoccasion = get_object_or_404(CourseOccasion, academic_year__year=year,
+    courseoccasion = get_object_or_404(CourseOccasion, year=year,
         slug=slug)
 
     context = {

From 725259850e2aa27404801ca12cb6d095c4249be0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 12:21:49 +0000
Subject: [PATCH 4/9] docs: update migration guide and README for AcademicYear
 removal

Remove ensure_academic_years references. Add data migration steps for
copying FK year values. Update clean install section.

Agent-Logs-Url: https://github.com/it-amanuens/rodatraden/sessions/b816d356-cc25-4262-a918-9016ea81368b

Co-authored-by: SpiderQubit <25958778+SpiderQubit@users.noreply.github.com>
---
 MIGRATION_GUIDE.md  | 87 +++++++++++++++++++++++++++------------------
 README.md           |  6 ++--
 rodatraden/views.py | 21 +++++------
 3 files changed, 67 insertions(+), 47 deletions(-)

diff --git a/MIGRATION_GUIDE.md b/MIGRATION_GUIDE.md
index 263fae8..6951427 100644
--- a/MIGRATION_GUIDE.md
+++ b/MIGRATION_GUIDE.md
@@ -17,6 +17,14 @@ schemaläggningsfunktionerna.
 - **Behörighet `can_manage_scheduling`** — Begränsar schemaläggning till
   utvalda användare.
 
+### Borttagna modeller
+- **`AcademicYear`** — Hela modellen är borttagen. `CourseOccasion.year` är nu
+  ett vanligt `IntegerField` (precis som `PrivateCourse.year`).
+  Visningstitlar som "20/21" beräknas automatiskt av `academic_year_title()`.
+  Årval i formulär genereras dynamiskt (nuvarande år ± 10) — inga
+  databasposter behöver skapas i förväg.
+- **`ensure_academic_years`-kommandot** — Borttaget (inte längre behövt).
+
 ### Borttagna fält
 - **`Course.closed`** — Oanvänt fält borttaget.
 
@@ -46,40 +54,69 @@ git pull origin main
 pip install -r requirements.txt
 ```
 
-### 4. Skapa migreringsfiler
+### 4. Kopiera år-data från AcademicYear till CourseOccasion (INNAN makemigrations)
 
-Eftersom migreringsfiler inte versionshanteras i detta projekt behöver de
-skapas lokalt:
+Innan du kör `makemigrations` måste befintliga FK-värden kopieras. Kör
+följande i Django-shell:
+
+```bash
+python manage.py shell -c "
+from rodatraden.models import CourseOccasion
+# This only works BEFORE the model changes are applied.
+# If academic_year_id still exists, copy the year values.
+from django.db import connection
+cursor = connection.cursor()
+cursor.execute('''
+    UPDATE rodatraden_courseoccasion co
+    SET year = (
+        SELECT ay.year
+        FROM rodatraden_academicyear ay
+        WHERE ay.id = co.academic_year_id
+    )
+''')
+print(f'Updated {cursor.rowcount} rows')
+"
+```
+
+Alternativt kan du skapa en data-migrering (se steg 5).
+
+### 5. Skapa migreringsfiler
 
 ```bash
 python manage.py makemigrations rodatraden
 ```
 
-Detta bör skapa migrering(ar) som:
+Django kommer att skapa migrering(ar) som:
 - Tar bort `Course.closed`
 - Lägger till `CourseOccasion.auto_generated`
-- Skapar `CourseScheduleSegment`-modellen med behörigheten
-  `can_manage_scheduling`
+- Skapar `CourseScheduleSegment`-modellen
+- **Lägger till `CourseOccasion.year` (IntegerField)**
+- **Tar bort `CourseOccasion.academic_year` (ForeignKey)**
+- **Tar bort `AcademicYear`-modellen**
+
+**VIKTIGT**: Om Django frågar om fältet `year` bytt namn från
+`academic_year`, svara **Nej** — det är ett nytt fält. Du kan behöva
+justera migreringsordningen så att data kopieras innan FK:n tas bort.
 
-### 5. Granska migreringen (valfritt)
+### 6. Granska migreringen (valfritt)
 
 ```bash
 python manage.py sqlmigrate rodatraden <nummer>
 ```
 
-### 6. Tillämpa migreringarna
+### 7. Tillämpa migreringarna
 
 ```bash
 python manage.py migrate
 ```
 
-### 7. Samla statiska filer
+### 8. Samla statiska filer
 
 ```bash
 python manage.py collectstatic --noinput
 ```
 
-### 8. Tilldela behörighet
+### 9. Tilldela behörighet
 
 Ge rätt användare behörigheten `can_manage_scheduling` via Djangos
 admin-panel (`/admin/auth/user/`) eller med ett skript:
@@ -96,7 +133,7 @@ for user in User.objects.filter(is_staff=True):
 "
 ```
 
-### 9. Importera schemaläggningssegment
+### 10. Importera schemaläggningssegment
 
 Segmenten för befintliga kurser kan genereras automatiskt från befintliga
 kurstillfällen:
@@ -109,7 +146,7 @@ python manage.py infer_course_scheduling
 python manage.py infer_course_scheduling --apply
 ```
 
-### 10. Validera
+### 11. Validera
 
 Kontrollera att segmenten matchar befintliga kurstillfällen:
 
@@ -117,27 +154,6 @@ Kontrollera att segmenten matchar befintliga kurstillfällen:
 python manage.py validate_course_schedule_parity
 ```
 
-### 11. Säkerställ akademiska år
-
-Kör kommandot som automatiskt skapar `AcademicYear`-poster för alla år från
-startåret (standard 2011) till och med innevarande år + 10.  Kommandot är
-idempotent och kan köras hur många gånger som helst utan att befintliga poster
-påverkas.
-
-```bash
-# Förhandsvisning (ingen data ändras)
-python manage.py ensure_academic_years
-
-# Skapa saknade poster
-python manage.py ensure_academic_years --apply
-
-# Justera antalet framtida år (standard: 10)
-python manage.py ensure_academic_years --apply --future-years 5
-```
-
-Lägg med fördel in kommandot i ett återkommande jobb (t.ex. cron eller ett
-driftsättningsskript) så att nya år läggs till automatiskt varje år.
-
 ### 12. Starta om servern
 
 Starta om webbservern (t.ex. IIS, gunicorn, eller liknande).
@@ -147,5 +163,6 @@ Starta om webbservern (t.ex. IIS, gunicorn, eller liknande).
 | Problem | Lösning |
 |---------|---------|
 | `makemigrations` skapar oväntade migreringar | Kontrollera att inga gamla migreringsfiler finns kvar |
-| Behörighetsfelet vid schemaläggning | Tilldela `can_manage_scheduling` (steg 8) |
-| Segment saknas | Kör `infer_course_scheduling --apply` (steg 9) |
+| Behörighetsfelet vid schemaläggning | Tilldela `can_manage_scheduling` (steg 9) |
+| Segment saknas | Kör `infer_course_scheduling --apply` (steg 10) |
+| `CourseOccasion.year` är NULL efter migrering | Steg 4 missades — kör SQL-kopieringen manuellt |
diff --git a/README.md b/README.md
index 8ccd15b..45467a3 100644
--- a/README.md
+++ b/README.md
@@ -174,13 +174,15 @@ 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 (run `python manage.py ensure_academic_years --apply` to auto-populate years from 2011 to current year + 10, instead of adding them manually)
+After this navigate to the admin interface. Here we will have to add entries like "institutioner" "Nivåer", "Spår" and "Tidsperioder". 
 - 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.
 
+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
 
 
diff --git a/rodatraden/views.py b/rodatraden/views.py
index a2e00f2..ee5738d 100644
--- a/rodatraden/views.py
+++ b/rodatraden/views.py
@@ -278,16 +278,17 @@ def _generate_occasions_all_years(request):
             co.delete()
 
     # Sort by the numeric year embedded in the title string.
-    # academic_year_title() always produces "XX/YY", so we can reverse-map
-    # back to the integer for a robust sort.
-    title_to_year = {}
-    for y in range(1900, 2200):
-        title_to_year[academic_year_title(y)] = y
+    # academic_year_title() produces "XX/YY", so we can parse the first two
+    # digits and add 2000 to get the year for a robust sort.
+    def _title_sort_key(t):
+        try:
+            return 2000 + int(t.split('/')[0])
+        except (ValueError, IndexError):
+            return float('inf')
 
     # Convert to list sorted by numeric year.
     results = []
-    for yr in sorted(year_results.keys(),
-                     key=lambda t: title_to_year.get(t, float('inf'))):
+    for yr in sorted(year_results.keys(), key=_title_sort_key):
         data = year_results[yr]
         if data['created'] or data['skipped_exists'] or data['removed']:
             results.append({
@@ -1517,9 +1518,9 @@ def block_course_list(request: HttpRequest, username: str, slug: str):
     courses_started_before = set()
     for co in block.courseoccasions.all():
         # Check if this course occasion starts before the period we're adding to
-        if co.academic_year.year < year:
+        if co.year < year:
             courses_started_before.add(co.course.id)
-        elif co.academic_year.year == year and co.time_period.week < start:
+        elif co.year == year and co.time_period.week < start:
             courses_started_before.add(co.course.id)
 
     # Get ALL course occasions starting in the given period, including those
@@ -1527,7 +1528,7 @@ def block_course_list(request: HttpRequest, username: str, slug: str):
     # which effectively limited retakes. Now they are shown but marked as
     # "in_block" so the user can see all available options.
     courseoccasions = CourseOccasion.objects.filter(
-        academic_year__year=year,
+        year=year,
         time_period__week__gte=start,
         time_period__week__lt=start+10
     ).order_by('course__title')

From 94856311465247a35217933af39de74e6d8938c0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 12:24:55 +0000
Subject: [PATCH 5/9] =?UTF-8?q?fix:=20address=20code=20review=20=E2=80=94?=
 =?UTF-8?q?=20extract=20YEAR=5FRANGE=5FOFFSET=20constant,=20add=20clean=5F?=
 =?UTF-8?q?year=20validation?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Extract YEAR_RANGE_OFFSET = 10 to models.py and use it consistently
in forms.py, filters.py, and views.py instead of magic numbers.
Add ValueError handling to CourseOccasionForm.clean_year().

Agent-Logs-Url: https://github.com/it-amanuens/rodatraden/sessions/b816d356-cc25-4262-a918-9016ea81368b

Co-authored-by: SpiderQubit <25958778+SpiderQubit@users.noreply.github.com>
---
 rodatraden/filters.py | 6 +++---
 rodatraden/forms.py   | 9 ++++++---
 rodatraden/models.py  | 4 ++++
 rodatraden/views.py   | 9 +++++----
 4 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/rodatraden/filters.py b/rodatraden/filters.py
index 29260e5..67c6aa8 100644
--- a/rodatraden/filters.py
+++ b/rodatraden/filters.py
@@ -2,7 +2,7 @@
 import django_filters
 from .models import (
     Course, Category, Level, Department, Profile, Track,
-    CourseOccasion, TimePeriod, academic_year_title
+    CourseOccasion, TimePeriod, academic_year_title, YEAR_RANGE_OFFSET
 )
 
 class CourseFilter(django_filters.FilterSet):
@@ -66,8 +66,8 @@ class CourseOccasionFilter(django_filters.FilterSet):
             choices=lambda: [('', 'Läsår')] + [
                 (y, academic_year_title(y))
                 for y in range(
-                    datetime.date.today().year - 10,
-                    datetime.date.today().year + 11,
+                    datetime.date.today().year - YEAR_RANGE_OFFSET,
+                    datetime.date.today().year + YEAR_RANGE_OFFSET + 1,
                 )
             ],
             empty_label=None,  # we include the empty option in choices above
diff --git a/rodatraden/forms.py b/rodatraden/forms.py
index 754a23f..21d39fc 100644
--- a/rodatraden/forms.py
+++ b/rodatraden/forms.py
@@ -6,7 +6,7 @@
     Course, Block, CourseOccasion, CourseScheduleSegment, Category,
     CategoryCourse, Prerequisite, Profile,
     CategoryExam, Exam, Report, PrivateCourse,
-    PrivateCourseCategory, User, academic_year_title
+    PrivateCourseCategory, User, academic_year_title, YEAR_RANGE_OFFSET
 )
 from .rodatraden_modules.mixins import (
     CategoryFormMixin, PrerequisiteFormMixin, SaveAndImportBlockMixin
@@ -16,7 +16,7 @@
 from bootstrap_modal_forms.forms import BSModalForm, BSModalModelForm
 
 
-def _dynamic_year_choices(extra_years=10):
+def _dynamic_year_choices(extra_years=YEAR_RANGE_OFFSET):
     """Build (value, label) tuples for current year ± extra_years.
 
     The range is wide enough to cover both historical and future course
@@ -257,7 +257,10 @@ def __init__(self, *args, **kwargs):
 
     def clean_year(self):
         """Coerce the ChoiceField string back to int for the IntegerField."""
-        return int(self.cleaned_data['year'])
+        try:
+            return int(self.cleaned_data['year'])
+        except (ValueError, TypeError):
+            raise forms.ValidationError('Ogiltigt år.')
 
     class Meta:
         model = CourseOccasion
diff --git a/rodatraden/models.py b/rodatraden/models.py
index 29b8242..efc3ad7 100644
--- a/rodatraden/models.py
+++ b/rodatraden/models.py
@@ -18,6 +18,10 @@ def academic_year_title(year: int) -> str:
     return f"{str(year)[2:]}/{str(year + 1)[2:]}"
 
 
+# How many years before/after today to show in dropdowns.
+YEAR_RANGE_OFFSET = 10
+
+
 def get_unique_slug(to_slug, model):
     """Generate unique slug for insert in model.
 
diff --git a/rodatraden/views.py b/rodatraden/views.py
index ee5738d..3f0856a 100644
--- a/rodatraden/views.py
+++ b/rodatraden/views.py
@@ -22,7 +22,7 @@
     Category, Course, CourseOccasion, CourseScheduleSegment, Block,
     Prerequisite, User, Profile,
     CategoryExam, CategoryCourse, Exam, Report,
-    PrivateCourse, ISPTemplate, academic_year_title
+    PrivateCourse, ISPTemplate, academic_year_title, YEAR_RANGE_OFFSET
 )
 from .tables import (
     CourseOccasionTable, ExamTable, ReportTable
@@ -131,7 +131,7 @@ def tools(request: HttpRequest):
     current = datetime.date.today().year
     acyears = [
         {'year': y, 'title': academic_year_title(y)}
-        for y in range(current - 10, current + 11)
+        for y in range(current - YEAR_RANGE_OFFSET, current + YEAR_RANGE_OFFSET + 1)
     ]
 
     context = {
@@ -278,8 +278,9 @@ def _generate_occasions_all_years(request):
             co.delete()
 
     # Sort by the numeric year embedded in the title string.
-    # academic_year_title() produces "XX/YY", so we can parse the first two
-    # digits and add 2000 to get the year for a robust sort.
+    # academic_year_title() produces "XX/YY" for years 2000-2099.  Parse the
+    # first two digits and add 2000 to recover the full year for sorting.
+    # This assumption is valid for all data in this system (earliest year: 2011).
     def _title_sort_key(t):
         try:
             return 2000 + int(t.split('/')[0])

From 80bf3d5ccefb308f8543c3bad74453ff9e5df12d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 15 Apr 2026 13:28:39 +0000
Subject: [PATCH 6/9] Replace TimePeriod FK with plain IntegerField; add LP5
 summer support

Agent-Logs-Url: https://github.com/it-amanuens/rodatraden/sessions/29702023-4425-43ed-9218-823651cb84d1

Co-authored-by: SpiderQubit <25958778+SpiderQubit@users.noreply.github.com>
---
 rodatraden/admin.py                           |  1 -
 rodatraden/filters.py                         | 14 ++--
 rodatraden/forms.py                           | 10 ++-
 .../commands/generate_course_occasions.py     |  8 ++-
 .../commands/infer_course_scheduling.py       | 36 +++++-----
 .../validate_course_schedule_parity.py        | 26 ++++---
 rodatraden/models.py                          | 71 ++++++++++---------
 rodatraden/rodatraden_modules/forms.py        |  7 +-
 rodatraden/rodatraden_modules/functions.py    |  4 +-
 rodatraden/tables.py                          |  2 +-
 .../rodatraden/course/course_detail.html      |  2 +-
 .../courseoccasion/courseoccasion_info.html   |  2 +-
 .../courseoccasion/courseoccasion_list.html   |  2 +-
 rodatraden/views.py                           | 27 +++----
 14 files changed, 116 insertions(+), 96 deletions(-)

diff --git a/rodatraden/admin.py b/rodatraden/admin.py
index f96933b..6b8d2e0 100644
--- a/rodatraden/admin.py
+++ b/rodatraden/admin.py
@@ -10,7 +10,6 @@
     Department,
     Level,
     Track,
-    TimePeriod,
     ISPTemplate,
     CourseScheduleSegment,
     Exam,
diff --git a/rodatraden/filters.py b/rodatraden/filters.py
index 67c6aa8..bb41099 100644
--- a/rodatraden/filters.py
+++ b/rodatraden/filters.py
@@ -2,7 +2,7 @@
 import django_filters
 from .models import (
     Course, Category, Level, Department, Profile, Track,
-    CourseOccasion, TimePeriod, academic_year_title, YEAR_RANGE_OFFSET
+    CourseOccasion, academic_year_title, YEAR_RANGE_OFFSET
 )
 
 class CourseFilter(django_filters.FilterSet):
@@ -73,9 +73,13 @@ class CourseOccasionFilter(django_filters.FilterSet):
             empty_label=None,  # we include the empty option in choices above
             field_name='year'
     )
-    time_period = django_filters.ModelChoiceFilter(
-            queryset=TimePeriod.objects.all().order_by('week'),
-            empty_label='Läsperiod', field_name='time_period'
+    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'), 
@@ -94,6 +98,6 @@ class CourseOccasionFilter(django_filters.FilterSet):
 
     class Meta:
         model = CourseOccasion
-        fields = ['title', 'year', 'time_period', 'categories', 'department',
+        fields = ['title', 'year', 'categories', 'department',
             'official'
         ]
diff --git a/rodatraden/forms.py b/rodatraden/forms.py
index 21d39fc..1502802 100644
--- a/rodatraden/forms.py
+++ b/rodatraden/forms.py
@@ -195,6 +195,8 @@ 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)
@@ -217,7 +219,7 @@ def clean_blacklisted_years(self):
 
     class Meta:
         model = CourseScheduleSegment
-        fields = ['course', 'time_period', 'frequency', 'start_year',
+        fields = ['course', 'start', 'frequency', 'start_year',
                   'end_year', 'weeks', 'blacklisted_years']
         widgets = {
             'course': forms.HiddenInput(),
@@ -245,7 +247,7 @@ def __init__(self, *args, **kwargs):
             # This hard-coding might be avoidable. Not sure...
             self.fields['course'].initial = courseocc_cpy.course
             self.fields['year'].initial = courseocc_cpy.year
-            self.fields['time_period'].initial = courseocc_cpy.time_period
+            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
@@ -255,6 +257,8 @@ def __init__(self, *args, **kwargs):
         self.fields['course'].widget.attrs['class'] = \
             'course-list-filter-courseocc-create'
 
+        self.fields['start'] = StartWeekField(label='Läsperiod')
+
     def clean_year(self):
         """Coerce the ChoiceField string back to int for the IntegerField."""
         try:
@@ -264,7 +268,7 @@ def clean_year(self):
 
     class Meta:
         model = CourseOccasion
-        fields = ['course', 'year', 'time_period', 'weeks',
+        fields = ['course', 'year', 'start', 'weeks',
         'note', 'contact_name', 'contact_email', 'official']
 
 
diff --git a/rodatraden/management/commands/generate_course_occasions.py b/rodatraden/management/commands/generate_course_occasions.py
index 37b7364..e517f20 100644
--- a/rodatraden/management/commands/generate_course_occasions.py
+++ b/rodatraden/management/commands/generate_course_occasions.py
@@ -67,17 +67,19 @@ def handle(self, *args, **options):
                 exists = CourseOccasion.objects.filter(
                     course=course,
                     year=year,
-                    time_period=segment.time_period,
+                    start=segment.start,
                 ).exists()
 
                 if exists:
                     skipped_exists += 1
                     continue
 
+                weeks_in_period = 10
+                period_number = segment.start // weeks_in_period + 1
                 self.stdout.write(
                     f'  {"CREATE" if apply else "WOULD CREATE"}  '
                     f'{course.title} — {title} '
-                    f'{segment.time_period.title} '
+                    f'LP{period_number} '
                     f'({segment.weeks} weeks)'
                 )
 
@@ -85,7 +87,7 @@ def handle(self, *args, **options):
                     CourseOccasion.objects.create(
                         course=course,
                         year=year,
-                        time_period=segment.time_period,
+                        start=segment.start,
                         weeks=segment.weeks,
                         official=True,
                         auto_generated=True,
diff --git a/rodatraden/management/commands/infer_course_scheduling.py b/rodatraden/management/commands/infer_course_scheduling.py
index 081d8b5..187e16e 100644
--- a/rodatraden/management/commands/infer_course_scheduling.py
+++ b/rodatraden/management/commands/infer_course_scheduling.py
@@ -1,11 +1,11 @@
 """
 Infer CourseScheduleSegment rows from existing CourseOccasion history.
 
-For each course, groups occasions by time_period and creates one segment
+For each course, groups occasions by start week and creates one segment
 per group with:
   - frequency = 'yearly'
-  - start_year = earliest year in that (course, period) group
-  - end_year   = latest year in that (course, period) group
+  - start_year = earliest year in that (course, start) group
+  - end_year   = latest year in that (course, start) group
   - weeks      = most common weeks value in the group
   - blacklisted_years = years in [start..end] that have no occasion
 
@@ -75,7 +75,7 @@ def handle(self, *args, **options):
 
             occasions = CourseOccasion.objects.filter(
                 course=course
-            ).select_related('time_period')
+            )
 
             if not occasions.exists():
                 stats['skipped_no_occasions'] += 1
@@ -109,22 +109,22 @@ def handle(self, *args, **options):
             self.stdout.write(self.style.SUCCESS('\nChanges saved.'))
 
     def _infer_segments(self, course, occasions):
-        """Return list of dicts describing one segment per (course, period)."""
-        # Group occasions by time_period
-        by_period = {}
+        """Return list of dicts describing one segment per (course, start)."""
+        # Group occasions by start week
+        by_start = {}
         for occ in occasions:
-            pid = occ.time_period_id
-            if pid not in by_period:
-                by_period[pid] = {
-                    'time_period': occ.time_period,
+            s = occ.start
+            if s not in by_start:
+                by_start[s] = {
+                    'start': s,
                     'years': [],
                     'weeks': [],
                 }
-            by_period[pid]['years'].append(occ.year)
-            by_period[pid]['weeks'].append(occ.weeks)
+            by_start[s]['years'].append(occ.year)
+            by_start[s]['weeks'].append(occ.weeks)
 
         segments = []
-        for pid, data in by_period.items():
+        for s, data in by_start.items():
             years = sorted(data['years'])
             start_year = min(years)
             end_year = max(years)
@@ -136,7 +136,7 @@ def _infer_segments(self, course, occasions):
 
             segments.append({
                 'course': course,
-                'time_period': data['time_period'],
+                'start': s,
                 'start_year': start_year,
                 'end_year': end_year,
                 'frequency': 'yearly',
@@ -147,12 +147,14 @@ def _infer_segments(self, course, occasions):
         return segments
 
     def _report(self, course, segments):
+        weeks_in_period = 10
         self.stdout.write(f'\n  {course.title} ({len(segments)} segment(s)):')
         for seg in segments:
             bl_str = (', '.join(str(y) for y in seg['blacklisted_years'])
                       if seg['blacklisted_years'] else '(none)')
+            period_number = seg['start'] // weeks_in_period + 1
             self.stdout.write(
-                f"    {seg['time_period'].title}: "
+                f"    LP{period_number}: "
                 f"{seg['start_year']}–{seg['end_year']}  "
                 f"freq={seg['frequency']}  "
                 f"weeks={seg['weeks']}  "
@@ -163,7 +165,7 @@ def _apply(self, segments):
         for seg in segments:
             CourseScheduleSegment.objects.create(
                 course=seg['course'],
-                time_period=seg['time_period'],
+                start=seg['start'],
                 start_year=seg['start_year'],
                 end_year=seg['end_year'],
                 frequency=seg['frequency'],
diff --git a/rodatraden/management/commands/validate_course_schedule_parity.py b/rodatraden/management/commands/validate_course_schedule_parity.py
index ba9db73..febfe89 100644
--- a/rodatraden/management/commands/validate_course_schedule_parity.py
+++ b/rodatraden/management/commands/validate_course_schedule_parity.py
@@ -2,9 +2,9 @@
 Validate that CourseScheduleSegment rules would generate the same
 CourseOccasion set that already exists in the database.
 
-Compares (course, year, period) tuples between:
+Compares (course, year, start) tuples between:
   - EXISTING: actual CourseOccasion rows
-  - EXPECTED: what active segments for each year/period would produce
+  - EXPECTED: what active segments for each year/start would produce
 
 Reports mismatches grouped as:
   - MISSING:  existing occasion not covered by any segment
@@ -62,15 +62,15 @@ def handle(self, *args, **options):
                 self.stdout.write(
                     self.style.WARNING(f'\n  MISMATCH  {course.title}')
                 )
-                for year, period_title in sorted(missing):
+                for year, start in sorted(missing):
                     self.stdout.write(
                         f'    MISSING (exists but rules skip): '
-                        f'year={year}  period={period_title}'
+                        f'year={year}  start={start}'
                     )
-                for year, period_title in sorted(extra):
+                for year, start in sorted(extra):
                     self.stdout.write(
                         f'    EXTRA   (rules would create):    '
-                        f'year={year}  period={period_title}'
+                        f'year={year}  start={start}'
                     )
                 total_missing += len(missing)
                 total_extra += len(extra)
@@ -100,18 +100,16 @@ def handle(self, *args, **options):
             )
 
     def _get_existing_tuples(self, course):
-        """Return set of (year, period_title) from actual CourseOccasion rows."""
-        occasions = CourseOccasion.objects.filter(
-            course=course
-        ).select_related('time_period')
+        """Return set of (year, start) from actual CourseOccasion rows."""
+        occasions = CourseOccasion.objects.filter(course=course)
         return {
-            (occ.year, occ.time_period.title)
+            (occ.year, occ.start)
             for occ in occasions
         }
 
     def _get_expected_tuples(self, course):
-        """Return set of (year, period_title) the segments would produce."""
-        segments = course.schedule_segments.select_related('time_period').all()
+        """Return set of (year, start) the segments would produce."""
+        segments = course.schedule_segments.all()
         if not segments:
             return set()
 
@@ -121,6 +119,6 @@ def _get_expected_tuples(self, course):
             end = segment.end_year or segment.start_year
             for year in range(start, end + 1):
                 if segment.is_active_in_year(year):
-                    expected.add((year, segment.time_period.title))
+                    expected.add((year, segment.start))
 
         return expected
diff --git a/rodatraden/models.py b/rodatraden/models.py
index efc3ad7..8ea3c95 100644
--- a/rodatraden/models.py
+++ b/rodatraden/models.py
@@ -184,29 +184,9 @@ class Meta:
         verbose_name_plural = 'Nivåer'
 
 
-# AcademicYear model removed — CourseOccasion.year is now a plain IntegerField
-# and the display title (e.g. "20/21") is computed by academic_year_title().
-
-
-class TimePeriod(models.Model):
-    """'Läsperioder' to which all courses is associated with.
-
-    For example, läsperiod 1 is at week 0 of the academic year.
-    """
-    title = models.CharField(max_length=250)
-    week = models.IntegerField()
-    # Timestamp
-    created_at = models.DateTimeField(auto_now_add=True, editable=False,
-            null=False, blank=False)
-    updated_at = models.DateTimeField(auto_now=True, editable=False, null=False,
-            blank=False)
-
-    def __str__(self):
-        return self.title
-
-    class Meta:
-        verbose_name = 'Tidsperiod'
-        verbose_name_plural = 'Tidsperioder'
+# TimePeriod model removed — CourseOccasion.start and CourseScheduleSegment.start
+# are now plain IntegerFields storing the week number (0 = LP1, 10 = LP2, …).
+# The display string (e.g. "LP2 — 3 veckor in") is computed by start_string.
 
 
 class Profile(models.Model):
@@ -531,10 +511,10 @@ class CourseScheduleSegment(models.Model):
         default='yearly',
         verbose_name='Frekvens'
     )
-    time_period = models.ForeignKey(
-        TimePeriod,
-        on_delete=models.CASCADE,
-        verbose_name='Läsperiod'
+    start = models.IntegerField(
+        verbose_name='Läsperiod',
+        help_text='Startvecka för perioden (0 = LP1, 10 = LP2, 20 = LP3, 30 = LP4, 40 = LP5)',
+        default=0,
     )
     weeks = models.IntegerField(
         default=5,
@@ -555,16 +535,28 @@ class CourseScheduleSegment(models.Model):
     class Meta:
         verbose_name = 'Schemaläggningssegment'
         verbose_name_plural = 'Schemaläggningssegment'
-        ordering = ['start_year', 'time_period__week']
+        ordering = ['start_year', 'start']
         permissions = [
             ('can_manage_scheduling', 'Kan hantera schemaläggning'),
         ]
 
     def __str__(self):
         end = self.end_year or '→'
-        return (f'{self.course.title}: {self.time_period.title} '
+        return (f'{self.course.title}: {self.start_string} '
                 f'{self.start_year}-{end} ({self.get_frequency_display()})')
 
+    @property
+    def start_string(self):
+        """Period label, e.g. 'LP2' or 'LP2 — 3 veckor in'."""
+        weeks_in_period = 10
+        period_number = self.start // weeks_in_period + 1
+        period_start_offset = self.start % 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 is_active_in_year(self, year):
         """Check if this segment covers the given year."""
         if year < self.start_year:
@@ -650,8 +642,9 @@ class CourseOccasion(models.Model):
             verbose_name='Kurs')
     # Plain integer — no FK lookup needed. Title derived via academic_year_title().
     year = models.IntegerField(verbose_name='År')
-    time_period = models.ForeignKey(TimePeriod, on_delete=models.CASCADE,
-            verbose_name='Läsperiod')
+    # Plain integer — LP1=0, LP2=10, LP3=20, LP4=30, LP5=40. Offset within
+    # period stored directly (e.g. start=13 → LP2, 3 weeks in).
+    start = models.IntegerField(verbose_name='Läsperiod', default=0)
     slug = models.SlugField(max_length=100, unique=True, editable=False)
     auto_generated = models.BooleanField(
         default=False,
@@ -705,7 +698,7 @@ def as_json(self):
 
         return dict(
             year=self.year,
-            start=self.time_period.week,
+            start=self.start,
             title=self.course.title,
             ects=self.course.ects,
             weeks=self.weeks,
@@ -731,7 +724,19 @@ def start_weeks_into_period(self):
         """The number of weeks into the start of the period the course
         starts."""
         
-        return get_start_weeks_into_period(self.time_period.week)
+        return get_start_weeks_into_period(self.start)
+
+    @property
+    def start_string(self):
+        """Period label, e.g. 'LP2' or 'LP2 — 3 veckor in'."""
+        weeks_in_period = 10
+        period_number = self.start // weeks_in_period + 1
+        period_start_offset = self.start % 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
 
     @property
     def year_title(self):
diff --git a/rodatraden/rodatraden_modules/forms.py b/rodatraden/rodatraden_modules/forms.py
index 8ca7acc..cce85ad 100644
--- a/rodatraden/rodatraden_modules/forms.py
+++ b/rodatraden/rodatraden_modules/forms.py
@@ -144,12 +144,15 @@ class StartWeekField(forms.MultiValueField):
     1. The starting period from a selection.
     2. The number of weeks after the start of the period that the course starts.
 
-    This information is converted into a starting week number between 0 and 40.
+    This information is converted into a starting week number between 0 and 49.
+    LP1 = week 0, LP2 = week 10, LP3 = week 20, LP4 = week 30, LP5 = week 40
+    (LP5 represents the summer period).
     """
 
     # A choice for a ChoiceField or Select widget is a 2-tuple on the form
     # (value, human readable name).
-    _period_choices = [(i, f'LP{i}') for i in range(1, 5)]
+    # LP1–LP4 are the regular academic periods; LP5 is the summer period.
+    _period_choices = [(i, f'LP{i}') for i in range(1, 6)]
     _week_offset_choices = [(i, f'+ {i} veckor') for i in range(10)]
 
     # The widgets need the choices to be able to list them as option elements
diff --git a/rodatraden/rodatraden_modules/functions.py b/rodatraden/rodatraden_modules/functions.py
index e7351ec..9981af0 100644
--- a/rodatraden/rodatraden_modules/functions.py
+++ b/rodatraden/rodatraden_modules/functions.py
@@ -26,7 +26,7 @@ def import_course_occasions(start_year: int, imported_block: Block):
 
     # Get all courseoccasions from selected block
     course_occasions = imported_block.courseoccasions.all().order_by(
-        'year', 'time_period__week'
+        'year', 'start'
     )
 
     # Difference in years from new block to the import block
@@ -42,7 +42,7 @@ def import_course_occasions(start_year: int, imported_block: Block):
             new_course_occasion = CourseOccasion.objects.get(
                 course = course_occasion.course,
                 year = new_year,
-                time_period__week = course_occasion.time_period.week
+                start = course_occasion.start
             )
             new_course_occasions.append(new_course_occasion)
         except:
diff --git a/rodatraden/tables.py b/rodatraden/tables.py
index 9afb1cc..cfe6182 100644
--- a/rodatraden/tables.py
+++ b/rodatraden/tables.py
@@ -43,7 +43,7 @@ class CourseOccasionTable(tables.Table):
     course = tables.Column(linkify=lambda record: record.get_absolute_url())
     # Year is now a direct IntegerField on CourseOccasion.
     year = tables.Column(accessor="year", verbose_name="År")
-    time_period = tables.Column(accessor="time_period__title",
+    time_period = tables.Column(accessor="start_string",
             verbose_name="Läsperiod")
 
     # Editing buttons
diff --git a/rodatraden/templates/rodatraden/course/course_detail.html b/rodatraden/templates/rodatraden/course/course_detail.html
index 179da8f..a7ba249 100644
--- a/rodatraden/templates/rodatraden/course/course_detail.html
+++ b/rodatraden/templates/rodatraden/course/course_detail.html
@@ -146,7 +146,7 @@ <h5 class="card-header">
         {% for segment in course.schedule_segments.all %}
           <div class="d-flex justify-content-between align-items-center mb-2">
             <div>
-              <strong>{{ segment.time_period.title }}</strong><br>
+              <strong>{{ segment.start_string }}</strong><br>
               <small>
                 {{ segment.start_year }}–{{ segment.end_year|default:"→" }}
                 · {{ segment.get_frequency_display }}
diff --git a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
index 34939f5..4066999 100644
--- a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
+++ b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
@@ -91,7 +91,7 @@ <h5 class="card-header">Kurstillfälle</h5>
           <table style="border-collapse: separate;border-spacing:1rem 0;">
             <tr>
               <td>Läsperiod</td>
-              <td>{{ courseoccasion.time_period.title }}</td>
+              <td>{{ courseoccasion.start_string }}</td>
             </tr>
             <tr>
               <td>Veckor</td>
diff --git a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_list.html b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_list.html
index 19b9ad0..f0f38da 100644
--- a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_list.html
+++ b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_list.html
@@ -28,7 +28,7 @@
       <form action="" method="get" class="form form-inline courseoccasion-filter-form">
         {% render_field filter.form.title class+="course-list-filter" %}
         {% render_field filter.form.year class+="course-list-filter-small" %}
-        {% render_field filter.form.time_period class+="course-list-filter" %}
+        {% render_field filter.form.time_period class+="course-list-filter-small" %}
         {% render_field filter.form.categories class+="course-list-filter" %}
         {% render_field filter.form.department class+="course-list-filter" %}
         {% render_field filter.form.official class+="course-list-filter-small" %}
diff --git a/rodatraden/views.py b/rodatraden/views.py
index 3f0856a..90fb001 100644
--- a/rodatraden/views.py
+++ b/rodatraden/views.py
@@ -64,7 +64,7 @@ def get_public_elective_course_occasions(block: Block):
 
     third_year_elective_course_occasions = block.courseoccasions.filter(
         year=third_year,
-        time_period__week__gte=fourth_period_start_week
+        start__gte=fourth_period_start_week
     )
 
     course_occasions_last_two_years = block.courseoccasions.filter(
@@ -183,12 +183,12 @@ def sync_course_occasions(course, dry_run=True):
             exists = CourseOccasion.objects.filter(
                 course=course,
                 year=year,
-                time_period=segment.time_period,
+                start=segment.start,
             ).exists()
 
             entry = {
                 'year_title': academic_year_title(year),
-                'period_title': segment.time_period.title,
+                'period_title': segment.start_string,
             }
 
             if exists:
@@ -199,7 +199,7 @@ def sync_course_occasions(course, dry_run=True):
                 CourseOccasion.objects.create(
                     course=course,
                     year=year,
-                    time_period=segment.time_period,
+                    start=segment.start,
                     weeks=segment.weeks,
                     official=True,
                     auto_generated=True,
@@ -211,15 +211,15 @@ def sync_course_occasions(course, dry_run=True):
             course=course,
             year=year,
             auto_generated=True,
-        ).select_related('time_period'):
+        ):
             covered = any(
-                seg.time_period_id == co.time_period_id
+                seg.start == co.start
                 for seg in segments
             )
             if not covered:
                 removed.append({
                     'year_title': academic_year_title(year),
-                    'period_title': co.time_period.title,
+                    'period_title': co.start_string,
                 })
                 if not dry_run:
                     co.delete()
@@ -269,11 +269,11 @@ def _generate_occasions_all_years(request):
         auto_generated=True,
     ).exclude(
         course__schedule_segments__isnull=False,
-    ).select_related('course', 'time_period'):
+    ).select_related('course'):
         yr = academic_year_title(co.year)
         year_results.setdefault(yr, {'created': [], 'skipped_exists': [], 'removed': []})
         year_results[yr]['removed'].append(
-            f'{co.course.title} — {co.time_period.title}')
+            f'{co.course.title} — {co.start_string}')
         if not dry_run:
             co.delete()
 
@@ -1521,7 +1521,7 @@ def block_course_list(request: HttpRequest, username: str, slug: str):
         # Check if this course occasion starts before the period we're adding to
         if co.year < year:
             courses_started_before.add(co.course.id)
-        elif co.year == year and co.time_period.week < start:
+        elif co.year == year and co.start < start:
             courses_started_before.add(co.course.id)
 
     # Get ALL course occasions starting in the given period, including those
@@ -1530,8 +1530,11 @@ def block_course_list(request: HttpRequest, username: str, slug: str):
     # "in_block" so the user can see all available options.
     courseoccasions = CourseOccasion.objects.filter(
         year=year,
-        time_period__week__gte=start,
-        time_period__week__lt=start+10
+        start__gte=start,
+        start__lt=start+10
+    ).exclude(
+        # Exclude course occasions already in THIS slot
+        block__id=block.id
     ).order_by('course__title')
 
     # Annotate each course occasion with retake and in-block status

From 0a5ef8fa3148e2d3f9ed26a56af71f2db89f01a6 Mon Sep 17 00:00:00 2001
From: Marc <marc@gitea.taginu.com>
Date: Sat, 18 Apr 2026 15:17:44 +0200
Subject: [PATCH 7/9] refactor: update migration guide and README for
 AcademicYear removal; enhance year choice logic in filters and forms

---
 MIGRATION_GUIDE.md    | 63 +++++++++++++++++++++++--------------------
 README.md             |  6 +++--
 rodatraden/filters.py | 19 ++++++++-----
 rodatraden/forms.py   | 24 ++++++++++++-----
 rodatraden/models.py  |  2 +-
 5 files changed, 69 insertions(+), 45 deletions(-)

diff --git a/MIGRATION_GUIDE.md b/MIGRATION_GUIDE.md
index 6951427..d841791 100644
--- a/MIGRATION_GUIDE.md
+++ b/MIGRATION_GUIDE.md
@@ -54,39 +54,45 @@ git pull origin main
 pip install -r requirements.txt
 ```
 
-### 4. Kopiera år-data från AcademicYear till CourseOccasion (INNAN makemigrations)
-
-Innan du kör `makemigrations` måste befintliga FK-värden kopieras. Kör
-följande i Django-shell:
+### 4. Skapa migreringsfiler
 
 ```bash
-python manage.py shell -c "
-from rodatraden.models import CourseOccasion
-# This only works BEFORE the model changes are applied.
-# If academic_year_id still exists, copy the year values.
-from django.db import connection
-cursor = connection.cursor()
-cursor.execute('''
-    UPDATE rodatraden_courseoccasion co
-    SET year = (
-        SELECT ay.year
-        FROM rodatraden_academicyear ay
-        WHERE ay.id = co.academic_year_id
-    )
-''')
-print(f'Updated {cursor.rowcount} rows')
-"
+python manage.py makemigrations rodatraden
 ```
 
-Alternativt kan du skapa en data-migrering (se steg 5).
-
-### 5. Skapa migreringsfiler
-
-```bash
-python manage.py makemigrations rodatraden
+### 5. Redigera migreringen (viktigt för befintlig data)
+
+För databaser som redan innehåller kurstillfällen behöver du justera den
+lokalt skapade migreringen så att data kopieras innan gamla FK-fält tas bort.
+
+Säker ordning i migreringen:
+- Lägg till `CourseOccasion.year` som **nullable** (`null=True`) först.
+- Lägg till `CourseOccasion.start` (om den inte redan finns) först.
+- Kör en data-kopiering (SQL eller `RunPython`):
+  - `CourseOccasion.year` från `AcademicYear.year`
+  - `CourseOccasion.start` från `TimePeriod.week`
+- Ta bort gamla FK-fält (`academic_year`, `time_period`).
+- Ta bort modellerna `AcademicYear` och `TimePeriod`.
+- Avsluta med att göra `CourseOccasion.year` icke-nullable.
+
+Exempel-SQL (i migrationsfilen, efter att `year`/`start` har lagts till):
+
+```sql
+UPDATE rodatraden_courseoccasion co
+SET year = ay.year
+FROM rodatraden_academicyear ay
+WHERE ay.id = co.academic_year_id;
+
+UPDATE rodatraden_courseoccasion co
+SET start = tp.week
+FROM rodatraden_timeperiod tp
+WHERE tp.id = co.time_period_id;
 ```
 
-Django kommer att skapa migrering(ar) som:
+Utan detta steg riskerar befintliga rader att få felaktiga värden eller tappa
+år/period-information.
+
+Typiska operationer i den lokala migreringen:
 - Tar bort `Course.closed`
 - Lägger till `CourseOccasion.auto_generated`
 - Skapar `CourseScheduleSegment`-modellen
@@ -95,8 +101,7 @@ Django kommer att skapa migrering(ar) som:
 - **Tar bort `AcademicYear`-modellen**
 
 **VIKTIGT**: Om Django frågar om fältet `year` bytt namn från
-`academic_year`, svara **Nej** — det är ett nytt fält. Du kan behöva
-justera migreringsordningen så att data kopieras innan FK:n tas bort.
+`academic_year`, svara **Nej** — det är ett nytt fält.
 
 ### 6. Granska migreringen (valfritt)
 
diff --git a/README.md b/README.md
index 45467a3..1cd7cf9 100644
--- a/README.md
+++ b/README.md
@@ -174,11 +174,13 @@ 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 "institutioner" "Nivåer", "Spår" and "Tidsperioder". 
+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.
diff --git a/rodatraden/filters.py b/rodatraden/filters.py
index bb41099..efc2de2 100644
--- a/rodatraden/filters.py
+++ b/rodatraden/filters.py
@@ -5,6 +5,17 @@
     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.
     
@@ -63,13 +74,7 @@ class CourseOccasionFilter(django_filters.FilterSet):
     )
     # Year is now a plain IntegerField — use ChoiceFilter with dynamic choices.
     year = django_filters.ChoiceFilter(
-            choices=lambda: [('', 'Läsår')] + [
-                (y, academic_year_title(y))
-                for y in range(
-                    datetime.date.today().year - YEAR_RANGE_OFFSET,
-                    datetime.date.today().year + YEAR_RANGE_OFFSET + 1,
-                )
-            ],
+            choices=_courseoccasion_year_choices,
             empty_label=None,  # we include the empty option in choices above
             field_name='year'
     )
diff --git a/rodatraden/forms.py b/rodatraden/forms.py
index 1502802..1543abe 100644
--- a/rodatraden/forms.py
+++ b/rodatraden/forms.py
@@ -16,16 +16,21 @@
 from bootstrap_modal_forms.forms import BSModalForm, BSModalModelForm
 
 
-def _dynamic_year_choices(extra_years=YEAR_RANGE_OFFSET):
+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 range(current - extra_years, current + extra_years + 1)
+        for y in sorted(years)
     ]
 
 
@@ -125,7 +130,9 @@ def __init__(self, *args, **kwargs):
         self._build_category_fields(categories)
 
         # Year choices computed dynamically — no database query needed.
-        year_choices = _dynamic_year_choices()
+        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
@@ -178,9 +185,10 @@ def __init__(self, *args, **kwargs):
             self.initial['course'] = self.request.GET['course']
 
         # 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(y), label)
-            for y, label in _dynamic_year_choices()
+            for y, label in _dynamic_year_choices(include_years=include_years)
         ]
         self.fields['start_year'] = forms.ChoiceField(
             choices=year_choices,
@@ -234,7 +242,9 @@ def __init__(self, *args, **kwargs):
 
         # Year is now a plain IntegerField — present as a dropdown with
         # dynamically computed year choices (current year ± 10).
-        year_choices = _dynamic_year_choices()
+        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,
@@ -288,7 +298,9 @@ class BlockForm(SaveAndImportBlockMixin, BSModalModelForm):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # Year choices computed dynamically — no database query needed.
-        years = _dynamic_year_choices()
+        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.
diff --git a/rodatraden/models.py b/rodatraden/models.py
index 8ea3c95..1690068 100644
--- a/rodatraden/models.py
+++ b/rodatraden/models.py
@@ -15,7 +15,7 @@ def academic_year_title(year: int) -> str:
 
     Example: 2011 → "11/12", 2020 → "20/21".
     """
-    return f"{str(year)[2:]}/{str(year + 1)[2:]}"
+    return f"{year % 100:02d}/{(year + 1) % 100:02d}"
 
 
 # How many years before/after today to show in dropdowns.

From 8a088a8b72f08cc2291a5eca8df3dbb57ed6826a Mon Sep 17 00:00:00 2001
From: Marc <marc@gitea.taginu.com>
Date: Sat, 18 Apr 2026 16:05:17 +0200
Subject: [PATCH 8/9] feat: add upgrade script for removing incremental years
 and updating CourseOccasion fields

---
 MIGRATION_GUIDE.md                  | 194 ++++++++++++---------------
 upgrade_remove_incremental_years.py | 200 ++++++++++++++++++++++++++++
 2 files changed, 287 insertions(+), 107 deletions(-)
 create mode 100644 upgrade_remove_incremental_years.py

diff --git a/MIGRATION_GUIDE.md b/MIGRATION_GUIDE.md
index d841791..4e9ea88 100644
--- a/MIGRATION_GUIDE.md
+++ b/MIGRATION_GUIDE.md
@@ -1,130 +1,93 @@
-# Migreringsguide — Automatisk schemaläggning
+# Migration Guide - Automatic Scheduling
 
-Den här guiden beskriver hur du uppgraderar produktionsservern med de nya
-schemaläggningsfunktionerna.
+This guide describes how to upgrade a production server with the new
+automatic scheduling functionality.
 
-## Sammanfattning av ändringar
+## Summary of changes
 
-### Nya funktioner
-- **CourseScheduleSegment-modell** — Regler som styr när en kurs ges (period,
-  frekvens, start/slutår, undantagsår).
-- **Schemaläggningskort** på kurssidan — CRUD för segment + "Verkställ"-knapp
-  som förhandsgranskar och skapar/tar bort kurstillfällen per kurs.
-- **Globalt genereringsverktyg** på `/verktyg/` — Generera kurstillfällen för
-  alla år baserat på alla kursers segment.
-- **`auto_generated`-fält** på CourseOccasion — Markerar kurstillfällen som
-  skapats automatiskt så att de kan hanteras separat.
-- **Behörighet `can_manage_scheduling`** — Begränsar schemaläggning till
-  utvalda användare.
+### New features
+- **`CourseScheduleSegment` model** - Rules for when a course is offered
+  (period, frequency, start/end year, excluded years).
+- **Scheduling card** on course detail pages - CRUD for segments + an
+  "Apply" action to preview and create/remove course occasions per course.
+- **Global generation tool** at `/verktyg/` - Generate course occasions for
+  all years based on all course segments.
+- **`auto_generated` field** on `CourseOccasion` - Marks occasions created
+  automatically so they can be managed separately.
+- **`can_manage_scheduling` permission** - Restricts scheduling actions to
+  selected users.
 
-### Borttagna modeller
-- **`AcademicYear`** — Hela modellen är borttagen. `CourseOccasion.year` är nu
-  ett vanligt `IntegerField` (precis som `PrivateCourse.year`).
-  Visningstitlar som "20/21" beräknas automatiskt av `academic_year_title()`.
-  Årval i formulär genereras dynamiskt (nuvarande år ± 10) — inga
-  databasposter behöver skapas i förväg.
-- **`ensure_academic_years`-kommandot** — Borttaget (inte längre behövt).
+### Removed models
+- **`AcademicYear`** - Removed. `CourseOccasion.year` is now a plain
+  `IntegerField` (same approach as `PrivateCourse.year`).
+  Display titles like "20/21" are computed by `academic_year_title()`.
+  Year options in forms are generated dynamically (current year +/- 10), so
+  no pre-created database rows are needed.
+- **`ensure_academic_years` management command** - Removed.
 
-### Borttagna fält
-- **`Course.closed`** — Oanvänt fält borttaget.
+### Removed fields
+- **`Course.closed`** - Removed unused field.
 
-### Oförändrade fält
-- **`CourseOccasion.contact_name`** och **`CourseOccasion.contact_email`** —
-  Kvar som förut på kurstillfällen. Dessa kopieras **inte** automatiskt vid
-  schemaläggning, men kan fortfarande redigeras manuellt per kurstillfälle.
+### Unchanged fields
+- **`CourseOccasion.contact_name`** and **`CourseOccasion.contact_email`** -
+  Still available on course occasions. These are **not** copied automatically
+  during scheduling and can still be edited manually per occasion.
 
-## Steg-för-steg
+## Step-by-step
 
-### 1. Säkerhetskopia
+### 1. Backup
 
 ```bash
-# Kopiera databasen innan migrering
+# Copy database before migration
 cp mydatabase mydatabase.backup_$(date +%Y%m%d)
 ```
 
-### 2. Hämta senaste koden
+### 2. Pull latest code
 
 ```bash
 git pull origin main
 ```
 
-### 3. Installera beroenden (om uppdaterade)
+### 3. Install dependencies (if updated)
 
 ```bash
 pip install -r requirements.txt
 ```
 
-### 4. Skapa migreringsfiler
+### 4. Run the upgrade script
 
-```bash
-python manage.py makemigrations rodatraden
-```
-
-### 5. Redigera migreringen (viktigt för befintlig data)
-
-För databaser som redan innehåller kurstillfällen behöver du justera den
-lokalt skapade migreringen så att data kopieras innan gamla FK-fält tas bort.
-
-Säker ordning i migreringen:
-- Lägg till `CourseOccasion.year` som **nullable** (`null=True`) först.
-- Lägg till `CourseOccasion.start` (om den inte redan finns) först.
-- Kör en data-kopiering (SQL eller `RunPython`):
-  - `CourseOccasion.year` från `AcademicYear.year`
-  - `CourseOccasion.start` från `TimePeriod.week`
-- Ta bort gamla FK-fält (`academic_year`, `time_period`).
-- Ta bort modellerna `AcademicYear` och `TimePeriod`.
-- Avsluta med att göra `CourseOccasion.year` icke-nullable.
-
-Exempel-SQL (i migrationsfilen, efter att `year`/`start` har lagts till):
-
-```sql
-UPDATE rodatraden_courseoccasion co
-SET year = ay.year
-FROM rodatraden_academicyear ay
-WHERE ay.id = co.academic_year_id;
-
-UPDATE rodatraden_courseoccasion co
-SET start = tp.week
-FROM rodatraden_timeperiod tp
-WHERE tp.id = co.time_period_id;
-```
+If you do not want to sync one specific migration file across environments,
+use the upgrade script.
 
-Utan detta steg riskerar befintliga rader att få felaktiga värden eller tappa
-år/period-information.
-
-Typiska operationer i den lokala migreringen:
-- Tar bort `Course.closed`
-- Lägger till `CourseOccasion.auto_generated`
-- Skapar `CourseScheduleSegment`-modellen
-- **Lägger till `CourseOccasion.year` (IntegerField)**
-- **Tar bort `CourseOccasion.academic_year` (ForeignKey)**
-- **Tar bort `AcademicYear`-modellen**
-
-**VIKTIGT**: Om Django frågar om fältet `year` bytt namn från
-`academic_year`, svara **Nej** — det är ett nytt fält.
-
-### 6. Granska migreringen (valfritt)
+The script will:
+- run an empty `makemigrations` locally with the next available number,
+- include a branch-based suffix in the migration name (for example
+  `0007_remove_incremental_years_copilot_remove_increment.py`),
+- write the required data-migration operations into that file,
+- run `migrate`.
 
 ```bash
-python manage.py sqlmigrate rodatraden <nummer>
+python upgrade_remove_incremental_years.py
 ```
 
-### 7. Tillämpa migreringarna
+Yes: this means each environment gets its own local migration file in
+`rodatraden/migrations/`, and that generated file is then applied by Django
+through `migrate`.
 
-```bash
-python manage.py migrate
-```
+This matches a workflow where `makemigrations` is usually local. For this
+specific upgrade, use the script instead of plain `makemigrations`, since
+Django cannot safely infer values for the new required `year` field.
 
-### 8. Samla statiska filer
+### 5. Collect static files
 
 ```bash
 python manage.py collectstatic --noinput
 ```
 
-### 9. Tilldela behörighet
+### 6. Grant permission
 
-Ge rätt användare behörigheten `can_manage_scheduling` via Djangos
-admin-panel (`/admin/auth/user/`) eller med ett skript:
+Grant `can_manage_scheduling` to relevant users via admin
+(`/admin/auth/user/`) or via script:
 
 ```bash
 python manage.py shell -c "
@@ -134,40 +97,57 @@ User = get_user_model()
 perm = Permission.objects.get(codename='can_manage_scheduling')
 for user in User.objects.filter(is_staff=True):
     user.user_permissions.add(perm)
-    print(f'Gav behörighet till {user.username}')
+    print(f'Granted permission to {user.username}')
 "
 ```
 
-### 10. Importera schemaläggningssegment
+### 7. Import scheduling segments
 
-Segmenten för befintliga kurser kan genereras automatiskt från befintliga
-kurstillfällen:
+Generate segments for existing courses from existing course occasions:
 
 ```bash
-# Förhandsvisning (ingen data ändras)
+# Preview only (no data changes)
 python manage.py infer_course_scheduling
 
-# Tillämpa
+# Apply changes
 python manage.py infer_course_scheduling --apply
 ```
 
-### 11. Validera
+### 8. Validate
 
-Kontrollera att segmenten matchar befintliga kurstillfällen:
+Verify that segments match existing course occasions:
 
 ```bash
 python manage.py validate_course_schedule_parity
 ```
 
-### 12. Starta om servern
+### 9. Restart server
+
+Restart your web server (for example IIS, gunicorn, or equivalent).
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| `makemigrations` wants to create new migrations | For this upgrade, run `python upgrade_remove_incremental_years.py` instead of plain `makemigrations`. |
+| Scheduling permission error | Grant `can_manage_scheduling` (step 6). |
+| Missing segments | Run `python manage.py infer_course_scheduling --apply` (step 7). |
+| `CourseOccasion.year` is NULL after migration | Step 4 was not executed correctly. Re-run `python upgrade_remove_incremental_years.py` and verify migration output. |
 
-Starta om webbservern (t.ex. IIS, gunicorn, eller liknande).
+## PR description text
 
-## Felsökning
+You can copy this into the PR:
 
-| Problem | Lösning |
-|---------|---------|
-| `makemigrations` skapar oväntade migreringar | Kontrollera att inga gamla migreringsfiler finns kvar |
-| Behörighetsfelet vid schemaläggning | Tilldela `can_manage_scheduling` (steg 9) |
-| Segment saknas | Kör `infer_course_scheduling --apply` (steg 10) |
-| `CourseOccasion.year` är NULL efter migrering | Steg 4 missades — kör SQL-kopieringen manuellt |
+```text
+Upgrading from master to this branch requires a branch-aware upgrade migration step.
+
+Run on each environment:
+1) Activate your virtual environment
+2) python upgrade_remove_incremental_years.py
+
+The script creates a local empty migration with the next available number and a
+branch-based name, injects the required data migration (AcademicYear/TimePeriod ->
+year/start), and runs migrate.
+
+Do not use plain makemigrations for this specific upgrade step.
+```
diff --git a/upgrade_remove_incremental_years.py b/upgrade_remove_incremental_years.py
new file mode 100644
index 0000000..f27aab1
--- /dev/null
+++ b/upgrade_remove_incremental_years.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+
+ROOT_DIR = Path(__file__).resolve().parent
+MIGRATIONS_DIR = ROOT_DIR / "rodatraden" / "migrations"
+
+
+def run(cmd: list[str], capture: bool = False) -> str:
+    result = subprocess.run(
+        cmd,
+        cwd=ROOT_DIR,
+        check=True,
+        text=True,
+        capture_output=capture,
+    )
+    if capture:
+        return result.stdout.strip()
+    return ""
+
+
+def get_branch_name() -> str:
+    try:
+        return run(["git", "rev-parse", "--abbrev-ref", "HEAD"], capture=True)
+    except Exception:
+        return "unknown"
+
+
+def slugify_branch(branch_name: str) -> str:
+    slug = branch_name.replace("/", "_").replace("-", "_")
+    slug = re.sub(r"[^A-Za-z0-9_]", "", slug)
+    if not slug:
+        slug = "unknown"
+    return slug[:24]
+
+
+def get_or_create_migration(tag: str) -> Path:
+    existing = sorted(MIGRATIONS_DIR.glob(f"*_{tag}.py"))
+    if existing:
+        migration_file = existing[-1]
+        print(f"Using existing {migration_file}")
+        return migration_file
+
+    run(
+        [
+            sys.executable,
+            "manage.py",
+            "makemigrations",
+            "rodatraden",
+            "--empty",
+            "--name",
+            tag,
+            "--noinput",
+        ]
+    )
+    created = sorted(MIGRATIONS_DIR.glob(f"*_{tag}.py"), key=lambda p: p.stat().st_mtime, reverse=True)
+    if not created:
+        raise RuntimeError(f"Could not find generated migration file for tag {tag}")
+    migration_file = created[0]
+    print(f"Created {migration_file}")
+    return migration_file
+
+
+def extract_dependency(migration_file: Path) -> str:
+    tree = ast.parse(migration_file.read_text(encoding="utf-8"), filename=str(migration_file))
+
+    for node in tree.body:
+        if isinstance(node, ast.ClassDef) and node.name == "Migration":
+            for stmt in node.body:
+                if isinstance(stmt, ast.Assign):
+                    if any(isinstance(t, ast.Name) and t.id == "dependencies" for t in stmt.targets):
+                        deps = ast.literal_eval(stmt.value)
+                        for app_label, migration_name in deps:
+                            if app_label == "rodatraden":
+                                return migration_name
+
+    raise RuntimeError("Could not determine rodatraden dependency from empty migration")
+
+
+def write_migration(migration_file: Path, dependency_name: str) -> None:
+    content = f'''from django.db import migrations, models
+
+
+def copy_time_period_and_academic_year_data(apps, schema_editor):
+    CourseOccasion = apps.get_model("rodatraden", "CourseOccasion")
+    CourseScheduleSegment = apps.get_model("rodatraden", "CourseScheduleSegment")
+
+    for occasion in CourseOccasion.objects.select_related("academic_year", "time_period").all():
+        occasion.year = occasion.academic_year.year
+        occasion.start = occasion.time_period.week
+        occasion.save(update_fields=["year", "start"])
+
+    for segment in CourseScheduleSegment.objects.select_related("time_period").all():
+        segment.start = segment.time_period.week
+        segment.save(update_fields=["start"])
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("rodatraden", "{dependency_name}"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="courseoccasion",
+            name="year",
+            field=models.IntegerField(blank=True, null=True, verbose_name="\u00c5r"),
+        ),
+        migrations.AddField(
+            model_name="courseoccasion",
+            name="start",
+            field=models.IntegerField(blank=True, default=0, null=True, verbose_name="L\u00e4speriod"),
+        ),
+        migrations.AddField(
+            model_name="courseschedulesegment",
+            name="start",
+            field=models.IntegerField(
+                blank=True,
+                default=0,
+                help_text="Startvecka f\u00f6r perioden (0 = LP1, 10 = LP2, 20 = LP3, 30 = LP4, 40 = LP5)",
+                null=True,
+                verbose_name="L\u00e4speriod",
+            ),
+        ),
+        migrations.RunPython(copy_time_period_and_academic_year_data, migrations.RunPython.noop),
+        migrations.RemoveField(
+            model_name="courseoccasion",
+            name="academic_year",
+        ),
+        migrations.RemoveField(
+            model_name="courseoccasion",
+            name="time_period",
+        ),
+        migrations.RemoveField(
+            model_name="courseschedulesegment",
+            name="time_period",
+        ),
+        migrations.AlterField(
+            model_name="courseoccasion",
+            name="start",
+            field=models.IntegerField(default=0, verbose_name="L\u00e4speriod"),
+        ),
+        migrations.AlterField(
+            model_name="courseoccasion",
+            name="year",
+            field=models.IntegerField(verbose_name="\u00c5r"),
+        ),
+        migrations.AlterField(
+            model_name="courseschedulesegment",
+            name="start",
+            field=models.IntegerField(
+                default=0,
+                help_text="Startvecka f\u00f6r perioden (0 = LP1, 10 = LP2, 20 = LP3, 30 = LP4, 40 = LP5)",
+                verbose_name="L\u00e4speriod",
+            ),
+        ),
+        migrations.AlterModelOptions(
+            name="courseschedulesegment",
+            options={{
+                "ordering": ["start_year", "start"],
+                "permissions": [("can_manage_scheduling", "Kan hantera schemal\u00e4ggning")],
+                "verbose_name": "Schemal\u00e4ggningssegment",
+                "verbose_name_plural": "Schemal\u00e4ggningssegment",
+            }},
+        ),
+        migrations.DeleteModel(
+            name="AcademicYear",
+        ),
+        migrations.DeleteModel(
+            name="TimePeriod",
+        ),
+    ]
+'''
+    migration_file.write_text(content, encoding="utf-8")
+
+
+def main() -> int:
+    branch_name = get_branch_name()
+    tag = f"remove_incremental_years_{slugify_branch(branch_name)}"
+
+    migration_file = get_or_create_migration(tag)
+    dependency_name = extract_dependency(migration_file)
+    write_migration(migration_file, dependency_name)
+
+    run([sys.executable, "manage.py", "migrate", "rodatraden"])
+    run([sys.executable, "manage.py", "migrate"])
+
+    print(f"Upgrade migration complete for branch: {branch_name}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
\ No newline at end of file

From a4bc7831182018b3139cd3dab3520917af849db5 Mon Sep 17 00:00:00 2001
From: Marc <marc@gitea.taginu.com>
Date: Tue, 28 Apr 2026 21:51:00 +0200
Subject: [PATCH 9/9] refactor: update courseoccasion_info view to include
 scheduled courses and adjust template for better display

---
 rodatraden/templates/rodatraden/base.html     |  2 -
 .../courseoccasion/courseoccasion_info.html   | 63 +++++++++----------
 rodatraden/views.py                           | 16 ++++-
 3 files changed, 46 insertions(+), 35 deletions(-)

diff --git a/rodatraden/templates/rodatraden/base.html b/rodatraden/templates/rodatraden/base.html
index 9628a9c..0d39bad 100644
--- a/rodatraden/templates/rodatraden/base.html
+++ b/rodatraden/templates/rodatraden/base.html
@@ -94,7 +94,6 @@ <h1 class="text-center rt-page-title">
           $(this).modalForm({formURL: $(this).data('id')});
         });
 
-        {% if user.is_staff %}
         /* Open modal for creation form */
         $(".add-item").each(function () {
           $(this).modalForm({formURL: $(this).data('id')});
@@ -112,7 +111,6 @@ <h1 class="text-center rt-page-title">
             isDeleteForm: true
           });
         })
-        {% endif %}
       });
 
       // Calculate the scrollbar width and make it accessible in CSS.
diff --git a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
index 4066999..93976b8 100644
--- a/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
+++ b/rodatraden/templates/rodatraden/courseoccasion/courseoccasion_info.html
@@ -82,42 +82,41 @@ <h5 class="card-header">Kursinfo</h5>
 
     <div class="col-lg-6">
       <div class="card">
-        <h5 class="card-header">Kurstillfälle</h5>
+        <h5 class="card-header">Kurstillfällen</h5>
         <div class="card-body">
-          <p class="lead"><a target="_blank" href="{% url 'courseoccasion-detail' courseoccasion.year courseoccasion.slug %}">
-            {{ course.title }}, {{courseoccasion.year }}
-          </a></p>
-
-          <table style="border-collapse: separate;border-spacing:1rem 0;">
-            <tr>
-              <td>Läsperiod</td>
-              <td>{{ courseoccasion.start_string }}</td>
-            </tr>
-            <tr>
-              <td>Veckor</td>
-              <td>{{ courseoccasion.weeks }}</td>
-            </tr>
-            <tr>
-              <td>Studietakt</td>
-              <td>{{ courseoccasion.pace }} %</td>
-            </tr>
-            {% if courseoccasion.contact_name %}
-            <tr>
-              <td>Kontaktperson</td>
-              <td><a target="_blank" href="mailto:{{ courseoccasion.contact_email }}">{{ courseoccasion.contact_name }}</a></td>
-            </tr>
-            {% endif %}
-          </table>
-
-          <hr>
-
-          {% if courseoccasion.official %}
-          <span class="badge badge-success">Godkänd</span>
-          {% else %}
+          {% for segment in course.schedule_segments.all %}
+            <div class="mb-2">
+              <strong>{{ segment.start_string }}</strong><br>
+              <small>
+                {{ segment.start_year }}–{{ segment.end_year|default:"→" }}
+                · {{ segment.get_frequency_display }}
+                · {{ segment.weeks }} veckor
+                {% if segment.blacklisted_years %}
+                  <br>Undantag: {{ segment.blacklisted_years|join:", " }}
+                {% endif %}
+              </small>
+            </div>
+            {% if not forloop.last %}<hr class="my-1">{% endif %}
+          {% empty %}
+            <p class="text-muted mb-0">Inga kurstillfällen konfigurerade.</p>
+          {% endfor %}
+        </div>
+      </div>
 
-          {% endif %}
+      {% if courses_requiring_this_course %}
+      <div class="card mt-3">
+        <h5 class="card-header">Ger behörighet (i blockschemat)</h5>
+        <div class="card-body">
+          <ul class="list-group list-group-flush">
+            {% for req_course in courses_requiring_this_course %}
+            <li class="list-group-item">
+              <a target="_blank" href="{% url 'course-detail' req_course.slug %}">{{ req_course.title }}</a>
+            </li>
+            {% endfor %}
+          </ul>
         </div>
       </div>
+      {% endif %}
     </div>
   </div>
 </div>
diff --git a/rodatraden/views.py b/rodatraden/views.py
index 90fb001..1a2f50e 100644
--- a/rodatraden/views.py
+++ b/rodatraden/views.py
@@ -847,16 +847,30 @@ def courseoccasion_info(request: HttpRequest):
     # Get valid IDs of the unmet prerequisites.
     unmet_prerequisite_ids = [
         int(id) for id in request.GET.getlist('unmet[]') if id.isdigit()]
+    # IDs of courses currently scheduled in the open block (provided by
+    # block schedule frontend). Used to scope the "Ger behörighet" list.
+    scheduled_course_ids = {
+        int(id) for id in request.GET.getlist('scheduled_course[]') if id.isdigit()
+    }
 
     unmet_prerequisites = Prerequisite.objects.filter(id__in=unmet_prerequisite_ids)
 
     courseoccasion = get_object_or_404(CourseOccasion, year=year,
         slug=slug)
 
+    course = courseoccasion.course
+    prerequisites = course.equivalent_prerequisites.all()
+    courses_requiring_this_course = list(set(
+        prerequisite.course for prerequisite in prerequisites
+        if prerequisite.course_id in scheduled_course_ids
+    ))
+    courses_requiring_this_course.sort(key=lambda c: c.title)
+
     context = {
         'courseoccasion': courseoccasion,
-        'course': courseoccasion.course,
+        'course': course,
         'unmet_prerequisites': unmet_prerequisites,
+        'courses_requiring_this_course': courses_requiring_this_course,
     }
 
     return render(request, 'rodatraden/courseoccasion/courseoccasion_info.html',