@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/DocumentTemplate.ts

@@ -1,22 +1,21 @@
-
-import { column, Model } from "@simonbackx/simple-database";
-import { isSimpleError, isSimpleErrors, SimpleError } from "@simonbackx/simple-errors";
-import { QueueHandler } from "@stamhoofd/queues";
+import { column, Model } from '@simonbackx/simple-database';
+import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
+import { QueueHandler } from '@stamhoofd/queues';
 import { DocumentData, DocumentPrivateSettings, DocumentSettings, DocumentStatus, DocumentTemplatePrivate, RecordAddressAnswer, RecordAnswer, RecordAnswerDecoder, RecordDateAnswer, RecordPriceAnswer, RecordSettings, RecordTextAnswer, RecordType } from '@stamhoofd/structures';
-import { Sorter } from "@stamhoofd/utility";
-import { v4 as uuidv4 } from "uuid";
+import { Sorter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
 
-import { render } from "../helpers/Handlebars";
-import { BalanceItem } from "./BalanceItem";
-import { Document } from "./Document";
-import { Group } from "./Group";
-import { Member, RegistrationWithMember } from "./Member";
-import { Organization } from "./Organization";
+import { render } from '../helpers/Handlebars';
+import { BalanceItem } from './BalanceItem';
+import { Document } from './Document';
+import { Group } from './Group';
+import { Member, RegistrationWithMember } from './Member';
+import { Organization } from './Organization';
 
 export class DocumentTemplate extends Model {
-    static table = "document_templates";
+    static table = 'document_templates';
 
-    @column({ primary: true, type: "string", beforeSave(value) {
+    @column({ primary: true, type: 'string', beforeSave(value) {
         return value ?? uuidv4();
     } })
     id!: string;
@@ -24,158 +23,158 @@ export class DocumentTemplate extends Model {
     /**
      * The HTML that is used to generate the PDF
      */
-    @column({ type: "string" })
-    html: string
+    @column({ type: 'string' })
+    html: string;
 
-    @column({ type: "string"})
-    organizationId: string
+    @column({ type: 'string' })
+    organizationId: string;
 
-    @column({ type: "string" })
-    status = DocumentStatus.Draft
+    @column({ type: 'string' })
+    status = DocumentStatus.Draft;
 
-    @column({ type: "boolean" })
-    updatesEnabled = true
+    @column({ type: 'boolean' })
+    updatesEnabled = true;
 
     /**
      * Settings of the smart document. This information is public
      */
-    @column({ type: "json", decoder: DocumentSettings })
-    settings: DocumentSettings
+    @column({ type: 'json', decoder: DocumentSettings })
+    settings: DocumentSettings;
 
     /**
-     * 
+     *
      */
-    @column({ type: "json", decoder: DocumentPrivateSettings })
-    privateSettings: DocumentPrivateSettings
+    @column({ type: 'json', decoder: DocumentPrivateSettings })
+    privateSettings: DocumentPrivateSettings;
 
-    @column({ type: "datetime" })
-    createdAt: Date = new Date()
+    @column({ type: 'datetime' })
+    createdAt: Date = new Date();
 
     @column({
-        type: "datetime", beforeSave() {
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+        type: 'datetime', beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 
     getPrivateStructure() {
-        return DocumentTemplatePrivate.create(this)
+        return DocumentTemplatePrivate.create(this);
     }
 
     /**
      * Returns the default answers for a given registration
      */
-    async buildAnswers(registration: RegistrationWithMember): Promise<{fieldAnswers: Map<string, RecordAnswer>, missingData: boolean}> {
-        const fieldAnswers = new Map<string, RecordAnswer>()
-        let missingData = false
+    async buildAnswers(registration: RegistrationWithMember): Promise<{ fieldAnswers: Map<string, RecordAnswer>; missingData: boolean }> {
+        const fieldAnswers = new Map<string, RecordAnswer>();
+        let missingData = false;
+
+        const group = await Group.getByID(registration.groupId);
+        const { payments } = await BalanceItem.getForRegistration(registration.id);
 
-        const group = await Group.getByID(registration.groupId)
-        const {payments} = await BalanceItem.getForRegistration(registration.id)
+        const paidAtDates = payments.flatMap(p => p.paidAt ? [p.paidAt?.getTime()] : []);
 
-        const paidAtDates = payments.flatMap(p => p.paidAt ? [p.paidAt?.getTime()] : [])
-        
         // We take the minimum date here, because there is a highter change of later paymetns to be for other things than the registration itself
-        const paidAt = paidAtDates.length ? new Date(Math.min(...paidAtDates)) : null
+        const paidAt = paidAtDates.length ? new Date(Math.min(...paidAtDates)) : null;
 
         // Some fields are supported by default in linked fields
         const defaultData: Record<string, RecordAnswer> = {
-            //"registration.startDate": registration.group.settings.startDate,
-            //"registration.endDate": registration.group.settings.endDate,   
-            "group.name": RecordTextAnswer.create({
+            // "registration.startDate": registration.group.settings.startDate,
+            // "registration.endDate": registration.group.settings.endDate,
+            'group.name': RecordTextAnswer.create({
                 settings: RecordSettings.create({
-                    id: "group.name",
+                    id: 'group.name',
                     type: RecordType.Text,
                 }), // settings will be overwritten
-                value: group?.settings?.name ?? ""
-            }),    
-            "registration.startDate": RecordDateAnswer.create({
+                value: group?.settings?.name ?? '',
+            }),
+            'registration.startDate': RecordDateAnswer.create({
                 settings: RecordSettings.create({
-                    id: "registration.startDate",
+                    id: 'registration.startDate',
                     type: RecordType.Date,
                 }), // settings will be overwritten
-                dateValue: group?.settings?.startDate
+                dateValue: group?.settings?.startDate,
             }),
-            "registration.endDate": RecordDateAnswer.create({
+            'registration.endDate': RecordDateAnswer.create({
                 settings: RecordSettings.create({
-                    id: "registration.endDate",
+                    id: 'registration.endDate',
                     type: RecordType.Date,
                 }), // settings will be overwritten
-                dateValue: group?.settings?.endDate
+                dateValue: group?.settings?.endDate,
             }),
-            "registration.price": 
+            'registration.price':
                 RecordPriceAnswer.create({
                     settings: RecordSettings.create({}), // settings will be overwritten
-                    value: registration.price
+                    value: registration.price,
                 }),
-            "registration.pricePaid": 
+            'registration.pricePaid':
                 RecordPriceAnswer.create({
                     settings: RecordSettings.create({}), // settings will be overwritten
-                    value: registration.pricePaid
+                    value: registration.pricePaid,
                 }),
-            "registration.paidAt": 
+            'registration.paidAt':
                 RecordDateAnswer.create({
                     settings: RecordSettings.create({
-                        id: "registration.paidAt",
+                        id: 'registration.paidAt',
                         type: RecordType.Date,
                     }), // settings will be overwritten
-                    dateValue: paidAt
+                    dateValue: paidAt,
                 }),
-            "member.firstName": RecordTextAnswer.create({
+            'member.firstName': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.firstName
+                value: registration.member.details.firstName,
             }),
-            "member.lastName":  RecordTextAnswer.create({
+            'member.lastName': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.lastName
+                value: registration.member.details.lastName,
             }),
-            "member.address": RecordAddressAnswer.create({
+            'member.address': RecordAddressAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                address: registration.member.details.address ?? null
+                address: registration.member.details.address ?? null,
             }),
-            "member.email": RecordTextAnswer.create({
+            'member.email': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.email ?? null
+                value: registration.member.details.email ?? null,
             }),
-            "member.birthDay": RecordDateAnswer.create({
+            'member.birthDay': RecordDateAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                dateValue: registration.member.details.birthDay
+                dateValue: registration.member.details.birthDay,
             }),
-            "parents[0].firstName": RecordTextAnswer.create({
+            'parents[0].firstName': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.parents[0]?.firstName
+                value: registration.member.details.parents[0]?.firstName,
             }),
-            "parents[0].lastName": RecordTextAnswer.create({
+            'parents[0].lastName': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.parents[0]?.lastName
+                value: registration.member.details.parents[0]?.lastName,
             }),
-            "parents[0].address": RecordAddressAnswer.create({
+            'parents[0].address': RecordAddressAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                address: registration.member.details.parents[0]?.address ?? null
+                address: registration.member.details.parents[0]?.address ?? null,
             }),
-            "parents[0].email": RecordTextAnswer.create({
+            'parents[0].email': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.parents[0]?.email ?? null
+                value: registration.member.details.parents[0]?.email ?? null,
             }),
-            "parents[1].firstName": RecordTextAnswer.create({
+            'parents[1].firstName': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.parents[1]?.firstName
+                value: registration.member.details.parents[1]?.firstName,
             }),
-            "parents[1].lastName": RecordTextAnswer.create({
+            'parents[1].lastName': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.parents[1]?.lastName
+                value: registration.member.details.parents[1]?.lastName,
             }),
-            "parents[1].address": RecordAddressAnswer.create({
+            'parents[1].address': RecordAddressAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                address: registration.member.details.parents[1]?.address ?? null
+                address: registration.member.details.parents[1]?.address ?? null,
             }),
-            "parents[1].email": RecordTextAnswer.create({
+            'parents[1].email': RecordTextAnswer.create({
                 settings: RecordSettings.create({}), // settings will be overwritten
-                value: registration.member.details.parents[1]?.email ?? null
-            })
-        }
+                value: registration.member.details.parents[1]?.email ?? null,
+            }),
+        };
 
         // Add data that is different for each member
         for (const field of this.privateSettings.templateDefinition.documentFieldCategories.flatMap(c => c.getAllRecords())) {
@@ -183,7 +182,7 @@ export class DocumentTemplate extends Model {
             // - Could either return an id of a recordSetting connected to member
             // - or an idea of defaultData that is supported by default
             // The result is always a recordAnswer whose type should match the type of the linkedField
-            const linkedToMemberAnswerSettingsIds = this.settings.linkedFields.get(field.id)
+            const linkedToMemberAnswerSettingsIds = this.settings.linkedFields.get(field.id);
 
             let found = false;
 
@@ -191,14 +190,14 @@ export class DocumentTemplate extends Model {
                 for (const linkedToMemberAnswerSettingsId of linkedToMemberAnswerSettingsIds) {
                     if (linkedToMemberAnswerSettingsId) {
                         const answer = registration.member.details.recordAnswers.get(linkedToMemberAnswerSettingsId);
-                        if (answer && !answer.isEmpty && answer.settings.type === field.type) {  
+                        if (answer && !answer.isEmpty && answer.settings.type === field.type) {
                             // We need to link it with the settings in the template
-                            const clone = answer.clone()
-                            clone.settings = field
-                            clone.reviewedAt = null // All linked fields are not reviewed. Unless they are manually changed by an admin later
-                        
-                            found = true
-                            fieldAnswers.set(field.id, clone)
+                            const clone = answer.clone();
+                            clone.settings = field;
+                            clone.reviewedAt = null; // All linked fields are not reviewed. Unless they are manually changed by an admin later
+
+                            found = true;
+                            fieldAnswers.set(field.id, clone);
                             break;
                         }
 
@@ -206,14 +205,15 @@ export class DocumentTemplate extends Model {
                         if (defaultData[linkedToMemberAnswerSettingsId] && !defaultData[linkedToMemberAnswerSettingsId].isEmpty) {
                             if (defaultData[linkedToMemberAnswerSettingsId] instanceof RecordAnswerDecoder.getClassForType(field.type)) {
                                 // We need to clone here, because the same default data can be used in multiple places
-                                const clone = defaultData[linkedToMemberAnswerSettingsId].clone()
-                                clone.settings = field
+                                const clone = defaultData[linkedToMemberAnswerSettingsId].clone();
+                                clone.settings = field;
 
-                                found = true
-                                fieldAnswers.set(field.id, clone)
+                                found = true;
+                                fieldAnswers.set(field.id, clone);
                                 break;
-                            } else {
-                                console.warn("Found type mismatch for default data: " + linkedToMemberAnswerSettingsId + " - " + field.id)
+                            }
+                            else {
+                                console.warn('Found type mismatch for default data: ' + linkedToMemberAnswerSettingsId + ' - ' + field.id);
                             }
                         }
                     }
@@ -228,29 +228,29 @@ export class DocumentTemplate extends Model {
                 // Add placeholder (so we have proper warnings)
                 const clone = RecordAnswerDecoder.getClassForType(field.type).create({
                     settings: field,
-                })
-                fieldAnswers.set(field.id, clone)
+                });
+                fieldAnswers.set(field.id, clone);
             }
         }
 
         // Add global answers (same for each document)
         for (const answer of this.settings.fieldAnswers.values()) {
             // todo: check duplicate
-            answer.reviewedAt = null
-            fieldAnswers.set(answer.settings.id, answer)
+            answer.reviewedAt = null;
+            fieldAnswers.set(answer.settings.id, answer);
         }
 
         // Add group based answers (same for each group)
-        for (const answer of this.privateSettings.groups.find(g => g.groupId === registration.groupId && g.cycle === registration.cycle)?.fieldAnswers?.values() ?? []){
+        for (const answer of this.privateSettings.groups.find(g => g.groupId === registration.groupId && g.cycle === registration.cycle)?.fieldAnswers?.values() ?? []) {
             // todo: check duplicate
-            answer.reviewedAt = null
-            fieldAnswers.set(answer.settings.id, answer)
+            answer.reviewedAt = null;
+            fieldAnswers.set(answer.settings.id, answer);
         }
 
         // Add other default data
         for (const key in defaultData) {
             if (defaultData[key] && defaultData[key].settings.id === key && !fieldAnswers.get(key)) {
-                fieldAnswers.set(key, defaultData[key])
+                fieldAnswers.set(key, defaultData[key]);
             }
         }
 
@@ -258,9 +258,10 @@ export class DocumentTemplate extends Model {
         if (!missingData) {
             for (const answer of fieldAnswers.values()) {
                 try {
-                    answer.validate()
-                } catch (e) {
-                    missingData = true
+                    answer.validate();
+                }
+                catch (e) {
+                    missingData = true;
                     break;
                 }
             }
@@ -268,33 +269,33 @@ export class DocumentTemplate extends Model {
 
         return {
             fieldAnswers,
-            missingData
-        }
+            missingData,
+        };
     }
 
     async createForRegistrationIfNeeded(registration: RegistrationWithMember) {
         // Check group and cycle
         for (const groupDefinition of this.privateSettings.groups) {
             if (groupDefinition.groupId === registration.groupId && groupDefinition.cycle === registration.cycle) {
-                const document = await this.generateForRegistration(registration)
+                const document = await this.generateForRegistration(registration);
                 if (document) {
-                    await document.save()
+                    await document.save();
                 }
             }
         }
     }
 
     private async generateForRegistration(registration: RegistrationWithMember) {
-        const {fieldAnswers, missingData} = await this.buildAnswers(registration)
-        const existingDocuments = await Document.where({ templateId: this.id, registrationId: registration.id }, {limit: 1})
+        const { fieldAnswers, missingData } = await this.buildAnswers(registration);
+        const existingDocuments = await Document.where({ templateId: this.id, registrationId: registration.id }, { limit: 1 });
 
         if (!this.checkIncluded(registration, fieldAnswers)) {
             if (existingDocuments.length > 0) {
                 for (const document of existingDocuments) {
-                    await document.delete()
+                    await document.delete();
                 }
             }
-            return null
+            return null;
         }
 
         const fieldId = 'registration.startDate';
@@ -309,33 +310,34 @@ export class DocumentTemplate extends Model {
             }
         }
 
-        const group = await Group.getByID(registration.groupId)
+        const group = await Group.getByID(registration.groupId);
         const description = `${registration.member.details.name}, ${group ? group.settings.name : ''}`;
 
         if (existingDocuments.length > 0) {
             for (const document of existingDocuments) {
-                await this.updateDocumentFor(document, registration)
-                document.data.name = this.settings.name
-                document.data.description = description
+                await this.updateDocumentFor(document, registration);
+                document.data.name = this.settings.name;
+                document.data.description = description;
                 if (document.status === DocumentStatus.Draft || document.status === DocumentStatus.Published) {
                     document.status = this.status;
                 }
-                await document.save()
+                await document.save();
                 return document;
             }
-        } else {
-            const document = new Document()
-            document.organizationId = this.organizationId
-            document.templateId = this.id
+        }
+        else {
+            const document = new Document();
+            document.organizationId = this.organizationId;
+            document.templateId = this.id;
             document.status = missingData ? DocumentStatus.MissingData : this.status;
             document.data = DocumentData.create({
                 name: this.settings.name,
                 description,
-                fieldAnswers
-            })
-            document.memberId = registration.member.id
-            document.registrationId = registration.id
-            await document.save()
+                fieldAnswers,
+            });
+            document.memberId = registration.member.id;
+            document.registrationId = registration.id;
+            await document.save();
             return document;
         }
     }
@@ -355,18 +357,19 @@ export class DocumentTemplate extends Model {
             }
 
             if (startDate) {
-                const age = registration.member.details.ageOnDate(startDate)
+                const age = registration.member.details.ageOnDate(startDate);
 
                 if (age === null) {
-                    console.warn("Missing member age checking maxAge")
+                    console.warn('Missing member age checking maxAge');
                     return false;
                 }
 
                 if (age > this.settings.maxAge) {
                     return false;
                 }
-            } else {
-                console.warn("Missing registration.startDate in fieldAnswers when checking maxAge")
+            }
+            else {
+                console.warn('Missing registration.startDate in fieldAnswers when checking maxAge');
             }
         }
 
@@ -387,19 +390,20 @@ export class DocumentTemplate extends Model {
                 if (price < this.settings.minPrice) {
                     return false;
                 }
-            } else {
-                console.warn("Missing registration.price in fieldAnswers when checking minPrice")
+            }
+            else {
+                console.warn('Missing registration.price in fieldAnswers when checking minPrice');
             }
         }
-        
+
         return true;
     }
 
-    async buildAll({generateNumbers = false} = {}) {
-        return await QueueHandler.schedule("documents-build-all/"+this.id, async () => {
+    async buildAll({ generateNumbers = false } = {}) {
+        return await QueueHandler.schedule('documents-build-all/' + this.id, async () => {
             if (!this.updatesEnabled) {
                 // Check status
-                const documents = await Document.where({ templateId: this.id })
+                const documents = await Document.where({ templateId: this.id });
                 for (const document of documents) {
                     if (document.status === DocumentStatus.Draft || document.status === DocumentStatus.Published) {
                         document.status = this.status;
@@ -409,7 +413,7 @@ export class DocumentTemplate extends Model {
 
                 // Generate numbers for all documents
                 if (generateNumbers) {
-                    let nextNumber = Math.max(0, ...documents.map(d => d.number).filter(n => n !== null) as number[]) + 1
+                    let nextNumber = Math.max(0, ...documents.map(d => d.number).filter(n => n !== null) as number[]) + 1;
                     for (const document of documents) {
                         if (document.number === null && document.status === DocumentStatus.Published) {
                             document.number = nextNumber;
@@ -418,42 +422,43 @@ export class DocumentTemplate extends Model {
                         }
                     }
                 }
-                return documents
+                return documents;
             }
-            
-            console.log('Building all documents for template', this.id)
-            const documentSet: Map<string, Document> = new Map()
+
+            console.log('Building all documents for template', this.id);
+            const documentSet: Map<string, Document> = new Map();
 
             for (const groupDefinition of this.privateSettings.groups) {
                 // Get the registrations for this group with this cycle
-                const registrations = await Member.getRegistrationWithMembersForGroup(groupDefinition.groupId)
+                const registrations = await Member.getRegistrationWithMembersForGroup(groupDefinition.groupId);
 
                 for (const registration of registrations) {
-                    const document = await this.generateForRegistration(registration)
+                    const document = await this.generateForRegistration(registration);
                     if (document) {
-                        documentSet.set(document.id, document)
+                        documentSet.set(document.id, document);
                     }
                 }
             }
 
             // Delete documents that no longer match and don't have a number yet
-            const documents = await Document.where({ templateId: this.id })
+            const documents = await Document.where({ templateId: this.id });
             for (const document of documents) {
                 if (!documentSet.has(document.id)) {
                     if (document.number === null) {
-                        await document.delete()
-                    } else {
+                        await document.delete();
+                    }
+                    else {
                         document.status = DocumentStatus.Deleted;
                         await document.save();
                     }
                 }
             }
 
-            const allDocuments = [...documentSet.values()]
+            const allDocuments = [...documentSet.values()];
 
             // Generate numbers for all documents
             if (generateNumbers) {
-                let nextNumber = Math.max(0, ...allDocuments.map(d => d.number).filter(n => n !== null) as number[]) + 1
+                let nextNumber = Math.max(0, ...allDocuments.map(d => d.number).filter(n => n !== null) as number[]) + 1;
                 for (const document of allDocuments) {
                     if (document.number === null && document.status === DocumentStatus.Published) {
                         document.number = nextNumber;
@@ -463,51 +468,51 @@ export class DocumentTemplate extends Model {
                 }
             }
 
-            return allDocuments
+            return allDocuments;
         });
     }
 
     private async buildContext(organization: Organization) {
         // Convert the field answers in a simplified javascript object
-        const documents = (await this.buildAll({generateNumbers: true})).filter(d => d.status === DocumentStatus.Published && !!d.number).sort((a, b) => Sorter.byNumberValue(b.number ?? 0, a.number ?? 0))
+        const documents = (await this.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) {
                 throw new SimpleError({
-                    code: "invalid_document_number",
+                    code: 'invalid_document_number',
                     message: 'Expected document number to be ' + (lastNumber + 1) + ' but got ' + document.number,
-                    human: "Er ging iets mis bij het nummeren van de documenten (ben je zeker dat je geen documenten hebt verwijderd of toegevoegd sinds de vorige export?). Als je de export nog niet hebt gebruikt in Belcotax kan je de nummering resetten en de export opnieuw proberen.",
-                })
+                    human: 'Er ging iets mis bij het nummeren van de documenten (ben je zeker dat je geen documenten hebt verwijderd of toegevoegd sinds de vorige export?). Als je de export nog niet hebt gebruikt in Belcotax kan je de nummering resetten en de export opnieuw proberen.',
+                });
             }
             lastNumber = document.number;
         }
 
         const data = {
-            "id": this.id,
-            "created_at": this.createdAt,
-            "documents": documents.map(d => d.buildContext(organization)),
+            id: this.id,
+            created_at: this.createdAt,
+            documents: documents.map(d => d.buildContext(organization)),
         };
 
         for (const field of this.settings.fieldAnswers.values()) {
-            const keys = field.settings.id.split('.')
-            let current = data
-            const lastKey = keys.pop()!
+            const keys = field.settings.id.split('.');
+            let current = data;
+            const lastKey = keys.pop()!;
             if (!lastKey) {
-                throw new Error("Invalid field id")
+                throw new Error('Invalid field id');
             }
             for (const key of keys) {
                 if (!current[key]) {
-                    current[key] = {}
+                    current[key] = {};
                 }
-                current = current[key]
+                current = current[key];
 
-                if (typeof current !== "object") {
-                    throw new Error("Invalid field type")
+                if (typeof current !== 'object') {
+                    throw new Error('Invalid field type');
                 }
             }
-            current[lastKey] = field.objectValue
+            current[lastKey] = field.objectValue;
         }
 
         return data;
@@ -517,31 +522,33 @@ export class DocumentTemplate extends Model {
         if (!this.privateSettings.templateDefinition.xmlExport) {
             return null;
         }
-        
+
         try {
-            const context = await this.buildContext(organization)
+            const context = await this.buildContext(organization);
             const renderedHtml = render(this.privateSettings.templateDefinition.xmlExport, context);
             return renderedHtml;
-        } catch (e) {
+        }
+        catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {
                 throw e;
             }
-            console.error('Failed to render document html', e)
+            console.error('Failed to render document html', e);
             return null;
         }
     }
 
     areAnswersComplete(answers: Map<string, RecordAnswer>) {
         for (const field of this.privateSettings.templateDefinition.documentFieldCategories.flatMap(c => c.getAllRecords())) {
-            const answer = answers.get(field.id)
+            const answer = answers.get(field.id);
             if (!answer) {
                 return false;
             }
             // Update settings
-            answer.settings = field
+            answer.settings = field;
             try {
-                answer.validate()
-            } catch (e) {
+                answer.validate();
+            }
+            catch (e) {
                 // Invalid
                 return false;
             }
@@ -550,32 +557,34 @@ export class DocumentTemplate extends Model {
     }
 
     async updateDocumentFor(document: Document, registration: RegistrationWithMember) {
-        const {fieldAnswers} = await this.buildAnswers(registration)
-        const existingAnswers = document.data.fieldAnswers
+        const { fieldAnswers } = await this.buildAnswers(registration);
+        const existingAnswers = document.data.fieldAnswers;
 
-        const newAnswers = new Map(existingAnswers)
+        const newAnswers = new Map(existingAnswers);
 
         for (const addAnswer of fieldAnswers.values()) {
-            const existing = newAnswers.get(addAnswer.settings.id) //newAnswers.findIndex(a => a.settings.id === addAnswer.settings.id)
+            const existing = newAnswers.get(addAnswer.settings.id); // newAnswers.findIndex(a => a.settings.id === addAnswer.settings.id)
             if (existing) {
                 // We already have an answer for this field, we'll only update it if addAnswer is reviewed later
                 if (!existing.isReviewedAfter(addAnswer)) {
-                    newAnswers.set(addAnswer.settings.id, addAnswer)
+                    newAnswers.set(addAnswer.settings.id, addAnswer);
                 }
-            } else {
-                newAnswers.set(addAnswer.settings.id, addAnswer)
+            }
+            else {
+                newAnswers.set(addAnswer.settings.id, addAnswer);
             }
         }
 
-        document.data.fieldAnswers = newAnswers
-        const complete = this.areAnswersComplete(newAnswers)
+        document.data.fieldAnswers = newAnswers;
+        const complete = this.areAnswersComplete(newAnswers);
 
         if (document.status !== DocumentStatus.Deleted) {
             if (!complete) {
-                document.status = DocumentStatus.MissingData
-            } else {
+                document.status = DocumentStatus.MissingData;
+            }
+            else {
                 if (document.status === DocumentStatus.MissingData) {
-                    document.status = this.status
+                    document.status = this.status;
                 }
             }
         }