@stamhoofd/backend 2.107.3 → 2.109.0

package/src/excel-loaders/registrations.ts

@@ -1,12 +1,12 @@
 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 { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint';
-import { GetRegistrationsEndpoint } from '../endpoints/global/registration/GetRegistrationsEndpoint';
-import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures';
-import { Context } from '../helpers/Context';
-import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper';
-import { baseMemberColumns } from './members';
+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';
+import { Context } from '../helpers/Context.js';
+import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper.js';
+import { baseMemberColumns } from './members.js';
 
 // Assign to a typed variable to assure we have correct type checking in place
 const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
@@ -22,7 +22,7 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
             }),
         },
         {
-            id: 'price',
+            id: 'priceName',
             name: $t(`dcc53f25-f0e9-4e3e-9f4f-e8cfa4e88755`),
             width: 30,
             getValue: (registration: PlatformRegistration) => {
@@ -31,6 +31,167 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                 };
             },
         },
+        {
+            id: 'price',
+            name: $t(`dcc53f25-f0e9-4e3e-9f4f-e8cfa4e88755`),
+            width: 30,
+            getValue: (registration: PlatformRegistration) => {
+                return {
+                    value: registration.balances.reduce((sum, r) => sum + (r.amountOpen + r.amountPaid + r.amountPending), 0) / 1_0000,
+                    style: {
+                        numberFormat: {
+                            id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                        },
+                    },
+                };
+            },
+        },
+        {
+            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(`8bec8990-4632-40b0-93f3-f27a3f2ddbdb`),
+            width: 20,
+            getValue: (registration: PlatformRegistration) => ({
+                value: registration.registeredAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
+        {
+            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'),
+            width: 40,
+            getValue: (registration: PlatformRegistration) => {
+                const organization = registration.member.family.getOrganization(registration.group.organizationId);
+                return ({
+                    value: organization?.name ?? $t('836c2cd3-32a3-43f2-b09c-600170fcd9cb'),
+                });
+            },
+        },
+        {
+            id: 'uri',
+            name: $t('9d283cbb-7ba2-4a16-88ec-ff0c19f39674'),
+            width: 40,
+            getValue: (registration: PlatformRegistration) => {
+                const organization = registration.member.family.getOrganization(registration.group.organizationId);
+                return ({
+                    value: organization?.uri ?? $t('836c2cd3-32a3-43f2-b09c-600170fcd9cb'),
+                });
+            },
+        },
+        {
+            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) {
@@ -71,7 +232,7 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                                             },
                                         }
                                     : {},
-                                value: options.length === 1 && returnAmount ? options[0].amount : options.map(option => returnAmount ? option.amount : option).join(', '),
+                                value: options.map(option => returnAmount ? option.amount : option.option.name).join(', '),
                             };
                         },
                     }];
@@ -178,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/MemberCharger.ts

@@ -3,17 +3,29 @@ import { BalanceItemType, MemberWithRegistrationsBlob } from '@stamhoofd/structu
 
 export class MemberCharger {
     static async chargeMany({ chargingOrganizationId, membersToCharge, price, amount, description, dueAt, createdAt }: { chargingOrganizationId: string; membersToCharge: MemberWithRegistrationsBlob[]; price: number; amount?: number; description: string; dueAt: Date | null; createdAt: Date | null }) {
-        const balanceItems = membersToCharge.map(memberBeingCharged => MemberCharger.createBalanceItem({
+        await Promise.all(membersToCharge.map(memberToCharge => MemberCharger.charge({
             price,
             amount,
             description,
             chargingOrganizationId,
-            memberBeingCharged,
+            memberToCharge,
             dueAt,
             createdAt,
-        }));
+        })));
+    }
+
+    static async charge({ chargingOrganizationId, memberToCharge, price, amount, description, dueAt, createdAt }: { chargingOrganizationId: string; memberToCharge: MemberWithRegistrationsBlob; price: number; amount?: number; description: string; dueAt: Date | null; createdAt: Date | null }) {
+        const balanceItem = MemberCharger.createBalanceItem({
+            price,
+            amount,
+            description,
+            chargingOrganizationId,
+            memberBeingCharged: memberToCharge,
+            dueAt,
+            createdAt,
+        });
 
-        await Promise.all(balanceItems.map(balanceItem => balanceItem.save()));
+        await balanceItem.save();
     }
 
     private static createBalanceItem({ price, amount, description, chargingOrganizationId, memberBeingCharged, dueAt, createdAt }: { price: number; amount?: number; description: string; chargingOrganizationId: string; memberBeingCharged: MemberWithRegistrationsBlob; dueAt: Date | null; createdAt: Date | null }): BalanceItem {

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);
+    }
+}

package/src/helpers/TagHelper.test.ts

@@ -1,5 +1,5 @@
 import { OrganizationTag } from '@stamhoofd/structures';
-import { TagHelper } from './TagHelper';
+import { TagHelper } from './TagHelper.js';
 
 // todo: move tests for methods of shared package to shared package
 describe('TagHelper', () => {
@@ -123,13 +123,13 @@ describe('TagHelper', () => {
 
             // assert
             expect(result).toHaveLength(6);
-            expect(result).toInclude('id5');
-            expect(result).toInclude('id3');
-            expect(result).toInclude('id4');
-            expect(result).toInclude('id6');
-            expect(result).toInclude('id7');
-            expect(result).toInclude('id0');
-            expect(result).not.toInclude('unknownTagId');
+            expect(result).toContain('id5');
+            expect(result).toContain('id3');
+            expect(result).toContain('id4');
+            expect(result).toContain('id6');
+            expect(result).toContain('id7');
+            expect(result).toContain('id0');
+            expect(result).not.toContain('unknownTagId');
         });
     });
 
@@ -199,7 +199,7 @@ describe('TagHelper', () => {
             // assert
             expect(tag5.childTags).toHaveLength(0);
             expect(tag7.childTags).toHaveLength(3);
-            expect(tag7.childTags).not.toInclude('doesNotExist1');
+            expect(tag7.childTags).not.toContain('doesNotExist1');
         });
 
         it('should return array of tags in the correct order', () => {

package/src/helpers/fetchToAsyncIterator.ts

@@ -1,5 +1,5 @@
 import { IPaginatedResponse, LimitedFilteredRequest } from '@stamhoofd/structures';
-import { FileSignService } from '../services/FileSignService';
+import { FileSignService } from '../services/FileSignService.js';
 
 export function fetchToAsyncIterator<T>(
     initialFilter: LimitedFilteredRequest,

package/src/helpers/outstandingBalanceJoin.ts

@@ -0,0 +1,49 @@
+import { CachedBalance, Registration } from '@stamhoofd/models';
+import { SQL, SQLAlias, SQLCalculation, SQLNamedExpression, SQLPlusSign, SQLSelectAs, SQLSum } from '@stamhoofd/sql';
+
+export const memberCachedBalanceForOrganizationJoin = SQL.leftJoin(
+    SQL.select('objectId', 'organizationId',
+        new SQLSelectAs(
+            new SQLSum(
+                SQL.column('amountOpen'),
+            ),
+            new SQLAlias('amountOpen'),
+        ),
+    )
+        .from(CachedBalance.table)
+        .where(SQL.column(CachedBalance.table, 'objectType'), 'member')
+        .groupBy(SQL.column(CachedBalance.table, 'objectId'), SQL.column(CachedBalance.table, 'organizationId')).as('memberCachedBalance') as SQLNamedExpression, 'memberCachedBalance',
+)
+    .where(SQL.column('objectId'), SQL.column(Registration.table, 'memberId'))
+    .andWhere(SQL.column('organizationId'), SQL.column(Registration.table, 'organizationId'));
+
+export const registrationCachedBalanceJoin = SQL.leftJoin(
+    SQL.select('objectId', 'organizationId',
+        new SQLSelectAs(
+            new SQLSum(
+                new SQLCalculation(
+                    SQL.column('amountOpen'),
+                    new SQLPlusSign(),
+                    SQL.column('amountPending'),
+                ),
+            ),
+            new SQLAlias('toPay'),
+        ),
+        new SQLSelectAs(
+            new SQLSum(
+                new SQLCalculation(
+                    SQL.column('amountOpen'),
+                    new SQLPlusSign(),
+                    SQL.column('amountPaid'),
+                    new SQLPlusSign(),
+                    SQL.column('amountPending'),
+                ),
+            ),
+            new SQLAlias('price'),
+        ),
+    )
+        .from(CachedBalance.table)
+        .where(SQL.column(CachedBalance.table, 'objectType'), 'registration')
+        .groupBy(SQL.column(CachedBalance.table, 'objectId'), SQL.column(CachedBalance.table, 'organizationId')).as('registrationCachedBalance') as SQLNamedExpression, 'registrationCachedBalance',
+)
+    .where(SQL.column('objectId'), SQL.column(Registration.table, 'id'));

package/src/seeds/1765896674-document-update-year.test.ts

@@ -0,0 +1,179 @@
+import { DocumentTemplate, DocumentTemplateFactory, GroupFactory, OrganizationFactory, RegistrationPeriod, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { migrateDocumentYears } from './1765896674-document-update-year.js';
+
+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: new Date(2021, 0, 1),
+                endDate: new Date(2021, 11, 31),
+                organization,
+            }).create();
+
+            organization.periodId = period1.id;
+            await organization.save();
+
+            const period2 = await new RegistrationPeriodFactory({
+                startDate: new Date(2019, 0, 1),
+                endDate: new Date(2019, 11, 31),
+                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(new Date(2021, 0, 1), new Date(2021, 11, 31), period1);
+            const group2 = await createGroup(new Date(2021, 0, 1), new Date(2021, 11, 31), period1);
+            const group3 = await createGroup(new Date(2019, 0, 1), new Date(2019, 11, 31), period2);
+
+            // document created in 2021
+            const document1 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document1.createdAt = new Date(2022, 0, 1);
+            await document1.save();
+
+            // document created in 2020
+            const document2 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document2.createdAt = new Date(2021, 0, 1);
+            await document2.save();
+
+            // document created in 2019
+            const document3 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document3.createdAt = new Date(2020, 0, 1);
+            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(2021);
+        });
+
+        test('groups overlapping period', async () => {
+            const organization = await new OrganizationFactory({
+            }).create();
+
+            const period1 = await new RegistrationPeriodFactory({
+                startDate: new Date(2021, 0, 1),
+                endDate: new Date(2021, 11, 31),
+                organization,
+            }).create();
+
+            organization.periodId = period1.id;
+            await organization.save();
+
+            const period2 = await new RegistrationPeriodFactory({
+                startDate: new Date(2020, 0, 1),
+                endDate: new Date(2020, 11, 31),
+                organization,
+            }).create();
+
+            const period3 = await new RegistrationPeriodFactory({
+                startDate: new Date(2019, 0, 1),
+                endDate: new Date(2019, 11, 31),
+                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(new Date(2020, 6, 1), new Date(2021, 5, 30), period1);
+            const group2 = await createGroup(new Date(2020, 7, 5), new Date(2021, 4, 3), period1);
+            const group3 = await createGroup(new Date(2018, 5, 1), new Date(2019, 10, 14), period3);
+
+            // document created in 2021
+            const document1 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document1.createdAt = new Date(2022, 0, 1);
+            await document1.save();
+
+            // document created in 2020
+            const document2 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document2.createdAt = new Date(2021, 0, 1);
+            await document2.save();
+
+            // document created in 2019
+            const document3 = await new DocumentTemplateFactory({
+                groups: [group1, group2, group3],
+                year: 0,
+            }).create();
+
+            document3.createdAt = new Date(2020, 0, 1);
+            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);
+            // should take 2020 because document was created in 2020
+            expect(updatedDocument2?.year).toBe(2020);
+            expect(updatedDocument3?.year).toBe(2021);
+        });
+    });
+
+    test('no groups should use year before creation', async () => {
+        // create document
+        const document = await new DocumentTemplateFactory({
+            groups: [],
+            year: 0,
+        }).create();
+
+        document.createdAt = new Date(2025, 0, 1);
+        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);
+    });
+});

package/src/seeds/1765896674-document-update-year.ts

@@ -0,0 +1,75 @@
+import { Migration } from '@simonbackx/simple-database';
+import { DocumentTemplate, Group } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+
+export async function migrateDocumentYears() {
+    let c = 0;
+    const totalDocuments = await DocumentTemplate.select().count();
+
+    for await (const document of DocumentTemplate.select().all()) {
+        c++;
+        if (c % 1000 === 0) {
+            console.log('Processed', c, 'of', totalDocuments);
+        }
+
+        // check
+        if (!document.year) {
+            // by default use the year before creation
+            let year: number = document.createdAt.getFullYear() - 1;
+
+            const groups = document.privateSettings.groups;
+            const groupIds: string[] = [...new Set(groups.map(g => g.group.id))];
+
+            if (groupIds.length > 0) {
+                const query = Group.select().where(SQL.where('id', groupIds));
+                const groupModels = await query.fetch();
+
+                // count the number of groups per year
+                const yearMap = new Map<number, number>();
+
+                for (const group of groupModels) {
+                    const startYear = group.settings.startDate.getFullYear();
+                    const endYear = group.settings.endDate.getFullYear();
+
+                    for (let y = startYear; y <= endYear; y++) {
+                        const count = yearMap.get(y) ?? 0;
+                        yearMap.set(y, count + 1);
+                    }
+                }
+
+                // find the year with the highest count
+                let topYear = 0;
+                let topCount = 0;
+                const yearBeforeCreation = document.createdAt.getFullYear() - 1;
+
+                for (const [year, count] of yearMap) {
+                    if (count > topCount
+                        // prefer the year before creation
+                        || (count === topCount && year === yearBeforeCreation)
+                        // next prefer the most recent year
+                        || (topYear !== yearBeforeCreation && year > topYear)
+                    ) {
+                        topYear = year;
+                        topCount = count;
+                    }
+                }
+
+                // use the year with the highest count
+                if (topCount > 0) {
+                    year = topYear;
+                }
+            }
+
+            document.year = year;
+            await document.save();
+        }
+    }
+};
+
+export default new Migration(async () => {
+    process.stdout.write('\n');
+    console.log('Start updating year of document templates.');
+    await migrateDocumentYears();
+
+    return Promise.resolve();
+});