@stamhoofd/backend 2.79.7 → 2.80.0

package/src/endpoints/global/events/PatchEventNotificationsEndpoint.ts

@@ -81,7 +81,7 @@ export class PatchEventNotificationsEndpoint extends Endpoint<Params, Query, Bod
                 if (index === 0) {
                     notification.startDate = model.startDate;
                     notification.endDate = model.endDate;
-                    const period = await RegistrationPeriod.getByDate(event.startDate);
+                    const period = await RegistrationPeriod.getByDate(model.startDate);
 
                     if (!period) {
                         throw new SimpleError({
@@ -141,7 +141,7 @@ export class PatchEventNotificationsEndpoint extends Endpoint<Params, Query, Bod
             if (
                 notification.status === EventNotificationStatus.Pending
                 || notification.status === EventNotificationStatus.Accepted
-                || (patch.status && patch.status !== EventNotificationStatus.Pending)
+                || (patch.status && (patch.status !== EventNotificationStatus.Pending || (notification.status !== EventNotificationStatus.Draft && notification.status !== EventNotificationStatus.Rejected && notification.status !== EventNotificationStatus.PartiallyAccepted)))
                 || patch.feedbackText !== undefined
             ) {
                 requiredPermissionLevel = PermissionLevel.Full;
@@ -187,6 +187,7 @@ export class PatchEventNotificationsEndpoint extends Endpoint<Params, Query, Bod
                     // Only allowed if complete
                     await this.validateAnswers(notification);
                 }
+                const previousStatus = notification.status;
                 notification.status = patch.status; // checks already happened
                 if (patch.status === EventNotificationStatus.Pending) {
                     notification.submittedBy = user.id;
@@ -198,15 +199,30 @@ export class PatchEventNotificationsEndpoint extends Endpoint<Params, Query, Bod
                     await EventNotificationService.sendReviewerEmail(EmailTemplateType.EventNotificationSubmittedReviewer, notification);
                 }
 
-                if (patch.status === EventNotificationStatus.Accepted) {
+                if ((patch.status === EventNotificationStatus.Accepted) && previousStatus !== EventNotificationStatus.Accepted) {
+                    // Make sure the accepted record answers stay in sync
+                    notification.acceptedRecordAnswers = notification.recordAnswers;
+
                     await EventNotificationService.sendSubmitterEmail(EmailTemplateType.EventNotificationAccepted, notification);
                 }
 
+                if ((patch.status === EventNotificationStatus.PartiallyAccepted) && previousStatus !== EventNotificationStatus.Accepted && previousStatus !== EventNotificationStatus.PartiallyAccepted) {
+                    // Make sure the accepted record answers stay in sync
+                    notification.acceptedRecordAnswers = notification.recordAnswers;
+
+                    await EventNotificationService.sendSubmitterEmail(EmailTemplateType.EventNotificationPartiallyAccepted, notification);
+                }
+
                 if (patch.status === EventNotificationStatus.Rejected) {
                     await EventNotificationService.sendSubmitterEmail(EmailTemplateType.EventNotificationRejected, notification);
                 }
             }
 
+            if (notification.status === EventNotificationStatus.Accepted) {
+                // Make sure the accepted record answers stay in sync (only for full accepted, since these cannot be changed)
+                notification.acceptedRecordAnswers = notification.recordAnswers;
+            }
+
             await notification.save();
             notifications.push(notification);
         }

package/src/endpoints/global/members/GetMembersEndpoint.ts

@@ -2,7 +2,7 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Member, Platform } from '@stamhoofd/models';
-import { SQL, compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { SQL, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, Country, CountryCode, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 import { DataValidator } from '@stamhoofd/utility';
 
@@ -37,12 +37,12 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         return [false];
     }
 
-    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest, permissionLevel: PermissionLevel = PermissionLevel.Read) {
         const organization = Context.organization;
         let scopeFilter: StamhoofdFilter | undefined = undefined;
 
         if (!organization && !Context.auth.canAccessAllPlatformMembers()) {
-            const tags = Context.auth.getPlatformAccessibleOrganizationTags(PermissionLevel.Read);
+            const tags = Context.auth.getPlatformAccessibleOrganizationTags(permissionLevel);
             if (tags !== 'all' && tags.length === 0) {
                 throw Context.auth.error();
             }
@@ -68,14 +68,14 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
 
         if (organization && !Context.auth.canAccessAllPlatformMembers()) {
             // Add organization scope filter
-            const groups = await Context.auth.getAccessibleGroups(organization.id);
+            const groups = await Context.auth.getAccessibleGroups(organization.id, permissionLevel);
 
             if (groups.length === 0) {
                 throw Context.auth.error();
             }
 
             if (groups === 'all') {
-                if (await Context.auth.hasFullAccess(organization.id)) {
+                if (await Context.auth.hasFullAccess(organization.id, permissionLevel)) {
                     // Can access full history for now
                     scopeFilter = {
                         registrations: {
@@ -168,7 +168,7 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             }
 
             // Is lidnummer?
-            if (!searchFilter && (q.search.match(/^[0-9]{4}-[0-9]{6}-[0-9]{1,2}$/) || q.search.match(/^[0-9]{10}$/))) {
+            if (!searchFilter && (q.search.match(/^[0-9]{4}-[0-9]{6}-[0-9]{1,2}$/) || q.search.match(/^[0-9]{9,10}$/))) {
                 searchFilter = {
                     memberNumber: {
                         $eq: q.search,
@@ -233,8 +233,8 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         return query;
     }
 
-    static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = await GetMembersEndpoint.buildQuery(requestQuery);
+    static async buildData(requestQuery: LimitedFilteredRequest, permissionLevel = PermissionLevel.Read) {
+        const query = await GetMembersEndpoint.buildQuery(requestQuery, permissionLevel);
         let data: SQLResultNamespacedRow[];
 
         try {
@@ -263,7 +263,7 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         const members = memberIds.map(id => _members.find(m => m.id === id)!);
 
         for (const member of members) {
-            if (!await Context.auth.canAccessMember(member, PermissionLevel.Read)) {
+            if (!await Context.auth.canAccessMember(member, permissionLevel)) {
                 throw Context.auth.error();
             }
         }

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.test.ts

@@ -1,5 +1,5 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import { OrganizationFactory } from '@stamhoofd/models';
+import { Organization, OrganizationFactory } from '@stamhoofd/models';
 import { v4 as uuidv4 } from 'uuid';
 
 import { testServer } from '../../../../tests/helpers/TestServer';
@@ -9,6 +9,10 @@ describe('Endpoint.SearchOrganization', () => {
     // Test endpoint
     const endpoint = new SearchOrganizationEndpoint();
 
+    afterEach(async () => {
+        await Organization.delete();
+    });
+
     test('Search for a given organization using exact search', async () => {
         const organization = await new OrganizationFactory({
             name: (uuidv4()).replace(/-/g, ''),
@@ -51,4 +55,184 @@ describe('Endpoint.SearchOrganization', () => {
         expect(response.status).toEqual(200);
         expect(response.body.map(o => o.id).sort()).toEqual(organizations.map(o => o.id).sort());
     });
+
+    test('Search organization by name using word should return best match first', async () => {
+        const name = 'WAT?';
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization ' + (i + 1),
+                city: 'Waterloo',
+            }).create();
+        }
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization 2 ' + (i + 1),
+                city: 'Wats',
+            }).create();
+        }
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'De Watten ' + (i + 1),
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name,
+        }).create();
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'De Watten 2 ' + (i + 1),
+            }).create();
+        }
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query: name,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(9);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using sentence should return best match first', async () => {
+        const query = 'Spaghetti Vreters';
+
+        for (const name of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'De Spaghetti Vretersschool']) {
+            await new OrganizationFactory({
+                name,
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(6);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using word should return organization with searchindex that starts with query first if limit reached', async () => {
+        const query = 'Gent';
+
+        for (let i = 0; i < 10; i++) {
+            await new OrganizationFactory({
+                name: 'Some other Gent organization ' + (i + 1),
+                city: 'Gent',
+            }).create();
+        }
+
+        for (let i = 0; i < 5; i++) {
+            await new OrganizationFactory({
+                name: 'De Gentenaars ' + (i + 1),
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'Gent',
+        }).create();
+
+        for (let i = 0; i < 3; i++) {
+            await new OrganizationFactory({
+                name: 'De Gentenaars 2 ' + (i + 1),
+            }).create();
+        }
+
+        for (let i = 0; i < 10; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization 2 ' + (i + 1),
+                city: 'Gent',
+            }).create();
+        }
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(15);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using sentence should return organization with name that starts with query first if limit reached', async () => {
+        const query = 'De Spaghetti Vreters';
+
+        // without the where like (if the limit is reached), 'Spaghetti Vreters Spaghetti Vreters' would come first ('De' is a stopword)
+        for (const name of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'Spaghetti Vreters', 'Spaghetti Vreters Spaghetti Vreters', 'De Spaghetti Vretersschool', 'Spaghetti 2', 'Spaghetti 3', 'Spaghetti 4', 'Spaghetti 5', 'Spaghetti 6', 'Spaghetti 7', 'Spaghetti 8', 'Spaghetti 9', 'Spaghetti 10']) {
+            await new OrganizationFactory({
+                name,
+            }).create();
+        }
+
+        let i = 1;
+        for (const city of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'De Spaghetti Vretersschool']) {
+            await new OrganizationFactory({
+                name: 'name ' + i,
+                city,
+            }).create();
+            i = i + 1;
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(15);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name and city should return organization that matches city and name first', async () => {
+        const query = 'De Spaghetti Vreters Gent';
+
+        for (let i = 0; i < 5; i++) {
+            await new OrganizationFactory({
+                name: 'De Spaghetti Vreters ' + (i + 1),
+                city: 'Wetteren',
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters 16',
+            city: 'Gent',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(6);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
 });

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.ts

@@ -1,6 +1,7 @@
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Organization } from '@stamhoofd/models';
+import { scalarToSQLExpression, SQL, SQLMatch, SQLWhere, SQLWhereLike } from '@stamhoofd/sql';
 import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 
@@ -32,28 +33,45 @@ export class SearchOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         // Escape query
-        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '');
-        if (query.length == 0) {
+        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '').trim();
+        if (query.length === 0) {
             // Do not try searching...
             return new Response([]);
         }
 
-        const match = {
-            sign: 'MATCH',
-            value: query + '*', // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
-            mode: 'BOOLEAN',
-        };
-
-        // We had to add an order by in the query to fix the limit. MySQL doesn't want to limit the results correctly if we don't explicitly sort the results on their relevance
-        const organizations = await Organization.where({ searchIndex: match, active: 1 }, {
-            limit: 15,
-            sort: [
-                {
-                    column: { searchIndex: match },
-                    direction: 'DESC',
-                },
-            ],
-        });
+        let matchValue: string;
+
+        if (query.includes(' ')) {
+            // give higher relevance if the searchindex includes the exact sentence
+            // give lower relevance if the last word is not a complete match
+            matchValue = `>("${query}") (${query}) <(${query}*)`;
+        }
+        else {
+            // give higher relevance if the searchindex includes the exact word
+            matchValue = `>${query} ${query}*`;
+        }
+
+        const limit = 15;
+
+        const whereMatch: SQLWhere = new SQLMatch(SQL.column(Organization.table, 'searchIndex'), scalarToSQLExpression(matchValue));
+
+        let organizations = await Organization.select()
+            .where(whereMatch)
+            .orderBy(whereMatch, 'DESC')
+            .limit(limit).fetch();
+
+        // if the limit is reached it is possible that organizations where the name starts with the query are missing -> fetch them and add them at the start
+        if (organizations.length === limit) {
+            const organizationsStartingWith = await Organization.select()
+                .where(new SQLWhereLike(SQL.column(Organization.table, 'name'), scalarToSQLExpression(`${query}%`)))
+                // order by relevance
+                .orderBy(whereMatch, 'DESC')
+                .limit(limit).fetch();
+
+            const organizationsStartingWithIds = new Set(organizationsStartingWith.map(o => o.id));
+
+            organizations = organizationsStartingWith.concat(organizations.filter(o => !organizationsStartingWithIds.has(o.id)));
+        }
 
         return new Response(await Promise.all(organizations.map(o => AuthenticatedStructures.organization(o))));
     }

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -352,6 +352,15 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                     });
                 }
 
+                const maximumStart = 1000 * 60 * 60 * 24 * 31 * 2; // 2 months in advance
+                if (period.startDate > new Date(Date.now() + maximumStart)) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'Het werkjaar die je wilt instellen is nog niet gestart',
+                        field: 'period',
+                    });
+                }
+
                 organization.periodId = period.id;
                 shouldUpdateSetupSteps = true;
             }

package/src/endpoints/organization/dashboard/organization/SetOrganizationDomainEndpoint.ts

@@ -133,9 +133,7 @@ export class SetOrganizationDomainEndpoint extends Endpoint<Params, Query, Body,
                         value: STAMHOOFD.domains.registrationCname + '.',
                     }));
                 }
-            }
 
-            if (request.body.mailDomain !== null) {
                 let priv: string;
                 let pub: string;
 
@@ -158,9 +156,18 @@ export class SetOrganizationDomainEndpoint extends Endpoint<Params, Query, Body,
                 // DKIM records
                 organization.privateMeta.dnsRecords.push(DNSRecord.create({
                     type: DNSRecordType.TXT,
-                    name: 'stamhoofd._domainkey.' + request.body.mailDomain + '.',
+                    name: Formatter.slug(STAMHOOFD.platformName) + '._domainkey.' + organization.privateMeta.pendingMailDomain + '.',
                     value: 'v=DKIM1; k=rsa; p=' + pub + '',
                 }));
+
+                // DMARC records
+                organization.privateMeta.dnsRecords.push(DNSRecord.create({
+                    type: DNSRecordType.TXT,
+                    name: '_dmarc.' + organization.privateMeta.pendingMailDomain + '.',
+                    value: 'v=DMARC1; p=quarantine; pct=100; sp=quarantine; aspf=r; adkim=r;',
+                    description: 'Opgelet met het instellen van deze DMARC-record voor je domeinnaam. Mogelijks bestaat er al een record met deze naam, voeg deze dan zeker niet dubbel toe en behoud best de huidige waarde (wel zou aspf en adkim op r moeten staan). De waarde die we voorstellen zorgt voor een sterke beveiliging, maar kan mogelijks problemen veroorzaken als je andere diensten gebruikt die op een onveilige manier emails versturen (zonder DKIM of SPF).',
+                    optional: true,
+                }));
             }
             else {
                 if (oldMailDomain) {

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

@@ -280,6 +280,15 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             });
         }
 
+        const maximumStart = 1000 * 60 * 60 * 24 * 31 * 2; // 2 months in advance
+        if (period.startDate > new Date(Date.now() + maximumStart)) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Het werkjaar die je wilt instellen is nog niet gestart',
+                field: 'period',
+            });
+        }
+
         const organizationPeriod = new OrganizationRegistrationPeriod();
         organizationPeriod.id = struct.id;
         organizationPeriod.organizationId = organization.id;

package/src/helpers/AdminPermissionChecker.ts

@@ -1,10 +1,10 @@
 import { AutoEncoderPatchType, PatchMap } from '@simonbackx/simple-encoding';
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import { BalanceItem, CachedBalance, Document, EmailTemplate, Event, EventNotification, Group, Member, MemberPlatformMembership, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, User, Webshop } from '@stamhoofd/models';
-import { AccessRight, EventPermissionChecker, FinancialSupportSettings, GroupCategory, GroupStatus, GroupType, MemberWithRegistrationsBlob, PermissionLevel, PermissionsResourceType, Platform as PlatformStruct, RecordCategory, RecordSettings } from '@stamhoofd/structures';
+import { AccessRight, EventPermissionChecker, FinancialSupportSettings, GroupCategory, GroupStatus, GroupType, MemberWithRegistrationsBlob, PermissionLevel, PermissionsResourceType, Platform as PlatformStruct, RecordSettings } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
-import { addTemporaryMemberAccess, hasTemporaryMemberAccess } from './TemporaryMemberAccess';
 import { MemberRecordStore } from '../services/MemberRecordStore';
+import { addTemporaryMemberAccess, hasTemporaryMemberAccess } from './TemporaryMemberAccess';
 
 /**
  * One class with all the responsabilities of checking permissions to each resource in the system by a given user, possibly in an organization context.
@@ -1091,7 +1091,7 @@ export class AdminPermissionChecker {
     }
 
     async getAccessibleGroups(organizationId: string, level: PermissionLevel = PermissionLevel.Read): Promise<string[] | 'all'> {
-        if (await this.hasFullAccess(organizationId)) {
+        if (await this.hasFullAccess(organizationId, level)) {
             return 'all';
         }
 

package/src/helpers/ForwardHandler.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 
 import { Email, EmailAddress, EmailInterface, EmailInterfaceRecipient } from '@stamhoofd/email';
-import { Organization } from '@stamhoofd/models';
+import { Organization, Platform } from '@stamhoofd/models';
 import { Formatter } from '@stamhoofd/utility';
 import { simpleParser } from 'mailparser';
 
@@ -66,7 +66,8 @@ export class ForwardHandler {
         // Send a new e-mail
         let defaultEmail: EmailInterfaceRecipient[] = [Email.getWebmasterToEmail()];
         let organizationEmails: EmailInterfaceRecipient[] = [];
-        const extraDescription = 'Dit bericht werd verstuurd naar ' + email + ', en werd automatisch doorgestuurd naar alle beheerders. Stel in Stamhoofd de e-mailadressen in om ervoor te zorgen dat antwoorden naar een specifiek e-mailadres worden verstuurd.';
+        const platform = await Platform.getShared();
+        const extraDescription = 'Dit bericht werd verstuurd naar ' + email + ', en werd automatisch doorgestuurd naar alle beheerders. Stel in ' + platform.config.name + ' de e-mailadressen in om ervoor te zorgen dat antwoorden naar een specifiek e-mailadres worden verstuurd.';
 
         function doBounce() {
             if (!from) {

package/src/helpers/MemberCharger.ts

@@ -0,0 +1,39 @@
+import { BalanceItem } from '@stamhoofd/models';
+import { BalanceItemType, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+import { BalanceItemService } from '../services/BalanceItemService';
+
+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({
+            price,
+            amount,
+            description,
+            chargingOrganizationId,
+            memberBeingCharged,
+            dueAt,
+            createdAt,
+        }));
+
+        await Promise.all(balanceItems.map(balanceItem => balanceItem.save()));
+        await BalanceItem.updateOutstanding(balanceItems);
+
+        // Reallocate
+        await BalanceItemService.reallocate(balanceItems, chargingOrganizationId);
+    }
+
+    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 {
+        const balanceItem = new BalanceItem();
+        balanceItem.unitPrice = price;
+        balanceItem.amount = amount ?? 1;
+        balanceItem.description = description;
+        balanceItem.type = BalanceItemType.Other;
+        balanceItem.memberId = memberBeingCharged.id;
+        balanceItem.organizationId = chargingOrganizationId;
+        balanceItem.dueAt = dueAt;
+        if (createdAt !== null) {
+            balanceItem.createdAt = createdAt;
+        }
+
+        return balanceItem;
+    }
+}

package/src/helpers/OrganizationCharger.ts

@@ -1,32 +1,17 @@
-import { SimpleError } from '@simonbackx/simple-errors';
-import { BalanceItem, Platform } from '@stamhoofd/models';
+import { BalanceItem } from '@stamhoofd/models';
 import { BalanceItemType, Organization as OrganizationStruct } from '@stamhoofd/structures';
 import { BalanceItemService } from '../services/BalanceItemService';
 
 export class OrganizationCharger {
-    static async chargeFromPlatform(args: { organizationsToCharge: OrganizationStruct[]; price: number; amount?: number; description: string }) {
-        const platform = await Platform.getShared();
-
-        const chargeVia = platform.membershipOrganizationId;
-
-        if (!chargeVia) {
-            throw new SimpleError({
-                code: 'missing_membership_organization',
-                message: 'Missing membershipOrganizationId',
-                human: 'Er is geen lokale groep verantwoordelijk voor de aanrekening van aansluitingen geconfigureerd',
-            });
-        }
-
-        await OrganizationCharger.chargeMany({ chargingOrganizationId: chargeVia, ...args });
-    }
-
-    static async chargeMany({ chargingOrganizationId, organizationsToCharge, price, amount, description }: { chargingOrganizationId: string; organizationsToCharge: OrganizationStruct[]; price: number; amount?: number; description: string }) {
+    static async chargeMany({ chargingOrganizationId, organizationsToCharge, price, amount, description, dueAt, createdAt }: { chargingOrganizationId: string; organizationsToCharge: OrganizationStruct[]; price: number; amount?: number; description: string; dueAt: Date | null; createdAt: Date | null }) {
         const balanceItems = organizationsToCharge.map(organizationBeingCharged => OrganizationCharger.createBalanceItem({
             price,
             amount,
             description,
             chargingOrganizationId,
             organizationBeingCharged,
+            dueAt,
+            createdAt,
         }));
 
         await Promise.all(balanceItems.map(balanceItem => balanceItem.save()));
@@ -36,7 +21,7 @@ export class OrganizationCharger {
         await BalanceItemService.reallocate(balanceItems, chargingOrganizationId);
     }
 
-    private static createBalanceItem({ price, amount, description, chargingOrganizationId, organizationBeingCharged }: { price: number; amount?: number; description: string; chargingOrganizationId: string; organizationBeingCharged: OrganizationStruct }): BalanceItem {
+    private static createBalanceItem({ price, amount, description, chargingOrganizationId, organizationBeingCharged, dueAt, createdAt }: { price: number; amount?: number; description: string; chargingOrganizationId: string; organizationBeingCharged: OrganizationStruct; dueAt: Date | null; createdAt: Date | null }): BalanceItem {
         const balanceItem = new BalanceItem();
         balanceItem.unitPrice = price;
         balanceItem.amount = amount ?? 1;
@@ -44,6 +29,10 @@ export class OrganizationCharger {
         balanceItem.type = BalanceItemType.Other;
         balanceItem.payingOrganizationId = organizationBeingCharged.id;
         balanceItem.organizationId = chargingOrganizationId;
+        balanceItem.dueAt = dueAt;
+        if (createdAt !== null) {
+            balanceItem.createdAt = createdAt;
+        }
 
         return balanceItem;
     }

package/src/services/EventNotificationService.ts

@@ -171,6 +171,7 @@ export class EventNotificationService {
 
     static async sendSubmitterEmail(type: EmailTemplateType, notification: EventNotification) {
         if (notification.endDate < new Date()) {
+            console.log('Skipped submitter email because it is in the past');
             // Ignore
             return;
         }
@@ -186,6 +187,8 @@ export class EventNotificationService {
 
     static async sendReviewerEmail(type: EmailTemplateType, notification: EventNotification) {
         if (notification.endDate < new Date()) {
+            console.log('Skipped reviewer email because it is in the past');
+
             // Ignore
             return;
         }