@stamhoofd/backend 2.108.0 → 2.110.0

package/src/endpoints/organization/dashboard/documents/PatchDocumentTemplatesEndpoint.test.ts

@@ -0,0 +1,282 @@
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { Endpoint, Request } from '@simonbackx/simple-endpoints';
+import { DocumentTemplate, DocumentTemplateFactory, Organization, OrganizationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, User, UserFactory } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { DocumentPrivateSettings, DocumentStatus, DocumentTemplateDefinition, DocumentTemplatePrivate, PermissionLevel, Permissions } from '@stamhoofd/structures';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { PatchDocumentTemplatesEndpoint } from './PatchDocumentTemplatesEndpoint.js';
+
+const baseUrl = `/organization/document-templates`;
+const endpoint = new PatchDocumentTemplatesEndpoint();
+type EndpointType = typeof endpoint;
+type Body = EndpointType extends Endpoint<any, any, infer B, any> ? B : never;
+
+describe('Endpoint.PatchDocumentTemplatesEndpoint', () => {
+    let period: RegistrationPeriod;
+    let organization: Organization;
+    let user: User;
+    let token: Token;
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        period = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1),
+            endDate: new Date(2023, 11, 31),
+        }).create();
+
+        organization = await new OrganizationFactory({ period })
+            .create();
+
+        user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+
+        token = await Token.createToken(user);
+    });
+
+    describe('put fiscal document', () => {
+        it('should throw if already has fiscal document in year', async () => {
+            // create existing fiscal document in same year
+            await new DocumentTemplateFactory({
+                organizationId: organization.id,
+                type: 'fiscal',
+                groups: [],
+                year: 2022,
+            }).create();
+
+            // create new fiscal document in same year
+            const arr: Body = new PatchableArray();
+            const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                organizationId: organization.id,
+                type: 'fiscal',
+                groups: [],
+                year: 2022,
+            }).createWithoutSave());
+
+            const newDocument = newDocumentModel.getPrivateStructure();
+            arr.addPut(newDocument);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+
+            await expect(testServer.test(endpoint, request))
+                .rejects
+                .toThrow(STExpect.errorWithCode('double_fiscal_document'));
+        });
+
+        it('should not throw if first fiscal document in year', async () => {
+            // delete existing docs from organization
+            await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+            const arr: Body = new PatchableArray();
+            const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                organizationId: organization.id,
+                type: 'fiscal',
+                groups: [],
+                year: 2022,
+            }).createWithoutSave());
+
+            const newDocument = newDocumentModel.getPrivateStructure();
+            arr.addPut(newDocument);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+
+            const result = await testServer.test(endpoint, request);
+
+            expect(result).toBeDefined();
+            expect(result.status).toBe(200);
+        });
+    });
+
+    describe('patch fiscal document', () => {
+        describe('change type to fiscal', () => {
+            it('should throw if already has fiscal document in year', async () => {
+                // create existing fiscal document in same year
+                await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create();
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in same year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'participation',
+                    groups: [],
+                    year: 2022,
+                }).create());
+
+                // change type to fiscal
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    privateSettings: DocumentPrivateSettings.patch({
+                        templateDefinition: DocumentTemplateDefinition.patch({
+                            type: 'fiscal',
+                        }),
+                    }),
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                await expect(testServer.test(endpoint, request))
+                    .rejects
+                    .toThrow(STExpect.errorWithCode('double_fiscal_document'));
+            });
+
+            it('should not throw if first fiscal document in year', async () => {
+                // delete existing docs from organization
+                await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in same year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'participation',
+                    groups: [],
+                    year: 2022,
+                }).create());
+
+                // change type to fiscal
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    privateSettings: DocumentPrivateSettings.patch({
+                        templateDefinition: DocumentTemplateDefinition.patch({
+                            type: 'fiscal',
+                        }),
+                    }),
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                const result = await testServer.test(endpoint, request);
+
+                expect(result).toBeDefined();
+                expect(result.status).toBe(200);
+            });
+        });
+
+        describe('change year', () => {
+            it('should throw if already has fiscal document in year', async () => {
+                // create existing fiscal document in same year
+                await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create();
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in other year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2021,
+                }).create());
+
+                // change year to same year as other existing document
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    year: 2022,
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                await expect(testServer.test(endpoint, request))
+                    .rejects
+                    .toThrow(STExpect.errorWithCode('double_fiscal_document'));
+            });
+
+            it('should not throw if first fiscal document in year', async () => {
+                // delete existing docs from organization
+                await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create new participation document in other year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2021,
+                }).create());
+
+                // change year to same year as other existing document
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    year: 2022,
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                const result = await testServer.test(endpoint, request);
+
+                expect(result).toBeDefined();
+                expect(result.status).toBe(200);
+            });
+        });
+
+        describe('do not change type or year of existing fiscal document', () => {
+            it('should not throw if multiple fiscal documents in year', async () => {
+                // delete existing docs from organization
+                await SQL.delete().from(SQL.table(DocumentTemplate.table)).where('organizationId', organization.id);
+
+                // create existing fiscal document in same year
+                await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create();
+
+                // create new fiscal document in same year
+                const arr: Body = new PatchableArray();
+
+                // create double fiscal document in same year
+                const newDocumentModel: DocumentTemplate = (await new DocumentTemplateFactory({
+                    organizationId: organization.id,
+                    type: 'fiscal',
+                    groups: [],
+                    year: 2022,
+                }).create());
+
+                // change status to published (do not change year or type)
+                arr.addPatch(DocumentTemplatePrivate.patch({
+                    id: newDocumentModel.id,
+                    status: DocumentStatus.Published,
+                }));
+
+                const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+                request.headers.authorization = 'Bearer ' + token.accessToken;
+
+                const result = await testServer.test(endpoint, request);
+
+                expect(result).toBeDefined();
+                expect(result.status).toBe(200);
+                expect(result.body.length).toBe(1);
+                expect(result.body[0].status).toBe(DocumentStatus.Published);
+            });
+        });
+    });
+});

package/src/endpoints/organization/dashboard/documents/{PatchDocumentTemplateEndpoint.ts → PatchDocumentTemplatesEndpoint.ts}

@@ -1,10 +1,11 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { DocumentTemplate, Token } from '@stamhoofd/models';
+import { DocumentTemplate } from '@stamhoofd/models';
 import { DocumentTemplatePrivate, PermissionLevel } from '@stamhoofd/structures';
 
-import { Context } from '../../../../helpers/Context';
+import { SQL, SQLWhereSign } from '@stamhoofd/sql';
+import { Context } from '../../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -15,7 +16,7 @@ type ResponseBody = DocumentTemplatePrivate[];
  * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
  */
 
-export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class PatchDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     bodyDecoder = new PatchableArrayDecoder(DocumentTemplatePrivate as Decoder<DocumentTemplatePrivate>, DocumentTemplatePrivate.patchType() as Decoder<AutoEncoderPatchType<DocumentTemplatePrivate>>, StringDecoder);
 
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -49,7 +50,19 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
             template.status = put.status;
             template.html = put.html;
             template.updatesEnabled = put.updatesEnabled;
+            template.year = put.year;
             template.organizationId = organization.id;
+
+            if (await this.doesYearAlreadyHaveFiscalDocument(template)) {
+                throw new SimpleError({
+                    code: 'double_fiscal_document',
+                    field: 'year',
+                    message: 'This year already has a fiscal document',
+                    human: $t('475f5f96-86bf-4124-a005-9904aaf72b37'),
+
+                });
+            }
+
             await template.save();
 
             // todo: Generate documents (maybe in background)
@@ -65,7 +78,14 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
                 throw Context.auth.notFoundOrNoAccess($t(`148bfab7-ca0e-4fac-8a0a-302ca7855fc8`));
             }
 
+            let shouldCheckIfAlreadyHasFiscalDocument = false;
+
             if (patch.privateSettings) {
+                const patchType = patch.privateSettings.templateDefinition?.type;
+
+                // only check if type has changed and new type is fiscal
+                shouldCheckIfAlreadyHasFiscalDocument = patchType !== undefined && template.privateSettings.templateDefinition.type !== patchType && patchType === 'fiscal';
+
                 template.privateSettings.patchOrPut(patch.privateSettings);
             }
 
@@ -85,6 +105,23 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
                 template.html = patch.html;
             }
 
+            if (patch.year) {
+                if (shouldCheckIfAlreadyHasFiscalDocument === false) {
+                    shouldCheckIfAlreadyHasFiscalDocument = template.year !== patch.year;
+                }
+
+                template.year = patch.year;
+            }
+
+            if (shouldCheckIfAlreadyHasFiscalDocument && await this.doesYearAlreadyHaveFiscalDocument(template)) {
+                throw new SimpleError({
+                    code: 'double_fiscal_document',
+                    field: 'year',
+                    message: 'This year already has a fiscal document',
+                    human: $t('475f5f96-86bf-4124-a005-9904aaf72b37'),
+                });
+            }
+
             await template.save();
 
             // Update documents
@@ -111,4 +148,20 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
             updatedTemplates,
         );
     }
+
+    private async doesYearAlreadyHaveFiscalDocument(template: DocumentTemplate) {
+        let query = SQL.select().from(SQL.table(DocumentTemplate.table))
+            .where(SQL.column('organizationId'), template.organizationId)
+            .where(SQL.column('year'), template.year)
+            .where(SQL.jsonExtract(SQL.column('privateSettings'), '$.value.templateDefinition.type'), 'fiscal');
+
+        // id is not set if put
+        if (template.id) {
+            query = query.where(SQL.column('id'), SQLWhereSign.NotEqual, template.id);
+        }
+
+        const result = await query.limit(1).count();
+
+        return result > 0;
+    }
 }

package/src/excel-loaders/members.ts

@@ -1,12 +1,12 @@
 import { XlsxBuiltInNumberFormat, XlsxTransformerColumn, XlsxTransformerSheet } from '@stamhoofd/excel-writer';
 import { Platform } from '@stamhoofd/models';
-import { ExcelExportType, Gender, GroupType, LimitedFilteredRequest, PlatformFamily, PlatformMember, Platform as PlatformStruct, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
+import { ExcelExportType, Gender, GroupType, LimitedFilteredRequest, MembershipStatus, PlatformFamily, PlatformMember, Platform as PlatformStruct, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
-import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint';
-import { GetMembersEndpoint } from '../endpoints/global/members/GetMembersEndpoint';
-import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures';
-import { Context } from '../helpers/Context';
-import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper';
+import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint.js';
+import { GetMembersEndpoint } from '../endpoints/global/members/GetMembersEndpoint.js';
+import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures.js';
+import { Context } from '../helpers/Context.js';
+import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper.js';
 
 export const baseMemberColumns: XlsxTransformerColumn<PlatformMember>[] = [
     {
@@ -150,6 +150,16 @@ export const baseMemberColumns: XlsxTransformerColumn<PlatformMember>[] = [
             value: object.details.nationalRegisterNumber?.toString() ?? '',
         }),
     },
+    {
+        id: 'membership',
+        name: $t(`c7d995f1-36a0-446e-9fcf-17ffb69f3f45`),
+        width: 20,
+        getValue: (member: PlatformMember) => {
+            return {
+                value: formatMembershipStatus(member.membershipStatus),
+            };
+        },
+    },
 
     ...XlsxTransformerColumnHelper.creatColumnsForParents(),
 
@@ -260,6 +270,35 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformMember> = {
                 };
             },
         },
+        {
+            id: 'outstandingBalance',
+            name: $t(`beb45452-dee7-4a7f-956c-e6db06aac20f`),
+            width: 30,
+            getValue: (v) => {
+                return {
+                    value: v.member.balances.reduce((sum, r) => sum + (r.amountOpen), 0) / 1_0000,
+                    style: {
+                        numberFormat: {
+                            id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                        },
+                    },
+                };
+            },
+
+        },
+        {
+            id: 'createdAt',
+            name: $t('c38e774e-e8ab-4549-b119-4eed380c626c'),
+            width: 20,
+            getValue: v => ({
+                value: v.member.createdAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
 
         // Registration records
         {
@@ -427,10 +466,25 @@ ExportToExcelEndpoint.loaders.set(ExcelExportType.Members, {
     ],
 });
 
-function formatGender(gender: Gender) {
+function formatGender(gender: Gender): string {
     switch (gender) {
         case Gender.Male: return $t(`f972abd4-de1e-484b-b7da-ad4c75d37808`);
         case Gender.Female: return $t(`e21f499d-1078-4044-be5d-6693d2636699`);
         default: return $t(`60f13ba4-c6c9-4388-9add-43a996bf6bee`);
     }
 }
+
+function formatMembershipStatus(status: MembershipStatus): string {
+    switch (status) {
+        case MembershipStatus.Trial:
+            return $t(`47c7c3c4-9246-40b7-b1e0-2cb408d5f79e`);
+        case MembershipStatus.Active:
+            return $t(`b56351e9-4847-4a0c-9eec-348d75c794c4`);
+        case MembershipStatus.Expiring:
+            return $t(`d9858110-37d9-4b4a-8bfb-d76b3cc5ef27`);
+        case MembershipStatus.Temporary:
+            return $t(`75e62d3c-f348-4104-8a1e-e11e6e7fbe32`);
+        case MembershipStatus.Inactive:
+            return $t(`1f8620fa-e8a5-4665-99c8-c1907a5b5768`);
+    }
+}

package/src/excel-loaders/registrations.ts

@@ -1,6 +1,6 @@
 import { XlsxBuiltInNumberFormat, XlsxTransformerSheet } from '@stamhoofd/excel-writer';
 import { Platform } from '@stamhoofd/models';
-import { ExcelExportType, LimitedFilteredRequest, PlatformMember, PlatformRegistration, Platform as PlatformStruct, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
+import { ExcelExportType, getGroupTypeName, LimitedFilteredRequest, PlatformMember, PlatformRegistration, Platform as PlatformStruct, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
 import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint.js';
 import { GetRegistrationsEndpoint } from '../endpoints/global/registration/GetRegistrationsEndpoint.js';
 import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures.js';
@@ -46,9 +46,41 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                 };
             },
         },
+        {
+            id: 'toPay',
+            width: 30,
+            name: $t(`3a97e6cb-012d-4007-9c54-49d3e5b72909`),
+            getValue: (registration: PlatformRegistration) => {
+                return {
+                    value: registration.balances.reduce((sum, r) => sum + (r.amountOpen + r.amountPending), 0) / 1_0000,
+                    style: {
+                        numberFormat: {
+                            id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                        },
+                    },
+                };
+            },
+
+        },
+        {
+            id: 'outstandingBalance',
+            name: $t(`beb45452-dee7-4a7f-956c-e6db06aac20f`),
+            width: 30,
+            getValue: (v) => {
+                return {
+                    value: v.member.member.balances.reduce((sum, r) => sum + (r.amountOpen), 0) / 1_0000,
+                    style: {
+                        numberFormat: {
+                            id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                        },
+                    },
+                };
+            },
+
+        },
         {
             id: 'registeredAt',
-            name: $t(`Inschrijvingsdatum`),
+            name: $t(`8bec8990-4632-40b0-93f3-f27a3f2ddbdb`),
             width: 20,
             getValue: (registration: PlatformRegistration) => ({
                 value: registration.registeredAt,
@@ -59,6 +91,45 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                 },
             }),
         },
+        {
+            id: 'startDate',
+            name: $t(`bbe0af99-b574-4719-a505-ca2285fa86e4`),
+            width: 20,
+            getValue: (registration: PlatformRegistration) => ({
+                value: registration.startDate,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'endDate',
+            name: $t(`aef10d71-39c4-4cdb-8252-5fd31781abd8`),
+            width: 20,
+            getValue: (registration: PlatformRegistration) => ({
+                value: registration.endDate,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'createdAt',
+            name: $t('63a86cdf-8a76-4e8c-9073-4f0b8970e808'),
+            width: 20,
+            getValue: (registration: PlatformRegistration) => ({
+                value: registration.member.member.createdAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
         {
             id: 'organization',
             name: $t('2f325358-6e2f-418c-9fea-31a14abbc17a'),
@@ -81,6 +152,46 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                 });
             },
         },
+        {
+            id: 'groupRegistration',
+            name: $t('7289b10e-a284-40ea-bc57-8287c6566a82'),
+            width: 40,
+            getValue: (registration: PlatformRegistration) => {
+                let value: string;
+
+                if (registration.payingOrganizationId) {
+                    const organization = registration.member.organizations.find(o => o.id === registration.payingOrganizationId);
+                    value = organization ? organization.name : $t(`bd1e59c8-3d4c-4097-ab35-0ce7b20d0e50`);
+                }
+                else {
+                    value = $t(`b8b730fb-f1a3-4c13-8ec4-0aebe08a1449`);
+                }
+
+                return ({
+                    value,
+                });
+            },
+        },
+        {
+            id: 'trialUntil',
+            name: $t(`1f2e9d09-717b-4c17-9bbe-dce3f3dcbff0`),
+            width: 40,
+            getValue: (registration: PlatformRegistration) => {
+                let value: Date | null = null;
+                if (registration.trialUntil && registration.trialUntil > new Date()) {
+                    value = new Date(registration.trialUntil.getTime());
+                }
+
+                return {
+                    value,
+                    style: {
+                        numberFormat: {
+                            id: XlsxBuiltInNumberFormat.DateSlash,
+                        },
+                    },
+                };
+            },
+        },
         // option menu
         {
             match(id) {
@@ -228,6 +339,16 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                 };
             },
         },
+        {
+            id: 'group.type',
+            name: $t('4fda497f-b2d8-43ef-b08c-a3e4e0b472b4'),
+            width: 20,
+            getValue: (registration: PlatformRegistration) => {
+                return {
+                    value: getGroupTypeName(registration.group.type),
+                };
+            },
+        },
     ],
 };
 

package/src/helpers/LimitedFilteredRequestHelper.ts

@@ -46,4 +46,28 @@ export class LimitedFilteredRequestHelper {
 
         return next;
     }
+
+    static fixInfiniteLoadingLoopWithTransform<R, T>({ request, results, sorters, transformer }: { request: LimitedFilteredRequest; results: R[]; sorters: SQLSortDefinitions<T>; transformer: (r: R) => T }): LimitedFilteredRequest | undefined {
+        let next: LimitedFilteredRequest | undefined;
+
+        if (results.length >= request.limit) {
+            const lastObject = transformer(results[results.length - 1]);
+            const nextFilter = getSortFilter(lastObject, sorters, request.sort);
+
+            next = new LimitedFilteredRequest({
+                filter: request.filter,
+                pageFilter: nextFilter,
+                sort: request.sort,
+                limit: request.limit,
+                search: request.search,
+            });
+
+            if (JSON.stringify(nextFilter) === JSON.stringify(request.pageFilter)) {
+                console.error('Found infinite loading loop for', request);
+                next = undefined;
+            }
+        }
+
+        return next;
+    }
 }

package/src/helpers/SQLTranslatedString.ts

@@ -0,0 +1,14 @@
+import { SQLColumnExpression, SQLExpression, SQLExpressionOptions, SQLQuery, SQLTranslatedStringHelper } from '@stamhoofd/sql';
+import { Language } from '@stamhoofd/structures';
+
+export class SQLTranslatedString implements SQLExpression {
+    private helper: SQLTranslatedStringHelper;
+
+    constructor(columnExpression: SQLColumnExpression, path: string) {
+        this.helper = new SQLTranslatedStringHelper(columnExpression, path, () => Language.English);
+    }
+
+    getSQL(options?: SQLExpressionOptions): SQLQuery {
+        return this.helper.getSQL(options);
+    }
+}