@stamhoofd/backend 2.122.0 → 2.122.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.122.0",
+    "version": "2.122.2",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -57,20 +57,20 @@
         "@simonbackx/simple-endpoints": "1.21.1",
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
-        "@stamhoofd/backend-env": "2.122.0",
-        "@stamhoofd/backend-i18n": "2.122.0",
-        "@stamhoofd/backend-middleware": "2.122.0",
-        "@stamhoofd/crons": "2.122.0",
-        "@stamhoofd/email": "2.122.0",
-        "@stamhoofd/excel-writer": "2.122.0",
-        "@stamhoofd/logging": "2.122.0",
-        "@stamhoofd/models": "2.122.0",
-        "@stamhoofd/object-differ": "2.122.0",
-        "@stamhoofd/queues": "2.122.0",
-        "@stamhoofd/sql": "2.122.0",
-        "@stamhoofd/structures": "2.122.0",
-        "@stamhoofd/types": "2.122.0",
-        "@stamhoofd/utility": "2.122.0",
+        "@stamhoofd/backend-env": "2.122.2",
+        "@stamhoofd/backend-i18n": "2.122.2",
+        "@stamhoofd/backend-middleware": "2.122.2",
+        "@stamhoofd/crons": "2.122.2",
+        "@stamhoofd/email": "2.122.2",
+        "@stamhoofd/excel-writer": "2.122.2",
+        "@stamhoofd/logging": "2.122.2",
+        "@stamhoofd/models": "2.122.2",
+        "@stamhoofd/object-differ": "2.122.2",
+        "@stamhoofd/queues": "2.122.2",
+        "@stamhoofd/sql": "2.122.2",
+        "@stamhoofd/structures": "2.122.2",
+        "@stamhoofd/types": "2.122.2",
+        "@stamhoofd/utility": "2.122.2",
         "archiver": "7.0.1",
         "axios": "1.16.0",
         "base-x": "3.0.11",
@@ -91,7 +91,7 @@
         "stripe": "16.12.0"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.122.0",
+        "@stamhoofd/test-utils": "2.122.2",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.1",
         "@types/mailparser": "3.4.6",
@@ -107,5 +107,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "3c022b7d7801fb105acfaa401432a8d029abda61"
+    "gitHead": "e7ddea427a321328588b839e475266a6364152e3"
 }

package/src/migrations/1752848561-groups-registration-periods.ts

@@ -46,7 +46,8 @@ async function start(dryRun: boolean) {
             // sort groups by start date
             groups.sort((a, b) => a.settings.startDate.getTime() - b.settings.startDate.getTime());
 
-            const bestCurrentPeriodSpan = await calculateBestCurrentPeriodSpan(groups);
+            const activeGroups = groups.filter(g => g.status !== GroupStatus.Archived && g.deletedAt === null);
+            const bestCurrentPeriodSpan = await calculateBestCurrentPeriodSpan(activeGroups);
 
             const allGroups: Group[] = await migrateGroups({ groups, organization, periodSpan: bestCurrentPeriodSpan }, dryRun);
 
@@ -435,6 +436,7 @@ async function migrateRegistrations({ organization, period, originalGroup, newGr
         newWaitingList.periodId = period.id;
         newWaitingList.settings = GroupSettings.create({
             name: TranslatedString.create($t(`%yh`) + ' ' + newGroup.settings.name.toString()),
+            period: period.getBaseStructure(),
         });
 
         const migrationData = new V1WaitingListMigrationData();
@@ -679,34 +681,9 @@ async function calculateBestCurrentPeriodSpan(groups: Group[]): Promise<{ startD
         }
         periodSpanCounts.set(bestPeriod, groups);
     }
-    // #endregion
-
-    // #region find the best year
-    let topYear = defaultYear;
-    const groupsInTopPeriodSpan = periodSpanCounts.get(topPeriodSpan) ?? [];
-
-    // calculate the number of groups in each year
-    const yearMap = new Map<number, Group[]>();
-    for (const { group, year } of groupsInTopPeriodSpan) {
-        const groups = yearMap.get(year) ?? [];
-        groups.push(group);
-        yearMap.set(year, groups);
-    }
-
-    // get the year with the most groups
-    let topYearCount = 0;
-    for (const [year, groups] of yearMap.entries()) {
-        if (groups.length > topYearCount) {
-            topYearCount = groups.length;
-            topYear = year;
-        }
-    }
-    // #endregion
-
-    const startDate = new Date(topYear, topPeriodSpan.startMonth, 1);
-    const endDate = new Date((new Date(topYear, topPeriodSpan.startMonth + topPeriodSpan.span)).getTime() - 1);
 
-    return { startDate, endDate };
+    const topYear = calculateTopYear(topPeriodSpan, groups);
+    return getTimeSpan(topYear, topPeriodSpan);
 }
 
 // #region helpers
@@ -831,9 +808,151 @@ function createPreviousGroup({ originalGroup, period, cycleInformation, index }:
             startDate,
             endDate,
             hasCustomDates: true,
+            period: period.getBaseStructure(),
         });
     newGroup.type = originalGroup.type;
 
     return newGroup;
 }
 // #endregion
+
+function calculateTopYear(periodSpan: PeriodSpan, groups: Group[]): number {
+    let topYear = periodSpan.startMonth > 6 ? 2025 : 2026;
+
+    if (groups.length === 0) {
+        return topYear;
+    }
+
+    const calculateTopYearHelper = (groups: Group[]): number => {
+        // most recent groups first (in case of ties)
+        const sortedGroups = [...groups].sort((a, b) => b.settings.startDate.getTime() - a.settings.startDate.getTime());
+
+        for (const group of sortedGroups) {
+            const year = getBestGroupYear(periodSpan, group);
+            if (year === null) {
+                continue;
+            }
+            const count = yearCount.get(year) ?? 0;
+            yearCount.set(year, count + 1);
+        }
+
+        let topYearCount = 0;
+
+        for (const [year, count] of yearCount.entries()) {
+            if (count > topYearCount) {
+                topYearCount = count;
+                topYear = year;
+            }
+        }
+
+        return topYear;
+    };
+
+    const yearCount = new Map<number, number>();
+
+    const areAllGroupsPossibleEvents: boolean = groups.every(group => isGroupShorterThanMonth(group));
+
+    if (areAllGroupsPossibleEvents) {
+        return calculateTopYearHelper(groups);
+    }
+
+    const ifEventsExcluded = calculateTopYearHelper(groups.filter(g => !isGroupShorterThanMonth(g)));
+    const ifEventsIncluded = calculateTopYearHelper(groups);
+    const difference = Math.abs(ifEventsIncluded - ifEventsExcluded);
+
+    // the difference should never be greater than 1
+    if (difference > 1) {
+        const max = Math.max(ifEventsIncluded, ifEventsExcluded);
+        // year cannot be bigger than 2026
+        if (max > 2026) {
+            return Math.min(ifEventsIncluded, ifEventsExcluded, 2026);
+        }
+        return max;
+    }
+
+    // year cannot be bigger than 2026
+    if (ifEventsExcluded > 2026 && ifEventsIncluded < 2026) {
+        return ifEventsIncluded;
+    }
+
+    return Math.min(ifEventsExcluded, 2026);
+}
+
+function isGroupShorterThanMonth(group: Group) {
+    const diffMs = group.settings.endDate.getTime() - group.settings.startDate.getTime();
+    const msPerDay = 24 * 60 * 60 * 1000;
+    const diffDays = diffMs / msPerDay;
+
+    return diffDays < 30;
+}
+
+function getTimeSpan(year: number, periodSpan: PeriodSpan): { startDate: Date; endDate: Date } {
+    const startDate = new Date(year, periodSpan.startMonth, 1);
+    const endDate = new Date((new Date(year, periodSpan.startMonth + periodSpan.span)).getTime() - 1);
+    return { startDate, endDate };
+}
+
+function getBestGroupYear(periodSpan: PeriodSpan, group: Group): number | null {
+    const startDate = group.settings.startDate;
+    const endDate = group.settings.endDate;
+    const groupTimeSpan = { startDate, endDate };
+
+    // ignore groups longer than 2 years
+    if (!isYearDifferenceLessThanTwo(startDate, endDate)) {
+        return null;
+    }
+
+    const startYear = startDate.getFullYear();
+
+    const possibleYears: number[] = [startYear + 1, startYear, startYear - 1];
+    let topDaysOverlap = 0;
+    let topYear = periodSpan.startMonth > 6 ? 2025 : 2026;
+
+    for (const possibleYear of possibleYears) {
+        const possibleTimeSpan = getTimeSpan(possibleYear, periodSpan);
+        const result = getDaysMissingAndOverlap(possibleTimeSpan, groupTimeSpan);
+        if (result.daysOverlapping > topDaysOverlap) {
+            topDaysOverlap = result.daysOverlapping;
+            topYear = possibleYear;
+        }
+    }
+
+    return topYear;
+}
+
+/**
+ * Checks if the difference in year between two dates is less than 2.
+ * @param {Date} date1
+ * @param {Date} date2
+ * @returns {boolean}
+ */
+function isYearDifferenceLessThanTwo(date1: Date, date2: Date): boolean {
+    const d1 = new Date(date1);
+    const d2 = new Date(date2);
+
+    // Get the base year difference
+    const yearDiff = d2.getFullYear() - d1.getFullYear();
+
+    // If the absolute difference is 0 or 1, it's definitely less than 2
+    if (Math.abs(yearDiff) < 2) {
+        return true;
+    }
+
+    // If the difference is exactly 2, we need to check the exact time elapsed.
+    // Example: Jan 1, 2022 to Jan 1, 2024 is exactly 2 years (should be false).
+    // Example: Jan 1, 2022 to Dec 31, 2023 is almost 2 years (true, handled above by diff=1 logic? No, 2023-2022=1).
+
+    // Actually, let's re-evaluate:
+    // If d1 = 2022-06-01, d2 = 2024-05-31 -> Year diff = 2. But actual time < 2 years.
+    // If d1 = 2022-06-01, d2 = 2024-06-01 -> Year diff = 2. Actual time = 2 years (not less than).
+
+    // The simplest way to check "less than 2 years" accurately including leap years and days:
+    // Calculate the difference in milliseconds and compare against 2 years worth of ms.
+
+    const MS_PER_YEAR = 365.25 * 24 * 60 * 60 * 1000; // Approximate average year length
+    const LIMIT = 2 * MS_PER_YEAR;
+
+    const diffTime = Math.abs(d2.getTime() - d1.getTime());
+
+    return diffTime < LIMIT;
+}

package/src/migrations/1752848565-groups-cached-period.ts

@@ -0,0 +1,51 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Group, RegistrationPeriod } from '@stamhoofd/models';
+import { SeedTools } from '../helpers/SeedTools.js';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    if (STAMHOOFD.platformName.toLowerCase() !== 'stamhoofd') {
+        console.log('skipped for platform (only runs for Stamhoofd): ' + STAMHOOFD.platformName);
+        return;
+    }
+
+    const dryRun = false;
+    await start(dryRun);
+
+    if (dryRun) {
+        throw new Error('Migration did not finish because of dryRun');
+    }
+});
+
+/**
+ * Groups in v1 have no cached period. This migration adds cached periods to groups that have no cached period yet.
+ * @param dryRun
+ */
+async function start(dryRun: boolean) {
+    await SeedTools.loop({
+        query: Group.select(),
+        batchSize: 50,
+        useTransactionPerBatch: true,
+        action: async (group: Group) => {
+            if (group.settings.period !== null) {
+                return;
+            }
+
+            const period = await RegistrationPeriod.getByID(group.periodId);
+            if (period) {
+                group.settings.period = period.getBaseStructure();
+                if (!dryRun) {
+                    await group.save();
+                }
+                return;
+            }
+
+            throw new Error(`No period found for group ${group.id} (periodId: ${group.periodId})`);
+        },
+
+    });
+}