@stamhoofd/backend 2.137.4 → 2.137.5

package/src/services/PlatformMembershipService.ts

@@ -1,6 +1,7 @@
 import { Model } from '@simonbackx/simple-database';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { logger } from '@simonbackx/simple-logging';
-import { Group, Member, MemberPlatformMembership, Organization, Platform, Registration, RegistrationPeriod } from '@stamhoofd/models';
+import { BalanceItem, Group, Member, MemberPlatformMembership, Organization, Platform, Registration, RegistrationPeriod } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
 import { AuditLogSource, PlatformMembershipTypeBehaviour } from '@stamhoofd/structures';
@@ -331,7 +332,7 @@ export class PlatformMembershipService {
                         membership.endDate = periodConfig.endDate;
                         membership.expireDate = periodConfig.expireDate;
                         membership.generated = true;
-                        await membership.calculatePrice(me, cheapestMembership.registration);
+                        await PlatformMembershipService.calculatePrice(membership, me, cheapestMembership.registration);
 
                         // Check if we have a not-locked but non-generated one that is cheaper
                         // if so, we stop and don't create a new one (but still delete others if required)
@@ -353,7 +354,7 @@ export class PlatformMembershipService {
                             if (!m.locked && m.generated) {
                                 // Update the price and dates of this active membership (could have changed)
                                 try {
-                                    await m.calculatePrice(me, cheapestMembership.registration);
+                                    await PlatformMembershipService.calculatePrice(m, me, cheapestMembership.registration);
                                 } catch (e) {
                                     // Ignore error: membership might not be available anymore
                                     if (!silent) {
@@ -381,7 +382,7 @@ export class PlatformMembershipService {
                                 // Update price
                                 if (!m.locked) {
                                     try {
-                                        await m.calculatePrice(me);
+                                        await PlatformMembershipService.calculatePrice(m, me);
                                     } catch (e) {
                                     // Ignore error: membership might not be available anymore
                                         if (!silent) {
@@ -419,4 +420,280 @@ export class PlatformMembershipService {
             });
         });
     }
+
+    /**
+     * Returns the last trial until date for this member. Null if this member does not have any trials
+     */
+    private static async isElegibleForTrial(membership: MemberPlatformMembership, member: Member) {
+        const period = await RegistrationPeriod.getByID(membership.periodId);
+        if (!period) {
+            return null;
+        }
+
+        if (!period.previousPeriodId) {
+            // We have no previous period = no data = no trials
+            return null;
+        }
+
+        const platform = await Platform.getSharedStruct();
+        const typeIds = platform.config.membershipTypes.filter(m => m.behaviour === PlatformMembershipTypeBehaviour.Period).map(m => m.id);
+
+        const previousMembership = await MemberPlatformMembership.select()
+            .where('memberId', member.id)
+            .where('deletedAt', null)
+            .where('periodId', period.previousPeriodId)
+            .where('membershipTypeId', typeIds)
+            .first(false);
+
+        const hasBlockingMemberships = !!previousMembership;
+
+        if (hasBlockingMemberships) {
+            return null;
+        }
+
+        // The member needs to be registered for at least one registration that had a trial
+        const registrations = await Registration.select()
+            .where('memberId', member.id)
+            .where('periodId', period.id)
+            .where('organizationId', membership.organizationId)
+            .where('deactivatedAt', null)
+            .where('registeredAt', '!=', null)
+            .where('trialUntil', '!=', null)
+            .fetch();
+
+        if (registrations.length === 0) {
+            return null;
+        }
+
+        const latestTrialUntil = new Date(Math.max(...registrations.map(r => r.trialUntil!.getTime())));
+        return latestTrialUntil;
+    }
+
+    private static async correctDates(membership: MemberPlatformMembership, member: Member, registration?: Registration) {
+        if (membership.locked) {
+            // price of locked membership cannot be changed
+            return;
+        }
+
+        const platform = await Platform.getSharedPrivateStruct();
+        const membershipType = platform.config.membershipTypes.find(m => m.id === membership.membershipTypeId);
+
+        if (!membershipType) {
+            throw new SimpleError({
+                code: 'invalid_membership_type',
+                message: 'Unknown membership type',
+                human: $t(`%GM`),
+            });
+        }
+
+        const periodConfig = membershipType.periods.get(membership.periodId);
+
+        if (!periodConfig) {
+            throw new SimpleError({
+                code: 'period_unavailable',
+                message: 'Membership not available for this period',
+                human: $t(`%GN`),
+            });
+        }
+
+        if (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days) {
+            // Make sure time is equal between start and end date
+            let startBrussels = Formatter.luxon(membership.startDate);
+            let endBrussels = Formatter.luxon(membership.endDate);
+            startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+            endBrussels = endBrussels.set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+            membership.startDate = startBrussels.toJSDate();
+            membership.endDate = endBrussels.toJSDate();
+            membership.expireDate = null;
+        } else {
+            membership.endDate = Formatter.luxon(periodConfig.endDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 }).toJSDate();
+            membership.expireDate = periodConfig.expireDate ? Formatter.luxon(periodConfig.expireDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 }).toJSDate() : null;
+
+            // Alter start date
+            if (registration) {
+                const preferredStartDate = registration.startDate ?? registration.registeredAt ?? membership.createdAt;
+                membership.startDate = periodConfig.startDate;
+
+                if (preferredStartDate > periodConfig.startDate && preferredStartDate < periodConfig.endDate) {
+                    let startBrussels = Formatter.luxon(preferredStartDate);
+                    startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+                    membership.startDate = startBrussels.toJSDate();
+                }
+            } else {
+                // Keep the set date, but make sure it is at 0:00 in CET
+                let startBrussels = Formatter.luxon(membership.startDate);
+                startBrussels = startBrussels.set({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+                membership.startDate = startBrussels.toJSDate();
+            }
+        }
+
+        let minimumStartDate = Formatter.luxon(periodConfig.startDate).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toJSDate();
+
+        if (!membership.existsInDatabase) {
+            if (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days) {
+                // Cannot create a membership in the past
+                minimumStartDate = Formatter.luxon(new Date()).set({ hour: 0, minute: 0, second: 0, millisecond: 0 }).toJSDate();
+            }
+        }
+
+        if (membership.startDate < minimumStartDate) {
+            membership.startDate = minimumStartDate;
+        }
+
+        if (membership.endDate < membership.startDate) {
+            membership.endDate = Formatter.luxon(membership.startDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 }).toJSDate();
+        }
+
+        const maximumEndDate = periodConfig.getMaximumEndDate(membership.startDate, membershipType.behaviour);
+        if (membership.endDate > maximumEndDate) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'endDate',
+                message: 'End date is after the maximum allowed end date',
+                human: $t('%15C', { date: Formatter.date(maximumEndDate) }),
+            });
+        }
+
+        if (periodConfig.trialDays) {
+            // Check whether you are elegible for a trial
+            const latestTrialDate = await PlatformMembershipService.isElegibleForTrial(membership, member);
+            if (latestTrialDate !== null) {
+                // Allowed to set trial until, maximum periodConfig.trialDays after startDate
+                let trialUntil = Formatter.luxon(membership.startDate).plus({ days: periodConfig.trialDays });
+                trialUntil = trialUntil.set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+
+                if (trialUntil.toJSDate() > latestTrialDate) {
+                    // Use the latest trial date instead
+                    trialUntil = Formatter.luxon(latestTrialDate);
+                }
+
+                // Max end date
+                if (trialUntil.toJSDate() > membership.endDate) {
+                    trialUntil = Formatter.luxon(membership.endDate).set({ hour: 23, minute: 59, second: 59, millisecond: 0 });
+                }
+
+                membership.trialUntil = trialUntil.toJSDate();
+            } else {
+                membership.trialUntil = null;
+            }
+        } else {
+            // No trial
+            membership.trialUntil = null;
+        }
+    }
+
+    static async calculatePrice(membership: MemberPlatformMembership, member: Member, registration?: Registration) {
+        if (membership.locked) {
+            // price of locked membership cannot be changed
+            return;
+        }
+
+        const platform = await Platform.getSharedPrivateStruct();
+        const membershipType = platform.config.membershipTypes.find(m => m.id === membership.membershipTypeId);
+
+        if (!membershipType) {
+            throw new SimpleError({
+                code: 'invalid_membership_type',
+                message: 'Unknown membership type',
+                human: $t(`%GM`),
+            });
+        }
+
+        const periodConfig = membershipType.periods.get(membership.periodId);
+
+        if (!periodConfig) {
+            throw new SimpleError({
+                code: 'period_unavailable',
+                message: 'Membership not available for this period',
+                human: $t(`%GN`),
+            });
+        }
+
+        const organization = await Organization.getByID(membership.organizationId);
+        if (!organization) {
+            throw new SimpleError({
+                // todo
+                code: 'not_found',
+                message: 'Organization not found',
+                human: $t(`%GO`),
+            });
+        }
+
+        const tagIds = organization.meta.tags;
+        const shouldApplyReducedPrice = member.details.shouldApplyReducedPrice;
+
+        // Correct dates so we get the correct price config
+        await PlatformMembershipService.correctDates(membership, member, registration);
+        const priceConfig = periodConfig.getPriceConfigForDate(membership.trialUntil ?? membership.startDate);
+        const earliestPriceConfig = periodConfig.getPriceConfigForDate(new Date(1950, 0, 1));
+
+        let freeDays = 0;
+
+        const d = membership.createdAt ?? new Date();
+
+        if (periodConfig.amountFree) {
+            // Check if this organization has rights to free memberships
+            const alreadyUsed = await MemberPlatformMembership.select()
+                .where('organizationId', membership.organizationId)
+                .where('membershipTypeId', membership.membershipTypeId)
+                .where('periodId', membership.periodId)
+                .where('deletedAt', null)
+                .whereNot('id', membership.id)
+                .where(
+                    SQL.where('createdAt', SQLWhereSign.Less, d)
+                        .or(
+                            SQL.where('createdAt', SQLWhereSign.Equal, d)
+                                .and('id', SQLWhereSign.Less, membership.id),
+                        ),
+                )
+                .sum(SQL.column('maximumFreeAmount'));
+
+            if (alreadyUsed < periodConfig.amountFree) {
+                freeDays = periodConfig.amountFree - alreadyUsed;
+                console.log('Free membership created for ', membership.id, periodConfig.amountFree, alreadyUsed);
+            } else {
+                console.log('No free membership created for', membership.id, periodConfig.amountFree, alreadyUsed);
+            }
+        }
+
+        if (membershipType.behaviour === PlatformMembershipTypeBehaviour.Days) {
+            const days = Math.round((membership.endDate.getTime() - membership.startDate.getTime()) / (1000 * 60 * 60 * 24));
+            membership.maximumFreeAmount = days;
+            membership.priceWithoutDiscount = earliestPriceConfig.calculatePrice(tagIds, false, days);
+            membership.price = priceConfig.calculatePrice(tagIds, shouldApplyReducedPrice, Math.max(0, days - freeDays));
+            membership.freeAmount = Math.min(days, freeDays);
+        } else {
+            membership.priceWithoutDiscount = earliestPriceConfig.getBasePrice(tagIds, false);
+            membership.price = priceConfig.getBasePrice(tagIds, shouldApplyReducedPrice);
+            membership.maximumFreeAmount = membership.price > 0 ? 1 : 0;
+            membership.freeAmount = 0;
+
+            if (freeDays > 0) {
+                membership.price = 0;
+                membership.freeAmount = 1;
+            }
+        }
+
+        // Never charge itself
+        const chargeVia = platform.membershipOrganizationId;
+        if (membership.organizationId === chargeVia) {
+            membership.price = 0;
+            membership.priceWithoutDiscount = 0;
+            membership.freeAmount = 0;
+            membership.maximumFreeAmount = 0;
+        }
+
+        if (membership.balanceItemId) {
+            membership.maximumFreeAmount = membership.freeAmount;
+
+            // Also update the balance item
+            const balanceItem = await BalanceItem.getByID(membership.balanceItemId);
+            if (balanceItem) {
+                balanceItem.unitPrice = membership.price;
+                await balanceItem.save();
+
+                // await BalanceItem.updateOutstanding([balanceItem]);
+            }
+        }
+    }
 }

package/src/services/RegistrationService.ts

@@ -1,6 +1,6 @@
 import { ManyToOneRelation } from '@simonbackx/simple-database';
 import { encodeObject } from '@simonbackx/simple-encoding';
-import { BalanceItem, Document, Group, Member, Organization, Registration, RegistrationInvitation, sendEmailTemplate } from '@stamhoofd/models';
+import { BalanceItem, Document, Group, Member, Organization, Platform, Registration, RegistrationInvitation, sendEmailTemplate } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { AppliedRegistrationDiscount, AuditLogSource, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, getAppHost, GroupType, Recipient, Replacement, StockReservation, Version } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
@@ -150,6 +150,7 @@ export const RegistrationService = {
         }
 
         const allowedEmails = member.details.getNotificationEmails();
+        const platform = await Platform.getSharedStruct();
 
         return member.users.map(user => Recipient.create({
             firstName: user.firstName,
@@ -167,7 +168,7 @@ export const RegistrationService = {
                 }),
                 Replacement.create({
                     token: 'registerUrl',
-                    value: 'https://' + getAppHost('registration', organization, user.permissions?.forOrganization(organization)?.isEmpty === false),
+                    value: 'https://' + getAppHost('registration', organization, user.permissions?.forOrganization(organization, platform, { inheritFromPlatform: false })?.isEmpty === false),
                 }),
                 Replacement.create({
                     token: 'groupName',

package/src/services/STPackageService.test.ts

@@ -0,0 +1,191 @@
+import { EmailMocker } from '@stamhoofd/email';
+import { EmailTemplateFactory, OrganizationFactory, STPackage, UserFactory } from '@stamhoofd/models';
+import { EmailTemplateType, PermissionLevel, Permissions, STPackageMeta, STPackageType } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
+import { vi } from 'vitest';
+import { STPackageService } from './STPackageService.js';
+
+const DAY = 1000 * 60 * 60 * 24;
+
+/**
+ * A global (not organization scoped) template that only contains the replacements the service fills
+ * in, so the rendered email can be asserted without depending on the real template contents.
+ */
+async function createExpirationTemplate(type: EmailTemplateType) {
+    await new EmailTemplateFactory({
+        type,
+        html: '<p>organizationName: {{organizationName}}</p>'
+            + '<p>packageName: {{packageName}}</p>'
+            + '<p>validUntil: {{validUntil}}</p>'
+            + '<p>validUntilDate: {{validUntilDate}}</p>'
+            + '<p>renewUrl: {{renewUrl}}</p>',
+    }).create();
+}
+
+async function createPackage(options: {
+    organizationId: string;
+    type: STPackageType;
+    /**
+     * Defaults to 10 days from now: inside the reminder window of every package type.
+     */
+    validUntil?: Date | null;
+    removeAt?: Date | null;
+    validAt?: Date | null;
+}) {
+    const pack = new STPackage();
+    pack.organizationId = options.organizationId;
+    pack.meta = STPackageMeta.create({
+        type: options.type,
+        startDate: new Date(Date.now() - 365 * DAY),
+    });
+    pack.validAt = options.validAt !== undefined ? options.validAt : new Date(Date.now() - 365 * DAY);
+    pack.validUntil = options.validUntil !== undefined ? options.validUntil : new Date(Date.now() + 10 * DAY);
+    pack.removeAt = options.removeAt ?? null;
+    await pack.save();
+    return pack;
+}
+
+async function createOrganizationWithAdmin() {
+    const organization = await new OrganizationFactory({}).create();
+    const admin = await new UserFactory({
+        organization,
+        firstName: 'Full',
+        lastName: 'Admin',
+        permissions: Permissions.create({ level: PermissionLevel.Full }),
+    }).create();
+    return { organization, admin };
+}
+
+describe('STPackageService', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    describe('sendExpiryEmail', () => {
+        test('Sends the reminder to the full admins of the organization and records it on the package', async () => {
+            TestUtils.setEnvironment('environment', 'production');
+            await createExpirationTemplate(EmailTemplateType.MembersExpirationReminder);
+
+            const { organization, admin } = await createOrganizationWithAdmin();
+
+            // A user without permissions should not receive the reminder
+            const member = await new UserFactory({ organization }).create();
+
+            const validUntil = new Date(Date.now() + 10 * DAY);
+            const pack = await createPackage({ organizationId: organization.id, type: STPackageType.Members, validUntil });
+
+            await STPackageService.sendExpiryEmail(pack);
+
+            const emails = await EmailMocker.getSucceededEmails();
+            expect(emails.length).toBe(1);
+            expect(emails[0].to).toContain(admin.email);
+            expect(emails[0].to).not.toContain(member.email);
+
+            expect(emails[0].html).toContain('organizationName: ' + organization.name);
+            expect(emails[0].html).toContain('packageName: ' + pack.meta.name);
+            expect(emails[0].html).toContain('validUntil: ' + Formatter.dateTime(validUntil));
+            expect(emails[0].html).toContain('validUntilDate: ' + Formatter.date(validUntil));
+            expect(emails[0].html).toContain(`renewUrl: https://${STAMHOOFD.domains.dashboard ?? 'stamhoofd.app'}/${organization.i18n.locale}/beheerders/${organization.uri}/instellingen/functionaliteiten`);
+
+            expect(pack.lastEmailAt).not.toBeNull();
+            expect(pack.emailCount).toBe(1);
+
+            const fromDatabase = await STPackage.getByID(pack.id);
+            expect(fromDatabase!.lastEmailAt).not.toBeNull();
+            expect(fromDatabase!.emailCount).toBe(1);
+        });
+
+        test('Counts the email, but does not set lastEmailAt, for a package type without a reminder', async () => {
+            TestUtils.setEnvironment('environment', 'production');
+            const { organization } = await createOrganizationWithAdmin();
+
+            // LegacyMembers has no expiration reminder template type
+            const pack = await createPackage({ organizationId: organization.id, type: STPackageType.LegacyMembers });
+
+            await STPackageService.sendExpiryEmail(pack);
+
+            expect(await EmailMocker.getSucceededCount()).toBe(0);
+            expect(pack.lastEmailAt).toBeNull();
+            expect(pack.emailCount).toBe(1);
+
+            const fromDatabase = await STPackage.getByID(pack.id);
+            expect(fromDatabase!.lastEmailAt).toBeNull();
+            expect(fromDatabase!.emailCount).toBe(1);
+        });
+
+        test('Does not send outside production, but still records the email on the package', async () => {
+            // The production guard only covers the send itself: the bookkeeping runs in every environment
+            expect(STAMHOOFD.environment).not.toBe('production');
+            await createExpirationTemplate(EmailTemplateType.MembersExpirationReminder);
+
+            const { organization } = await createOrganizationWithAdmin();
+            const pack = await createPackage({ organizationId: organization.id, type: STPackageType.Members });
+
+            await STPackageService.sendExpiryEmail(pack);
+
+            expect(await EmailMocker.getSucceededCount()).toBe(0);
+            expect(pack.lastEmailAt).not.toBeNull();
+            expect(pack.emailCount).toBe(1);
+
+            const fromDatabase = await STPackage.getByID(pack.id);
+            expect(fromDatabase!.lastEmailAt).not.toBeNull();
+            expect(fromDatabase!.emailCount).toBe(1);
+        });
+
+        test('Logs and skips the email when the organization of the package no longer exists', async () => {
+            TestUtils.setEnvironment('environment', 'production');
+            await createExpirationTemplate(EmailTemplateType.MembersExpirationReminder);
+            const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+            const pack = await createPackage({ organizationId: uuidv4(), type: STPackageType.Members });
+
+            await STPackageService.sendExpiryEmail(pack);
+
+            expect(consoleError).toHaveBeenCalledWith('Could not find package organization ' + pack.id);
+            expect(await EmailMocker.getSucceededCount()).toBe(0);
+
+            // A missing organization does not stop the bookkeeping
+            expect(pack.emailCount).toBe(1);
+        });
+
+        test('Does not send or count a package that is not due', async () => {
+            TestUtils.setEnvironment('environment', 'production');
+            await createExpirationTemplate(EmailTemplateType.MembersExpirationReminder);
+
+            const { organization } = await createOrganizationWithAdmin();
+
+            const neverActivated = await createPackage({ organizationId: organization.id, type: STPackageType.Members, validAt: null });
+
+            // Expires in 100 days, which is outside the 32 day window of a members package
+            const notExpiringSoon = await createPackage({ organizationId: organization.id, type: STPackageType.Members, validUntil: new Date(Date.now() + 100 * DAY) });
+
+            await STPackageService.sendExpiryEmail(neverActivated);
+            await STPackageService.sendExpiryEmail(notExpiringSoon);
+
+            expect(await EmailMocker.getSucceededCount()).toBe(0);
+            expect(neverActivated.emailCount).toBe(0);
+            expect(neverActivated.lastEmailAt).toBeNull();
+            expect(notExpiringSoon.emailCount).toBe(0);
+            expect(notExpiringSoon.lastEmailAt).toBeNull();
+        });
+
+        test('Counts, but does not send, a package that is already removed', async () => {
+            TestUtils.setEnvironment('environment', 'production');
+            await createExpirationTemplate(EmailTemplateType.MembersExpirationReminder);
+
+            const { organization } = await createOrganizationWithAdmin();
+            const pack = await createPackage({ organizationId: organization.id, type: STPackageType.Members, removeAt: new Date(Date.now() - DAY) });
+
+            await STPackageService.sendExpiryEmail(pack);
+
+            expect(await EmailMocker.getSucceededCount()).toBe(0);
+            expect(pack.lastEmailAt).toBeNull();
+            expect(pack.emailCount).toBe(1);
+
+            const fromDatabase = await STPackage.getByID(pack.id);
+            expect(fromDatabase!.emailCount).toBe(1);
+        });
+    });
+});

package/src/services/STPackageService.ts

@@ -1,7 +1,7 @@
-import { BalanceItem, Organization, Platform, STPackage } from '@stamhoofd/models';
+import { BalanceItem, Organization, Platform, sendEmailTemplate, STPackage } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
 import type { Company } from '@stamhoofd/structures';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, getPricingTypeName, STPackageStatus, STPackageType, STPackageTypeHelper, STPricingType, TranslatedString } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, getPricingTypeName, Recipient, Replacement, STPackageStatus, STPackageType, STPackageTypeHelper, STPricingType, TranslatedString } from '@stamhoofd/structures';
 import { Formatter, STMath } from '@stamhoofd/utility';
 import { VATService } from './VATService.js';
 
@@ -263,6 +263,118 @@ export class STPackageService {
         await this.updateOrganizationPackages(organizationId);
     }
 
+    /**
+     * Send the expiration reminder of a package if one is due, and record on the package that it was
+     * sent (also when nothing was sent, so a package is only ever considered once).
+     */
+    static async sendExpiryEmail(pack: STPackage) {
+        if (pack.validAt === null) {
+            // never activated
+            return;
+        }
+
+        if (pack.removeAt && pack.removeAt <= new Date()) {
+            pack.emailCount += 1;
+            await pack.save();
+            return;
+        }
+
+        let allowDays = 0;
+        let type: EmailTemplateType | null = null;
+
+        if (pack.meta.type === STPackageType.Members) {
+            type = EmailTemplateType.MembersExpirationReminder;
+            allowDays = 32;
+        } else if (pack.meta.type === STPackageType.Webshops) {
+            type = EmailTemplateType.WebshopsExpirationReminder;
+            allowDays = 32;
+        } else if (pack.meta.type === STPackageType.SingleWebshop) {
+            type = EmailTemplateType.SingleWebshopExpirationReminder;
+            allowDays = 7;
+        } else if (pack.meta.type === STPackageType.TrialMembers) {
+            type = EmailTemplateType.TrialMembersExpirationReminder;
+            allowDays = 3;
+        } else if (pack.meta.type === STPackageType.TrialWebshops) {
+            type = EmailTemplateType.TrialWebshopsExpirationReminder;
+            allowDays = 3;
+        }
+
+        const allowFrom = new Date(Date.now() + 1000 * 60 * 60 * 24 * allowDays);
+        if (type && (pack.validUntil === null || pack.validUntil < new Date() || pack.validUntil > allowFrom)) {
+            console.log('Skip sending expiration email for ' + pack.id);
+            return;
+        }
+
+        if (type) {
+            console.log('Sending expiration email for ' + pack.id, type);
+            if (STAMHOOFD.environment === 'production') {
+                await this.sendEmailTemplate(pack, {
+                    type,
+                });
+            }
+            pack.lastEmailAt = new Date();
+        } else {
+            console.log('Skip sending expiration email for ' + pack.id + ' (no type)');
+        }
+
+        pack.emailCount += 1;
+        await pack.save();
+    }
+
+    /**
+     * Send an email template about a package to the full administrators of its organization.
+     */
+    static async sendEmailTemplate(pack: STPackage, data: {
+        type: EmailTemplateType;
+    }) {
+        const organization = await Organization.getByID(pack.organizationId);
+
+        if (!organization) {
+            console.error('Could not find package organization ' + pack.id);
+            return;
+        }
+
+        const admins = await organization.getFullAdmins();
+
+        const recipients = admins.map(admin =>
+            Recipient.create({
+                firstName: admin.firstName,
+                lastName: admin.lastName,
+                email: admin.email,
+                replacements: [
+                    Replacement.create({
+                        token: 'organizationName',
+                        value: organization.name,
+                    }),
+                    Replacement.create({
+                        token: 'packageName',
+                        value: pack.meta.name ?? '',
+                    }),
+                    Replacement.create({
+                        token: 'validUntil',
+                        value: pack.validUntil ? Formatter.dateTime(pack.validUntil) : 'nooit',
+                    }),
+                    Replacement.create({
+                        token: 'validUntilDate',
+                        value: pack.validUntil ? Formatter.date(pack.validUntil) : 'nooit',
+                    }),
+                    Replacement.create({
+                        token: 'renewUrl',
+                        value: `https://${(STAMHOOFD.domains.dashboard ?? 'stamhoofd.app')}/${organization.i18n.locale}/beheerders/${organization.uri}/instellingen/functionaliteiten`,
+                    }),
+                ],
+            }),
+        );
+
+        // Create e-mail builder
+        await sendEmailTemplate(null, {
+            template: {
+                type: data.type,
+            },
+            recipients,
+        });
+    }
+
     static async markBalanceRestored(organizationId: string) {
         console.log('Marking packages as restored for ' + organizationId);