@stamhoofd/backend 2.137.4 → 2.137.5

package/src/excel-loaders/registrations.ts

@@ -1,17 +1,17 @@
 import type { XlsxTransformerSheet } from '@stamhoofd/excel-writer';
 import { XlsxBuiltInNumberFormat } from '@stamhoofd/excel-writer';
 import { Platform } from '@stamhoofd/models';
-import type { LimitedFilteredRequest, PlatformMember } from '@stamhoofd/structures';
-import { ExcelExportType, getGroupTypeName, PlatformRegistration, Platform as PlatformStruct, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
+import type { LimitedFilteredRequest, PlatformMember, Platform as PlatformStruct } from '@stamhoofd/structures';
+import { ExcelExportType, getGroupTypeName, PlatformRegistration, UnencodeablePaginatedResponse } from '@stamhoofd/structures';
 import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint.js';
 import { GetRegistrationsEndpoint } from '../endpoints/global/registration/GetRegistrationsEndpoint.js';
 import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures.js';
 import { Context } from '../helpers/Context.js';
 import { XlsxTransformerColumnHelper } from '../helpers/XlsxTransformerColumnHelper.js';
-import { baseMemberColumns } from './members.js';
+import { getBaseMemberColumns } from './members.js';
 
 // Assign to a typed variable to assure we have correct type checking in place
-const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
+const getSheet = (platform: PlatformStruct): XlsxTransformerSheet<PlatformMember, PlatformRegistration> => ({
     id: 'registrations',
     name: $t('%1EI'),
     columns: [
@@ -294,7 +294,7 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                 ];
             },
         },
-        ...baseMemberColumns.map(column => XlsxTransformerColumnHelper.transformColumnForProperty({
+        ...getBaseMemberColumns(platform).map(column => XlsxTransformerColumnHelper.transformColumnForProperty({
             column,
             key: 'member',
             getPropertyValue: (registration: PlatformRegistration) => registration.member,
@@ -341,7 +341,7 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
                     };
                 }
                 return {
-                    value: PlatformStruct.shared.config.defaultAgeGroups.find(g => g.id === defaultAgeGroupId)?.name ?? $t(`%wJ`),
+                    value: platform.config.defaultAgeGroups.find(g => g.id === defaultAgeGroupId)?.name ?? $t(`%wJ`),
                 };
             },
         },
@@ -356,7 +356,7 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformRegistration> = {
             },
         },
     ],
-};
+});
 
 ExportToExcelEndpoint.loaders.set(ExcelExportType.Registrations, {
     fetch: async (query: LimitedFilteredRequest) => {
@@ -370,7 +370,7 @@ ExportToExcelEndpoint.loaders.set(ExcelExportType.Registrations, {
             next: result.next,
         });
     },
-    sheets: [
-        sheet,
+    getSheets: platform => [
+        getSheet(platform),
     ],
 });

package/src/helpers/AdminPermissionChecker.ts

@@ -794,7 +794,7 @@ export class AdminPermissionChecker {
 
             // Check if this user has permissions for the current scoped organization
             if (this.organization && await this.hasFullAccess(this.organization.id)) {
-                if (user.permissions?.forOrganization(this.organization)) {
+                if (user.permissions?.forOrganization(this.organization, this.platform, { inheritFromPlatform: false })) {
                     return true;
                 }
             }

package/src/helpers/AuthenticatedStructures.ts

@@ -1,9 +1,9 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import type { AuditLog, Document, EventNotification, MemberWithUsersRegistrationsAndGroups, Order, Ticket } from '@stamhoofd/models';
-import { BalanceItem, CachedBalance, Event, Group, Invoice, Member, MemberPlatformMembership, MemberResponsibilityRecord, Organization, OrganizationRegistrationPeriod, Payment, Registration, RegistrationInvitation, RegistrationPeriod, User, Webshop } from '@stamhoofd/models';
+import { BalanceItem, CachedBalance, Event, Group, Invoice, Member, MemberPlatformMembership, MemberResponsibilityRecord, Organization, OrganizationRegistrationPeriod, Payment, Platform as PlatformModel, Registration, RegistrationInvitation, RegistrationPeriod, User, Webshop } from '@stamhoofd/models';
 import type { PaymentGeneral } from '@stamhoofd/structures';
 import { BaseOrganization, getAppHost, OrganizationPrivateMetaData } from '@stamhoofd/structures';
-import { Payment as PaymentStruct, AuditLogReplacement, AuditLogReplacementType, AuditLog as AuditLogStruct, BalanceItem as BalanceItemStruct, DetailedReceivableBalance, Document as DocumentStruct, EventNotification as EventNotificationStruct, Event as EventStruct, GenericBalance, Group as GroupStruct, GroupType, InvitationGroupData, InvitationMemberData, InvoicedBalanceItem, InvoiceStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberRegistrationInvitation, MembersBlob, MemberWithRegistrationsBlob, NamedObject, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentCustomer, PermissionLevel, Platform, PrivateOrder, PrivateWebshop, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, RegistrationInvitation as RegistrationInvitationStruct, RegistrationsBlob, RegistrationWithMemberBlob, TicketPrivate, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { Payment as PaymentStruct, AuditLogReplacement, AuditLogReplacementType, AuditLog as AuditLogStruct, BalanceItem as BalanceItemStruct, DetailedReceivableBalance, Document as DocumentStruct, EventNotification as EventNotificationStruct, Event as EventStruct, GenericBalance, Group as GroupStruct, GroupType, InvitationGroupData, InvitationMemberData, InvoicedBalanceItem, InvoiceStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberRegistrationInvitation, MembersBlob, MemberWithRegistrationsBlob, NamedObject, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentCustomer, PermissionLevel, PrivateOrder, PrivateWebshop, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, RegistrationInvitation as RegistrationInvitationStruct, RegistrationsBlob, RegistrationWithMemberBlob, TicketPrivate, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
 import { Sorter } from '@stamhoofd/utility';
 
 import { SQL } from '@stamhoofd/sql';
@@ -465,11 +465,12 @@ export class AuthenticatedStructures {
             return MembersBlob.create({ members: [], organizations: [] });
         }
 
+        const platform = await PlatformModel.getSharedStruct();
         const organizations = new Map<string, Organization>();
         const relevantPeriodIds = Formatter.uniqueArray([
-            Platform.shared.period.previousPeriodId,
-            Platform.shared.period.id,
-            Platform.shared.period.nextPeriodId,
+            platform.period.previousPeriodId,
+            platform.period.id,
+            platform.period.nextPeriodId,
             Context.organization?.periodId ?? null,
         ].filter(id => id !== null)) as string[];
 
@@ -520,7 +521,7 @@ export class AuthenticatedStructures {
             organizationIds.push(STAMHOOFD.singleOrganization);
         }
 
-        const membershipOrganizationId = Platform.shared.membershipOrganizationId;
+        const membershipOrganizationId = platform.membershipOrganizationId;
         if (membershipOrganizationId && Context.auth.hasSomePlatformAccess()) {
             if (await Context.auth.hasSomeAccess(membershipOrganizationId)) {
                 organizationIds.push(membershipOrganizationId);
@@ -1007,6 +1008,7 @@ export class AuthenticatedStructures {
             ...balances.filter(b => b.objectType === ReceivableBalanceType.user || b.objectType === ReceivableBalanceType.userWithoutMembers).map(b => b.objectId),
         ]);
         const users = userIds.length > 0 ? await User.getByIDs(...userIds) : [];
+        const platform = await PlatformModel.getSharedStruct();
 
         const result: { balance: CachedBalance; object: ReceivableBalanceObject }[] = [];
 
@@ -1131,7 +1133,7 @@ export class AuthenticatedStructures {
             } else if (balance.objectType === ReceivableBalanceType.user || balance.objectType === ReceivableBalanceType.userWithoutMembers) {
                 const user = users.find(m => m.id === balance.objectId) ?? null;
                 if (user) {
-                    const url = Context.organization && Context.organization.id === balance.organizationId ? 'https://' + getAppHost('registration', Context.organization, user.permissions?.forOrganization(Context.organization)?.isEmpty === false) : '';
+                    const url = Context.organization && Context.organization.id === balance.organizationId ? 'https://' + getAppHost('registration', Context.organization, user.permissions?.forOrganization(Context.organization, platform, { inheritFromPlatform: false })?.isEmpty === false) : '';
                     object = ReceivableBalanceObject.create({
                         id: balance.objectId,
                         name: user.name || user.email,
@@ -1193,6 +1195,7 @@ export class AuthenticatedStructures {
         const users = await User.getByIDs(...userIds);
         const organizationsIds = Formatter.uniqueArray(logs.map(l => l.organizationId).filter(id => id !== null));
         const organizations = await Organization.getByIDs(...organizationsIds);
+        const platform = await PlatformModel.getSharedStruct();
 
         for (const log of logs) {
             const user = log.userId ? (users.find(u => u.id === log.userId) ?? null) : null;
@@ -1200,10 +1203,10 @@ export class AuthenticatedStructures {
 
             if (user) {
                 if (!await Context.auth.canAccessUser(user)) {
-                    if (user.permissions?.platform !== null) {
+                    if (user.permissions?.forPlatform(platform) !== null) {
                         userStruct = NamedObject.create({
                             id: '',
-                            name: $t(`%wi`) + ' ' + Platform.shared.config.name,
+                            name: $t(`%wi`) + ' ' + platform.config.name,
                         });
                     } else {
                         userStruct = NamedObject.create({

package/src/helpers/MembershipCharger.ts

@@ -3,6 +3,7 @@ import { BalanceItem, Member, MemberPlatformMembership, Platform, RegistrationPe
 import { SQL, SQLOrderBy, SQLWhereSign } from '@stamhoofd/sql';
 import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType, TranslatedString } from '@stamhoofd/structures';
 import { Formatter, sleep } from '@stamhoofd/utility';
+import { PlatformMembershipService } from '../services/PlatformMembershipService.js';
 
 export const MembershipCharger = {
     async charge() {
@@ -86,7 +87,7 @@ export const MembershipCharger = {
 
                 // Force price update (required because could have changed - especially for free memberships in combination with deletes)
                 try {
-                    await membership.calculatePrice(member);
+                    await PlatformMembershipService.calculatePrice(membership, member);
                 } catch (e) {
                     console.error('Failed to update price for membership. Not charged.', membership.id, e);
                     continue;
@@ -194,7 +195,7 @@ export const MembershipCharger = {
 
                 // Force price update (required because could have changed - especially for free memberships in combination with deletes)
                 try {
-                    await membership.calculatePrice(member);
+                    await PlatformMembershipService.calculatePrice(membership, member);
                     await membership.save();
                 } catch (e) {
                     console.error('Failed to update price for membership', membership.id, e);

package/src/services/BalanceItemService.ts

@@ -7,6 +7,7 @@ import { Formatter } from '@stamhoofd/utility';
 import { GroupedThrottledQueue } from '../helpers/GroupedThrottledQueue.js';
 import { ThrottledQueue } from '../helpers/ThrottledQueue.js';
 import { AuditLogService } from './AuditLogService.js';
+import { OrderService } from './OrderService.js';
 import { PaymentReallocationService } from './PaymentReallocationService.js';
 import { RegistrationService } from './RegistrationService.js';
 import { STPackageService } from './STPackageService.js';
@@ -235,7 +236,7 @@ export class BalanceItemService {
             const order = await Order.getByID(balanceItem.orderId);
             if (order) {
                 shouldMarkUpdated = false;
-                await order.markPaid(payment, organization);
+                await OrderService.markPaid(order, payment, organization);
 
                 // Save number in balance description
                 if (order.number !== null) {

package/src/services/DocumentRenderService.test.ts

@@ -0,0 +1,229 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Document, DocumentTemplateFactory, Organization } from '@stamhoofd/models';
+import { Address, DocumentData, DocumentStatus, File, Image, OrganizationMetaData, PlatformConfig, Platform as PlatformStruct, RecordSettings, RecordTextAnswer, RecordType } from '@stamhoofd/structures';
+import { Country } from '@stamhoofd/types/Country';
+import { DocumentRenderService } from './DocumentRenderService.js';
+
+function createImage(id: string) {
+    return Image.create({
+        id,
+        source: new File({
+            id,
+            server: 'https://files.example.com',
+            path: id + '.png',
+            size: 100,
+        }),
+    });
+}
+
+/**
+ * An organization that is not saved in the database: enough to build a context with.
+ */
+function createOrganization(meta?: Partial<{ horizontalLogo: Image | null; squareLogo: Image | null }>) {
+    const organization = new Organization();
+    organization.name = 'Test organization';
+    organization.meta = OrganizationMetaData.create({
+        horizontalLogo: meta?.horizontalLogo ?? null,
+        squareLogo: meta?.squareLogo ?? null,
+    });
+    organization.address = Address.create({
+        street: 'Demostraat',
+        number: '12',
+        city: 'Gent',
+        postalCode: '9000',
+        country: Country.Belgium,
+    });
+    return organization;
+}
+
+function createDocument() {
+    const document = new Document();
+    document.data = DocumentData.create({ name: 'Test document' });
+    return document;
+}
+
+function createPlatform(config: Partial<{ logoDocuments: Image | null; horizontalLogo: Image | null; squareLogo: Image | null }>) {
+    return PlatformStruct.create({
+        config: PlatformConfig.create({
+            logoDocuments: config.logoDocuments ?? null,
+            horizontalLogo: config.horizontalLogo ?? null,
+            squareLogo: config.squareLogo ?? null,
+        }),
+    });
+}
+
+/**
+ * An answer that cannot be mapped onto the context object, so building the context throws.
+ */
+function createInvalidFieldAnswers() {
+    return new Map([
+        ['', RecordTextAnswer.create({
+            settings: RecordSettings.create({ id: '', type: RecordType.Text }),
+            value: 'Some value',
+        })],
+    ]);
+}
+
+const xmlExport = '<documents>{{#each documents}}<document>{{{this.number}}}</document>{{/each}}</documents>';
+
+/**
+ * Builds a locked template: a locked template makes buildAll return the documents unchanged, so the
+ * numbers set up here are exactly what the renumbering logic gets to see.
+ */
+async function createTemplateWithDocuments(numbers: number[], options?: { xmlExport?: string | null; lockDocuments?: boolean }) {
+    const template = await new DocumentTemplateFactory({
+        groups: [],
+        status: DocumentStatus.Published,
+    }).createWithoutSave();
+
+    template.privateSettings.templateDefinition.xmlExport = options?.xmlExport === undefined ? xmlExport : options.xmlExport;
+    await template.save();
+
+    const documents: Document[] = [];
+    for (const number of numbers) {
+        const document = new Document();
+        document.organizationId = template.organizationId;
+        document.templateId = template.id;
+        document.status = DocumentStatus.Published;
+        document.number = number;
+        document.data = DocumentData.create({ name: 'Test document' });
+        await document.save();
+
+        if (options?.lockDocuments) {
+            document.isLocked = true;
+            await document.save({ forceSave: true });
+        }
+        documents.push(document);
+    }
+
+    // Lock last: a locked template can no longer be saved normally
+    template.isLocked = true;
+    await template.save({ forceSave: true });
+
+    const organization = (await Organization.getByID(template.organizationId))!;
+    return { template, organization, documents };
+}
+
+describe('DocumentRenderService', () => {
+    describe('buildDocumentContext', () => {
+        test('The platform logo falls back from logoDocuments to horizontalLogo to squareLogo', () => {
+            const logoDocuments = createImage('logo-documents');
+            const horizontalLogo = createImage('horizontal-logo');
+            const squareLogo = createImage('square-logo');
+
+            const organization = createOrganization();
+            const document = createDocument();
+
+            const all = DocumentRenderService.buildDocumentContext(document, organization, createPlatform({ logoDocuments, horizontalLogo, squareLogo }));
+            expect(all['platform'].logo.id).toBe(logoDocuments.id);
+            expect(all['logo'].id).toBe(logoDocuments.id);
+
+            const withoutDocumentsLogo = DocumentRenderService.buildDocumentContext(document, organization, createPlatform({ horizontalLogo, squareLogo }));
+            expect(withoutDocumentsLogo['platform'].logo.id).toBe(horizontalLogo.id);
+            expect(withoutDocumentsLogo['logo'].id).toBe(horizontalLogo.id);
+
+            const onlySquareLogo = DocumentRenderService.buildDocumentContext(document, organization, createPlatform({ squareLogo }));
+            expect(onlySquareLogo['platform'].logo.id).toBe(squareLogo.id);
+            expect(onlySquareLogo['logo'].id).toBe(squareLogo.id);
+        });
+
+        test('No logo is added to the context when the platform and the organization have none', () => {
+            const context = DocumentRenderService.buildDocumentContext(createDocument(), createOrganization(), createPlatform({}));
+
+            expect(context['platform']).toBeUndefined();
+            expect(context['logo']).toBeUndefined();
+            expect(context['organization'].logo).toBeUndefined();
+        });
+
+        test('The organization logo takes precedence over the platform logo', () => {
+            const platformLogo = createImage('logo-documents');
+            const organizationLogo = createImage('organization-horizontal-logo');
+
+            const organization = createOrganization({ horizontalLogo: organizationLogo });
+            const context = DocumentRenderService.buildDocumentContext(createDocument(), organization, createPlatform({ logoDocuments: platformLogo }));
+
+            expect(context['logo'].id).toBe(organizationLogo.id);
+            expect(context['organization'].logo.id).toBe(organizationLogo.id);
+
+            // The platform logo remains available separately
+            expect(context['platform'].logo.id).toBe(platformLogo.id);
+        });
+    });
+
+    describe('getRenderedHtml', () => {
+        test('It returns null and logs when building the context fails', async () => {
+            const template = await new DocumentTemplateFactory({ groups: [] }).create();
+
+            const document = createDocument();
+            document.templateId = template.id;
+            document.organizationId = template.organizationId;
+            document.data.fieldAnswers = createInvalidFieldAnswers();
+
+            const consoleError = vitest.spyOn(console, 'error').mockImplementation(() => {});
+
+            try {
+                await expect(DocumentRenderService.getRenderedHtml(document, createOrganization())).resolves.toBeNull();
+                expect(consoleError).toHaveBeenCalledWith('Failed to render document html', expect.any(Error));
+            } finally {
+                consoleError.mockRestore();
+            }
+        });
+
+        test('It returns null when the template no longer exists', async () => {
+            const document = createDocument();
+            document.templateId = '00000000-0000-4000-8000-000000000000';
+
+            await expect(DocumentRenderService.getRenderedHtml(document, createOrganization())).resolves.toBeNull();
+        });
+    });
+
+    describe('getRenderedXml', () => {
+        test('It renumbers the published documents to be strictly increasing and saves them', async () => {
+            const { template, organization, documents } = await createTemplateWithDocuments([1, 3, 7]);
+
+            const xml = await DocumentRenderService.getRenderedXml(template, organization);
+
+            expect(xml).toBe('<documents><document>1</document><document>2</document><document>3</document></documents>');
+
+            // The gaps are closed in the database too
+            for (const [index, document] of documents.entries()) {
+                const reloaded = await Document.getByID(document.id);
+                expect(reloaded!.number).toBe(index + 1);
+            }
+        });
+
+        test('It rethrows a SimpleError instead of swallowing it', async () => {
+            // A locked document cannot be renumbered: saving it throws a SimpleError
+            const { template, organization } = await createTemplateWithDocuments([2], { lockDocuments: true });
+
+            const error = await DocumentRenderService.getRenderedXml(template, organization).then(() => null, (e: unknown) => e);
+
+            expect(error).toBeInstanceOf(SimpleError);
+            expect((error as SimpleError).code).toBe('locked');
+        });
+
+        test('It returns null and logs for any other error', async () => {
+            const { template, organization } = await createTemplateWithDocuments([1]);
+
+            template.settings.fieldAnswers = createInvalidFieldAnswers();
+
+            const consoleError = vitest.spyOn(console, 'error').mockImplementation(() => {});
+
+            try {
+                await expect(DocumentRenderService.getRenderedXml(template, organization)).resolves.toBeNull();
+                expect(consoleError).toHaveBeenCalledWith('Failed to render document html', expect.any(Error));
+            } finally {
+                consoleError.mockRestore();
+            }
+        });
+
+        test('It returns null without building anything when the template has no xml export', async () => {
+            const { template, organization, documents } = await createTemplateWithDocuments([2], { xmlExport: null });
+
+            await expect(DocumentRenderService.getRenderedXml(template, organization)).resolves.toBeNull();
+
+            // No renumbering happened
+            expect((await Document.getByID(documents[0]!.id))!.number).toBe(2);
+        });
+    });
+});

package/src/services/DocumentRenderService.ts

@@ -0,0 +1,180 @@
+import { isSimpleError, isSimpleErrors } from '@simonbackx/simple-errors';
+import type { Document, Organization } from '@stamhoofd/models';
+import { DocumentTemplate, Platform } from '@stamhoofd/models';
+import { render } from '@stamhoofd/models/helpers/Handlebars.js';
+import type { Platform as PlatformStruct } from '@stamhoofd/structures';
+import { DocumentStatus, Version } from '@stamhoofd/structures';
+import { Sorter } from '@stamhoofd/utility';
+
+/**
+ * Renders documents and document templates into HTML/XML.
+ */
+export class DocumentRenderService {
+    /**
+     * Build the handlebars context of a single document.
+     */
+    static buildDocumentContext(document: Document, organization: Organization, platform: PlatformStruct) {
+        // Convert the field answers in a simplified javascript object
+        const data: Record<string, any> = {
+            id: document.id,
+            name: document.data.name,
+            number: document.number,
+            created_at: document.createdAt,
+            organization: {
+                name: organization.name,
+                companyName: organization.meta.companies[0]?.name || organization.name,
+                companyNumber: organization.meta.companies[0]?.companyNumber || null,
+                address: organization.address,
+                companyAddress: organization.meta.companies[0]?.address ?? organization.address,
+            },
+        };
+        const platformLogo = platform.config.logoDocuments ?? platform.config.horizontalLogo ?? platform.config.squareLogo;
+        const organizationLogo = organization.meta.horizontalLogo ?? organization.meta.squareLogo;
+        const logo = organizationLogo || platformLogo;
+
+        if (organizationLogo) {
+            data['organization'] = {
+                ...data['organization'],
+                logo: organizationLogo.encode({ version: Version }) ?? null,
+            };
+        }
+
+        if (platformLogo) {
+            data['platform'] = {
+                logo: platformLogo.encode({ version: Version }) ?? null,
+            };
+        }
+
+        if (logo) {
+            data['logo'] = logo.encode({ version: Version }) ?? null;
+        }
+
+        for (const field of document.data.fieldAnswers.values()) {
+            const keys = field.settings.id.split('.');
+            let current = data;
+            const lastKey = keys.pop()!;
+            if (!lastKey) {
+                throw new Error('Invalid field id');
+            }
+            for (const key of keys) {
+                if (!current[key]) {
+                    current[key] = {};
+                }
+                current = current[key];
+
+                if (typeof current !== 'object') {
+                    throw new Error('Invalid field type');
+                }
+            }
+            current[lastKey] = field.objectValue;
+        }
+        return data;
+    }
+
+    /**
+     * Build the handlebars context of a whole template.
+     *
+     * Note that this writes: an XML export is the moment the numbering becomes final, so any gaps
+     * left by deleted documents are closed and the new numbers are saved.
+     */
+    private static async buildTemplateContext(template: DocumentTemplate, organization: Organization) {
+        // Convert the field answers in a simplified javascript object
+        const documents = (await template.buildAll({ generateNumbers: true })).filter(d => d.status === DocumentStatus.Published && !!d.number).sort((a, b) => Sorter.byNumberValue(b.number ?? 0, a.number ?? 0));
+
+        // Check numbers are strictly increasing
+        let lastNumber = 0;
+        for (const document of documents) {
+            if (document.number !== lastNumber + 1) {
+                document.number = lastNumber + 1;
+                await document.save();
+            }
+            lastNumber = document.number;
+        }
+
+        const platform = await Platform.getSharedStruct();
+
+        const data: Record<string, any> = {
+            id: template.id,
+            created_at: template.createdAt,
+            documents: documents.map(d => this.buildDocumentContext(d, organization, platform)),
+            organization: {
+                name: organization.name,
+                companyName: organization.meta.companies[0]?.name || organization.name,
+                companyNumber: organization.meta.companies[0]?.companyNumber || null,
+                address: organization.address,
+                companyAddress: organization.meta.companies[0]?.address ?? organization.address,
+            },
+        };
+
+        for (const field of template.settings.fieldAnswers.values()) {
+            const keys = field.settings.id.split('.');
+            let current = data;
+            const lastKey = keys.pop()!;
+            if (!lastKey) {
+                throw new Error('Invalid field id');
+            }
+            for (const key of keys) {
+                if (!current[key]) {
+                    current[key] = {};
+                }
+                current = current[key];
+
+                if (typeof current !== 'object') {
+                    throw new Error('Invalid field type');
+                }
+            }
+            current[lastKey] = field.objectValue;
+        }
+
+        return data;
+    }
+
+    /**
+     * Render a document with the html of the template it belongs to.
+     */
+    static async getRenderedHtml(document: Document, organization: Organization): Promise<string | null> {
+        const template = await DocumentTemplate.getByID(document.templateId);
+        if (!template) {
+            return null;
+        }
+
+        return await this.getRenderedHtmlForTemplate(document, organization, template.html);
+    }
+
+    private static async getRenderedHtmlForTemplate(document: Document, organization: Organization, htmlTemplate: string): Promise<string | null> {
+        try {
+            const platform = await Platform.getSharedStruct();
+            const context = this.buildDocumentContext(document, organization, platform);
+            const renderedHtml = await render(htmlTemplate, context);
+            return renderedHtml;
+        } catch (e) {
+            console.error('Failed to render document html', e);
+            return null;
+        }
+    }
+
+    /**
+     * Render the XML export of a template, containing all its published documents.
+     *
+     * Unlike getRenderedHtml this rethrows SimpleErrors: building the context finalises the document
+     * numbering, and a failure there (a locked document for example) has to reach the user instead of
+     * silently turning into a missing export.
+     */
+    static async getRenderedXml(template: DocumentTemplate, organization: Organization): Promise<string | null> {
+        if (!template.privateSettings.templateDefinition.xmlExport) {
+            return null;
+        }
+
+        try {
+            const context = await this.buildTemplateContext(template, organization);
+            const renderedHtml = await render(template.privateSettings.templateDefinition.xmlExport, context);
+            return renderedHtml;
+        } catch (e) {
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                throw e;
+            }
+            console.error('Failed to render document html', e);
+            return null;
+        }
+    }
+}