@stamhoofd/backend 2.123.2 → 2.124.1

package/package.json

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

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.test.ts

@@ -0,0 +1,232 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import type { Organization, Token } from '@stamhoofd/models';
+import { OrganizationFactory, STPackageFactory, UserFactory } from '@stamhoofd/models';
+import { LimitedFilteredRequest, OrganizationMetaData, OrganizationType, PermissionLevel, Permissions, STPackageBundle, type StamhoofdFilter, UmbrellaOrganization } from '@stamhoofd/structures';
+import { Country } from '@stamhoofd/types/Country';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { testServer } from '../../../../tests/helpers/TestServer.js';
+import { initPlatformAdmin } from '../../../../tests/init/index.js';
+import { initMembershipOrganization } from '../../../../tests/init/initMembershipOrganization.js';
+import { GetOrganizationsEndpoint } from './GetOrganizationsEndpoint.js';
+
+const baseUrl = `/admin/organizations`;
+const endpoint = new GetOrganizationsEndpoint();
+
+describe('Endpoint.GetOrganizationsEndpoint', () => {
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'organization');
+    });
+
+    beforeAll(async () => {
+        await initMembershipOrganization();
+    });
+
+    const search = async (searchTerm: string, token: Token): Promise<string[]> => {
+        const request = Request.get({
+            path: baseUrl,
+            // Platform admins are not scoped to an organization, so no host is required
+            host: '',
+            query: new LimitedFilteredRequest({
+                search: searchTerm,
+                limit: 100,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+        const response = await testServer.test(endpoint, request);
+        return response.body.results.map(o => o.id);
+    };
+
+    const filter = async (filter: StamhoofdFilter, token: Token): Promise<string[]> => {
+        const request = Request.get({
+            path: baseUrl,
+            host: '',
+            query: new LimitedFilteredRequest({
+                filter,
+                limit: 100,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+        const response = await testServer.test(endpoint, request);
+        return response.body.results.map(o => o.id);
+    };
+
+    // Creates an admin (user with permissions) for the given organization
+    const createAdmin = async (organization: Organization, data: { firstName?: string; lastName?: string; email?: string }) => {
+        return await new UserFactory({
+            organization,
+            permissions: Permissions.create({ level: PermissionLevel.Full }),
+            ...data,
+        }).create();
+    };
+
+    test('Searches organizations by name', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const organization = await new OrganizationFactory({ name: 'Bombilcious Tennis Club' }).create();
+
+        expect(await search('Bombilcious Tennis Club', adminToken)).toContain(organization.id);
+    });
+
+    test('Searches organizations by uri', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const organization = await new OrganizationFactory({ }).create();
+
+        expect(await search(organization.uri, adminToken)).toContain(organization.id);
+    });
+
+    test('Does not search organizations by admin name', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const organization = await new OrganizationFactory({ name: 'Halfnamed Club' }).create();
+        await createAdmin(organization, { firstName: 'Zwervinkel' });
+
+        expect(await search('Zwervinkel', adminToken)).not.toContain(organization.id);
+    });
+
+    test('Does not match users without permissions (non-admins)', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const organization = await new OrganizationFactory({ name: 'Memberonly Club' }).create();
+
+        // A regular user (no permissions) linked to the organization
+        await new UserFactory({ organization, firstName: 'Solitary', lastName: 'Pangolin' }).create();
+
+        expect(await search('Solitary Pangolin', adminToken)).not.toContain(organization.id);
+    });
+
+    test('Searches admins by email', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const organization = await new OrganizationFactory({ name: 'Mailable Club' }).create();
+        await createAdmin(organization, { email: 'findme@admin-search-test.com' });
+
+        expect(await search('findme@admin-search-test.com', adminToken)).toContain(organization.id);
+    });
+
+    test('Does search the organization name when the search contains an @', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        // The organization name itself contains an @, but there is no admin with a matching email
+        const organization = await new OrganizationFactory({ name: 'weird@orgname-test.com' }).create();
+
+        expect(await search('weird@orgname-test.com', adminToken)).toContain(organization.id);
+    });
+
+    test('Does not match admins of other organizations by email', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const organization = await new OrganizationFactory({ name: 'Owner Club' }).create();
+        const otherOrganization = await new OrganizationFactory({ name: 'Bystander Club' }).create();
+        await createAdmin(organization, { email: 'unique-owner@admin-search-test.com' });
+
+        const results = await search('unique-owner@admin-search-test.com', adminToken);
+        expect(results).toContain(organization.id);
+        expect(results).not.toContain(otherOrganization.id);
+    });
+
+    test('Filters organizations by active package type', async () => {
+        const { adminToken } = await initPlatformAdmin();
+
+        const membersOrg = await new OrganizationFactory({ name: 'Packaged Members Club' }).create();
+        await new STPackageFactory({ organization: membersOrg, bundle: STPackageBundle.Members }).create();
+
+        const webshopsOrg = await new OrganizationFactory({ name: 'Packaged Webshops Club' }).create();
+        await new STPackageFactory({ organization: webshopsOrg, bundle: STPackageBundle.Webshops }).create();
+
+        const results = await filter({
+            packages: {
+                $elemMatch: {
+                    type: {
+                        $in: ['Members'],
+                    },
+                },
+            },
+        }, adminToken);
+
+        expect(results).toContain(membersOrg.id);
+        expect(results).not.toContain(webshopsOrg.id);
+    });
+
+    test('Does not match organizations whose package is no longer valid', async () => {
+        const { adminToken } = await initPlatformAdmin();
+
+        const expiredOrg = await new OrganizationFactory({ name: 'Expired Members Club' }).create();
+        // removeAt in the past => package is no longer active
+        await new STPackageFactory({
+            organization: expiredOrg,
+            bundle: STPackageBundle.Members,
+            removeAt: new Date(Date.now() - 1000 * 60 * 60 * 24),
+        }).create();
+
+        const results = await filter({
+            packages: {
+                $elemMatch: {
+                    type: {
+                        $in: ['Members'],
+                    },
+                },
+            },
+        }, adminToken);
+
+        expect(results).not.toContain(expiredOrg.id);
+    });
+
+    // Creates an organization with a specific type and/or umbrella organization
+    const createOrganizationWithMeta = async (name: string, metaPatch: { type?: OrganizationType; umbrellaOrganization?: UmbrellaOrganization | null }) => {
+        const meta = OrganizationMetaData.create({
+            type: metaPatch.type ?? OrganizationType.Other,
+            umbrellaOrganization: metaPatch.umbrellaOrganization ?? null,
+            defaultEndDate: new Date(),
+            defaultStartDate: new Date(),
+            defaultPrices: [],
+        });
+        return await new OrganizationFactory({ name, meta }).create();
+    };
+
+    test('Filters organizations by type', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const youthOrg = await createOrganizationWithMeta('Youthful Club', { type: OrganizationType.Youth });
+        const sportOrg = await createOrganizationWithMeta('Sporty Club', { type: OrganizationType.Sport });
+
+        const results = await filter({ type: { $in: [OrganizationType.Youth] } }, adminToken);
+        expect(results).toContain(youthOrg.id);
+        expect(results).not.toContain(sportOrg.id);
+    });
+
+    test('Filters organizations by umbrella organization', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const scoutsOrg = await createOrganizationWithMeta('Scouts Club', { umbrellaOrganization: UmbrellaOrganization.ScoutsEnGidsenVlaanderen });
+        const otherOrg = await createOrganizationWithMeta('No Umbrella Club', { umbrellaOrganization: null });
+
+        const results = await filter({ umbrellaOrganization: { $in: [UmbrellaOrganization.ScoutsEnGidsenVlaanderen] } }, adminToken);
+        expect(results).toContain(scoutsOrg.id);
+        expect(results).not.toContain(otherOrg.id);
+    });
+
+    test('Filters organizations by country', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        // OrganizationFactory creates organizations in Belgium by default
+        const org = await new OrganizationFactory({ name: 'Belgian Club' }).create();
+
+        expect(await filter({ country: { $in: [Country.Belgium] } }, adminToken)).toContain(org.id);
+        expect(await filter({ country: { $in: [Country.Netherlands] } }, adminToken)).not.toContain(org.id);
+    });
+
+    test('Filters organizations by street', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        // OrganizationFactory uses 'Demostraat' as the street
+        const org = await new OrganizationFactory({ name: 'Streeted Club' }).create();
+
+        expect(await filter({ street: { $contains: 'Demostraat' } }, adminToken)).toContain(org.id);
+        expect(await filter({ street: { $contains: 'Nonexistentstreet' } }, adminToken)).not.toContain(org.id);
+    });
+
+    test('Filters organizations by creation date', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const org = await new OrganizationFactory({ name: 'Freshly Created Club' }).create();
+
+        const anHourAgo = new Date(Date.now() - 1000 * 60 * 60);
+        const inAnHour = new Date(Date.now() + 1000 * 60 * 60);
+
+        expect(await filter({ createdAt: { $gt: anHourAgo } }, adminToken)).toContain(org.id);
+        expect(await filter({ createdAt: { $gt: inAnHour } }, adminToken)).not.toContain(org.id);
+    });
+});

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.ts

@@ -72,25 +72,47 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
         }
 
         if (q.search) {
-            let searchFilter: StamhoofdFilter | null = null;
-
-            // todo: auto detect e-mailaddresses and search on admins
-            searchFilter = {
-                $or: [
-                    {
-                        name: {
-                            $contains: q.search,
+            let searchFilter: StamhoofdFilter;
+
+            if (q.search.includes('@')) {
+                // Automatically search in the email addresses of admins instead of the organization name
+                searchFilter = {
+                    $or: [
+                        {
+                            name: {
+                                $contains: q.search,
+                            },
                         },
-                    },
-                    {
-                        uri: q.search,
-                    },
-                ],
-            };
-
-            if (searchFilter) {
-                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
+                        {
+                            uri: q.search,
+                        },
+                        {
+                            admins: {
+                                $elemMatch: {
+                                    email: {
+                                        $contains: q.search,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                };
+            } else {
+                searchFilter = {
+                    $or: [
+                        {
+                            name: {
+                                $contains: q.search,
+                            },
+                        },
+                        {
+                            uri: q.search,
+                        },
+                    ],
+                };
             }
+
+            query.where(await compileToSQLFilter(searchFilter, filterCompilers));
         }
 
         if (q instanceof LimitedFilteredRequest) {
@@ -103,7 +125,7 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             query.limit(q.limit);
         }
 
-        console.log('GetOrganizationsEndpoint query', query.getSQL());
+        // console.log('GetOrganizationsEndpoint query', query.getSQL());
 
         return query;
     }

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint.ts

@@ -1,8 +1,8 @@
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
-import { DetailedReceivableBalance, PaymentStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import { DetailedReceivableBalance, PaymentStatus, PermissionLevel, ReceivableBalanceType } from '@stamhoofd/structures';
 
-import { BalanceItem, BalanceItemPayment, CachedBalance, MemberUser, Payment } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, CachedBalance, Member, MemberUser, Payment, Registration } from '@stamhoofd/models';
 import { Context } from '../../../../helpers/Context.js';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
 import { SQL } from '@stamhoofd/sql';
@@ -35,9 +35,23 @@ export class GetReceivableBalanceEndpoint extends Endpoint<Params, Query, Body,
         const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 
-        // If the user has permission, we'll also search if he has access to the organization's key
         if (!await Context.auth.canManageFinances(organization.id)) {
-            throw Context.auth.error();
+            // Group-level financial access is sufficient for member and registration balance views
+            if (request.params.type === ReceivableBalanceType.member) {
+                const member = await Member.getByIdWithUsersAndRegistrations(request.params.id);
+                if (!member || !await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, organization.id)) {
+                    throw Context.auth.error();
+                }
+            } else if (request.params.type === ReceivableBalanceType.registration) {
+                const registration = await Registration.select().where('id', request.params.id).first(false);
+                if (!registration) throw Context.auth.error();
+                const member = await Member.getByIdWithUsersAndRegistrations(registration.memberId);
+                if (!member || !await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, organization.id)) {
+                    throw Context.auth.error();
+                }
+            } else {
+                throw Context.auth.error();
+            }
         }
 
         let paymentModels: Payment[] = [];

package/src/endpoints/organization/dashboard/webshops/PatchWebshopEndpoint.ts

@@ -146,7 +146,7 @@ export class PatchWebshopEndpoint extends Endpoint<Params, Query, Body, Response
                         throw new SimpleError({
                             code: 'invalid_field',
                             message: 'domainUri is reserved for internal webshop routes',
-                            human: $t("%1a4"),
+                            human: $t('%1a4'),
                             field: 'customUrl',
                         });
                     }
@@ -194,7 +194,7 @@ export class PatchWebshopEndpoint extends Endpoint<Params, Query, Body, Response
                     throw new SimpleError({
                         code: 'invalid_field',
                         message: 'Uri is reserved for internal webshop routes',
-                        human: $t("%1a4"),
+                        human: $t('%1a4'),
                         field: 'uri',
                     });
                 }

package/src/excel-loaders/members.ts

@@ -302,6 +302,12 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformMember> = {
             }),
         },
 
+        // Group categories
+        XlsxTransformerColumnHelper.createGroupCategoryColumns<PlatformMember>({
+            matchId: 'groupCategory',
+            getMember: member => member,
+        }),
+
         // Registration records
         {
             match(id) {

package/src/excel-loaders/payments.ts

@@ -178,8 +178,8 @@ function createOrderItemPaymentRows(
         rows.push(
             createSyntheticBalanceItemPayment({
                 source: item,
-                customTitle: $t('Leveringskosten'),
-                description: $t('Leveringskosten'),
+                customTitle: $t('%1eU'),
+                description: $t('%1eU'),
                 amount: 1,
                 price: order.data.deliveryPrice,
             }),
@@ -190,8 +190,8 @@ function createOrderItemPaymentRows(
         rows.push(
             createSyntheticBalanceItemPayment({
                 source: item,
-                customTitle: $t('Administratiekosten'),
-                description: $t('Administratiekosten'),
+                customTitle: $t('%xK'),
+                description: $t('%xK'),
                 amount: 1,
                 price: order.data.administrationFee,
             }),
@@ -203,8 +203,8 @@ function createOrderItemPaymentRows(
         rows.push(
             createSyntheticBalanceItemPayment({
                 source: item,
-                customTitle: $t('Correctie bestelling'),
-                description: $t('Correctie bestelling'),
+                customTitle: $t('%1eE'),
+                description: $t('%1eE'),
                 amount: 1,
                 price: difference,
             }),
@@ -226,8 +226,8 @@ function addOrderDiscountRows(
         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) }),
+                customTitle: $t('%1ei', { percentage: Formatter.percentage(order.data.percentageDiscount) }),
+                description: $t('%1ei', { percentage: Formatter.percentage(order.data.percentageDiscount) }),
                 amount: 1,
                 price: -appliedPercentageDiscount,
             }),
@@ -240,8 +240,8 @@ function addOrderDiscountRows(
         rows.push(
             createSyntheticBalanceItemPayment({
                 source: item,
-                customTitle: $t('Korting'),
-                description: $t('Vaste korting'),
+                customTitle: $t('%176'),
+                description: $t('%1eM'),
                 amount: 1,
                 price: -fixedDiscount,
             }),
@@ -251,10 +251,10 @@ function addOrderDiscountRows(
 
 function getPartialOrderPaymentDescription(order: PaymentExportOrder): string {
     if (order.number !== null) {
-        return $t('Gedeeltelijke betaling/terugbetaling voor bestelling #{number}', { number: order.number.toString() });
+        return $t('%1eO', { number: order.number.toString() });
     }
 
-    return $t('Gedeeltelijke betaling/terugbetaling voor bestelling');
+    return $t('%1eH');
 }
 
 function createSyntheticBalanceItemPayment({
@@ -344,7 +344,7 @@ function getBalanceItemColumns(): XlsxTransformerColumn<PaymentWithItem>[] {
         },
         {
             id: 'balanceItem.title',
-            name: $t('Titel'),
+            name: $t('%vC'),
             width: 40,
             getValue: (object: PaymentWithItem) => ({
                 value: object.balanceItemPayment.customTitle || object.balanceItemPayment.balanceItem.itemTitle,

package/src/excel-loaders/registrations.ts

@@ -261,6 +261,11 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                 ];
             },
         },
+        // Group categories
+        XlsxTransformerColumnHelper.createGroupCategoryColumns<PlatformRegistration>({
+            matchId: 'groupCategory',
+            getMember: registration => registration.member,
+        }),
         // recordAnswers
         {
             match(id) {

package/src/helpers/XlsxTransformerColumnHelper.test.ts

@@ -0,0 +1,169 @@
+import type { XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
+import type { PlatformMember } from '@stamhoofd/structures';
+import {
+    Group,
+    GroupCategory,
+    GroupCategorySettings,
+    GroupSettings,
+    MemberDetails,
+    MembersBlob,
+    MemberWithRegistrationsBlob,
+    Organization,
+    OrganizationRegistrationPeriod,
+    OrganizationRegistrationPeriodSettings,
+    Platform,
+    PlatformFamily,
+    Registration,
+    RegistrationPeriod,
+    TranslatedString,
+} from '@stamhoofd/structures';
+import { XlsxTransformerColumnHelper } from './XlsxTransformerColumnHelper.js';
+
+describe('XlsxTransformerColumnHelper', () => {
+    describe('createGroupCategoryColumns', () => {
+        function createGroup(organization: Organization, periodId: string, name: string) {
+            return Group.create({
+                organizationId: organization.id,
+                periodId,
+                settings: GroupSettings.create({
+                    name: new TranslatedString(name),
+                }),
+            });
+        }
+
+        function setup() {
+            const period = RegistrationPeriod.create({});
+
+            // Build the organization with two categories, each holding a few groups
+            const organization = Organization.create({});
+
+            const kapoenen = createGroup(organization, period.id, 'Kapoenen');
+            const wouters = createGroup(organization, period.id, 'Wouters');
+            const jonggivers = createGroup(organization, period.id, 'Jonggivers');
+            const groepsleiding = createGroup(organization, period.id, 'Groepsleiding');
+            const takleiding = createGroup(organization, period.id, 'Takleiding');
+
+            const ageGroupsCategory = GroupCategory.create({
+                settings: GroupCategorySettings.create({ name: 'Leeftijdsgroepen' }),
+                groupIds: [kapoenen.id, wouters.id, jonggivers.id],
+            });
+            const leadershipCategory = GroupCategory.create({
+                settings: GroupCategorySettings.create({ name: 'Leiding' }),
+                groupIds: [groepsleiding.id, takleiding.id],
+            });
+            const root = GroupCategory.create({
+                id: 'root',
+                categoryIds: [ageGroupsCategory.id, leadershipCategory.id],
+            });
+
+            organization.period = OrganizationRegistrationPeriod.create({
+                period,
+                groups: [kapoenen, wouters, jonggivers, groepsleiding, takleiding],
+                settings: OrganizationRegistrationPeriodSettings.create({
+                    categories: [root, ageGroupsCategory, leadershipCategory],
+                    rootCategoryId: root.id,
+                }),
+            });
+
+            return { organization, period, ageGroupsCategory, leadershipCategory, groups: { kapoenen, wouters, jonggivers, groepsleiding, takleiding } };
+        }
+
+        function createMember(organization: Organization, registeredGroups: Group[]) {
+            const blob = MembersBlob.create({
+                organizations: [organization],
+                members: [
+                    MemberWithRegistrationsBlob.create({
+                        details: MemberDetails.create({ firstName: 'John', lastName: 'Doe' }),
+                        registrations: registeredGroups.map(group => Registration.create({
+                            organizationId: organization.id,
+                            group,
+                            groupPrice: group.settings.prices[0],
+                            registeredAt: new Date(),
+                        })),
+                    }),
+                ],
+            });
+
+            const family = PlatformFamily.create(blob, { platform: Platform.create({}), contextOrganization: organization });
+            return family.members[0];
+        }
+
+        function getColumn(categoryId: string): XlsxTransformerConcreteColumn<PlatformMember> {
+            const column = XlsxTransformerColumnHelper.createGroupCategoryColumns<PlatformMember>({
+                matchId: 'groupCategory',
+                getMember: member => member,
+            });
+
+            if (!('match' in column)) {
+                throw new Error('Expected a match column');
+            }
+
+            const matched = column.match(`groupCategory.${categoryId}`);
+            expect(matched).toBeDefined();
+            expect(matched).toHaveLength(1);
+            return matched![0];
+        }
+
+        it('lists the groups a member is registered for within a category', () => {
+            const { organization, ageGroupsCategory, leadershipCategory, groups } = setup();
+            const member = createMember(organization, [groups.kapoenen, groups.jonggivers, groups.groepsleiding]);
+
+            expect(getColumn(ageGroupsCategory.id).getValue(member).value).toBe('Jonggivers, Kapoenen');
+            expect(getColumn(leadershipCategory.id).getValue(member).value).toBe('Groepsleiding');
+        });
+
+        it('returns an empty value when the member has no registrations in the category', () => {
+            const { organization, leadershipCategory, groups } = setup();
+            const member = createMember(organization, [groups.kapoenen]);
+
+            expect(getColumn(leadershipCategory.id).getValue(member).value).toBe('');
+        });
+
+        it('does not match ids without a category id', () => {
+            const column = XlsxTransformerColumnHelper.createGroupCategoryColumns<PlatformMember>({
+                matchId: 'groupCategory',
+                getMember: member => member,
+            });
+
+            if (!('match' in column)) {
+                throw new Error('Expected a match column');
+            }
+
+            expect(column.match('groupCategory')).toBeUndefined();
+            expect(column.match('groupCategory.')).toBeUndefined();
+            expect(column.match('somethingElse.123')).toBeUndefined();
+        });
+
+        it('resolves groups in nested subcategories', () => {
+            const period = RegistrationPeriod.create({});
+            const organization = Organization.create({});
+
+            const kapoenen = createGroup(organization, period.id, 'Kapoenen');
+            const welpen = createGroup(organization, period.id, 'Welpen');
+
+            const subCategory = GroupCategory.create({
+                settings: GroupCategorySettings.create({ name: 'Jongste tak' }),
+                groupIds: [welpen.id],
+            });
+            const ageGroupsCategory = GroupCategory.create({
+                settings: GroupCategorySettings.create({ name: 'Leeftijdsgroepen' }),
+                groupIds: [kapoenen.id],
+                categoryIds: [subCategory.id],
+            });
+            const root = GroupCategory.create({ id: 'root', categoryIds: [ageGroupsCategory.id] });
+
+            organization.period = OrganizationRegistrationPeriod.create({
+                period,
+                groups: [kapoenen, welpen],
+                settings: OrganizationRegistrationPeriodSettings.create({
+                    categories: [root, ageGroupsCategory, subCategory],
+                    rootCategoryId: root.id,
+                }),
+            });
+
+            const member = createMember(organization, [kapoenen, welpen]);
+
+            expect(getColumn(ageGroupsCategory.id).getValue(member).value).toBe('Kapoenen, Welpen');
+        });
+    });
+});

package/src/helpers/XlsxTransformerColumnHelper.ts

@@ -1,7 +1,8 @@
 import type { XlsxTransformerColumn, XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
 import { isXlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
-import type { Address, Parent, PlatformMember, RecordAnswer, RecordSettings } from '@stamhoofd/structures';
+import type { Address, GroupCategory, Parent, PlatformMember, RecordAnswer, RecordSettings } from '@stamhoofd/structures';
 import { CountryHelper, ParentTypeHelper, RecordCategory, RecordType } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
 
 export class XlsxTransformerColumnHelper {
     static formatBoolean(value: boolean | undefined | null): string {
@@ -242,6 +243,77 @@ export class XlsxTransformerColumnHelper {
         };
     }
 
+    /**
+     * Creates a dynamic column for a group category. The matched id is `${matchId}.${categoryId}`, where categoryId
+     * refers to a category in the current period of the organization the member is registered at. The value is a
+     * comma separated list of all the groups the member is registered for in the current period that belong to that
+     * category (including its subcategories).
+     */
+    static createGroupCategoryColumns<T>({ matchId, getMember }: { matchId: string; getMember: (object: T) => PlatformMember }): XlsxTransformerColumn<T> {
+        return {
+            match(id) {
+                if (!id.startsWith(matchId + '.')) {
+                    return;
+                }
+
+                const categoryId = id.substring(matchId.length + 1);
+                if (!categoryId) {
+                    return;
+                }
+
+                return [
+                    {
+                        id: `${matchId}.${categoryId}`,
+                        name: $t(`%M2`),
+                        width: 40,
+                        getValue: (object: T) => {
+                            const member = getMember(object);
+
+                            for (const organization of member.organizations) {
+                                const categories = organization.period.settings.categories;
+                                if (!categories.find(c => c.id === categoryId)) {
+                                    continue;
+                                }
+
+                                const groupIds = XlsxTransformerColumnHelper.collectGroupIdsForCategory(categoryId, categories);
+                                const registrations = member.filterRegistrations({ groupIds, organizationId: organization.id });
+                                const names = Formatter.uniqueArray(registrations.map(r => r.group.settings.name.toString())).sort();
+
+                                return {
+                                    value: names.join(', '),
+                                };
+                            }
+
+                            return {
+                                value: '',
+                            };
+                        },
+                    },
+                ];
+            },
+        };
+    }
+
+    /**
+     * Recursively collects all group ids that belong to a category and its subcategories.
+     */
+    private static collectGroupIdsForCategory(categoryId: string, categories: GroupCategory[], seen = new Set<string>()): string[] {
+        if (seen.has(categoryId)) {
+            return [];
+        }
+        seen.add(categoryId);
+
+        const category = categories.find(c => c.id === categoryId);
+        if (!category) {
+            return [];
+        }
+
+        return [
+            ...category.groupIds,
+            ...category.categoryIds.flatMap(id => XlsxTransformerColumnHelper.collectGroupIdsForCategory(id, categories, seen)),
+        ];
+    }
+
     /**
      * Makes it possible to reuse an XlsxTransformerColumn, for example member columns exist, PlatformRegistration has
      * a property member, so we can reuse the member columns for PlatformRegistration.

package/src/seeds/{1782208150-group-permissions.ts → 1782421125-group-permissions.ts}

@@ -35,10 +35,6 @@ async function start(dryRun: boolean) {
                 .where('periodId', organization.periodId)
                 .fetch();
 
-            if (groups.length === 0) {
-                return;
-            }
-
             // handle group permissions
             for (const group of groups) {
                 const groupPermissions = group.privateSettings.permissions;
@@ -157,7 +153,7 @@ function handlePermissionRoleForGroup(organization: Organization, group: Group,
         return;
     }
 
-    specificGroupPermissions.merge(convertedRessourcePermissions);
+    specificGroupPermissions.add(convertedRessourcePermissions);
     return;
 }
 
@@ -209,7 +205,7 @@ function handlePermissionRoleForGroupCategory(organization: Organization, oldCat
         return;
     }
 
-    specificGroupCategoryPermissions.merge(convertedRessourcePermissions);
+    specificGroupCategoryPermissions.add(convertedRessourcePermissions);
     return;
 }
 
@@ -261,7 +257,7 @@ function handlePermissionRoleForWebshop(organization: Organization, webshop: Web
         return;
     }
 
-    specificWebshopPermissions.merge(convertedRessourcePermissions);
+    specificWebshopPermissions.add(convertedRessourcePermissions);
     return;
 }
 

package/src/sql-filters/balance-item-payments.ts

@@ -1,5 +1,5 @@
 import type { SQLFilterDefinitions } from '@stamhoofd/sql';
-import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
@@ -30,5 +30,42 @@ export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
             type: SQLValueType.String,
             nullable: true,
         }),
+        type: createColumnFilter({
+            expression: SQL.column('balance_items', 'type'),
+            type: SQLValueType.String,
+            nullable: false,
+        }),
+        registration: createExistsFilter(
+            SQL.select()
+                .from(SQL.table('registrations'))
+                .where(
+                    SQL.column('registrations', 'id'),
+                    SQL.column('balance_items', 'registrationId'),
+                ),
+            {
+                ...baseSQLFilterCompilers,
+                groupId: createColumnFilter({
+                    expression: SQL.column('registrations', 'groupId'),
+                    type: SQLValueType.String,
+                    nullable: false,
+                }),
+            },
+        ),
+        order: createExistsFilter(
+            SQL.select()
+                .from(SQL.table('webshop_orders'))
+                .where(
+                    SQL.column('webshop_orders', 'id'),
+                    SQL.column('balance_items', 'orderId'),
+                ),
+            {
+                ...baseSQLFilterCompilers,
+                webshopId: createColumnFilter({
+                    expression: SQL.column('webshop_orders', 'webshopId'),
+                    type: SQLValueType.String,
+                    nullable: false,
+                }),
+            },
+        ),
     },
 };

package/src/sql-filters/organizations.ts

@@ -29,6 +29,16 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Boolean,
         nullable: false,
     }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('organizations', 'createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    street: createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column('organizations', 'address'), '$.value.street'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
     city: createColumnFilter({
         expression: SQL.jsonExtract(SQL.column('organizations', 'address'), '$.value.city'),
         type: SQLValueType.JSONString,
@@ -188,6 +198,42 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
             }),
         },
     ),
+    admins: createExistsFilter(
+        SQL.select()
+            .from(SQL.table('users'))
+            .where(
+                SQL.column('users', 'organizationId'),
+                SQL.column('organizations', 'id'),
+            )
+            .where(SQL.column('users', 'permissions'), SQLWhereSign.NotEqual, new SQLNull()),
+        {
+            ...baseSQLFilterCompilers,
+            name: createColumnFilter({
+                expression: new SQLConcat(
+                    SQL.coalesce(SQL.column('users', 'firstName'), new SQLScalar('')),
+                    new SQLScalar(' '),
+                    SQL.coalesce(SQL.column('users', 'lastName'), new SQLScalar('')),
+                ),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            firstName: createColumnFilter({
+                expression: SQL.column('users', 'firstName'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            lastName: createColumnFilter({
+                expression: SQL.column('users', 'lastName'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            email: createColumnFilter({
+                expression: SQL.column('users', 'email'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+        },
+    ),
     companies: createExistsFilter(
         /**
          * There is a bug in MySQL 8 that is fixed in 9.3

package/src/sql-sorters/organizations.ts

@@ -88,4 +88,26 @@ export const organizationSorters: SQLSortDefinitions<Organization> = {
             });
         },
     },
+    umbrellaOrganization: {
+        getValue(a) {
+            return a.meta.umbrellaOrganization;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('meta'), '$.value.umbrellaOrganization', 'CHAR'),
+                direction,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return a.createdAt;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
 };

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

@@ -1,237 +0,0 @@
-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,
-    });
-}