@stamhoofd/backend 2.122.8 → 2.123.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.122.8",
+    "version": "2.123.0",
     "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.8",
-        "@stamhoofd/backend-i18n": "2.122.8",
-        "@stamhoofd/backend-middleware": "2.122.8",
-        "@stamhoofd/crons": "2.122.8",
-        "@stamhoofd/email": "2.122.8",
-        "@stamhoofd/excel-writer": "2.122.8",
-        "@stamhoofd/logging": "2.122.8",
-        "@stamhoofd/models": "2.122.8",
-        "@stamhoofd/object-differ": "2.122.8",
-        "@stamhoofd/queues": "2.122.8",
-        "@stamhoofd/sql": "2.122.8",
-        "@stamhoofd/structures": "2.122.8",
-        "@stamhoofd/types": "2.122.8",
-        "@stamhoofd/utility": "2.122.8",
+        "@stamhoofd/backend-env": "2.123.0",
+        "@stamhoofd/backend-i18n": "2.123.0",
+        "@stamhoofd/backend-middleware": "2.123.0",
+        "@stamhoofd/crons": "2.123.0",
+        "@stamhoofd/email": "2.123.0",
+        "@stamhoofd/excel-writer": "2.123.0",
+        "@stamhoofd/logging": "2.123.0",
+        "@stamhoofd/models": "2.123.0",
+        "@stamhoofd/object-differ": "2.123.0",
+        "@stamhoofd/queues": "2.123.0",
+        "@stamhoofd/sql": "2.123.0",
+        "@stamhoofd/structures": "2.123.0",
+        "@stamhoofd/types": "2.123.0",
+        "@stamhoofd/utility": "2.123.0",
         "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.8",
+        "@stamhoofd/test-utils": "2.123.0",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.1",
         "@types/mailparser": "3.4.6",
@@ -107,5 +107,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "6326798a67de66af62b5cdebcb81eacd48afdb29"
+    "gitHead": "5030664a2a57bf8626611b181e7c12d86a0293f6"
 }

package/src/endpoints/auth/GetUserEndpoint.test.ts

@@ -3,6 +3,7 @@ import { OrganizationFactory, Token, UserFactory } from '@stamhoofd/models';
 
 import { testServer } from '../../../tests/helpers/TestServer.js';
 import { GetUserEndpoint } from './GetUserEndpoint.js';
+import { STExpect } from '@stamhoofd/test-utils';
 
 describe('Endpoint.GetUser', () => {
     // Test endpoint
@@ -48,4 +49,46 @@ describe('Endpoint.GetUser', () => {
 
         await expect(testServer.test(endpoint, r)).rejects.toThrow(/expired/i);
     });
+
+    test('Can request details of an API user by token without knowing the organization scope', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({ organization, apiUser: true }).create();
+        const token = await Token.createToken(user);
+
+        const r = Request.buildJson('GET', '/v1/user');
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body.id).toEqual(user.id);
+        expect(response.body.organizationId).toEqual(organization.id);
+    });
+
+    test('Cannot request details of an normal user by token without knowing the organization scope', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({ organization }).create();
+        const token = await Token.createToken(user);
+
+        const r = Request.buildJson('GET', '/v1/user');
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        await expect(testServer.test(endpoint, r)).rejects.toThrow(STExpect.simpleError({
+            code: 'invalid_access_token'
+        }));
+    });
+
+    test('Cannot request details of an API user by token with wrong organization scope', async () => {
+        const wrongOrganization = await new OrganizationFactory({}).create();
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({ organization, apiUser: true }).create();
+        const token = await Token.createToken(user);
+
+        const r = Request.buildJson('GET', '/v1/user', wrongOrganization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        await expect(testServer.test(endpoint, r)).rejects.toThrow(STExpect.simpleError({
+            code: 'invalid_access_token'
+        }));
+    });
+
 });

package/src/endpoints/auth/GetUserEndpoint.ts

@@ -1,7 +1,6 @@
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import type { UserWithMembers } from '@stamhoofd/structures';
-
 import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures.js';
 import { Context } from '../../helpers/Context.js';
 
@@ -26,7 +25,7 @@ export class GetUserEndpoint extends Endpoint<Params, Query, Body, ResponseBody>
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.setOptionalOrganizationScope();
-        const { user } = await Context.authenticate({ allowWithoutAccount: true });
+        const { user } = await Context.authenticate({ allowWithoutAccount: true, allowUnscoped: true });
 
         return new Response(
             await AuthenticatedStructures.userWithMembers(user),

package/src/endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint.ts

@@ -455,7 +455,8 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             }
 
             if (shouldUpdatePeriodIds) {
-                if (model.settings.hasBundleDiscounts) {
+                const oldOrganizationPeriod = await OrganizationRegistrationPeriod.select().where('periodId', model.periodId).where('organizationId', model.organizationId).first(false);
+                if (oldOrganizationPeriod && model.settings.hasBundleDiscounts(oldOrganizationPeriod)) {
                     throw new SimpleError({
                         code: 'change_period_not_allowed',
                         message: 'This group cannot be moved to another period because it has bundle discounts.',

package/src/excel-loaders/payments.test.ts

@@ -0,0 +1,201 @@
+import { BalanceItem, BalanceItemPaymentDetailed, BalanceItemRelation, BalanceItemRelationType, BalanceItemType, Cart, CartItem, CartItemPrice, OrderData, PaymentGeneral, PaymentMethod, PaymentStatus, Product, ProductPrice, TranslatedString } from '@stamhoofd/structures';
+import { expandPaymentBalanceItemPayments } from './payments.js';
+
+function createOrderData(options: {
+    percentageDiscount?: number;
+    fixedDiscount?: number;
+} = {}) {
+    const productPrice = ProductPrice.create({
+        id: 'large',
+        name: 'Groot',
+        price: 3500,
+    });
+    const otherProductPrice = ProductPrice.create({
+        id: 'small',
+        name: 'Klein',
+        price: 2500,
+    });
+    const product = Product.create({
+        id: 'coffee',
+        name: 'Koffie',
+        prices: [productPrice, otherProductPrice],
+    });
+    const cartItem = CartItem.create({
+        id: 'cart-item-1',
+        product,
+        productPrice,
+        amount: 2,
+        unitPrice: 3500,
+        calculatedPrices: [
+            CartItemPrice.create({ price: 3500 }),
+            CartItemPrice.create({ price: 3500 }),
+        ],
+    });
+
+    return OrderData.create({
+        cart: Cart.create({
+            items: [cartItem],
+        }),
+        administrationFee: 500,
+        percentageDiscount: options.percentageDiscount ?? 0,
+        fixedDiscount: options.fixedDiscount ?? 0,
+    });
+}
+
+function createPayment(price: number): PaymentGeneral {
+    return PaymentGeneral.create({
+        id: 'payment-1',
+        method: PaymentMethod.Transfer,
+        status: PaymentStatus.Succeeded,
+        price,
+        balanceItemPayments: [
+            BalanceItemPaymentDetailed.create({
+                id: 'balance-item-payment-1',
+                price,
+                balanceItem: BalanceItem.create({
+                    id: 'balance-item-1',
+                    type: BalanceItemType.Order,
+                    orderId: 'order-1',
+                    description: 'Bestelling #1',
+                    amount: 1,
+                    unitPrice: price,
+                    relations: new Map([
+                        [BalanceItemRelationType.Webshop, BalanceItemRelation.create({
+                            id: 'webshop-1',
+                            name: new TranslatedString('Clubshop'),
+                        })],
+                    ]),
+                }),
+            }),
+        ],
+    });
+}
+
+function expectRowsToMatchReplacedPayment(rows: BalanceItemPaymentDetailed[], payment: PaymentGeneral) {
+    expect(rows.reduce((sum, row) => sum + row.price, 0)).toBe(payment.balanceItemPayments[0].price);
+}
+
+describe('payments excel loader', () => {
+    describe('expandPaymentBalanceItemPayments', () => {
+        it('splits a full order payment into order item rows and fees', () => {
+            const orderData = createOrderData();
+            const payment = createPayment(orderData.totalPrice);
+
+            const rows = expandPaymentBalanceItemPayments(payment, new Map([
+                ['order-1', { id: 'order-1', number: 123, data: orderData }],
+            ]));
+
+            expect(rows).toHaveLength(2);
+            expect(rows[0].customTitle).toBe('Koffie');
+            expect(rows[0].balanceItem.description).toBe('Groot');
+            expect(rows[0].amount).toBe(2);
+            expect(rows[0].unitPrice).toBe(3500);
+            expect(rows[0].price).toBe(7000);
+            expect(rows[1].customTitle).toBe('Administratiekosten');
+            expect(rows[1].balanceItem.description).toBe('Administratiekosten');
+            expect(rows[1].amount).toBe(1);
+            expect(rows[1].price).toBe(500);
+            expectRowsToMatchReplacedPayment(rows, payment);
+        });
+
+        it('adds order discount rows when splitting a full order payment', () => {
+            const orderData = createOrderData({
+                percentageDiscount: 1000,
+                fixedDiscount: 300,
+            });
+            const payment = createPayment(orderData.totalPrice);
+
+            const rows = expandPaymentBalanceItemPayments(payment, new Map([
+                ['order-1', { id: 'order-1', number: 123, data: orderData }],
+            ]));
+
+            expect(rows).toHaveLength(4);
+            expect(rows.map(row => row.customTitle)).toEqual([
+                'Koffie',
+                'Korting (10%)',
+                'Korting',
+                'Administratiekosten',
+            ]);
+            expect(rows.map(row => row.balanceItem.description)).toEqual([
+                'Groot',
+                'Korting (10%)',
+                'Vaste korting',
+                'Administratiekosten',
+            ]);
+            expect(rows.map(row => row.price)).toEqual([
+                7000,
+                -700,
+                -300,
+                500,
+            ]);
+            expectRowsToMatchReplacedPayment(rows, payment);
+        });
+
+        it('caps order discount rows to the cart subtotal', () => {
+            const orderData = createOrderData({
+                percentageDiscount: 10000,
+                fixedDiscount: 3000,
+            });
+            const payment = createPayment(orderData.totalPrice);
+
+            const rows = expandPaymentBalanceItemPayments(payment, new Map([
+                ['order-1', { id: 'order-1', number: 123, data: orderData }],
+            ]));
+
+            expect(rows).toHaveLength(3);
+            expect(rows.map(row => row.customTitle)).toEqual([
+                'Koffie',
+                'Korting (100%)',
+                'Administratiekosten',
+            ]);
+            expect(rows.map(row => row.balanceItem.description)).toEqual([
+                'Groot',
+                'Korting (100%)',
+                'Administratiekosten',
+            ]);
+            expect(rows.map(row => row.price)).toEqual([
+                7000,
+                -7000,
+                500,
+            ]);
+            expectRowsToMatchReplacedPayment(rows, payment);
+        });
+
+        it('keeps partial order payments and refunds as single rows', () => {
+            const orderData = createOrderData();
+            const orderMap = new Map([
+                ['order-1', { id: 'order-1', number: 123, data: orderData }],
+            ]);
+
+            const changedRows = expandPaymentBalanceItemPayments(createPayment(1000), orderMap);
+            expect(changedRows).toHaveLength(1);
+            expect(changedRows[0].balanceItem.description).toBe('Gedeeltelijke betaling/terugbetaling voor bestelling #123');
+            expect(changedRows[0].amount).toBe(1);
+            expect(changedRows[0].price).toBe(1000);
+
+            const refundRows = expandPaymentBalanceItemPayments(createPayment(-1000), orderMap);
+            expect(refundRows).toHaveLength(1);
+            expect(refundRows[0].balanceItem.description).toBe('Gedeeltelijke betaling/terugbetaling voor bestelling #123');
+            expect(refundRows[0].amount).toBe(1);
+            expect(refundRows[0].price).toBe(-1000);
+        });
+
+        it('only splits the same full order once per export page', () => {
+            const orderData = createOrderData();
+            const orderMap = new Map([
+                ['order-1', { id: 'order-1', number: 123, data: orderData }],
+            ]);
+            const addedOrderIds = new Set<string>();
+
+            const firstRows = expandPaymentBalanceItemPayments(createPayment(orderData.totalPrice), orderMap, addedOrderIds);
+            const secondRows = expandPaymentBalanceItemPayments(createPayment(orderData.totalPrice), orderMap, addedOrderIds);
+
+            expect(firstRows).toHaveLength(2);
+            expect(secondRows).toHaveLength(1);
+            expect(secondRows[0].balanceItem.description).toBe('Gedeeltelijke betaling/terugbetaling voor bestelling #123');
+            expect(secondRows[0].price).toBe(orderData.totalPrice);
+            expectRowsToMatchReplacedPayment(firstRows, createPayment(orderData.totalPrice));
+            expectRowsToMatchReplacedPayment(secondRows, createPayment(orderData.totalPrice));
+        });
+    });
+});

package/src/excel-loaders/payments.ts

@@ -1,22 +1,34 @@
 import { field } from '@simonbackx/simple-encoding';
 import type { XlsxTransformerColumn, XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
 import { XlsxBuiltInNumberFormat } from '@stamhoofd/excel-writer';
-import { StripeAccount } from '@stamhoofd/models';
-import type { BalanceItemPaymentDetailed } from '@stamhoofd/structures';
-import { BalanceItemRelationType, ExcelExportType, getBalanceItemRelationTypeName, getBalanceItemTypeName, PaginatedResponse, PaymentGeneral, PaymentMethodHelper, PaymentStatusHelper, StripeAccount as StripeAccountStruct } from '@stamhoofd/structures';
+import { Order, StripeAccount } from '@stamhoofd/models';
+import type { OrderData } from '@stamhoofd/structures';
+import { BalanceItem, BalanceItemPaymentDetailed, BalanceItemRelationType, BalanceItemType, ExcelExportType, getBalanceItemRelationTypeName, getBalanceItemTypeName, PaginatedResponse, PaymentGeneral, PaymentMethodHelper, PaymentStatusHelper, StripeAccount as StripeAccountStruct } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint.js';
 import { GetPaymentsEndpoint } from '../endpoints/organization/dashboard/payments/GetPaymentsEndpoint.js';
 import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper.js';
 
 type PaymentWithItem = {
-    payment: PaymentGeneral;
-    balanceItemPayment: BalanceItemPaymentDetailed;
+    payment: PaymentGeneralWithStripeAccount;
+    balanceItemPayment: PaymentExportBalanceItemPayment;
+};
+
+type PaymentExportOrder = {
+    id: string;
+    number: number | null;
+    data: OrderData;
+};
+
+export type PaymentExportBalanceItemPayment = BalanceItemPaymentDetailed & {
+    customTitle: string | null;
 };
 
 export class PaymentGeneralWithStripeAccount extends PaymentGeneral {
     @field({ decoder: StripeAccountStruct, nullable: true })
     stripeAccount: StripeAccountStruct | null = null;
+
+    expandedBalanceItemPayments: PaymentExportBalanceItemPayment[] = [];
 }
 
 ExportToExcelEndpoint.loaders.set(ExcelExportType.Payments, {
@@ -31,11 +43,21 @@ ExportToExcelEndpoint.loaders.set(ExcelExportType.Payments, {
             accounts = (await StripeAccount.getByIDs(...stripeAccountIds)).map(s => StripeAccountStruct.create(s));
         }
 
+        const orderIds = Formatter.uniqueArray(
+            data.results.flatMap(payment => payment.balanceItemPayments.flatMap((item) => {
+                return item.balanceItem.orderId ? [item.balanceItem.orderId] : [];
+            })),
+        );
+        const orders = orderIds.length > 0 ? await Order.getByIDs(...orderIds) : [];
+        const orderMap = new Map<string, PaymentExportOrder>(orders.map(order => [order.id, order]));
+        const addedOrderIds = new Set<string>();
+
         return new PaginatedResponse({
             ...data,
             results: data.results.map((p) => {
                 const payment = PaymentGeneralWithStripeAccount.create(p);
                 payment.stripeAccount = p.stripeAccountId ? (accounts.find(a => a.id === p.stripeAccountId) ?? null) : null;
+                payment.expandedBalanceItemPayments = expandPaymentBalanceItemPayments(payment, orderMap, addedOrderIds);
                 return payment;
             }),
         });
@@ -56,7 +78,7 @@ ExportToExcelEndpoint.loaders.set(ExcelExportType.Payments, {
         {
             id: 'balanceItemPayments',
             name: $t(`%Ly`),
-            transform: (data: PaymentGeneral): PaymentWithItem[] => data.balanceItemPayments.map(p => ({
+            transform: (data: PaymentGeneralWithStripeAccount): PaymentWithItem[] => data.expandedBalanceItemPayments.map(p => ({
                 payment: data,
                 balanceItemPayment: p,
             })),
@@ -100,6 +122,177 @@ ExportToExcelEndpoint.loaders.set(ExcelExportType.Payments, {
     ],
 });
 
+export function expandPaymentBalanceItemPayments(
+    payment: PaymentGeneral,
+    orderMap: Map<string, PaymentExportOrder>,
+    addedOrderIds = new Set<string>(),
+): PaymentExportBalanceItemPayment[] {
+    return payment.balanceItemPayments.flatMap((item) => {
+        const orderId = item.balanceItem.orderId;
+        if (!orderId) {
+            return [createExportBalanceItemPayment(item, null)];
+        }
+
+        const order = orderMap.get(orderId);
+        if (!order) {
+            return [createExportBalanceItemPayment(item, null)];
+        }
+
+        if (!addedOrderIds.has(order.id) && item.price === order.data.totalPrice) {
+            addedOrderIds.add(order.id);
+            return createOrderItemPaymentRows(item, order);
+        }
+
+        return [
+            createSyntheticBalanceItemPayment({
+                source: item,
+                description: getPartialOrderPaymentDescription(order),
+                amount: 1,
+                price: item.price,
+            }),
+        ];
+    });
+}
+
+function createOrderItemPaymentRows(
+    item: BalanceItemPaymentDetailed,
+    order: PaymentExportOrder,
+): PaymentExportBalanceItemPayment[] {
+    const rows: PaymentExportBalanceItemPayment[] = [];
+
+    for (const orderItem of order.data.cart.items) {
+        rows.push(
+            createSyntheticBalanceItemPayment({
+                source: item,
+                customTitle: orderItem.product.name,
+                description: orderItem.description,
+                amount: orderItem.amount,
+                price: orderItem.getPrice(),
+            }),
+        );
+    }
+
+    addOrderDiscountRows(rows, item, order);
+
+    if (order.data.deliveryPrice) {
+        rows.push(
+            createSyntheticBalanceItemPayment({
+                source: item,
+                customTitle: $t('Leveringskosten'),
+                description: $t('Leveringskosten'),
+                amount: 1,
+                price: order.data.deliveryPrice,
+            }),
+        );
+    }
+
+    if (order.data.administrationFee) {
+        rows.push(
+            createSyntheticBalanceItemPayment({
+                source: item,
+                customTitle: $t('Administratiekosten'),
+                description: $t('Administratiekosten'),
+                amount: 1,
+                price: order.data.administrationFee,
+            }),
+        );
+    }
+
+    const difference = item.price - rows.reduce((sum, row) => sum + row.price, 0);
+    if (difference !== 0) {
+        rows.push(
+            createSyntheticBalanceItemPayment({
+                source: item,
+                customTitle: $t('Correctie bestelling'),
+                description: $t('Correctie bestelling'),
+                amount: 1,
+                price: difference,
+            }),
+        );
+    }
+
+    return rows;
+}
+
+function addOrderDiscountRows(
+    rows: PaymentExportBalanceItemPayment[],
+    item: BalanceItemPaymentDetailed,
+    order: PaymentExportOrder,
+) {
+    let remainingDiscountablePrice = order.data.cart.price;
+
+    const appliedPercentageDiscount = Math.min(order.data.appliedPercentageDiscount, remainingDiscountablePrice);
+    if (appliedPercentageDiscount > 0) {
+        rows.push(
+            createSyntheticBalanceItemPayment({
+                source: item,
+                customTitle: $t('Korting ({percentage})', { percentage: Formatter.percentage(order.data.percentageDiscount) }),
+                description: $t('Korting ({percentage})', { percentage: Formatter.percentage(order.data.percentageDiscount) }),
+                amount: 1,
+                price: -appliedPercentageDiscount,
+            }),
+        );
+        remainingDiscountablePrice -= appliedPercentageDiscount;
+    }
+
+    const fixedDiscount = Math.min(order.data.fixedDiscount, remainingDiscountablePrice);
+    if (fixedDiscount > 0) {
+        rows.push(
+            createSyntheticBalanceItemPayment({
+                source: item,
+                customTitle: $t('Korting'),
+                description: $t('Vaste korting'),
+                amount: 1,
+                price: -fixedDiscount,
+            }),
+        );
+    }
+}
+
+function getPartialOrderPaymentDescription(order: PaymentExportOrder): string {
+    if (order.number !== null) {
+        return $t('Gedeeltelijke betaling/terugbetaling voor bestelling #{number}', { number: order.number.toString() });
+    }
+
+    return $t('Gedeeltelijke betaling/terugbetaling voor bestelling');
+}
+
+function createSyntheticBalanceItemPayment({
+    source,
+    customTitle = null,
+    description,
+    amount,
+    price,
+}: {
+    source: BalanceItemPaymentDetailed;
+    customTitle?: string | null;
+    description: string;
+    amount: number;
+    price: number;
+}): PaymentExportBalanceItemPayment {
+    return createExportBalanceItemPayment(BalanceItemPaymentDetailed.create({
+        ...source,
+        price,
+        balanceItem: BalanceItem.create({
+            ...source.balanceItem,
+            type: BalanceItemType.Order,
+            relations: new Map(source.balanceItem.relations),
+            description,
+            amount,
+            unitPrice: amount === 0 ? 0 : price / amount,
+        }),
+    }), customTitle);
+}
+
+function createExportBalanceItemPayment(
+    item: BalanceItemPaymentDetailed,
+    customTitle: string | null,
+): PaymentExportBalanceItemPayment {
+    return Object.assign(item, {
+        customTitle,
+    });
+}
+
 function getBalanceItemColumns(): XlsxTransformerColumn<PaymentWithItem>[] {
     return [
         {
@@ -149,12 +342,25 @@ function getBalanceItemColumns(): XlsxTransformerColumn<PaymentWithItem>[] {
                 };
             },
         },
+        {
+            id: 'balanceItem.title',
+            name: $t('Titel'),
+            width: 40,
+            getValue: (object: PaymentWithItem) => ({
+                value: object.balanceItemPayment.customTitle || object.balanceItemPayment.balanceItem.itemTitle,
+            }),
+        },
         {
             id: 'balanceItem.description',
             name: $t(`%6o`),
-            width: 40,
+            width: 50,
             getValue: (object: PaymentWithItem) => ({
-                value: object.balanceItemPayment.balanceItem.description,
+                value: object.balanceItemPayment.balanceItem.itemDescription || object.balanceItemPayment.balanceItem.description,
+                style: {
+                    alignment: {
+                        wrapText: true,
+                    },
+                },
             }),
         },
         {

package/src/helpers/AdminPermissionChecker.ts

@@ -209,6 +209,14 @@ export class AdminPermissionChecker {
         return this.user.permissions.organizationPermissions.get(typeof organizationOrId === 'string' ? organizationOrId : organizationOrId.id) ?? null;
     }
 
+    getUnloadedPlatformPermissions() {
+        if (!this.user.permissions) {
+            return null;
+        }
+
+        return this.user.permissions.globalPermissions;
+    }
+
     async canAccessPrivateOrganizationData(organization: Organization) {
         if (!this.checkScope(organization.id)) {
             return false;
@@ -232,7 +240,7 @@ export class AdminPermissionChecker {
             return false;
         }
 
-        if (!await this.hasSomeUnloadedAccess(organization)) {
+        if (!await this.hasSomeUnloadedAccess(organization) && !this.hasSomeUnloadedPlatformAccess()) {
             return false;
         }
         return true;
@@ -1130,6 +1138,11 @@ export class AdminPermissionChecker {
         return !!unloadedPermissions && !unloadedPermissions.isEmpty;
     }
 
+    hasSomeUnloadedPlatformAccess(): boolean {
+        const unloadedPermissions = this.getUnloadedPlatformPermissions();
+        return !!unloadedPermissions && !unloadedPermissions.isEmpty;
+    }
+
     async canManageAdmins(organizationId: string) {
         return !this.user.isApiUser && (await this.hasFullAccess(organizationId));
     }

package/src/helpers/Context.ts

@@ -223,7 +223,7 @@ export class ContextInstance {
         }
     }
 
-    async authenticate({ allowWithoutAccount = false }: { allowWithoutAccount?: boolean } = {}): Promise<{ user: User; token: Token }> {
+    async authenticate({ allowWithoutAccount = false, allowUnscoped = false }: { allowWithoutAccount?: boolean; allowUnscoped?: boolean } = {}): Promise<{ user: User; token: Token }> {
         let header = this.request.headers.authorization;
 
         if (!header && this.request.method === 'POST') {
@@ -255,7 +255,7 @@ export class ContextInstance {
 
         const token = await Token.getByAccessToken(accessToken, true);
 
-        if (!token || (this.organization && token.user.organizationId !== null && token.user.organizationId !== this.organization.id) || (!this.organization && token.user.organizationId)) {
+        if (!token || (this.organization && token.user.organizationId !== null && token.user.organizationId !== this.organization.id) || (!this.organization && token.user.organizationId && (!allowUnscoped || !token.user.isApiUser))) {
             if (token?.user) {
                 console.log(
                     'Failed auth: ' + token?.user.email + ' (' + token?.user.id + ')',
@@ -269,6 +269,11 @@ export class ContextInstance {
             });
         }
 
+        if (!this.organization && token.user.organizationId && allowUnscoped) {
+            // Automatically scope full request to the user's scope
+            await this.setManualOrganizationScope(await Organization.getByID(token.user.organizationId, true));
+        }
+
         if (token.isAccessTokenExpired()) {
             if (token?.user) {
                 console.log(

package/src/helpers/FileCache.ts

@@ -116,9 +116,13 @@ export class FileCache {
             });
         }
 
-        const date = new Date(year, month - 1, day, 0, 0, 0);
-        const now = new Date();
-        now.setHours(0, 0, 0, 0);
+        const date = Formatter.luxon().set({
+            day,
+            month,
+            year,
+        }).startOf('day').toJSDate();
+
+        const now = Formatter.luxon().startOf('day').toJSDate();
 
         const diff = now.getTime() - date.getTime();
 

package/src/migrate.ts

@@ -8,10 +8,10 @@ Column.setJSONVersion(Version);
 process.env.TZ = 'UTC';
 
 // Polyfill require.resolve, since import.meta.resolve is not supported by vitest
-import { createRequire } from 'node:module';
-import { GlobalHelper } from './helpers/GlobalHelper.js';
 import { I18n } from '@stamhoofd/backend-i18n/I18n';
 import { QueryableModel } from '@stamhoofd/sql';
+import { createRequire } from 'node:module';
+import { GlobalHelper } from './helpers/GlobalHelper.js';
 const require = createRequire(import.meta.url);
 
 const emailPath = require.resolve('@stamhoofd/email');
@@ -50,34 +50,37 @@ const start = async () => {
         database: null,
     });
 
-    await globalDatabase.statement(query);
+    try {
+        await globalDatabase.statement(query);
 
-    // External migrations
-    if (!await Migration.runAll(path.dirname(modelsPath) + '/migrations')) {
-        throw new Error('Migrations failed');
-    }
-    if (!await Migration.runAll(path.dirname(emailPath) + '/../migrations')) {
-        throw new Error('Email migrations failed');
-    }
+        // External migrations
+        if (!await Migration.runAll(path.dirname(modelsPath) + '/migrations')) {
+            throw new Error('Migrations failed');
+        }
+        if (!await Migration.runAll(path.dirname(emailPath) + '/../migrations')) {
+            throw new Error('Email migrations failed');
+        }
 
-    // Internal
-    await I18n.load();
-    GlobalHelper.loadGlobalTranslateFunction();
+        // Internal
+        await I18n.load();
+        GlobalHelper.loadGlobalTranslateFunction();
 
-    if (!await Migration.runAll(import.meta.dirname + '/migrations')) {
-        throw new Error('Internal migrations failed');
-    }
+        if (!await Migration.runAll(import.meta.dirname + '/migrations')) {
+            throw new Error('Internal migrations failed');
+        }
 
-    if (killSignalReceived) {
-        console.error(chalk.red('Killing process due to received signal during migration'));
-        process.exit(1);
+        if (killSignalReceived) {
+            console.error(chalk.red('Killing process due to received signal during migration'));
+            process.exit(1);
+        }
+
+        // Reload database to prevent connection state leakage
+        await Database.reload({});
+    } finally {
+        await globalDatabase.end();
+        process.off('SIGTERM', handler);
+        process.off('SIGINT', handler);
     }
-
-    // Reload database to prevent connection state leakage
-    await Database.reload({});
-
-    process.off('SIGTERM', handler);
-    process.off('SIGINT', handler);
 };
 
 export async function run() {

package/src/seeds/1782296682-create-missing-group-categories.ts

@@ -0,0 +1,237 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Group, Organization, OrganizationRegistrationPeriod, V1GroupMigrationData } from '@stamhoofd/models';
+import { GroupCategory, GroupCategorySettings, GroupType } from '@stamhoofd/structures';
+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');
+    }
+});
+
+// only check organizations that were checked in the 'fix' migration
+const relevantOrganizations = new Set(['f2543d6b-523e-4b03-848b-838200b1ff41', '11a478dd-e8cf-4160-80dd-8b48d20a6d39', '6d1c32cf-2ef0-4738-bacb-d553488f97b9', '3e6f5cb9-e130-4dda-92c9-26682fa09509', '57815733-5750-492f-beb1-1efd6229803a', '7677e32d-763a-4033-bc74-30d13f27556d', '7ac75a0f-f365-4ddc-836c-66a3267f24f0', '9dced404-a92d-44c4-b301-ecd29b6ac4e0', '97928f8a-b8d1-44cc-918f-09d0ae896c3b', 'f0edb665-1ce0-442a-88e7-5a62ea78c5fc', '842ada22-82f3-4cef-a1da-ae5da20b208d', '33744473-9ad9-4d3e-a9fc-31cd1b6a2753', 'ed6e74f1-51a0-4e04-8195-e722b015eeb5', '10827cc5-5f29-46cf-b26e-5fd11a9342cc', '5f4d4a26-43c3-4f80-86ad-64d07d5a46a7', '74e2bcbf-0ff9-484b-988a-e11d147122c0', 'c69512bc-ea0c-427a-ab90-08c3dcf1c856', '16742d64-0b31-4ce7-9c1e-6194882045b9', '95d59803-c50e-4bc1-adc9-90ade32b7579', 'eb6ccffa-41c5-45df-b4e4-1eb5749bc0fe', '1a534005-2784-400c-b8fe-bde09c901259', '27e06924-49a6-468c-a16e-b5735ace1894', '7a86f3db-08d8-4752-a77d-eb85f2167942', 'f562c735-7bf4-4e2e-8c0f-6584e8e96a1d', 'e2afe517-cd35-4d9e-a561-125ad184a2ff', 'fd934e40-734c-442d-b338-c3ae288dd55d']);
+
+// only check groups that were checked in the 'fix' migration
+const relevantGroups = new Set([
+    '020a313c-0e97-4068-84ba-783d91e768a4', '02420f62-1a07-4e2a-ae92-13c35320fb27', '0b6d8422-857f-46e4-a632-a4af322c9193', '12ba896a-e064-4697-a5df-69664c9bd8cb', '134e33f9-3560-4eca-977b-aaef01af5ed4', '1a9bb59a-c85a-4338-94c6-f82061f1ee0e', '1bf5519d-4645-4c51-8ae5-7a202bb74e9e', '1c86c401-c32b-4c6f-a2b5-fb15649efa74', '1ddc6fde-f512-43ac-8e15-2496601e900e', '20cab6ae-fb30-4de8-948e-60caf0979ff7', '22194f9d-fba2-4497-b7b0-de8ba6e884ff', '2384f112-d50d-4fcf-b6f2-45db73a8944c', '26693e8a-b73d-4f28-a41c-d281ba91fb3e', '287ff7b8-3319-40fb-ad25-26b139db3272', '2e473bf7-36f9-4276-8770-032db776d154', '3282e30c-a3db-4f00-b827-646fcc532c43', '3490cfd8-4c0b-487f-8f0d-c96c62950160', '3d68762b-8133-42e0-a642-7649864b09b3', '4a7d205b-e996-4841-b21c-1336642e670d', '52b0285c-4935-4577-bc7b-30d0b8804fc9', '579263b6-ceb1-4be0-a31e-9a4a904f0cae', '5870423f-6faf-492e-accb-4bd110365328', '60e24adb-5bb3-48de-9008-5b80c905a01a', '6535d9b4-f2ad-4f7e-b7e2-9e50ddf5eff6', '6a508234-08aa-4b0b-9647-7aeb9d80fa5a', '722f3bdf-d9df-4a78-a4c1-783c9af3d21b', '754bb111-caad-49b3-8dde-5bd0f3ad9104', '76aef892-19b5-4deb-9276-0c6b19b652fd', '78fa525b-e346-4b78-9e25-f9b1b5134b77', '7989ea9d-354d-4eff-9350-8eb8a6c4732b', '7aba3792-0138-4302-8550-2ccb456a37ad', '7c480cd5-8db3-4c03-8f0b-a88556df0234', '8113c2a2-e788-4f11-815f-4b019d7ca966', '82958c24-bc12-45f2-9d0d-3c8b902df052', '88c28670-cf97-42e2-ae9e-d836d349c2e6', '88d87c1a-749f-453c-a60b-e54a7001a9f0', '8983c1d5-e8aa-4628-a251-17220336fad5', '89ced76d-8c98-4f83-bffa-8b467289972d', '8abed111-cda2-4bb8-8d98-21291a85fb4f', '8bb9b1c6-2d40-4a69-bbd5-63ce152b1a91', '8f98e452-e174-4946-96ec-888cc3498f56', '8fdffd17-84fa-41f7-8b74-744578d4b9d9', '92ae627b-8aa4-4197-885e-603d4a1be8aa', '9852662c-7e9f-4c26-a6d3-6335b49b9b3b', 'a06ddcb5-dc9c-4bec-a0f8-40fd4ab20016', 'a25bbeae-86b9-4162-8570-d121845f26e9', 'a690c59b-72eb-40bb-b181-d9dc904f9ec1', 'a9b0a795-3b7e-40bb-b8ec-65280d149dba', 'ab9ddbb9-21bc-4a8e-be7f-036554b70db4', 'bea51786-4d47-4bcb-bf79-fc636f047cbb', 'c806a74d-f0ae-4473-86bd-facb92085eb1', 'c9064135-322e-4848-9de0-61011d067697', 'cb7e738f-bcb5-4bc5-9962-2608ea9c4094', 'cbc21e01-bb7e-4f1d-94c8-d4aac3b7247d', 'cf766627-3e32-45a1-8d62-865b6cc1d4ed', 'd0cf99ce-24e9-4912-9dc8-660b4ff57dcc', 'd2a536af-f23d-4c3e-8275-dc2e5116ab60', 'd715451c-6292-4d58-83f8-ffce115fca21', 'd76b57b8-10c4-43e4-94d1-bb66d1053bb4', 'dcffb511-131b-401c-a4b5-13810596bc42', 'df010c46-fc79-401c-a4a4-1fddb478acff', 'dfaf11b8-f835-4952-99e1-2b0279931b05', 'e0b8e823-4213-4919-b1ed-70395ad15df2', 'e9470495-097c-47b5-8e63-cd4f7370fa2d', 'e9fe89f8-780b-417f-a4ee-b48e0b0bb8ad', 'eda36826-ee68-414d-a773-cb41e1a1e2d6', 'edaa90fa-869b-4f3c-8b90-4ea41fe9a364', 'f163d78a-9539-43a3-aeb7-443559599342', 'f24e2ca9-3036-4839-9ff4-91bd4ecb5c91', 'f665642c-93e7-4886-bd6e-f94252d54e77', 'f7e5436c-855d-4bf9-b2de-94e9d0fd3052', 'f822b26a-715a-4154-b2a2-b11e38373fad', 'fe2e4ec5-cee4-4648-ae87-2f8dee7f42c8', 'ff3a7e68-feb7-4aca-983d-a8f8315851e7',
+]);
+
+async function start(dryRun: boolean) {
+    await SeedTools.loop({
+        query: Organization.select(),
+        batchSize: 50,
+        useTransactionPerBatch: true,
+        action: async (organization: Organization) => {
+            if (!relevantOrganizations.has(organization.id)) {
+                return;
+            }
+
+            await createMissingGroupCategories(organization, dryRun);
+        },
+    });
+}
+
+async function createMissingGroupCategories(organization: Organization, dryRun: boolean) {
+    const organizationPeriods = await OrganizationRegistrationPeriod.select()
+        .where('organizationId', organization.id)
+        // exclude current period
+        .andWhereNot('periodId', organization.periodId)
+        .fetch();
+
+    if (organizationPeriods.length > 1) {
+        console.error('found multiple periods for organization: ' + organization.id);
+    }
+
+    for (const organizationPeriod of organizationPeriods) {
+        const groups: Group[] = await Group.select()
+            .where('organizationId', organization.id)
+            // only for period being looped
+            .andWhere('periodId', organizationPeriod.periodId)
+            .andWhere('type', GroupType.Membership)
+            .andWhere('deletedAt', null)
+            .fetch();
+
+        if (groups.length === 0) {
+            continue;
+        }
+
+        const allCategories = organizationPeriod.settings.categories;
+
+        for (const group of groups) {
+            const category = allCategories.find(c => c.groupIds.includes(group.id));
+
+            // only create missing category if group is not in any category yet
+            if (!category) {
+                const oldGroupId = await getOldGroupId(group);
+                if (!relevantGroups.has(oldGroupId)) {
+                    throw new Error('not expected');
+                }
+
+                const oldGroup = await Group.getByID(oldGroupId);
+                if (!oldGroup) {
+                    throw new Error('Old group not found: ' + oldGroupId);
+                }
+
+                const { path, organizationPeriod: currentOrganizationPeriod } = await findPath(oldGroup);
+
+                const allArchivedCategories = organizationPeriod.settings.categories;
+
+                const archivedRoot = organizationPeriod.settings.rootCategory;
+                if (!archivedRoot) {
+                    throw new Error('archived root category not found');
+                }
+                let thisLayer = getChildCategories(archivedRoot, allArchivedCategories);
+                const equalArchivedPath: GroupCategory[] = [organizationPeriod.settings.rootCategory!];
+
+                for (const currentPeriodCategory of path) {
+                    if (currentPeriodCategory === currentOrganizationPeriod.settings.rootCategory) {
+                        continue;
+                    }
+
+                    // only exact match for last category is needed
+                    const exactMatch = currentPeriodCategory !== path[path.length - 1];
+                    const equalArchivedCategories = thisLayer.filter(archivedCategory => isEqualCategory(currentPeriodCategory, archivedCategory, exactMatch));
+                    if (equalArchivedCategories.length > 1) {
+                        throw new Error(`Found multiple equal categories (${currentPeriodCategory.settings.name}): ` + equalArchivedCategories.map(c => c.settings.name).join(', '));
+                    }
+
+                    if (equalArchivedCategories.length === 0) {
+                        break;
+                    }
+
+                    const equalArchivedCategory = equalArchivedCategories[0];
+                    thisLayer = getChildCategories(equalArchivedCategory, allArchivedCategories);
+                    equalArchivedPath.push(equalArchivedCategory);
+                }
+
+                // logging
+                console.log('organization: ', organization.name);
+                console.log('group: ', group.settings.name.toString());
+                logPath(path, 'current');
+                logPath(equalArchivedPath, 'archived');
+
+                if (path.length === equalArchivedPath.length) {
+                    // complete match -> add group to last category
+                    const lastCategory = equalArchivedPath[equalArchivedPath.length - 1];
+
+                    if (lastCategory.groupIds.length) {
+                        throw new Error('not expected last category has group ids');
+                    }
+
+                    // create new category
+                    const newCategory = createCategoryForOriginalGroup(oldGroup, [group.id]);
+                    lastCategory.categoryIds.push(newCategory.id);
+                    organizationPeriod.settings.categories.push(newCategory);
+
+                    if (!dryRun) {
+                        await organizationPeriod.save();
+                    }
+                } else {
+                    // should not happen
+                    console.error('no complete match');
+                }
+            }
+        }
+    }
+}
+
+function getChildCategories(category: GroupCategory, allCategories: GroupCategory[]) {
+    const results: GroupCategory[] = [];
+
+    for (const childId of category.categoryIds) {
+        const child = allCategories.find(c => c.id === childId);
+        if (!child) {
+            throw new Error('child category not found');
+        }
+        results.push(child);
+    }
+
+    return results;
+}
+
+async function getOldGroupId(group: Group) {
+    const data = await V1GroupMigrationData.select().where('newGroupId', group.id).first(true);
+    return data.oldGroupId;
+}
+
+/**
+ * Find the path from the old group to the root category.
+ */
+async function findPath(oldGroup: Group): Promise<{ path: GroupCategory[]; organizationPeriod: OrganizationRegistrationPeriod }> {
+    /**
+     * Returns all the parent categories of the group starting with the root category (= start) or null if not found.
+     */
+    function getPathToGroup(groupId: string, start: GroupCategory, allCategories: GroupCategory[]): GroupCategory[] | null {
+        if (start.groupIds.includes(groupId)) {
+            return [start];
+        }
+
+        for (const childCategoryId of start.categoryIds) {
+            const childCategory = allCategories.find(c => c.id === childCategoryId);
+            if (childCategory) {
+                const childPath = getPathToGroup(groupId, childCategory, allCategories);
+                if (childPath !== null) {
+                    return [start, ...childPath];
+                }
+            }
+        }
+
+        return null;
+    }
+
+    const organizationPeriod = await OrganizationRegistrationPeriod.select()
+        .where('organizationId', oldGroup.organizationId)
+        .where('periodId', oldGroup.periodId)
+        .first(true);
+
+    const root = organizationPeriod.settings.rootCategory;
+    if (!root) {
+        throw new Error('root category not found');
+    }
+
+    const path = getPathToGroup(oldGroup.id, root, organizationPeriod.settings.categories);
+    if (path === null) {
+        throw new Error('path not found');
+    }
+
+    return {
+        organizationPeriod,
+        path,
+    };
+}
+
+function logPath(path: GroupCategory[], prefix: string): void {
+    console.log(`${prefix} path: ${path.map(c => c.settings.name).join(' > ')}`);
+}
+
+function isEqualCategory(currentPeriodCategory: GroupCategory, archivedPeriodCategory: GroupCategory, exactMatch: boolean) {
+    if (exactMatch) {
+        return archivedPeriodCategory.settings.name === currentPeriodCategory.settings.name;
+    }
+    return archivedPeriodCategory.settings.name.startsWith(currentPeriodCategory.settings.name);
+}
+
+function createCategoryForOriginalGroup(originalGroup: Group, groupIds: string[]) {
+    return GroupCategory.create({
+        settings: GroupCategorySettings.create({
+            name: originalGroup.settings.name.toString(),
+            public: false,
+            maximumRegistrations: null,
+        }),
+        groupIds,
+    });
+}

package/src/migrations/1750090029-document-update-year.test.ts

@@ -1,181 +0,0 @@
-import type { RegistrationPeriod } from '@stamhoofd/models';
-import { DocumentTemplate, DocumentTemplateFactory, GroupFactory, OrganizationFactory, RegistrationPeriodFactory } from '@stamhoofd/models';
-import { migrateDocumentYears } from './1750090029-document-update-year.js';
-import { Formatter } from '@stamhoofd/utility';
-
-describe('migration.document-update-year', () => {
-    describe('should use most frequent year of groups', () => {
-        test('groups with date in period', async () => {
-            const organization = await new OrganizationFactory({
-            }).create();
-
-            const period1 = await new RegistrationPeriodFactory({
-                startDate: Formatter.luxon().set({ day: 1, month: 1, year: 2021 }).toJSDate(),
-                endDate: Formatter.luxon().set({ day: 31, month: 12, year: 2021 }).toJSDate(),
-                organization,
-            }).create();
-
-            organization.periodId = period1.id;
-            await organization.save();
-
-            const period2 = await new RegistrationPeriodFactory({
-                startDate: Formatter.luxon().set({ day: 1, month: 1, year: 2019 }).toJSDate(),
-                endDate: Formatter.luxon().set({ day: 31, month: 12, year: 2019 }).toJSDate(),
-                organization,
-            }).create();
-
-            const createGroup = async (startDate: Date, endDate: Date, period: RegistrationPeriod) => {
-                const group = await new GroupFactory({ organization, period }).create();
-                group.settings.startDate = startDate;
-                group.settings.endDate = endDate;
-                await group.save();
-                return group;
-            };
-
-            // groups
-            const group1 = await createGroup(Formatter.luxon().set({ day: 1, month: 1, year: 2021 }).toJSDate(), Formatter.luxon().set({ day: 31, month: 12, year: 2021 }).toJSDate(), period1);
-            const group2 = await createGroup(Formatter.luxon().set({ day: 1, month: 1, year: 2021 }).toJSDate(), Formatter.luxon().set({ day: 31, month: 12, year: 2021 }).toJSDate(), period1);
-            const group3 = await createGroup(Formatter.luxon().set({ day: 1, month: 1, year: 2019 }).toJSDate(), Formatter.luxon().set({ day: 31, month: 12, year: 2019 }).toJSDate(), period2);
-
-            // document created in 2021
-            const document1 = await new DocumentTemplateFactory({
-                groups: [group1, group2, group3],
-                year: 0,
-            }).create();
-
-            document1.createdAt = Formatter.luxon().set({ day: 1, month: 1, year: 2022 }).toJSDate();
-            await document1.save();
-
-            // document created in 2020
-            const document2 = await new DocumentTemplateFactory({
-                groups: [group1, group2, group3],
-                year: 0,
-            }).create();
-
-            document2.createdAt = Formatter.luxon().set({ day: 1, month: 1, year: 2021 }).toJSDate();
-            await document2.save();
-
-            // document created in 2019
-            const document3 = await new DocumentTemplateFactory({
-                groups: [group1, group2, group3],
-                year: 0,
-            }).create();
-
-            document3.createdAt = Formatter.luxon().set({ day: 1, month: 1, year: 2020 }).toJSDate();
-            await document3.save();
-
-            // act
-            await migrateDocumentYears();
-
-            // assert
-            const updatedDocument1 = await DocumentTemplate.getByID(document1.id);
-            const updatedDocument2 = await DocumentTemplate.getByID(document2.id);
-            const updatedDocument3 = await DocumentTemplate.getByID(document3.id);
-
-            // take most frequent year and prefer date of document creation
-            expect(updatedDocument1?.year).toBe(2021);
-            expect(updatedDocument2?.year).toBe(2021);
-            expect(updatedDocument3?.year).toBe(2020); // maxed at creation year
-        });
-
-        test('groups overlapping period', async () => {
-            const organization = await new OrganizationFactory({
-            }).create();
-
-            const period1 = await new RegistrationPeriodFactory({
-                startDate: Formatter.luxon().set({ day: 1, month: 1, year: 2021 }).toJSDate(),
-                endDate: Formatter.luxon().set({ day: 31, month: 12, year: 2021 }).toJSDate(),
-                organization,
-            }).create();
-
-            organization.periodId = period1.id;
-            await organization.save();
-
-            const period2 = await new RegistrationPeriodFactory({
-                startDate: Formatter.luxon().set({ day: 1, month: 1, year: 2020 }).toJSDate(),
-                endDate: Formatter.luxon().set({ day: 31, month: 12, year: 2020 }).toJSDate(),
-                organization,
-            }).create();
-
-            const period3 = await new RegistrationPeriodFactory({
-                startDate: Formatter.luxon().set({ day: 1, month: 1, year: 2019 }).toJSDate(),
-                endDate: Formatter.luxon().set({ day: 31, month: 12, year: 2019 }).toJSDate(),
-                organization,
-            }).create();
-
-            const createGroup = async (startDate: Date, endDate: Date, period: RegistrationPeriod) => {
-                const group = await new GroupFactory({ organization, period }).create();
-                group.settings.startDate = startDate;
-                group.settings.endDate = endDate;
-                await group.save();
-                return group;
-            };
-
-            // groups
-            const group1 = await createGroup(Formatter.luxon().set({ day: 1, month: 7, year: 2020 }).toJSDate(), Formatter.luxon().set({ day: 30, month: 6, year: 2021 }).toJSDate(), period1);
-            const group2 = await createGroup(Formatter.luxon().set({ day: 5, month: 8, year: 2020 }).toJSDate(), Formatter.luxon().set({ day: 3, month: 5, year: 2021 }).toJSDate(), period1);
-            const group3 = await createGroup(Formatter.luxon().set({ day: 1, month: 6, year: 2018 }).toJSDate(), Formatter.luxon().set({ day: 14, month: 11, year: 2019 }).toJSDate(), period3);
-
-            // document created in 2021
-            const document1 = await new DocumentTemplateFactory({
-                groups: [group1, group2, group3],
-                year: 0,
-            }).create();
-
-            document1.createdAt = Formatter.luxon().set({ day: 1, month: 1, year: 2022 }).toJSDate();
-            await document1.save();
-
-            // document created in 2020
-            const document2 = await new DocumentTemplateFactory({
-                groups: [group1, group2, group3],
-                year: 0,
-            }).create();
-
-            document2.createdAt = Formatter.luxon().set({ day: 1, month: 1, year: 2021 }).toJSDate();
-            await document2.save();
-
-            // document created in 2019
-            const document3 = await new DocumentTemplateFactory({
-                groups: [group1, group2, group3],
-                year: 0,
-            }).create();
-
-            document3.createdAt = Formatter.luxon().set({ day: 1, month: 1, year: 2020 }).toJSDate();
-            await document3.save();
-
-            // act
-            await migrateDocumentYears();
-
-            // assert
-            const updatedDocument1 = await DocumentTemplate.getByID(document1.id);
-            const updatedDocument2 = await DocumentTemplate.getByID(document2.id);
-            const updatedDocument3 = await DocumentTemplate.getByID(document3.id);
-
-            // take most frequent year and prefer date of document creation
-            expect(updatedDocument1?.year).toBe(2020);
-            // should take 2020 because document was created in 2020
-            expect(updatedDocument2?.year).toBe(2020);
-            expect(updatedDocument3?.year).toBe(2020);
-        });
-    });
-
-    test('no groups should use year before creation', async () => {
-        // create document
-        const document = await new DocumentTemplateFactory({
-            groups: [],
-            year: 0,
-        }).create();
-
-        document.createdAt = Formatter.luxon().set({ day: 1, month: 1, year: 2025 }).toJSDate();
-        await document.save();
-
-        // act
-        await migrateDocumentYears();
-
-        // assert
-        const updatedDocument = await DocumentTemplate.getByID(document.id);
-
-        // year should be year of creation
-        expect(updatedDocument?.year).toBe(2024);
-    });
-});