@stamhoofd/backend 2.71.0 → 2.73.0

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.71.0",
+    "version": "2.73.0",
     "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.71.0",
-        "@stamhoofd/backend-middleware": "2.71.0",
-        "@stamhoofd/email": "2.71.0",
-        "@stamhoofd/models": "2.71.0",
-        "@stamhoofd/queues": "2.71.0",
-        "@stamhoofd/sql": "2.71.0",
-        "@stamhoofd/structures": "2.71.0",
-        "@stamhoofd/utility": "2.71.0",
+        "@stamhoofd/backend-i18n": "2.73.0",
+        "@stamhoofd/backend-middleware": "2.73.0",
+        "@stamhoofd/email": "2.73.0",
+        "@stamhoofd/models": "2.73.0",
+        "@stamhoofd/queues": "2.73.0",
+        "@stamhoofd/sql": "2.73.0",
+        "@stamhoofd/structures": "2.73.0",
+        "@stamhoofd/utility": "2.73.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "8b35d36e694303905aa27cf9bff5539777d6ace1"
+    "gitHead": "fee6c6f01c19d15010807f2bac6a3ab5ee14019e"
 }

package/src/audit-logs/OrganizationLogger.ts

@@ -3,7 +3,7 @@ import { AuditLogType } from '@stamhoofd/structures';
 import { getDefaultGenerator, ModelLogger } from './ModelLogger';
 
 export const OrganizationLogger = new ModelLogger(Organization, {
-    skipKeys: ['searchIndex'],
+    skipKeys: ['searchIndex', 'serverMeta'],
     optionsGenerator: getDefaultGenerator({
         created: AuditLogType.OrganizationAdded,
         updated: AuditLogType.OrganizationEdited,

package/src/audit-logs/PlatformLogger.ts

@@ -3,6 +3,7 @@ import { getDefaultGenerator, ModelLogger } from './ModelLogger';
 import { AuditLogType } from '@stamhoofd/structures';
 
 export const PlatformLogger = new ModelLogger(Platform, {
+    skipKeys: ['serverConfig'],
     optionsGenerator: getDefaultGenerator({
         updated: AuditLogType.PlatformSettingsChanged,
     }),

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/auth/CreateTokenEndpoint.ts

@@ -86,7 +86,8 @@ export class CreateTokenEndpoint extends Endpoint<Params, Query, Body, ResponseB
 
                 if (STAMHOOFD.userMode === 'platform') {
                     const platform = await Platform.getShared();
-                    if (!platform.config.loginMethods.includes(LoginMethod.Password)) {
+                    const config = platform.config.loginMethods.get(LoginMethod.Password);
+                    if (!config) {
                         throw new SimpleError({
                             code: 'not_supported',
                             message: 'This platform does not support password login',
@@ -94,6 +95,15 @@ export class CreateTokenEndpoint extends Endpoint<Params, Query, Body, ResponseB
                             statusCode: 400,
                         });
                     }
+
+                    if (!config.isEnabledForEmail(request.body.username)) {
+                        throw new SimpleError({
+                            code: 'not_supported',
+                            message: 'Login method not supported',
+                            human: 'Je kan op dit account niet inloggen met een wachtwoord. Gebruik een andere methode om in te loggen.',
+                            statusCode: 400,
+                        });
+                    }
                 }
 
                 const user = await User.login(organization?.id ?? null, request.body.username, request.body.password);

package/src/endpoints/auth/ForgotPasswordEndpoint.ts

@@ -1,8 +1,9 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { PasswordToken, sendEmailTemplate, User } from '@stamhoofd/models';
-import { EmailTemplateType, ForgotPasswordRequest, Recipient, Replacement } from '@stamhoofd/structures';
+import { PasswordToken, Platform, sendEmailTemplate, User } from '@stamhoofd/models';
+import { EmailTemplateType, ForgotPasswordRequest, LoginMethod, Recipient, Replacement } from '@stamhoofd/structures';
 
+import { SimpleError } from '@simonbackx/simple-errors';
 import { Context } from '../../helpers/Context';
 
 type Params = Record<string, never>;
@@ -28,6 +29,29 @@ export class ForgotPasswordEndpoint extends Endpoint<Params, Query, Body, Respon
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOptionalOrganizationScope();
+
+        if (STAMHOOFD.userMode === 'platform') {
+            const platform = await Platform.getShared();
+            const config = platform.config.loginMethods.get(LoginMethod.Password);
+            if (!config) {
+                throw new SimpleError({
+                    code: 'not_supported',
+                    message: 'This platform does not support password login',
+                    human: 'Dit platform ondersteunt geen wachtwoord login',
+                    statusCode: 400,
+                });
+            }
+
+            if (!config.isEnabledForEmail(request.body.email)) {
+                throw new SimpleError({
+                    code: 'not_supported',
+                    message: 'Login method not supported',
+                    human: 'Je kan op dit account geen wachtwoord gebruiken om in te loggen.',
+                    statusCode: 400,
+                });
+            }
+        }
+
         const user = await User.getForAuthentication(organization?.id ?? null, request.body.email, { allowWithoutAccount: true });
 
         if (!user) {

package/src/endpoints/auth/PatchUserEndpoint.ts

@@ -1,8 +1,8 @@
 import { AutoEncoderPatchType, Decoder, isPatch } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { EmailVerificationCode, Member, PasswordToken, Token, User } from '@stamhoofd/models';
-import { NewUser, PermissionLevel, SignupResponse, UserPermissions, UserWithMembers } from '@stamhoofd/structures';
+import { EmailVerificationCode, Member, PasswordToken, Platform, Token, User } from '@stamhoofd/models';
+import { LoginMethod, NewUser, PermissionLevel, SignupResponse, UserPermissions, UserWithMembers } from '@stamhoofd/structures';
 
 import { Context } from '../../helpers/Context';
 import { MemberUserSyncer } from '../../helpers/MemberUserSyncer';
@@ -135,6 +135,28 @@ export class PatchUserEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         }
 
         if (editUser.id === user.id && request.body.password) {
+            if (STAMHOOFD.userMode === 'platform') {
+                const platform = await Platform.getShared();
+                const config = platform.config.loginMethods.get(LoginMethod.Password);
+                if (!config) {
+                    throw new SimpleError({
+                        code: 'not_supported',
+                        message: 'This platform does not support password login',
+                        human: 'Dit platform ondersteunt geen wachtwoord login',
+                        statusCode: 400,
+                    });
+                }
+
+                if (!config.isEnabledForEmail(editUser.email)) {
+                    throw new SimpleError({
+                        code: 'not_supported',
+                        message: 'Login method not supported',
+                        human: 'Je kan op dit account geen wachtwoord gebruiken om in te loggen.',
+                        statusCode: 400,
+                    });
+                }
+            }
+
             // password changes
             await editUser.changePassword(request.body.password);
             await PasswordToken.clearFor(editUser.id);

package/src/endpoints/auth/SignupEndpoint.ts

@@ -32,7 +32,7 @@ export class SignupEndpoint extends Endpoint<Params, Query, Body, ResponseBody>
 
         if (STAMHOOFD.userMode === 'platform') {
             const platform = await Platform.getShared();
-            if (!platform.config.loginMethods.includes(LoginMethod.Password)) {
+            if (!platform.config.loginMethods.has(LoginMethod.Password)) {
                 throw new SimpleError({
                     code: 'not_supported',
                     message: 'This platform does not support password login',

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

@@ -3,15 +3,15 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Member, Platform } from '@stamhoofd/models';
 import { SQL, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
-import { CountFilteredRequest, Country, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
+import { CountFilteredRequest, Country, CountryCode, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 import { DataValidator } from '@stamhoofd/utility';
 
+import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import parsePhoneNumber from 'libphonenumber-js/max';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { memberFilterCompilers } from '../../../sql-filters/members';
 import { memberSorters } from '../../../sql-sorters/members';
-import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
@@ -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) {
@@ -141,7 +141,9 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             if (!searchFilter && q.search.match(/^\+?[0-9\s-]+$/)) {
                 // Try to format as phone so we have 1:1 space matches
                 try {
-                    const phoneNumber = parsePhoneNumber(q.search, (Context.i18n.country as Country) || Country.Belgium);
+                    const country = (Context.i18n.country as CountryCode) || Country.Belgium;
+
+                    const phoneNumber = parsePhoneNumber(q.search, country);
                     if (phoneNumber && phoneNumber.isValid()) {
                         const formatted = phoneNumber.formatInternational();
                         searchFilter = {
@@ -219,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;
+}