@stamhoofd/backend 2.96.2 → 2.97.0

package/src/endpoints/global/email/PatchEmailEndpoint.ts

@@ -1,6 +1,6 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Email, Platform } from '@stamhoofd/models';
-import { EmailPreview, EmailRecipientsStatus, EmailStatus, Email as EmailStruct, PermissionLevel } from '@stamhoofd/structures';
+import { EmailPreview, EmailStatus, Email as EmailStruct, PermissionLevel } from '@stamhoofd/structures';
 
 import { AutoEncoderPatchType, Decoder, patchObject } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
@@ -40,8 +40,8 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         if (!model || (model.organizationId !== (organization?.id ?? null))) {
             throw new SimpleError({
                 code: 'not_found',
-                human: 'Email not found',
-                message: $t(`9ddb6616-f62d-4c91-82a9-e5cf398e4c4a`),
+                message: 'Email not found',
+                human: $t(`9ddb6616-f62d-4c91-82a9-e5cf398e4c4a`),
                 statusCode: 404,
             });
         }
@@ -118,8 +118,8 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             if (model.status !== EmailStatus.Draft) {
                 throw new SimpleError({
                     code: 'not_draft',
-                    human: 'Email is not a draft',
-                    message: $t(`Je kan de ontvangerslijst alleen aanpassen als de e-mail nog een concept is`),
+                    message: 'Email is not a draft',
+                    human: $t(`ace4d2e8-88d6-479f-bd8b-d576cc0ed1f2`),
                     statusCode: 400,
                 });
             }
@@ -128,6 +128,29 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             rebuild = true;
         }
 
+        if (request.body.sendAsEmail !== undefined) {
+            if (model.status !== EmailStatus.Draft) {
+                throw new SimpleError({
+                    code: 'not_draft',
+                    message: 'Email is not a draft',
+                    human: $t(`02b05c0d-908b-4200-8fb8-5fc01f539514`),
+                    statusCode: 400,
+                });
+            }
+
+            model.sendAsEmail = request.body.sendAsEmail ?? true;
+        }
+
+        if (request.body.showInMemberPortal !== undefined) {
+            model.showInMemberPortal = request.body.showInMemberPortal ?? false;
+
+            if (model.showInMemberPortal) {
+                if (!model.recipientFilter.canShowInMemberPortal) {
+                    model.showInMemberPortal = false;
+                }
+            }
+        }
+
         // Attachments
         if (request.body.attachments !== undefined) {
             model.attachments = patchObject(model.attachments, request.body.attachments);
@@ -159,34 +182,6 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                 });
             }
 
-            model.throwIfNotReadyToSend();
-
-            const replacement = '{{unsubscribeUrl}}';
-
-            if (model.html) {
-                // Check email contains an unsubscribe button
-                if (!model.html.includes(replacement)) {
-                    throw new SimpleError({
-                        code: 'missing_unsubscribe_button',
-                        message: 'Missing unsubscribe button',
-                        human: $t(`dd55e04b-e5d9-4d9a-befc-443eef4175a8`),
-                        field: 'html',
-                    });
-                }
-            }
-
-            if (model.text) {
-                // Check email contains an unsubscribe button
-                if (!model.text.includes(replacement)) {
-                    throw new SimpleError({
-                        code: 'missing_unsubscribe_button',
-                        message: 'Missing unsubscribe button',
-                        human: $t(`dd55e04b-e5d9-4d9a-befc-443eef4175a8`),
-                        field: 'text',
-                    });
-                }
-            }
-
             // Preview the sending status
             await model.queueForSending();
         }

package/src/endpoints/global/email-recipients/GetEmailRecipientsEndpoint.test.ts

@@ -186,6 +186,173 @@ describe('Endpoint.GetEmailRecipients', () => {
         });
     });
 
+    test('It can request all email recipients of a single email in combination with other filters', async () => {
+        const email = new Email();
+        email.subject = 'test subject';
+        email.status = EmailStatus.Draft;
+        email.text = 'test email';
+        email.html = `<p style="margin: 0; padding: 0; line-height: 1.4;">test email</p>`;
+        email.json = {};
+        email.organizationId = organization.id;
+        email.senderId = sender2.id;
+        await email.save();
+
+        const emailRecipient = new EmailRecipient();
+        emailRecipient.email = 'jan.janssens@geenemail.com';
+        emailRecipient.firstName = 'Jan';
+        emailRecipient.lastName = 'Janssens';
+        emailRecipient.emailId = email.id;
+        emailRecipient.organizationId = organization.id;
+        await emailRecipient.save();
+
+        const request = Request.get({
+            path: baseUrl,
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                filter: {
+                    emailId: email.id,
+                    email: {
+                        $contains: 'jan',
+                    },
+                },
+                limit: 10,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token2.accessToken,
+            },
+        });
+        const result = await testServer.test(endpoint, request);
+        expect(result.body.results).toHaveLength(1);
+        expect(result.body.results[0]).toMatchObject({
+            id: emailRecipient.id,
+        });
+    });
+
+    test('[Regression] It can request all email recipients of a single email in combination with $and filters', async () => {
+        const email = new Email();
+        email.subject = 'test subject';
+        email.status = EmailStatus.Draft;
+        email.text = 'test email';
+        email.html = `<p style="margin: 0; padding: 0; line-height: 1.4;">test email</p>`;
+        email.json = {};
+        email.organizationId = organization.id;
+        email.senderId = sender2.id;
+        await email.save();
+
+        const emailRecipient = new EmailRecipient();
+        emailRecipient.email = 'jan.janssens@geenemail.com';
+        emailRecipient.firstName = 'Jan';
+        emailRecipient.lastName = 'Janssens';
+        emailRecipient.emailId = email.id;
+        emailRecipient.organizationId = organization.id;
+        await emailRecipient.save();
+
+        const request = Request.get({
+            path: baseUrl,
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                filter: {
+                    $and: [
+                        { emailId: email.id },
+                        { email: { $contains: 'jan' } },
+                    ],
+                },
+                limit: 10,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token2.accessToken,
+            },
+        });
+        const result = await testServer.test(endpoint, request);
+        expect(result.body.results).toHaveLength(1);
+        expect(result.body.results[0]).toMatchObject({
+            id: emailRecipient.id,
+        });
+    });
+
+    test('[Regression] It can request all email recipients of a single email in combination with multiple $and filters', async () => {
+        const email = new Email();
+        email.subject = 'test subject';
+        email.status = EmailStatus.Draft;
+        email.text = 'test email';
+        email.html = `<p style="margin: 0; padding: 0; line-height: 1.4;">test email</p>`;
+        email.json = {};
+        email.organizationId = organization.id;
+        email.senderId = sender2.id;
+        await email.save();
+
+        const emailRecipient = new EmailRecipient();
+        emailRecipient.email = 'jan.janssens@geenemail.com';
+        emailRecipient.firstName = 'Jan';
+        emailRecipient.lastName = 'Janssens';
+        emailRecipient.emailId = email.id;
+        emailRecipient.organizationId = organization.id;
+        await emailRecipient.save();
+
+        const request = Request.get({
+            path: baseUrl,
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                filter: {
+                    $and: [
+                        { emailId: email.id },
+                        { email: { $contains: 'jan' } },
+                    ],
+                    email: { $contains: 'ssens' },
+                },
+                limit: 10,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token2.accessToken,
+            },
+        });
+        const result = await testServer.test(endpoint, request);
+        expect(result.body.results).toHaveLength(1);
+        expect(result.body.results[0]).toMatchObject({
+            id: emailRecipient.id,
+        });
+    });
+
+    test('It cannot request all email recipients of a single email in combination with $or filters', async () => {
+        const email = new Email();
+        email.subject = 'test subject';
+        email.status = EmailStatus.Draft;
+        email.text = 'test email';
+        email.html = `<p style="margin: 0; padding: 0; line-height: 1.4;">test email</p>`;
+        email.json = {};
+        email.organizationId = organization.id;
+        email.senderId = sender2.id;
+        await email.save();
+
+        const emailRecipient = new EmailRecipient();
+        emailRecipient.email = 'jan.janssens@geenemail.com';
+        emailRecipient.firstName = 'Jan';
+        emailRecipient.lastName = 'Janssens';
+        emailRecipient.emailId = email.id;
+        emailRecipient.organizationId = organization.id;
+        await emailRecipient.save();
+
+        const request = Request.get({
+            path: baseUrl,
+            host: organization.getApiHost(),
+            query: new LimitedFilteredRequest({
+                filter: {
+                    $or: [
+                        { emailId: email.id },
+                        { email: { $contains: 'jan' } },
+                    ],
+                },
+                limit: 10,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token2.accessToken,
+            },
+        });
+        await expect(testServer.test(endpoint, request))
+            .rejects
+            .toThrow(STExpect.errorWithCode('permission_denied'));
+    });
+
     test('It cannot request all email recipients of a single email if read permission for another sender', async () => {
         const email = new Email();
         email.subject = 'test subject';

package/src/endpoints/global/email-recipients/GetEmailRecipientsEndpoint.ts

@@ -50,7 +50,7 @@ export class GetEmailRecipientsEndpoint extends Endpoint<Params, Query, Body, Re
             if (!await validateEmailRecipientFilter({ filter: q.filter, permissionLevel: PermissionLevel.Read })) {
                 throw Context.auth.error({
                     message: 'You do not have sufficient permissions to view all email recipients',
-                    human: $t(`Je hebt niet voldoende toegangsrechten om alle email ontvangers te bekijken. Filter op één specifieke e-mail.`),
+                    human: $t(`d499972f-270c-44f6-ad7e-9d5359aef609`),
                 });
             }
         }

package/src/endpoints/global/email-recipients/helpers/validateEmailRecipientFilter.ts

@@ -9,9 +9,26 @@ export async function validateEmailRecipientFilter({ filter, permissionLevel }:
         emailId: FilterWrapperMarker,
     };
 
-    const unwrapped = unwrapFilter(filter, requiredFilter);
+    let unwrapped = unwrapFilter(filter, requiredFilter);
     if (!unwrapped.match) {
-        return false;
+        if (typeof filter === 'object'
+            && filter !== null
+            && filter['$and']
+            && Array.isArray(filter['$and'])
+            && Object.keys(filter).length >= 1 // does not matter if more than 1, because root is always $and together
+            && filter['$and'].length > 0
+        ) {
+            for (const subFilter of filter['$and']) {
+                unwrapped = unwrapFilter(subFilter as StamhoofdFilter, requiredFilter);
+                if (unwrapped.match) {
+                    // Found!
+                    break;
+                }
+            }
+        }
+        if (!unwrapped.match) {
+            return false;
+        }
     }
 
     const emailIds = typeof unwrapped.markerValue === 'string'
@@ -25,7 +42,7 @@ export async function validateEmailRecipientFilter({ filter, permissionLevel }:
             code: 'invalid_field',
             field: 'filter',
             message: 'You must filter on an email id of the email recipients you are trying to access',
-            human: $t(`Je hebt niet voldoende toegangsrechten om alle email ontvangers te bekijken.`),
+            human: $t(`9f352fd4-5e4d-4899-81ce-b69889ebfe9d`),
         });
     }
 
@@ -55,7 +72,7 @@ export async function validateEmailRecipientFilter({ filter, permissionLevel }:
         if (!await Context.auth.canAccessEmail(email, permissionLevel)) {
             throw Context.auth.error({
                 message: 'You do not have access to this email',
-                human: $t(`Je hebt geen toegangsrechten tot de ontvangers van deze email`),
+                human: $t(`590a37ed-0f3a-4c66-8e20-08ac00ae761d`),
             });
         }
     }

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

@@ -1,8 +1,8 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Group, Member, Platform } from '@stamhoofd/models';
-import { SQL, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
+import { Group, Member, Platform, Registration } from '@stamhoofd/models';
+import { SQL, SQLExpression, SQLSelect, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, GroupType, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort } from '@stamhoofd/structures';
 
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
@@ -11,7 +11,7 @@ import { RegistrationWithMemberBlob } from '@stamhoofd/structures/dist/src/membe
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { LimitedFilteredRequestHelper } from '../../../helpers/LimitedFilteredRequestHelper';
-import { registrationFilterCompilers } from '../../../sql-filters/registrations';
+import { groupJoin, registrationFilterCompilers } from '../../../sql-filters/registrations';
 import { registrationSorters } from '../../../sql-sorters/registrations';
 import { GetMembersEndpoint } from '../members/GetMembersEndpoint';
 import { validateGroupFilter } from '../members/helpers/validateGroupFilter';
@@ -40,6 +40,29 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
+    static selectRegistrationWithGroup(...columns: (SQLExpression | string)[]): SQLSelect<Registration & { group: Group }> {
+        const transformer = (row: SQLResultNamespacedRow): Registration & { group: Group } => {
+            const d = Registration.fromRow(row[Registration.table]);
+
+            if (!d) {
+                console.error('Could not transform row', row, 'into model', Registration.table, 'check if the primary key is returned in the query');
+                throw new Error('Missing data for model ' + Registration.table);
+            }
+
+            const g = Group.fromRow(row[Group.table]);
+            if (!g) {
+                console.error('Could not transform row', row, 'into model', Group.table, 'check if the primary key is returned in the query');
+                throw new Error('Missing data for model ' + Group.table);
+            }
+
+            return d.setRelation(Registration.group, g);
+        };
+
+        const select = new SQLSelect(transformer, ...(columns.length === 0 ? [SQL.wildcard(), SQL.wildcard(Group.table)] : columns));
+        select.join(groupJoin);
+        return select.from(SQL.table(Registration.table));
+    }
+
     static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest, permissionLevel: PermissionLevel = PermissionLevel.Read) {
         const organization = Context.organization;
         let scopeFilter: StamhoofdFilter | undefined = undefined;
@@ -115,15 +138,8 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
             }
         }
 
-        const query = SQL
-            .select(
-                SQL.column('registrations', 'id'),
-                SQL.column('registrations', 'memberId'),
-            )
+        const query = this.selectRegistrationWithGroup()
             .setMaxExecutionTime(15 * 1000)
-            .from(
-                SQL.table('registrations'),
-            )
             .where('registeredAt', '!=', null);
 
         if (scopeFilter) {
@@ -161,7 +177,9 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
 
     static async buildData(requestQuery: LimitedFilteredRequest, permissionLevel = PermissionLevel.Read) {
         const query = await GetRegistrationsEndpoint.buildQuery(requestQuery, permissionLevel);
-        let data: SQLResultNamespacedRow[];
+        let data: (Registration & {
+            group: Group;
+        })[];
 
         try {
             data = await query.fetch();
@@ -177,14 +195,13 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
             throw error;
         }
 
-        const registrationData = data.map((r) => {
-            if (typeof r.registrations.memberId === 'string' && typeof r.registrations.id === 'string') {
-                return { memberId: r.registrations.memberId, id: r.registrations.id };
+        for (const registration of data) {
+            if (!await Context.auth.canAccessRegistration(registration, permissionLevel)) {
+                throw Context.auth.error();
             }
-            throw new Error('Expected string');
-        });
+        }
 
-        const members = await Member.getBlobByIds(...registrationData.map(r => r.memberId));
+        const members = await Member.getBlobByIds(...data.map(r => r.memberId));
 
         for (const member of members) {
             if (!await Context.auth.canAccessMember(member, permissionLevel)) {
@@ -192,7 +209,7 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
             }
         }
 
-        const registrationsBlob = await AuthenticatedStructures.registrationsBlob(registrationData, members);
+        const registrationsBlob = await AuthenticatedStructures.registrationsBlob(data, members);
 
         const next = LimitedFilteredRequestHelper.fixInfiniteLoadingLoop({
             request: requestQuery,

package/src/helpers/AdminPermissionChecker.ts

@@ -161,9 +161,14 @@ export class AdminPermissionChecker {
             }
         }
         else {
-            // User is limited to a scope
-            if (this.user.organizationId) {
-                return false;
+            if (STAMHOOFD.userMode === 'organization') {
+                // User is limited to a scope: can't access platform resources
+                if (this.user.organizationId) {
+                    return false;
+                }
+            }
+            else {
+                // User can access platform resources (e.g. API keys)
             }
         }
 

package/src/helpers/AuthenticatedStructures.ts

@@ -456,6 +456,9 @@ export class AuthenticatedStructures {
 
         const memberBlobs: MemberWithRegistrationsBlob[] = [];
         for (const member of members) {
+            const filtered: (Registration & {
+                group: Group;
+            })[] = [];
             for (const registration of member.registrations) {
                 if (includeContextOrganization || registration.organizationId !== Context.auth.organization?.id) {
                     const found = organizations.get(registration.id);
@@ -464,8 +467,11 @@ export class AuthenticatedStructures {
                         organizations.set(organization.id, organization);
                     }
                 }
+                if (organizations.get(registration.organizationId)?.active || (Context.auth.organization && Context.auth.organization.active && registration.organizationId === Context.auth.organization.id) || await Context.auth.hasFullAccess(registration.organizationId)) {
+                    filtered.push(registration);
+                }
             }
-            member.registrations = member.registrations.filter(r => (Context.auth.organization && Context.auth.organization.active && r.organizationId === Context.auth.organization.id) || (organizations.get(r.organizationId)?.active ?? false));
+            member.registrations = filtered;
             const balancesPermission = await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, Context.organization?.id);
 
             let memberBalances: GenericBalance[] = [];
@@ -521,7 +527,13 @@ export class AuthenticatedStructures {
             }
         }
 
-        const activeOrganizations = [...organizations.values()].filter(o => o.active);
+        const activeOrganizations: Organization[] = [];
+
+        for (const organization of organizations.values()) {
+            if (organization.active || await Context.auth.hasFullAccess(organization.id)) {
+                activeOrganizations.push(organization);
+            }
+        }
         const organizationStructs = await this.organizations(activeOrganizations);
 
         // Load missing groups
@@ -588,30 +600,46 @@ export class AuthenticatedStructures {
         return (await this.eventNotifications([eventNotification]))[0];
     }
 
-    static async registrationsBlob(registrationData: {
-        memberId: string;
-        id: string;
-    }[], members: MemberWithRegistrations[], includeContextOrganization = false, includeUser?: User): Promise<RegistrationsBlob> {
+    static async registrationsBlob(registrations: (Registration & { group: Group })[], members: MemberWithRegistrations[], includeContextOrganization = false, includeUser?: User): Promise<RegistrationsBlob> {
         const membersBlob = await this.membersBlob(members, includeContextOrganization, includeUser);
 
         const memberBlobs = membersBlob.members;
 
-        const registrationWithMemberBlobs = registrationData.map(({ id, memberId }) => {
-            const memberBlob = memberBlobs.find(m => m.id === memberId);
+        const registrationWithMemberBlobs: RegistrationWithMemberBlob[] = [];
+        for (const registration of registrations) {
+            const memberBlob = memberBlobs.find(m => m.id === registration.memberId);
             if (!memberBlob) {
                 throw new Error('Member not found');
             }
 
-            const registration = memberBlob.registrations.find(r => r.id === id);
-            if (!registration) {
-                throw new Error('Registration not found: ' + id);
+            let r = memberBlob.registrations.find(r => r.id === registration.id);
+
+            if (!r) {
+                const member = members.find(m => m.id === registration.memberId);
+                const balancesPermission = member ? (await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, Context.organization?.id)) : false;
+                r = registration.getStructure();
+                r.balances = balancesPermission
+                    ? ((await CachedBalance.getForObjects([registration.id], null)).map((b) => {
+                            return GenericBalance.create(b);
+                        }))
+                    : [];
+                r.group = await this.group(registration.group);
+
+                memberBlob.registrations.push(r);
+
+                // Add organization if missing
+                if (!membersBlob.organizations.find(o => o.id === r!.organizationId)) {
+                    const organization = await Context.auth.getOrganization(r!.organizationId);
+                    membersBlob.organizations.push(organization.getBaseStructure());
+                }
             }
 
-            return RegistrationWithMemberBlob.create({
-                ...registration,
+            const struct = RegistrationWithMemberBlob.create({
+                ...r,
                 member: memberBlob,
             });
-        });
+            registrationWithMemberBlobs.push(struct);
+        }
 
         return RegistrationsBlob.create({
             registrations: registrationWithMemberBlobs,

package/src/helpers/Context.ts

@@ -309,11 +309,11 @@ export class ContextInstance {
 
         if (this.organization && !this.organization.active) {
             // For inactive organizations, you always need permissions to view them
-            if (!await Context.auth.hasFullAccess(this.organization.id)) {
+            if (!Context.auth.hasSomePlatformAccess() || !await Context.auth.hasFullAccess(this.organization.id)) {
                 throw new SimpleError({
                     code: 'archived',
-                    message: 'Full access is required to view inactive organizations',
-                    human: $t('31bc55e4-1cf3-495a-8b35-686a4cc25f69'),
+                    message: 'Platform access is required to view inactive organizations',
+                    human: $t('3e8dba08-a505-41ec-96c1-b2b5c1c17852'),
                     statusCode: 401,
                 });
             }

package/src/seeds/1755790070-fill-email-recipient-errors.ts

@@ -28,7 +28,7 @@ function stringToError(message: string) {
             new SimpleError({
                 code: 'email_skipped_unsubscribed',
                 message: 'Recipient has unsubscribed',
-                human: $t('De ontvanger heeft zich afgemeld voor e-mails'),
+                human: $t('ffbebae7-eac3-44fe-863b-25942c5be7d0'),
             }),
         );
     }
@@ -38,7 +38,7 @@ function stringToError(message: string) {
             new SimpleError({
                 code: 'email_skipped_unsubscribed',
                 message: 'Recipient has unsubscribed from marketing',
-                human: $t('De ontvanger heeft zich afgemeld voor e-mails'),
+                human: $t('ffbebae7-eac3-44fe-863b-25942c5be7d0'),
             }),
         );
     }
@@ -48,7 +48,7 @@ function stringToError(message: string) {
             new SimpleError({
                 code: 'all_filtered',
                 message: 'All recipients are filtered due to hard bounce or spam',
-                human: $t('Deze ontvanger komt voor op de gedeelde bounce of spamlijst. De ontvanger was eerder permanent onbereikbaar of heeft eerder een e-mail als spam gemarkeerd.'),
+                human: $t('f6ca0939-f191-4aba-9c53-cd370453c0bc'),
             }),
         );
     }

package/src/sql-filters/members.ts

@@ -440,14 +440,14 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                         throw new SimpleError({
                             code: 'not_found',
                             message: 'This email does not exist.',
-                            human: $t('Deze e-mail bestaat niet (meer)'),
+                            human: $t('491156e4-a75d-4487-a97e-b208cd3a1d11'),
                             statusCode: 404,
                         });
                     }
                     if (!await Context.auth.canAccessEmail(email)) {
                         throw Context.auth.error({
                             message: 'No permissions to access this email.',
-                            human: $t('Je hebt niet voldoende toegangsrechten om te filteren op deze e-mail'),
+                            human: $t('be46002c-d77e-42ca-b163-23bde0bc628c'),
                         });
                     }
                 },

package/src/sql-filters/registrations.ts

@@ -5,7 +5,7 @@ import { memberFilterCompilers } from './members';
 
 export const memberJoin = SQL.join(Member.table).where(SQL.column(Member.table, 'id'), SQL.column(Registration.table, 'memberId'));
 
-const groupJoin = SQL.join(Group.table).where(SQL.column(Group.table, 'id'), SQL.column(Registration.table, 'groupId'));
+export const groupJoin = SQL.join(Group.table).where(SQL.column(Group.table, 'id'), SQL.column(Registration.table, 'groupId'));
 
 export const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,