@stamhoofd/backend 2.135.0 → 2.136.1

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

@@ -1,8 +1,10 @@
 import type { AutoEncoderPatchType } from '@simonbackx/simple-encoding';
+import { PatchMap } from '@simonbackx/simple-encoding';
 import { Request } from '@simonbackx/simple-endpoints';
 import type { Organization, RegistrationPeriod, User } from '@stamhoofd/models';
 import { Email, EmailRecipient, GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { AccessRight, EmailRecipientFilter, EmailRecipientSubfilter, EmailStatus, Email as EmailStruct, OrganizationEmail, Parent, PermissionLevel, Permissions, PermissionsResourceType, ResourcePermissions, UserPermissions, Version } from '@stamhoofd/structures';
+import { AccessRight, EmailContent, EmailRecipientFilter, EmailRecipientSubfilter, EmailStatus, Email as EmailStruct, OrganizationEmail, Parent, PermissionLevel, Permissions, PermissionsResourceType, ResourcePermissions, UserPermissions, Version } from '@stamhoofd/structures';
+import { Language } from '@stamhoofd/types/Language';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
 import { PatchEmailEndpoint } from './PatchEmailEndpoint.js';
@@ -1199,4 +1201,288 @@ describe('Endpoint.PatchEmailEndpoint', () => {
             expect(sentEmail.html).toContain('Identical Email');
         }
     });
+
+    describe('Translations', () => {
+        const createDraftEmail = async (options: { language?: Language } = {}) => {
+            const email = new Email();
+            email.subject = 'Default subject';
+            email.status = EmailStatus.Draft;
+            email.text = 'Default text';
+            email.html = '<p>Default html</p>';
+            email.json = {};
+            email.language = options.language ?? null;
+            email.userId = user.id;
+            email.organizationId = organization.id;
+            email.senderId = sender.id;
+            await email.save();
+            return email;
+        };
+
+        test('the first language can be set without creating a translation', async () => {
+            const email = await createDraftEmail();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: Language.Dutch,
+            });
+
+            const response = await patchEmail(body, token, organization);
+            expect(response.body.language).toBe(Language.Dutch);
+            expect(response.body.translations.size).toBe(0);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.size).toBe(0);
+            expect(saved!.subject).toBe('Default subject');
+        });
+
+        test('a translation can be added to a draft email', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.French, EmailContent.create({ subject: 'Sujet français', html: '<p>Français</p>', text: 'Français' })]]),
+            });
+
+            const response = await patchEmail(body, token, organization);
+            expect(response.body.translations.get(Language.French)!.subject).toBe('Sujet français');
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.translations.get(Language.French)!.subject).toBe('Sujet français');
+            expect(saved!.subject).toBe('Default subject');
+            expect(saved!.language).toBe(Language.Dutch);
+        });
+
+        test('a translation can be removed from a draft email', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+                [Language.English, EmailContent.create({ subject: 'English subject' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.French, null]]),
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.translations.size).toBe(1);
+            expect(saved!.translations.get(Language.English)!.subject).toBe('English subject');
+            expect(saved!.language).toBe(Language.Dutch);
+        });
+
+        test('removing the default language applies the move-over patch atomically', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français', html: '<p>Français</p>', text: 'Français' })],
+            ]);
+            await email.save();
+
+            // The UI removes the default language by moving the first remaining translation
+            // into the default content in a single patch
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: Language.French,
+                subject: 'Sujet français',
+                html: '<p>Français</p>',
+                text: 'Français',
+                translations: new PatchMap([[Language.French, null]]),
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.language).toBe(Language.French);
+            expect(saved!.subject).toBe('Sujet français');
+            expect(saved!.html).toBe('<p>Français</p>');
+            expect(saved!.translations.size).toBe(0);
+        });
+
+        test('removing the last language keeps the content', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: null,
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.language).toBeNull();
+            expect(saved!.subject).toBe('Default subject');
+            expect(saved!.html).toBe('<p>Default html</p>');
+        });
+
+        test('patching the subject keeps the translations', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                subject: 'New default subject',
+            });
+
+            await patchEmail(body, token, organization);
+
+            const saved = await Email.getByID(email.id);
+            expect(saved!.subject).toBe('New default subject');
+            expect(saved!.language).toBe(Language.Dutch);
+            expect(saved!.translations.get(Language.French)!.subject).toBe('Sujet français');
+        });
+
+        test('rejects a translation without a default language', async () => {
+            const email = await createDraftEmail();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.French, EmailContent.create({ subject: 'Sujet français' })]]),
+            });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        test('rejects a translation for the default language itself', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                translations: new PatchMap([[Language.Dutch, EmailContent.create({ subject: 'Nederlands onderwerp' })]]),
+            });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        test('rejects clearing the default language while translations remain', async () => {
+            const email = await createDraftEmail({ language: Language.Dutch });
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({
+                id: email.id,
+                language: null,
+            });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_translations'));
+        });
+
+        const createSendableEmail = async () => {
+            const email = new Email();
+            email.subject = 'Default subject';
+            email.status = EmailStatus.Draft;
+            email.text = 'Default text {{unsubscribeUrl}}';
+            email.html = '<!DOCTYPE html><html><body><p>Default html</p>{{unsubscribeUrl}}</body></html>';
+            email.json = {};
+            email.language = Language.Dutch;
+            email.userId = user.id;
+            email.organizationId = organization.id;
+            email.senderId = sender.id;
+            return email;
+        };
+
+        test('cannot send an email with an incomplete translation', async () => {
+            const email = await createSendableEmail();
+            email.translations = new Map([
+                [Language.French, EmailContent.create({ subject: 'Sujet français', text: '', html: '' })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({ id: email.id, status: EmailStatus.Sending });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('invalid_field'));
+        });
+
+        test('cannot send an email when a translation misses the unsubscribe button', async () => {
+            const email = await createSendableEmail();
+            email.translations = new Map([
+                [Language.French, EmailContent.create({
+                    subject: 'Sujet français',
+                    text: 'Texte français',
+                    html: '<!DOCTYPE html><html><body><p>Français</p></body></html>',
+                })],
+            ]);
+            await email.save();
+
+            const body = EmailStruct.patch({ id: email.id, status: EmailStatus.Sending });
+
+            await expect(patchEmail(body, token, organization))
+                .rejects
+                .toThrow(STExpect.errorWithCode('missing_unsubscribe_button'));
+        });
+    });
+
+    describe('Example recipients per language', () => {
+        // The greeting translations looked up in shared/locales/dist/locales/digit/{nl,fr}-BE.json,
+        // hardcoded on purpose so we don't verify $t with the same $t machinery we're testing
+        const dutchGreeting = 'Dag';
+        const frenchGreeting = 'Bonjour';
+
+        const createDraftEmail = async (options: { language?: Language; translations?: Map<Language, EmailContent> } = {}) => {
+            const email = new Email();
+            email.subject = 'Default subject';
+            email.status = EmailStatus.Draft;
+            email.text = 'Default text';
+            email.html = '<p>Default html</p>';
+            email.json = {};
+            email.language = options.language ?? null;
+            email.translations = options.translations ?? new Map();
+            email.userId = user.id;
+            email.organizationId = organization.id;
+            email.senderId = sender.id;
+            await email.save();
+            return email;
+        };
+
+        const greetingOf = (recipient: { replacements: { token: string; value: string }[] }) => {
+            return recipient.replacements.find(r => r.token === 'greeting')?.value;
+        };
+
+        test('the same example recipient is returned with replacements in every supported language', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French] });
+            const email = await createDraftEmail();
+
+            const response = await patchEmail(EmailStruct.patch({ id: email.id }), token, organization);
+            const preview = response.body;
+
+            // The deprecated single example recipient is still returned
+            expect(preview.exampleRecipient).not.toBeNull();
+            expect(greetingOf(preview.exampleRecipient!)).toBe(`${dutchGreeting} ${preview.exampleRecipient!.firstName},`);
+        });
+
+        test('every language the email has content for is included when it is supported', async () => {
+            TestUtils.setEnvironment('locales', { BE: [Language.Dutch, Language.French, Language.English] });
+            const email = await createDraftEmail({
+                language: Language.Dutch,
+                translations: new Map([[Language.English, EmailContent.create({ subject: 'English subject', html: '<p>English</p>', text: 'English' })]]),
+            });
+
+            const response = await patchEmail(EmailStruct.patch({ id: email.id }), token, organization);
+            const preview = response.body;
+
+            expect([...preview.exampleRecipients.keys()].sort()).toEqual([Language.Dutch, Language.English].sort());
+            const english = preview.exampleRecipients.get(Language.English)!;
+            expect(english.language).toBe(Language.English);
+
+            // The exact English text is machine-generated and can change between locale builds:
+            // assert it was generated in its own language (not in one of the other languages)
+            expect(greetingOf(english)).toBeDefined();
+            expect(greetingOf(english)).not.toBe(greetingOf(preview.exampleRecipients.get(Language.Dutch)!));
+        });
+    });
 });

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

@@ -2,7 +2,7 @@ import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { Email, Platform } from '@stamhoofd/models';
 import type { EmailPreview } from '@stamhoofd/structures';
-import { EmailRecipientsStatus, EmailStatus, Email as EmailStruct, PermissionLevel } from '@stamhoofd/structures';
+import { EmailRecipientsStatus, EmailStatus, Email as EmailStruct, PermissionLevel, validateEmailTranslations } from '@stamhoofd/structures';
 
 import type { AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
 import { patchObject } from '@simonbackx/simple-encoding';
@@ -114,6 +114,25 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             model.json = request.body.json;
         }
 
+        if (request.body.translations !== undefined) {
+            const lang = [...model.translations.keys()];
+            model.translations = patchObject(model.translations, request.body.translations);
+            const after = [...model.translations.keys()];
+
+            if (JSON.stringify(lang.sort()) && JSON.stringify(after.sort())) {
+                rebuild = true;
+            }
+        }
+
+        if (request.body.language !== undefined) {
+            model.language = request.body.language;
+            rebuild = true;
+        }
+
+        if (request.body.translations !== undefined || request.body.language !== undefined) {
+            validateEmailTranslations(model);
+        }
+
         if (request.body.recipientFilter) {
             if (model.status !== EmailStatus.Draft) {
                 throw new SimpleError({
@@ -192,6 +211,6 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             await model.queueForSending();
         }
 
-        return new Response(await model.getPreviewStructure());
+        return new Response(await model.getPreviewStructure({ allLanguages: true }));
     }
 }

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

@@ -3,7 +3,7 @@ import { Request } from '@simonbackx/simple-endpoints';
 import type { MemberWithUsersRegistrationsAndGroups, RegistrationPeriod } from '@stamhoofd/models';
 import { EventFactory, GroupFactory, MemberFactory, OrganizationFactory, RecordCategoryFactory, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import type { SortList } from '@stamhoofd/structures';
-import { AccessRight, EventMeta, GroupType, LimitedFilteredRequest, NamedObject, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, RecordAnswer, RecordTextAnswer, RecordType, ResourcePermissions, SortItemDirection } from '@stamhoofd/structures';
+import { AccessRight, EventMeta, GroupType, LimitedFilteredRequest, NamedObject, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, RecordAnswer, RecordDateAnswer, RecordTextAnswer, RecordType, ResourcePermissions, SortItemDirection } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { GetMembersEndpoint } from './GetMembersEndpoint.js';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
@@ -1446,6 +1446,124 @@ describe('Endpoint.GetMembersEndpoint', () => {
     });
 
     describe('Record answer filtering', () => {
+        test('A user can filter members on the date of a date record answer', async () => {
+            const resources = new Map();
+
+            const organization = await new OrganizationFactory({ period, roles: [] })
+                .create();
+
+            const recordCategory = await new RecordCategoryFactory({
+                records: [
+                    {
+                        type: RecordType.Date,
+                    },
+                ],
+            }).create();
+
+            await initPlatformRecordCategory({ recordCategory });
+            const record = recordCategory.records[0];
+
+            const user = await new UserFactory({
+                organization,
+                permissions: Permissions.create({
+                    level: PermissionLevel.None,
+                    roles: [],
+                    resources,
+                }),
+            })
+                .create();
+
+            const token = await Token.createToken(user);
+
+            // The member we are looking for: answered with a time of day that is not midnight
+            const member1 = await new MemberFactory({}).create();
+            const answer1 = RecordDateAnswer.create({ settings: record });
+            answer1.dateValue = new Date(2023, 5, 10, 14, 30, 15);
+            member1.details.recordAnswers.set(record.id, answer1);
+            await member1.save();
+
+            // Answered with a different date
+            const member2 = await new MemberFactory({}).create();
+            const answer2 = RecordDateAnswer.create({ settings: record });
+            answer2.dateValue = new Date(2023, 5, 11, 14, 30, 15);
+            member2.details.recordAnswers.set(record.id, answer2);
+            await member2.save();
+
+            // Did not answer the question
+            const member3 = await new MemberFactory({}).create();
+
+            const group = await new GroupFactory({ organization, period }).create();
+
+            resources.set(
+                PermissionsResourceType.Groups, new Map([[
+                    group.id,
+                    ResourcePermissions.create({
+                        level: PermissionLevel.Read,
+                        accessRights: [],
+                    }),
+                ]]),
+            );
+
+            resources.set(
+                PermissionsResourceType.RecordCategories, new Map([[
+                    recordCategory.id,
+                    ResourcePermissions.create({
+                        level: PermissionLevel.Read,
+                        accessRights: [],
+                    }),
+                ]]),
+            );
+
+            await user.save();
+
+            await new RegistrationFactory({ member: member1, group }).create();
+            await new RegistrationFactory({ member: member2, group }).create();
+            await new RegistrationFactory({ member: member3, group }).create();
+
+            const request = Request.get({
+                path: baseUrl,
+                host: organization.getApiHost(),
+                query: new LimitedFilteredRequest({
+                    filter: {
+                        registrations: {
+                            $elemMatch: {
+                                groupId: group.id,
+                            },
+                        },
+                        details: {
+                            recordAnswers: {
+                                [record.id]: {
+                                    // Same filter as the date filter in the UI builds for 'equals'
+                                    $and: [
+                                        {
+                                            dateValue: {
+                                                $gte: new Date(2023, 5, 10),
+                                            },
+                                        },
+                                        {
+                                            dateValue: {
+                                                $lte: new Date(2023, 5, 10, 23, 59, 59, 999),
+                                            },
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                    limit: 10,
+                }),
+                headers: {
+                    authorization: 'Bearer ' + token.accessToken,
+                },
+            });
+
+            const response = await testServer.test(endpoint, request);
+            expect(response.status).toBe(200);
+            expect(response.body.results.members).toIncludeSameMembers([
+                expect.objectContaining({ id: member1.id }),
+            ]);
+        });
+
         test('[REGRESSION] A user with minimal access can also view platform record answers in platform scope', async () => {
             /**
              * When fetching members via the admin api, without organization scope, we need to calculate which records to return and which not.