@stamhoofd/backend 2.72.0 → 2.73.1

package/index.ts

@@ -97,6 +97,7 @@ const start = async () => {
     await import('./src/excel-loaders/members');
     await import('./src/excel-loaders/payments');
     await import('./src/excel-loaders/organizations');
+    await import('./src/excel-loaders/receivable-balances');
 
     // Register Email Recipient loaders
     await import('./src/email-recipient-loaders/members');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.72.0",
+    "version": "2.73.1",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -37,14 +37,14 @@
         "@simonbackx/simple-encoding": "2.19.0",
         "@simonbackx/simple-endpoints": "1.15.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.72.0",
-        "@stamhoofd/backend-middleware": "2.72.0",
-        "@stamhoofd/email": "2.72.0",
-        "@stamhoofd/models": "2.72.0",
-        "@stamhoofd/queues": "2.72.0",
-        "@stamhoofd/sql": "2.72.0",
-        "@stamhoofd/structures": "2.72.0",
-        "@stamhoofd/utility": "2.72.0",
+        "@stamhoofd/backend-i18n": "2.73.1",
+        "@stamhoofd/backend-middleware": "2.73.1",
+        "@stamhoofd/email": "2.73.1",
+        "@stamhoofd/models": "2.73.1",
+        "@stamhoofd/queues": "2.73.1",
+        "@stamhoofd/sql": "2.73.1",
+        "@stamhoofd/structures": "2.73.1",
+        "@stamhoofd/utility": "2.73.1",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "9ca2f0fff00eafff2a398dbfdbfb032367473d1c"
+    "gitHead": "af8fb928f0d8fdfe07dcf1433d99a79a0cc44ea7"
 }

package/src/email-recipient-loaders/orders.ts

@@ -54,7 +54,7 @@ Email.recipientLoaders.set(EmailRecipientFilterType.Orders, {
                 $neq: null,
             },
         }]);
-        const q = GetWebshopOrdersEndpoint.buildQuery(query);
+        const q = await GetWebshopOrdersEndpoint.buildQuery(query);
         return await q.count();
     },
 });

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

@@ -28,7 +28,7 @@ export class GetOrganizationsCountEndpoint extends Endpoint<Params, Query, Body,
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.authenticate();
-        const query = GetOrganizationsEndpoint.buildQuery(request.query);
+        const query = await GetOrganizationsEndpoint.buildQuery(request.query);
 
         const count = await query
             .count();

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

@@ -5,11 +5,11 @@ import { Organization } from '@stamhoofd/models';
 import { SQL, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
 import { CountFilteredRequest, LimitedFilteredRequest, Organization as OrganizationStruct, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
+import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { organizationFilterCompilers } from '../../../sql-filters/organizations';
 import { organizationSorters } from '../../../sql-sorters/organizations';
-import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
@@ -35,7 +35,7 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
         const tags = Context.auth.getPlatformAccessibleOrganizationTags(PermissionLevel.Read);
         if (tags !== 'all' && tags.length === 0) {
             throw Context.auth.error();
@@ -62,11 +62,11 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             );
 
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
@@ -80,13 +80,13 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             };
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);
@@ -116,7 +116,7 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             });
         }
 
-        const query = GetOrganizationsEndpoint.buildQuery(requestQuery);
+        const query = await GetOrganizationsEndpoint.buildQuery(requestQuery);
         let data: SQLResultNamespacedRow[];
 
         try {

package/src/endpoints/global/addresses/SearchRegionsEndpoint.ts

@@ -31,8 +31,28 @@ export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, Respons
 
     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 rawQuery = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ');
+        const words = rawQuery.split(' ').filter(w => w.length > 0);
+
+        // Escape words
+        const cleanedWords: string[] = [];
+        for (const [index, word] of words.entries()) {
+            // If contains special char (non a-zA-Z) - escape with " character
+            if (/^[a-zA-Z0-9]*$/.test(word)) {
+                if (index === words.length - 1) {
+                    cleanedWords.push('+' + word + '*');
+                }
+                else {
+                    cleanedWords.push('+' + word);
+                }
+            }
+            else {
+                cleanedWords.push('+"' + word + '"');
+            }
+        }
+        const query = cleanedWords.join(' ');
+
+        if (query.length === 0) {
             // Do not try searching...
             return new Response(SearchRegions.create({
                 cities: [],
@@ -43,7 +63,7 @@ export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, Respons
 
         const match = {
             sign: 'MATCH',
-            value: query + '*', // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
+            value: query, // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
             mode: 'BOOLEAN',
         };
 

package/src/endpoints/global/audit-logs/GetAuditLogsEndpoint.ts

@@ -61,11 +61,11 @@ export class GetAuditLogsEndpoint extends Endpoint<Params, Query, Body, Response
             );
 
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
@@ -78,7 +78,7 @@ export class GetAuditLogsEndpoint extends Endpoint<Params, Query, Body, Response
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);

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

@@ -34,7 +34,7 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         return [false];
     }
 
-    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
         const organization = Context.organization;
         let scopeFilter: StamhoofdFilter | undefined = undefined;
 
@@ -60,11 +60,11 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
             );
 
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
@@ -78,13 +78,13 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
             };
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);
@@ -96,7 +96,7 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
     }
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = GetEventsEndpoint.buildQuery(requestQuery);
+        const query = await GetEventsEndpoint.buildQuery(requestQuery);
         const data = await query.fetch();
 
         const events = Event.fromRows(data, Event.table);

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

@@ -1,15 +1,15 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Event, Group, Platform, RegistrationPeriod } from '@stamhoofd/models';
-import { Event as EventStruct, GroupType, NamedObject, Group as GroupStruct, AuditLogType, AuditLogSource } from '@stamhoofd/structures';
+import { AuditLogSource, Event as EventStruct, Group as GroupStruct, GroupType, NamedObject } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
 import { Formatter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
-import { PatchOrganizationRegistrationPeriodsEndpoint } from '../../organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint';
 import { AuditLogService } from '../../../services/AuditLogService';
+import { PatchOrganizationRegistrationPeriodsEndpoint } from '../../organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint';
 
 type Params = { id: string };
 type Query = undefined;
@@ -67,6 +67,22 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 });
             }
 
+            if (event.meta.defaultAgeGroupIds && event.meta.defaultAgeGroupIds.length === 0) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Empty default age groups',
+                    human: 'Kies minstens één standaard leeftijdsgroep',
+                });
+            }
+
+            if (event.meta.organizationTagIds && event.meta.organizationTagIds.length === 0) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Empty organization tag ids',
+                    human: 'Kies minstens één tag',
+                });
+            }
+
             const eventOrganization = await this.checkEventAccess(event);
             event.id = put.id;
             event.name = put.name;
@@ -85,7 +101,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     throw new SimpleError({
                         code: 'invalid_period',
                         message: 'No period found for this start date',
-                        human: 'Oeps, je kan nog geen evenementen met inschrijvingen aanmaken in deze periode. Dit werkjaar is nog niet aangemaakt in het systeem.',
+                        human: Context.i18n.$t('5959a6a9-064a-413c-871f-c74a145ed569'),
                         field: 'startDate',
                     });
                 }
@@ -154,6 +170,22 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 });
             }
 
+            if (event.meta.defaultAgeGroupIds && event.meta.defaultAgeGroupIds.length === 0) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Empty default age groups',
+                    human: 'Kies minstens één standaard leeftijdsgroep',
+                });
+            }
+
+            if (event.meta.organizationTagIds && event.meta.organizationTagIds.length === 0) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Empty organization tag ids',
+                    human: 'Kies minstens één tag',
+                });
+            }
+
             const eventOrganization = await this.checkEventAccess(event);
             if (eventOrganization) {
                 event.meta.organizationCache = NamedObject.create({ id: eventOrganization.id, name: eventOrganization.name });
@@ -210,7 +242,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                         throw new SimpleError({
                             code: 'invalid_period',
                             message: 'No period found for this start date',
-                            human: 'Oeps, je kan nog geen evenementen met inschrijvingen aanmaken in deze periode. Dit werkjaar is nog niet aangemaakt in het systeem.',
+                            human: Context.i18n.$t('5959a6a9-064a-413c-871f-c74a145ed569'),
                             field: 'startDate',
                         });
                     }

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

@@ -127,11 +127,11 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             );
 
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
@@ -221,13 +221,13 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             // todo: Address search detection
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);

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

@@ -16,6 +16,7 @@ import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
 import { RegistrationService } from '../../../services/RegistrationService';
+import { shouldCheckIfMemberIsDuplicateForPatch, shouldCheckIfMemberIsDuplicateForPut } from './shouldCheckIfMemberIsDuplicate';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -107,10 +108,12 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             struct.details.cleanData();
             member.details = struct.details;
 
-            const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode);
-            if (duplicate) {
+            if (shouldCheckIfMemberIsDuplicateForPut(struct)) {
+                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode);
+                if (duplicate) {
                 // Merge data
-                member = duplicate;
+                    member = duplicate;
+                }
             }
 
             // We risk creating a new member without being able to access it manually afterwards
@@ -166,6 +169,8 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             patch = await Context.auth.filterMemberPatch(member, patch);
             const originalDetails = member.details.clone();
 
+            let shouldCheckDuplicate = false;
+
             if (patch.details) {
                 if (patch.details.isPut()) {
                     throw new SimpleError({
@@ -176,6 +181,8 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     });
                 }
 
+                shouldCheckDuplicate = shouldCheckIfMemberIsDuplicateForPatch(patch, originalDetails);
+
                 const wasReduced = member.details.shouldApplyReducedPrice;
                 member.details.patchOrPut(patch.details);
                 member.details.cleanData();
@@ -185,17 +192,20 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 }
             }
 
-            const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode);
-            if (duplicate) {
-                // Remove the member from the list
-                const iii = members.findIndex(m => m.id === member.id);
-                if (iii !== -1) {
-                    members.splice(iii, 1);
-                }
+            if (shouldCheckDuplicate) {
+                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode);
 
-                // Add new
-                members.push(duplicate);
-                continue;
+                if (duplicate) {
+                    // Remove the member from the list
+                    const iii = members.findIndex(m => m.id === member.id);
+                    if (iii !== -1) {
+                        members.splice(iii, 1);
+                    }
+
+                    // Add new
+                    members.push(duplicate);
+                    continue;
+                }
             }
 
             await member.save();
@@ -315,7 +325,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     throw new SimpleError({
                         code: 'invalid_field',
                         message: 'Invalid organization',
-                        human: 'Je kan een functie enkel toekennen aan leden die zijn ingeschreven in het huidige werkjaar',
+                        human: Context.i18n.$t('d41cdbe3-57e3-4a2e-83bc-cb9e65c9c840'),
                     });
                 }
 

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

@@ -0,0 +1,34 @@
+import { AutoEncoderPatchType } from '@simonbackx/simple-encoding';
+import { MemberDetails, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+
+export function shouldCheckIfMemberIsDuplicateForPatch(patch: { details: MemberDetails | AutoEncoderPatchType<MemberDetails> | undefined }, originalDetails: MemberDetails): boolean {
+    if (patch.details === undefined) {
+        return false;
+    }
+
+    return (
+    // has long first name
+        ((patch.details.firstName !== undefined && patch.details.firstName.length > 3) || (patch.details.firstName === undefined && originalDetails.firstName.length > 3))
+        // or has long last name
+        || ((patch.details.lastName !== undefined && patch.details.lastName.length > 3) || (patch.details.lastName === undefined && originalDetails.lastName.length > 3))
+    )
+    // has name change or birthday change
+    && (
+    // has first name change
+        (patch.details.firstName !== undefined && patch.details.firstName !== originalDetails.firstName)
+        // has last name change
+        || (patch.details.lastName !== undefined && patch.details.lastName !== originalDetails.lastName)
+        // has birth day change
+        || (patch.details.birthDay !== undefined && patch.details.birthDay?.getTime() !== originalDetails.birthDay?.getTime())
+    );
+}
+
+export function shouldCheckIfMemberIsDuplicateForPut(put: MemberWithRegistrationsBlob): boolean {
+    if (put.details.firstName.length <= 3 && put.details.lastName.length <= 3) {
+        return false;
+    }
+
+    const age = put.details.age;
+    // do not check if member is duplicate for historical members
+    return age !== null && age < 81;
+}

package/src/endpoints/global/platform/PatchPlatformEnpoint.ts

@@ -8,9 +8,9 @@ import { QueueHandler } from '@stamhoofd/queues';
 import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
 import { PeriodHelper } from '../../../helpers/PeriodHelper';
+import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 import { TagHelper } from '../../../helpers/TagHelper';
 import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
-import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -265,6 +265,16 @@ export class PatchPlatformEndpoint extends Endpoint<
         newPremiseTypes: PlatformPremiseType[],
         oldPremiseTypes: PlatformPremiseType[],
     ) {
+        // should be updated because the step will be removed
+        if (newPremiseTypes.length === 0 && oldPremiseTypes.length !== 0) {
+            return true;
+        }
+
+        // should be updated because the step will be added
+        if (newPremiseTypes.length !== 0 && oldPremiseTypes.length === 0) {
+            return true;
+        }
+
         for (const premiseType of newPremiseTypes) {
             const id = premiseType.id;
             const oldVersion = oldPremiseTypes.find(x => x.id === id);

package/src/endpoints/global/registration/PatchUserMembersEndpoint.ts

@@ -2,13 +2,13 @@ import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArra
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Document, Member, RateLimiter } from '@stamhoofd/models';
-import { AuditLogType, MemberDetails, MembersBlob, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+import { MemberDetails, MembersBlob, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { PatchOrganizationMembersEndpoint } from '../../global/members/PatchOrganizationMembersEndpoint';
-import { AuditLogService } from '../../../services/AuditLogService';
+import { shouldCheckIfMemberIsDuplicateForPatch, shouldCheckIfMemberIsDuplicateForPut } from '../members/shouldCheckIfMemberIsDuplicate';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = PatchableArrayAutoEncoder<MemberWithRegistrationsBlob>;
@@ -61,10 +61,12 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
 
             this.throwIfInvalidDetails(member.details);
 
-            const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode);
-            if (duplicate) {
-                addedMembers.push(duplicate);
-                continue;
+            if (shouldCheckIfMemberIsDuplicateForPut(struct)) {
+                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode);
+                if (duplicate) {
+                    addedMembers.push(duplicate);
+                    continue;
+                }
             }
 
             await member.save();
@@ -86,6 +88,8 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             const securityCode = struct.details?.securityCode; // will get cleared after the filter
             struct = await Context.auth.filterMemberPatch(member, struct);
 
+            let shouldCheckDuplicate = false;
+
             if (struct.details) {
                 if (struct.details.isPut()) {
                     throw new SimpleError({
@@ -96,6 +100,8 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
                     });
                 }
 
+                shouldCheckDuplicate = shouldCheckIfMemberIsDuplicateForPatch(struct, member.details);
+
                 member.details.patchOrPut(struct.details);
                 member.details.cleanData();
                 this.throwIfInvalidDetails(member.details);
@@ -110,14 +116,16 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
                 });
             }
 
-            const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode);
-            if (duplicate) {
+            if (shouldCheckDuplicate) {
+                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode);
+                if (duplicate) {
                 // Remove the member from the list
-                members.splice(members.findIndex(m => m.id === member.id), 1);
+                    members.splice(members.findIndex(m => m.id === member.id), 1);
 
-                // Add new
-                addedMembers.push(duplicate);
-                continue;
+                    // Add new
+                    addedMembers.push(duplicate);
+                    continue;
+                }
             }
 
             await member.save();

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -359,10 +359,14 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
         const createdBalanceItems: BalanceItem[] = [];
         const unrelatedCreatedBalanceItems: BalanceItem[] = [];
+        const deletedBalanceItems: BalanceItem[] = [];
         const shouldMarkValid = whoWillPayNow === 'nobody' || checkout.paymentMethod === PaymentMethod.Transfer || checkout.paymentMethod === PaymentMethod.PointOfSale || checkout.paymentMethod === PaymentMethod.Unknown;
 
         // Create negative balance items
-        for (const registrationStruct of [...checkout.cart.deleteRegistrations, ...checkout.cart.items.flatMap(i => i.replaceRegistrations)]) {
+        for (const { registration: registrationStruct, deleted } of [
+            ...checkout.cart.deleteRegistrations.map(r => ({ registration: r, deleted: true })),
+            ...checkout.cart.items.flatMap(i => i.replaceRegistrations).map(r => ({ registration: r, deleted: false })),
+        ]) {
             if (whoWillPayNow !== 'nobody') {
                 // this also fixes the issue that we cannot delete the registration right away if we would need to wait for a payment
                 throw new SimpleError({
@@ -398,7 +402,11 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
             // We can alter right away since whoWillPayNow is nobody, and shouldMarkValid will always be true
             // Find all balance items of this registration and set them to zero
-            await BalanceItem.deleteForDeletedRegistration(existingRegistration.id);
+            deletedBalanceItems.push(...(await BalanceItem.deleteForDeletedRegistration(existingRegistration.id, {
+                cancellationFeePercentage: deleted ? checkout.cancellationFeePercentage : 0,
+            })));
+
+            // todo: add cancelation fee
 
             // Clear the registration
             let group = groups.find(g => g.id === existingRegistration.groupId);
@@ -695,7 +703,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         }
 
         // Reallocate
-        await BalanceItemService.reallocate([...createdBalanceItems, ...unrelatedCreatedBalanceItems], organization.id);
+        await BalanceItemService.reallocate([...createdBalanceItems, ...unrelatedCreatedBalanceItems, ...deletedBalanceItems], organization.id);
 
         // Update occupancy
         for (const group of groups) {

package/src/endpoints/organization/dashboard/documents/GetDocumentsCountEndpoint.ts

@@ -35,7 +35,7 @@ export class GetDocumentsCountEndpoint extends Endpoint<Params, Query, Body, Res
             throw Context.auth.error();
         }
 
-        const query = GetDocumentsEndpoint.buildQuery(request.query);
+        const query = await GetDocumentsEndpoint.buildQuery(request.query);
 
         const count = await query
             .count();