@stamhoofd/backend 2.89.1 → 2.90.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.89.1",
+    "version": "2.90.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -12,7 +12,8 @@
         "dev": "wait-on ../../shared/middleware/dist/index.js && concurrently -r 'yarn -s build --watch --preserveWatchOutput' \"yarn -s dev:watch\"",
         "dev:watch": "wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --watch '../../../shared/*/dist/' --watch '../../shared/*/dist/' --ext .ts,.json,.sql,.js --delay 2000ms --exec 'node --enable-source-maps ./dist/index.js' --signal SIGTERM",
         "dev:backend": "yarn -s dev",
-        "build": "rm -rf ./dist/src/migrations && rm -rf ./dist/src/seeds && tsc -b",
+        "build": "rm -rf ./dist/src/migrations && rm -rf ./dist/src/seeds && yarn -s copy-assets && tsc -b",
+        "copy-assets": "rsync --delete --mkpath --exclude='*.ts' --exclude='*.js' -r --checksum ./src/ ./dist/src/",
         "build:full": "yarn -s clear && yarn -s build",
         "clear": "rm -rf ./dist",
         "start": "yarn -s build && node --enable-source-maps ./dist/index.js",
@@ -44,14 +45,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.89.1",
-        "@stamhoofd/backend-middleware": "2.89.1",
-        "@stamhoofd/email": "2.89.1",
-        "@stamhoofd/models": "2.89.1",
-        "@stamhoofd/queues": "2.89.1",
-        "@stamhoofd/sql": "2.89.1",
-        "@stamhoofd/structures": "2.89.1",
-        "@stamhoofd/utility": "2.89.1",
+        "@stamhoofd/backend-i18n": "2.90.0",
+        "@stamhoofd/backend-middleware": "2.90.0",
+        "@stamhoofd/email": "2.90.0",
+        "@stamhoofd/models": "2.90.0",
+        "@stamhoofd/queues": "2.90.0",
+        "@stamhoofd/sql": "2.90.0",
+        "@stamhoofd/structures": "2.90.0",
+        "@stamhoofd/utility": "2.90.0",
         "archiver": "^7.0.1",
         "axios": "^1.8.2",
         "cookie": "^0.7.0",
@@ -69,5 +70,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "538a0e198d2db14c1e7650c75a645113b4394e71"
+    "gitHead": "d360b2ce795e378363765863457cd595f4841b73"
 }

package/src/boot.ts

@@ -20,6 +20,7 @@ import { PlatformMembershipService } from './services/PlatformMembershipService'
 import { UniqueUserService } from './services/UniqueUserService';
 import { QueueHandler } from '@stamhoofd/queues';
 import { SimpleError } from '@simonbackx/simple-errors';
+import { UitpasService } from './services/uitpas/UitpasService';
 
 process.on('unhandledRejection', (error: Error) => {
     console.error('unhandledRejection');
@@ -229,6 +230,7 @@ const start = async () => {
     PlatformMembershipService.listen();
     DocumentService.listen();
     SetupStepUpdater.listen();
+    UitpasService.listen();
 
     startCrons();
     seeds().catch(console.error);

package/src/crons/balance-emails.ts

@@ -1,5 +1,5 @@
 import { registerCron } from '@stamhoofd/crons';
-import { CachedBalance, Email, EmailRecipient, Organization, Platform, User } from '@stamhoofd/models';
+import { CachedBalance, Email, EmailRecipient, Organization, User } from '@stamhoofd/models';
 import { IterableSQLSelect, readDynamicSQLExpression, SQL, SQLCalculation, SQLPlusSign } from '@stamhoofd/sql';
 import { EmailRecipientFilter, EmailRecipientFilterType, EmailRecipientSubfilter, EmailTemplateType, OrganizationEmail, ReceivableBalanceType, StamhoofdFilter } from '@stamhoofd/structures';
 import { ContextInstance } from '../helpers/Context';
@@ -31,11 +31,6 @@ async function balanceEmails() {
         savedIterator = Organization.select().limit(10).all();
     }
 
-    const platform = await Platform.getSharedPrivateStruct();
-
-    if (!platform.config.featureFlags.includes('balance-emails')) {
-        return;
-    }
     const systemUser = await User.getSystem();
 
     for await (const organization of savedIterator.maxQueries(5)) {

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.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 { Organization } from '@stamhoofd/models';
-import { SQL, compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { SQL, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, LimitedFilteredRequest, Organization as OrganizationStruct, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';

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

@@ -0,0 +1,42 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { UitpasService } from '../../../services/uitpas/UitpasService';
+import { UitpasOrganizersResponse } from '@stamhoofd/structures';
+import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import { Context } from '../../../helpers/Context';
+
+type Params = Record<string, never>;
+class Query extends AutoEncoder {
+    @field({ decoder: StringDecoder })
+    name: string;
+}
+type Body = undefined;
+type ResponseBody = UitpasOrganizersResponse;
+
+export class SearchUitpasOrganizersEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/organization/search-uitpas-organizers', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        if (!await Context.auth.hasFullAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+        const uitpasOrganizersResponse = await UitpasService.searchUitpasOrganizers(request.query.name);
+
+        return new Response(uitpasOrganizersResponse);
+    }
+}

package/src/endpoints/global/audit-logs/GetAuditLogsEndpoint.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 { AuditLog } from '@stamhoofd/models';
-import { SQL, SQLFilterDefinitions, SQLSortDefinitions, compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { SQL, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { AuditLog as AuditLogStruct, CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -15,7 +15,7 @@ type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<AuditLogStruct[], LimitedFilteredRequest>;
 
-const filterCompilers: SQLFilterDefinitions = auditLogFilterCompilers;
+const filterCompilers = auditLogFilterCompilers;
 const sorters: SQLSortDefinitions<AuditLog> = auditLogSorters;
 
 export class GetAuditLogsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
@@ -46,13 +46,13 @@ export class GetAuditLogsEndpoint extends Endpoint<Params, Query, Body, Response
                 scopeFilter = {
                     organizationId: organization.id,
                 };
-            } else {
+            }
+            else {
                 if (!q.filter || typeof q.filter !== 'object' || !('objectId' in q.filter)) {
                     scopeFilter = {
                         organizationId: organization.id,
                     };
                 }
-                
             }
         }
         else {

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

@@ -2,21 +2,21 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { EventNotification } from '@stamhoofd/models';
-import { SQL, SQLFilterDefinitions, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
+import { SQL, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { AccessRight, CountFilteredRequest, EventNotification as EventNotificationStruct, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
+import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { eventNotificationsFilterCompilers } from '../../../sql-filters/event-notifications';
 import { eventNotificationsSorters } from '../../../sql-sorters/event-notifications';
-import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<EventNotificationStruct[], LimitedFilteredRequest>;
 
-const filterCompilers: SQLFilterDefinitions = eventNotificationsFilterCompilers;
+const filterCompilers = eventNotificationsFilterCompilers;
 const sorters: SQLSortDefinitions<SQLResultNamespacedRow> = eventNotificationsSorters;
 
 export class GetEventNotificationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {

package/src/endpoints/global/events/GetEventsEndpoint.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 { Event } from '@stamhoofd/models';
-import { SQL, SQLFilterDefinitions, SQLSortDefinitions, compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { SQL, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, Event as EventStruct, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -15,7 +15,7 @@ type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<EventStruct[], LimitedFilteredRequest>;
 
-const filterCompilers: SQLFilterDefinitions = eventFilterCompilers;
+const filterCompilers = eventFilterCompilers;
 const sorters: SQLSortDefinitions<Event> = eventSorters;
 
 export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {

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

@@ -1,7 +1,7 @@
 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 { AuditLogSource, Event as EventStruct, Group as GroupStruct, GroupType, NamedObject } from '@stamhoofd/structures';
+import { Event, Group, Platform, RegistrationPeriod, Webshop } from '@stamhoofd/models';
+import { AuditLogSource, Event as EventStruct, Group as GroupStruct, GroupType, NamedObject, PermissionLevel } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
@@ -309,6 +309,27 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 PatchEventsEndpoint.throwIfAddressIsMissing(event);
             }
 
+            if (patch.webshopId !== undefined) {
+                if (patch.webshopId === null) {
+                    event.webshopId = null;
+                }
+                else {
+                    const webshop = await Webshop.getByID(patch.webshopId);
+                    if (!webshop || (event.organizationId && webshop.organizationId !== event.organizationId)) {
+                        throw new SimpleError({
+                            code: 'not_found',
+                            message: 'Webshop not found',
+                            human: $t(`c5f3d2c3-9d7a-473d-ba91-63ce104a2de5`),
+                            field: 'webshopId',
+                        });
+                    }
+                    if (!await Context.auth.canAccessWebshop(webshop, PermissionLevel.Read)) {
+                        throw Context.auth.error($t('2ee1d364-8747-430d-8a33-094e01df465e'));
+                    }
+                    event.webshopId = webshop.id;
+                }
+            }
+
             await event.save();
 
             if (event.groupId) {

package/src/endpoints/global/groups/GetGroupsEndpoint.ts

@@ -4,7 +4,7 @@ import { assertSort, CountFilteredRequest, getSortFilter, Group as GroupStruct,
 import { Decoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Group } from '@stamhoofd/models';
-import { applySQLSorter, compileToModernSQLFilter, SQLModernFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { applySQLSorter, compileToSQLFilter, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { groupFilterCompilers } from '../../../sql-filters/groups';
@@ -15,7 +15,7 @@ type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<GroupStruct[], LimitedFilteredRequest>;
 
-const filterCompilers: SQLModernFilterDefinitions = groupFilterCompilers;
+const filterCompilers: SQLFilterDefinitions = groupFilterCompilers;
 const sorters: SQLSortDefinitions<Group> = groupSorters;
 
 export class GetGroupsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
@@ -47,11 +47,11 @@ export class GetGroupsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         const query = Group.select();
 
         if (scopeFilter) {
-            query.where(await compileToModernSQLFilter(scopeFilter, filterCompilers));
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(await compileToModernSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
@@ -62,13 +62,13 @@ export class GetGroupsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
             };
 
             if (searchFilter) {
-                query.where(await compileToModernSQLFilter(searchFilter, filterCompilers));
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(await compileToModernSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);

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

@@ -77,11 +77,12 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
             const token = await Token.createToken(user);
 
             const arr: Body = new PatchableArray();
+            const newBirthDay = new Date(existingMember.details.birthDay!.getTime() + 1);
             const put = MemberWithRegistrationsBlob.create({
                 details: MemberDetails.create({
                     firstName,
                     lastName,
-                    birthDay: new Date(existingMember.details.birthDay!.getTime() + 1),
+                    birthDay: newBirthDay,
                     email: 'anewemail@example.com',
                 }),
             });
@@ -100,7 +101,7 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
             const member = response.body.members[0];
             expect(member.details.firstName).toBe(firstName);
             expect(member.details.lastName).toBe(lastName);
-            expect(member.details.birthDay).toEqual(existingMember.details.birthDay);
+            expect(member.details.birthDay).toEqual(newBirthDay);
             expect(member.details.email).toBe('anewemail@example.com'); // this has been merged
             expect(member.details.alternativeEmails).toHaveLength(0);
         });
@@ -141,11 +142,12 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
             const token = await Token.createToken(user);
 
             const arr: Body = new PatchableArray();
+            const newBirthDay = new Date(existingMember.details.birthDay!.getTime() + 1);
             const put = MemberWithRegistrationsBlob.create({
                 details: MemberDetails.create({
                     firstName,
                     lastName,
-                    birthDay: new Date(existingMember.details.birthDay!.getTime() + 1),
+                    birthDay: newBirthDay,
                     securityCode: existingMember.details.securityCode,
                     email: 'anewemail@example.com',
                 }),
@@ -165,9 +167,9 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
             const member = response.body.members[0];
             expect(member.details.firstName).toBe(firstName);
             expect(member.details.lastName).toBe(lastName);
-            expect(member.details.birthDay).toEqual(existingMember.details.birthDay);
-            expect(member.details.email).toBe('original@example.com'); // this has been merged
-            expect(member.details.alternativeEmails).toEqual(['anewemail@example.com']); // this has been merged
+            expect(member.details.birthDay).toEqual(newBirthDay);
+            expect(member.details.email).toBe('anewemail@example.com'); // this has been merged
+            expect(member.details.alternativeEmails).toEqual(['original@example.com']); // this has been merged
 
             // Check the registration is still there
             expect(member.registrations.length).toBe(1);

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

@@ -14,10 +14,10 @@ import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
+import { MemberNumberService } from '../../../services/MemberNumberService';
 import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
 import { RegistrationService } from '../../../services/RegistrationService';
 import { shouldCheckIfMemberIsDuplicateForPatch } from './shouldCheckIfMemberIsDuplicate';
-import { MemberNumberService } from '../../../services/MemberNumberService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -957,7 +957,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             throw new SimpleError({
                 code: 'known_member_missing_rights',
                 message: 'Creating known member without sufficient access rights',
-                human: `${member.details.firstName} is al gekend in ons systeem, maar jouw e-mailadres niet. Om toegang te krijgen heb je de beveiligingscode nodig.`,
+                human: $t(`{member} is al gekend in ons systeem, maar jouw e-mailadres niet. Om toegang te krijgen heb je de beveiligingscode nodig.`, { member: member.details.firstName }),
                 statusCode: 400,
             });
         }

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

@@ -24,6 +24,7 @@ export class GetPlatformEndpoint extends Endpoint<Params, Query, Body, ResponseB
     }
 
     async handle(_: DecodedRequest<Params, Query, Body>) {
+        await Context.setOptionalOrganizationScope({ willAuthenticate: true });
         await Context.optionalAuthenticate({ allowWithoutAccount: false });
 
         if (Context.optionalAuth?.hasSomePlatformAccess()) {

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

@@ -1,11 +1,11 @@
+import { Database } from '@simonbackx/simple-database';
 import { PatchableArray, PatchMap } from '@simonbackx/simple-encoding';
 import { Endpoint, Request } from '@simonbackx/simple-endpoints';
 import { GroupFactory, MemberFactory, OrganizationFactory, Platform, RegistrationFactory, Token, UserFactory } from '@stamhoofd/models';
 import { MemberDetails, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PatchAnswers, PermissionLevel, RecordCategory, RecordSettings, RecordTextAnswer, TranslatedString } from '@stamhoofd/structures';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer';
 import { PatchUserMembersEndpoint } from './PatchUserMembersEndpoint';
-import { Database } from '@simonbackx/simple-database';
-import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 
 const baseUrl = `/members`;
 const endpoint = new PatchUserMembersEndpoint();
@@ -69,11 +69,12 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
             const token = await Token.createToken(user);
 
             const arr: Body = new PatchableArray();
+            const newBirthDay = new Date(existingMember.details.birthDay!.getTime() + 1);
             const put = MemberWithRegistrationsBlob.create({
                 details: MemberDetails.create({
                     firstName,
                     lastName,
-                    birthDay: new Date(existingMember.details.birthDay!.getTime() + 1),
+                    birthDay: newBirthDay,
                     email: 'anewemail@example.com',
                 }),
             });
@@ -92,7 +93,7 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
             const member = response.body.members[0];
             expect(member.details.firstName).toBe(firstName);
             expect(member.details.lastName).toBe(lastName);
-            expect(member.details.birthDay).toEqual(existingMember.details.birthDay);
+            expect(member.details.birthDay).toEqual(newBirthDay);
             expect(member.details.email).toBe('anewemail@example.com'); // this has been merged
             expect(member.details.alternativeEmails).toHaveLength(0);
         });
@@ -129,11 +130,12 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
             const token = await Token.createToken(user);
 
             const arr: Body = new PatchableArray();
+            const newBirthDay = new Date(existingMember.details.birthDay!.getTime() + 1);
             const put = MemberWithRegistrationsBlob.create({
                 details: MemberDetails.create({
                     firstName,
                     lastName,
-                    birthDay: new Date(existingMember.details.birthDay!.getTime() + 1),
+                    birthDay: newBirthDay,
                     securityCode: existingMember.details.securityCode,
                     email: 'anewemail@example.com',
                 }),
@@ -153,9 +155,9 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
             const member = response.body.members[0];
             expect(member.details.firstName).toBe(firstName);
             expect(member.details.lastName).toBe(lastName);
-            expect(member.details.birthDay).toEqual(existingMember.details.birthDay);
-            expect(member.details.email).toBe('original@example.com'); // this has been merged
-            expect(member.details.alternativeEmails).toEqual(['anewemail@example.com']); // this has been merged
+            expect(member.details.birthDay).toEqual(newBirthDay);
+            expect(member.details.email).toBe('anewemail@example.com'); // this has been merged
+            expect(member.details.alternativeEmails).toEqual(['original@example.com']); // this has been merged
 
             // Check the registration is still there
             expect(member.registrations.length).toBe(1);

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

@@ -345,6 +345,17 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             registration.pricePaid = 0;
             registration.payingOrganizationId = null;
 
+            if (checkout.isAdminFromSameOrganization) {
+                registration.sendConfirmationEmail = checkout.sendConfirmationEmail;
+            }
+            else {
+                registration.sendConfirmationEmail = true;
+                if (checkout.asOrganizationId) {
+                    // use group default
+                    registration.sendConfirmationEmail = group.privateSettings.sendConfirmationEmailForManualRegistrations;
+                }
+            }
+
             // NOTE: we don't reset deactivatedAt - registeredAt, because those will get reset when markValid is called later on (while keeping the original registeredAt date)
             // registration.deactivatedAt = null;
             // registration.registeredAt = null; // this is required to trigger platform membership updates

package/src/endpoints/global/registration-periods/GetRegistrationPeriodsEndpoint.ts

@@ -1,12 +1,12 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, RegistrationPeriod as RegistrationPeriodStruct, PaginatedResponse, StamhoofdFilter } from '@stamhoofd/structures';
+import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, PaginatedResponse, RegistrationPeriod as RegistrationPeriodStruct, StamhoofdFilter } from '@stamhoofd/structures';
 
+import { Decoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { RegistrationPeriod } from '@stamhoofd/models';
 import { applySQLSorter, compileToSQLFilter, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
 import { registrationPeriodFilterCompilers } from '../../../sql-filters/registration-periods';
 import { registrationPeriodSorters } from '../../../sql-sorters/registration-periods';
-import { Decoder } from '@simonbackx/simple-encoding';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;

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

@@ -3,7 +3,7 @@ import { Document } from '@stamhoofd/models';
 import { assertSort, CountFilteredRequest, Document as DocumentStruct, getSortFilter, LimitedFilteredRequest, PaginatedResponse, SearchFilterFactory, StamhoofdFilter } from '@stamhoofd/structures';
 
 import { Decoder } from '@simonbackx/simple-encoding';
-import { compileToSQLFilter, applySQLSorter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { applySQLSorter, compileToSQLFilter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 import { LimitedFilteredRequestHelper } from '../../../../helpers/LimitedFilteredRequestHelper';
@@ -46,9 +46,7 @@ export class GetDocumentsEndpoint extends Endpoint<Params, Query, Body, Response
         const query = SQL
             .select(SQL.wildcard(documentTable))
             .from(SQL.table(documentTable))
-            .where(await compileToSQLFilter({
-                organizationId: organization.id,
-            }, filterCompilers));
+            .where('organizationId', organization.id);
 
         if (q.filter) {
             query.where(await compileToSQLFilter(q.filter, filterCompilers));
@@ -151,7 +149,6 @@ function getDocumentSearchFilter(search: string | null): StamhoofdFilter | null
                     $contains: search,
                 },
             },
-        ]
-        ,
+        ],
     };
 }

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

@@ -0,0 +1,38 @@
+import { Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { UitpasGetClientIdResponse } from '@stamhoofd/structures';
+
+import { Context } from '../../../../helpers/Context';
+import { UitpasService } from '../../../../services/uitpas/UitpasService';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = UitpasGetClientIdResponse;
+
+export class GetUitpasClientIdEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/organization/uitpas-client-id', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle() {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        if (!await Context.auth.hasFullAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const resp = new UitpasGetClientIdResponse();
+        resp.clientId = await UitpasService.getClientIdFor(organization.id);
+        return new Response(resp);
+    }
+}

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

@@ -2,7 +2,7 @@ import { AutoEncoderPatchType, cloneObject, Decoder, isPatchableArray, isPatchMa
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
 import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, StripeAccount, Webshop } from '@stamhoofd/models';
-import { BuckarooSettings, Company, MemberResponsibility, OrganizationMetaData, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, PermissionRoleDetailed, PermissionRoleForResponsibility, PermissionsResourceType, ResourcePermissions } from '@stamhoofd/structures';
+import { BuckarooSettings, Company, MemberResponsibility, OrganizationMetaData, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, PermissionRoleDetailed, PermissionRoleForResponsibility, PermissionsResourceType, ResourcePermissions, UitpasClientCredentialsStatus } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
@@ -12,6 +12,7 @@ import { MemberUserSyncer } from '../../../../helpers/MemberUserSyncer';
 import { SetupStepUpdater } from '../../../../helpers/SetupStepUpdater';
 import { TagHelper } from '../../../../helpers/TagHelper';
 import { ViesHelper } from '../../../../helpers/ViesHelper';
+import { UitpasService } from '../../../../services/uitpas/UitpasService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -297,6 +298,35 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
 
                     updateTags = true;
                 }
+
+                if (request.body.meta.uitpasClientCredentialsStatus) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'You cannot set the uitpasClientCredentialsStatus manually',
+                        human: $t('Je kan de status van de UiTPAS-credentials niet handmatig instellen'),
+                    });
+                }
+
+                if (request.body.meta.uitpasOrganizerId) {
+                    const oldStatus = organization.meta.uitpasClientCredentialsStatus;
+                    // re-evaluate the status
+                    if (oldStatus !== UitpasClientCredentialsStatus.NotConfigured) {
+                        organization.meta.uitpasClientCredentialsStatus = UitpasClientCredentialsStatus.NotChecked;
+                        organization.meta.uitpasOrganizerId = request.body.meta.uitpasOrganizerId;
+                        const { status } = await UitpasService.checkPermissionsFor(organization.id, organization.meta.uitpasOrganizerId);
+                        organization.meta.uitpasClientCredentialsStatus = status;
+                    }
+
+                    // human message is ignored here
+                    // if (human) {
+                    //     const e = new SimpleError({
+                    //         code: 'uitpas-client-credentials-error',
+                    //         message: 'set-uitpas-credentials-returned-human-message',
+                    //         human: human,
+                    //     })
+                    //     errors.addError(e)
+                    // }
+                }
             }
 
             if (request.body.active !== undefined) {