@stamhoofd/backend 2.137.4 → 2.137.5

package/src/services/OrganizationEmailService.ts

@@ -0,0 +1,211 @@
+import { I18n } from '@stamhoofd/backend-i18n';
+import type { Organization } from '@stamhoofd/models';
+import { sendEmailTemplate } from '@stamhoofd/models';
+import { EmailTemplateType, Replacement, STPackageType } from '@stamhoofd/structures';
+import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
+
+export class OrganizationEmailService {
+    static async sendEmailTemplate(organization: Organization, data: {
+        type: EmailTemplateType;
+        personal?: boolean;
+        bcc?: boolean;
+    }) {
+        const recipients = await organization.getAdminRecipients();
+        const defaultI18n = new I18n(Language.Dutch, Country.Belgium);
+        const i18n = organization.i18n;
+
+        const replaceAll = [
+            {
+                from: defaultI18n.localizedDomains.marketing(),
+                to: i18n.localizedDomains.marketing(),
+            },
+            {
+                from: defaultI18n.$t('%2a'),
+                to: i18n.$t('%2a'),
+            },
+            {
+                from: defaultI18n.$t('%19'),
+                to: i18n.$t('%19'),
+            },
+        ];
+
+        await sendEmailTemplate(null, {
+            replaceAll,
+            recipients,
+            template: {
+                type: data.type,
+            },
+            singleBcc: data.bcc ? { email: 'simon@stamhoofd.be' } : undefined,
+            type: 'transactional',
+            defaultReplacements: [
+                Replacement.create({
+                    token: 'mailDomain',
+                    value: organization.privateMeta.mailDomain ?? organization.privateMeta.pendingMailDomain ?? '',
+                }),
+                Replacement.create({
+                    token: 'organizationName',
+                    value: organization.name,
+                }),
+            ],
+            unsubscribeType: 'marketing',
+            fromStamhoofd: true,
+        });
+    }
+
+    static async checkDrips(organization: Organization) {
+        const days7 = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+
+        // Welcome drip
+        // Created maximum 7 days ago
+        if (organization.createdAt > days7 && !organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWelcome)) {
+            await this.sendEmailTemplate(organization, {
+                type: EmailTemplateType.OrganizationDripWelcome,
+                personal: true,
+            });
+
+            organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripWelcome);
+            await organization.save();
+
+            return; // Never send more than 1 drip email on the same day
+        }
+
+        // Webshop trial checkin
+        if (!organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWebshopTrialCheckin)) {
+            if (organization.meta.packages.isWebshopsTrial) {
+                const activeTime = organization.meta.packages.getActiveTime(STPackageType.TrialWebshops);
+                if (activeTime !== null && activeTime > 4 * 24 * 60 * 60 * 1000) {
+                    // 7 days checkin
+                    await this.sendEmailTemplate(organization, {
+                        type: EmailTemplateType.OrganizationDripWebshopTrialCheckin,
+                        personal: true,
+                    });
+
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialCheckin);
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialCheckin); // also mark members checkin
+                    await organization.save();
+
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+
+        // Members trial checkin
+        if (!organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripMembersTrialCheckin)) {
+            if (organization.meta.packages.isMembersTrial) {
+                const activeTime = organization.meta.packages.getActiveTime(STPackageType.TrialMembers);
+                if (activeTime !== null && activeTime > 4 * 24 * 60 * 60 * 1000) {
+                    // 7 days checkin
+                    await this.sendEmailTemplate(organization, {
+                        type: EmailTemplateType.OrganizationDripMembersTrialCheckin,
+                        personal: true,
+                    });
+
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialCheckin);
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialCheckin); // Also mark webshop trial checkin
+                    await organization.save();
+
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+
+        // Webshop trial expired after 1 week
+        if (!organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWebshopTrialExpired)) {
+            if (!organization.meta.packages.useWebshops) {
+                const deactivatedTime = organization.meta.packages.getDeactivatedTime(STPackageType.TrialWebshops);
+                if (deactivatedTime !== null && deactivatedTime < 14 * 24 * 60 * 60 * 1000 && deactivatedTime > 7 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate(organization, {
+                        type: EmailTemplateType.OrganizationDripWebshopTrialExpired,
+                        personal: true,
+                    });
+
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialExpired);
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialExpired); // also mark members
+                    await organization.save();
+
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+
+        if (!organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripMembersTrialExpired)) {
+            if (!organization.meta.packages.useMembers) {
+                const deactivatedTime = organization.meta.packages.getDeactivatedTime(STPackageType.TrialMembers);
+                if (deactivatedTime !== null && deactivatedTime < 14 * 24 * 60 * 60 * 1000 && deactivatedTime > 7 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate(organization, {
+                        type: EmailTemplateType.OrganizationDripMembersTrialExpired,
+                        personal: true,
+                    });
+
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersTrialExpired);
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopTrialExpired); // also mark webshops
+                    await organization.save();
+
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+
+        // trial expired reminder (after 10 months)
+        if (!organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripTrialExpiredReminder)) {
+            if (!organization.meta.packages.isPaid && !organization.meta.packages.wasPaid) {
+                const deactivatedTime1 = organization.meta.packages.getDeactivatedTime(STPackageType.TrialWebshops);
+                const deactivatedTime2 = organization.meta.packages.getDeactivatedTime(STPackageType.TrialMembers);
+
+                const deactivatedTime = deactivatedTime1 && deactivatedTime2 ? Math.max(deactivatedTime1, deactivatedTime2) : (deactivatedTime1 ? deactivatedTime1 : deactivatedTime2);
+
+                if (deactivatedTime !== null && deactivatedTime > 10 * 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 13 * 31 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate(organization, {
+                        type: EmailTemplateType.OrganizationDripTrialExpiredReminder,
+                        personal: true,
+                        bcc: true,
+                    });
+
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripTrialExpiredReminder);
+                    await organization.save();
+
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+
+        if (!organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripWebshopNotRenewed)) {
+            if (!organization.meta.packages.useWebshops) {
+                const deactivatedTime = organization.meta.packages.getDeactivatedTime(STPackageType.Webshops);
+
+                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30 * 3 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate(organization, {
+                        type: EmailTemplateType.OrganizationDripWebshopNotRenewed,
+                        personal: true,
+                        bcc: true,
+                    });
+
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripWebshopNotRenewed);
+                    await organization.save();
+
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+
+        if (!organization.serverMeta.hasEmail(EmailTemplateType.OrganizationDripMembersNotRenewed)) {
+            if (!organization.meta.packages.useMembers) {
+                const deactivatedTime = organization.meta.packages.getDeactivatedTime(STPackageType.Members);
+
+                if (deactivatedTime !== null && deactivatedTime > 30 * 24 * 60 * 60 * 1000 && deactivatedTime < 30 * 3 * 24 * 60 * 60 * 1000) {
+                    await this.sendEmailTemplate(organization, {
+                        type: EmailTemplateType.OrganizationDripMembersNotRenewed,
+                        personal: true,
+                        bcc: true,
+                    });
+
+                    organization.serverMeta.addEmail(EmailTemplateType.OrganizationDripMembersNotRenewed);
+                    await organization.save();
+
+                    return; // Never send more than 1 drip email on the same day
+                }
+            }
+        }
+    }
+}

package/src/services/PasswordForgotService.test.ts

@@ -0,0 +1,99 @@
+import { I18n } from '@stamhoofd/backend-i18n';
+import { Organization, OrganizationFactory, PasswordToken, User, UserFactory } from '@stamhoofd/models';
+import { Address, OrganizationMetaData, PermissionLevel, Permissions } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Country } from '@stamhoofd/types/Country';
+import { PasswordForgotService } from './PasswordForgotService.js';
+
+const i18n = new I18n(I18n.defaultLanguage, I18n.defaultCountry);
+
+/**
+ * An organization that is not saved in the database: enough to build an url with.
+ */
+function buildOrganization(id = 'organization-1') {
+    const organization = new Organization();
+    organization.id = id;
+    organization.name = 'Test organization';
+    organization.uri = 'test-organization';
+    organization.meta = OrganizationMetaData.create({});
+    organization.address = Address.create({
+        street: 'Demostraat',
+        number: '12',
+        city: 'Gent',
+        postalCode: '9000',
+        country: Country.Belgium,
+    });
+    return organization;
+}
+
+function buildUser(organizationId: string | null) {
+    const user = new User();
+    user.id = 'user-1';
+    user.organizationId = organizationId;
+    user.email = 'user@example.com';
+    return user;
+}
+
+function buildToken(user: User, token: string) {
+    const passwordToken = new PasswordToken();
+    passwordToken.token = token;
+    passwordToken.userId = user.id;
+    return passwordToken;
+}
+
+describe('PasswordForgotService', () => {
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'organization');
+    });
+
+    describe('getPasswordRecoveryUrl', () => {
+        test('An administrator of the organization gets a dashboard url', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const admin = await new UserFactory({
+                organization,
+                permissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+
+            const url = new URL(await PasswordForgotService.getPasswordRecoveryUrl(admin, organization, i18n));
+
+            expect(url.host).toBe(STAMHOOFD.domains.dashboard);
+            expect(url.pathname).toMatch(/\/reset-password$/);
+        });
+
+        test('A user without permissions for the organization gets a registration url', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const member = await new UserFactory({ organization }).create();
+
+            const url = new URL(await PasswordForgotService.getPasswordRecoveryUrl(member, organization, i18n));
+
+            expect(url.host).not.toBe(STAMHOOFD.domains.dashboard);
+            expect(url.host.split('.')[0]).toBe(organization.uri);
+            expect(url.pathname).toMatch(/\/reset-password$/);
+        });
+
+        test('The url points to the reset-password page with a url encoded token', async () => {
+            const organization = buildOrganization();
+            const user = buildUser(organization.id);
+
+            const url = await PasswordForgotService.getPasswordRecoveryUrlForToken(buildToken(user, 'a+b/c=d&e'), organization, i18n, user);
+
+            expect(url).toMatch(/\/reset-password\?token=a%2Bb%2Fc%3Dd%26e$/);
+            expect(new URL(url).searchParams.get('token')).toBe('a+b/c=d&e');
+        });
+
+        test('Throws when the user belongs to a different organization', async () => {
+            const user = buildUser('a-different-organization');
+
+            await expect(PasswordForgotService.getPasswordRecoveryUrlForToken(buildToken(user, 'my-token'), buildOrganization(), i18n, user))
+                .rejects
+                .toThrow('Unexpected mismatch in organization id for PasswordToken');
+        });
+
+        test('Allows a user without an organization in every scope', async () => {
+            const user = buildUser(null);
+
+            await expect(PasswordForgotService.getPasswordRecoveryUrlForToken(buildToken(user, 'my-token'), buildOrganization(), i18n, user))
+                .toResolve();
+        });
+    });
+});

package/src/services/PasswordForgotService.ts

@@ -0,0 +1,38 @@
+import type { I18n } from '@stamhoofd/backend-i18n';
+import type { Organization } from '@stamhoofd/models';
+import { PasswordToken, Platform, User } from '@stamhoofd/models';
+import { getAppHost } from '@stamhoofd/structures';
+
+/**
+ * Builds the password recovery links. Which app the link points to depends on whether the user is an
+ * administrator of the organization.
+ */
+export class PasswordForgotService {
+    /**
+     * Create a new password token for the user and build the recovery url for it.
+     */
+    static async getPasswordRecoveryUrl(user: User, organization: Organization | null, i18n: I18n, validUntil?: Date) {
+        // Send an e-mail to say you already have an account + follow password forgot flow
+        const token = await PasswordToken.createToken(user, validUntil);
+        return await this.getPasswordRecoveryUrlForToken(token, organization, i18n, user);
+    }
+
+    /**
+     * Build the recovery url for an already created password token.
+     * Pass the user to avoid an extra query when it is already loaded.
+     */
+    static async getPasswordRecoveryUrlForToken(token: PasswordToken, organization: Organization | null, i18n: I18n, user?: User) {
+        const tokenUser = user ?? await User.getByID(token.userId);
+        if (!tokenUser) {
+            throw new Error('PasswordToken without a valid user');
+        }
+
+        if (tokenUser.organizationId !== null && ((tokenUser.organizationId ?? null) !== (organization?.id ?? null))) {
+            throw new Error('Unexpected mismatch in organization id for PasswordToken');
+        }
+
+        const hasOrganizationPermissions = organization ? tokenUser.permissions?.forOrganization(organization, await Platform.getSharedStruct())?.isEmpty === false : false;
+        const host = 'https://' + getAppHost(hasOrganizationPermissions ? 'dashboard' : 'registration', organization, hasOrganizationPermissions, i18n);
+        return host + '/reset-password?token=' + encodeURIComponent(token.token);
+    }
+}

package/src/services/PlatformMembershipService.test.ts

@@ -0,0 +1,180 @@
+import { MemberFactory, MemberPlatformMembership, OrganizationFactory, Platform, RegistrationFactory, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { PlatformMembershipType, PlatformMembershipTypeBehaviour, PlatformMembershipTypeConfig, PlatformMembershipTypeConfigPrice, ReduceablePrice } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Formatter } from '@stamhoofd/utility';
+import { PlatformMembershipService } from './PlatformMembershipService.js';
+
+describe('PlatformMembershipService.calculatePrice', () => {
+    const membershipPrice = 25_00;
+
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'platform');
+        vitest.useFakeTimers({ shouldAdvanceTime: true, toFake: ['Date'] }).setSystemTime(new Date(2024, 4, 1, 0, 0, 0, 0));
+    });
+
+    afterEach(() => {
+        vitest.useRealTimers();
+    });
+
+    async function setupDaysMembership(maximumDays: number) {
+        const period = await new RegistrationPeriodFactory({
+            startDate: new Date(2024, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2024, 11, 31, 23, 59, 59, 999),
+        }).create();
+        const organization = await new OrganizationFactory({ period }).create();
+        const member = await new MemberFactory({ organization }).create();
+        const membershipType = PlatformMembershipType.create({
+            name: 'Days membership',
+            behaviour: PlatformMembershipTypeBehaviour.Days,
+            periods: new Map([
+                [period.id, PlatformMembershipTypeConfig.create({
+                    startDate: period.startDate,
+                    endDate: period.endDate,
+                    maximumDays,
+                })],
+            ]),
+        });
+
+        const platform = await Platform.getForEditing();
+        platform.periodId = period.id;
+        platform.config.membershipTypes = [membershipType];
+        await platform.save();
+
+        const membership = new MemberPlatformMembership();
+        membership.memberId = member.id;
+        membership.membershipTypeId = membershipType.id;
+        membership.organizationId = organization.id;
+        membership.periodId = period.id;
+
+        return { member, membership };
+    }
+
+    /**
+     * Creates a period membership type with a single configured price, and a membership that is
+     * ready to be priced. The period has a previous period, which is required to become eligible
+     * for a trial.
+     */
+    async function setupPeriodMembership(options: { trialDays?: number } = {}) {
+        const previousPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2023, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        const period = await new RegistrationPeriodFactory({
+            startDate: new Date(2024, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2024, 11, 31, 23, 59, 59, 0),
+            previousPeriodId: previousPeriod.id,
+        }).create();
+
+        const organization = await new OrganizationFactory({ period }).create();
+        const member = await new MemberFactory({ organization }).create();
+
+        const membershipType = PlatformMembershipType.create({
+            name: 'Period membership',
+            behaviour: PlatformMembershipTypeBehaviour.Period,
+            periods: new Map([
+                [period.id, PlatformMembershipTypeConfig.create({
+                    startDate: period.startDate,
+                    endDate: period.endDate,
+                    trialDays: options.trialDays ?? 0,
+                    prices: [
+                        PlatformMembershipTypeConfigPrice.create({
+                            prices: new Map([['', ReduceablePrice.create({ price: membershipPrice })]]),
+                        }),
+                    ],
+                })],
+            ]),
+        });
+
+        const platform = await Platform.getForEditing();
+        platform.periodId = period.id;
+        platform.config.membershipTypes = [membershipType];
+        await platform.save();
+
+        const membership = new MemberPlatformMembership();
+        membership.memberId = member.id;
+        membership.membershipTypeId = membershipType.id;
+        membership.organizationId = organization.id;
+        membership.periodId = period.id;
+        membership.startDate = period.startDate;
+        membership.endDate = period.endDate;
+
+        return { member, membership, organization, period };
+    }
+
+    test('allows the inclusive maximum number of days', async () => {
+        const { member, membership } = await setupDaysMembership(2);
+        membership.startDate = new Date(2024, 4, 1, 0, 0, 0, 0);
+        membership.endDate = new Date(2024, 4, 2, 0, 0, 0, 0);
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+        expect(membership.maximumFreeAmount).toBe(2);
+    });
+
+    test('rejects days memberships that exceed maximum days', async () => {
+        const { member, membership } = await setupDaysMembership(2);
+        membership.startDate = new Date(2024, 4, 1, 0, 0, 0, 0);
+        membership.endDate = new Date(2024, 4, 3, 0, 0, 0, 0);
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).rejects.toMatchObject({
+            code: 'invalid_field',
+            field: 'endDate',
+        });
+    });
+
+    test('calculates the configured price of a period membership', async () => {
+        const { member, membership } = await setupPeriodMembership();
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+
+        expect(membership.price).toBe(membershipPrice);
+        expect(membership.priceWithoutDiscount).toBe(membershipPrice);
+        expect(membership.freeAmount).toBe(0);
+        expect(membership.maximumFreeAmount).toBe(1);
+        expect(membership.trialUntil).toBeNull();
+    });
+
+    test('does not recalculate the price of a locked membership', async () => {
+        const { member, membership } = await setupPeriodMembership();
+        membership.locked = true;
+        membership.price = 1_00;
+        membership.priceWithoutDiscount = 2_00;
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+
+        expect(membership.price).toBe(1_00);
+        expect(membership.priceWithoutDiscount).toBe(2_00);
+    });
+
+    test('rejects a membership with an unknown membership type', async () => {
+        const { member, membership } = await setupPeriodMembership();
+        membership.membershipTypeId = 'unknown-membership-type';
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).rejects.toMatchObject({
+            code: 'invalid_membership_type',
+        });
+
+        // The price is not silently set to zero
+        expect(membership.price).toBe(0);
+        expect(membership.priceWithoutDiscount).toBe(0);
+    });
+
+    test('grants a trial period only when the member has a registration with a trial', async () => {
+        const { member, membership, organization } = await setupPeriodMembership({ trialDays: 14 });
+
+        // Without a registration that had a trial, the member is not eligible for a trial
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+        expect(membership.trialUntil).toBeNull();
+
+        const registration = await new RegistrationFactory({ member, organization }).create();
+        registration.trialUntil = new Date(2024, 4, 20, 12, 0, 0, 0);
+        await registration.save();
+
+        await expect(PlatformMembershipService.calculatePrice(membership, member)).resolves.toBeUndefined();
+
+        // The trial ends trialDays after the start date of the membership
+        expect(membership.trialUntil).not.toBeNull();
+        expect(Formatter.dateIso(membership.trialUntil!)).toBe('2024-01-15');
+        expect(membership.price).toBe(membershipPrice);
+    });
+});