@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/Document.ts

@@ -1,202 +1,205 @@
-
-import { column, Model } from "@simonbackx/simple-database";
+import { column, Model } from '@simonbackx/simple-database';
 import { Document as DocumentStruct, DocumentData, DocumentStatus } from '@stamhoofd/structures';
-import { Formatter } from "@stamhoofd/utility";
-import { v4 as uuidv4 } from "uuid";
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
 
-import { render } from "../helpers/Handlebars";
-import { RegistrationWithMember } from "./Member";
-import { Organization } from "./Organization";
+import { render } from '../helpers/Handlebars';
+import { RegistrationWithMember } from './Member';
+import { Organization } from './Organization';
 
 export class Document extends Model {
-    static table = "documents";
+    static table = 'documents';
 
-    @column({ primary: true, type: "string", beforeSave(value) {
+    @column({ primary: true, type: 'string', beforeSave(value) {
         return value ?? uuidv4();
     } })
     id!: string;
 
-    @column({ type: "string"})
-    organizationId: string
+    @column({ type: 'string' })
+    organizationId: string;
 
-    @column({ type: "string"})
-    templateId: string
+    @column({ type: 'string' })
+    templateId: string;
 
     /**
      * Used to give a member access to the document
      */
-    @column({ type: "string", nullable: true })
-    memberId: string | null = null
+    @column({ type: 'string', nullable: true })
+    memberId: string | null = null;
 
     /**
      * Used to identify document already created for a registration (= to update it)
      */
-    @column({ type: "string", nullable: true })
-    registrationId: string | null = null
+    @column({ type: 'string', nullable: true })
+    registrationId: string | null = null;
 
-    @column({ type: "string" })
-    status = DocumentStatus.Draft
+    @column({ type: 'string' })
+    status = DocumentStatus.Draft;
 
     /**
      * Assigned when exporting the document
      */
-    @column({ type: "integer", nullable: true })
-    number: number | null = null
+    @column({ type: 'integer', nullable: true })
+    number: number | null = null;
 
     /**
      * Settings of the document. This information is public
      */
-    @column({ type: "json", decoder: DocumentData })
-    data = DocumentData.create({})
+    @column({ type: 'json', decoder: DocumentData })
+    data = DocumentData.create({});
 
-    @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;
 
     getStructure() {
-        return DocumentStruct.create(this)
+        return DocumentStruct.create(this);
     }
 
     buildContext(organization: Organization) {
         // Convert the field answers in a simplified javascript object
         const data = {
-            "id": this.id,
-            "name": this.data.name,
-            "number": this.number,
-            "created_at": this.createdAt,
-            "organization.logo": organization.meta.squareLogo,
+            'id': this.id,
+            'name': this.data.name,
+            'number': this.number,
+            'created_at': this.createdAt,
+            'organization.logo': organization.meta.squareLogo,
         };
 
         for (const field of this.data.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;
     }
 
     async updateData(): Promise<void> {
         if (!this.registrationId) {
-            console.log('No registration id, skipping update')
-            return
+            console.log('No registration id, skipping update');
+            return;
         }
-        const DocumentTemplate = (await import("./DocumentTemplate")).DocumentTemplate
-        const template = await DocumentTemplate.getByID(this.templateId)
+        const DocumentTemplate = (await import('./DocumentTemplate')).DocumentTemplate;
+        const template = await DocumentTemplate.getByID(this.templateId);
         if (!template) {
-            console.log('No template, skipping update')
-            return
+            console.log('No template, skipping update');
+            return;
         }
 
         if (!template.updatesEnabled) {
-            console.log('No updatesEnabled, skipping update')
-            return
+            console.log('No updatesEnabled, skipping update');
+            return;
         }
 
-        const Member = (await import("./Member")).Member
-        const [registration] = await Member.getRegistrationWithMembersByIDs([this.registrationId])
+        const Member = (await import('./Member')).Member;
+        const [registration] = await Member.getRegistrationWithMembersByIDs([this.registrationId]);
         if (!registration) {
-            console.log('No registration, skipping update')
-            return
+            console.log('No registration, skipping update');
+            return;
         }
 
-        await template.updateDocumentFor(this, registration)
+        await template.updateDocumentFor(this, registration);
     }
 
     static async updateForMember(memberId: string) {
         try {
-            console.log('Updating documents for member', memberId)
-            const Member = (await import("./Member")).Member
-            const member = await Member.getWithRegistrations(memberId)
+            console.log('Updating documents for member', memberId);
+            const Member = (await import('./Member')).Member;
+            const member = await Member.getWithRegistrations(memberId);
             if (member) {
-                const organizationIds = Formatter.uniqueArray(member.registrations.map(r => r.organizationId))
+                const organizationIds = Formatter.uniqueArray(member.registrations.map(r => r.organizationId));
                 for (const organizationId of organizationIds) {
-                    await this.updateForRegistrations(member.registrations.map(r => r.id), organizationId)
+                    await this.updateForRegistrations(member.registrations.map(r => r.id), organizationId);
                 }
             }
-        } catch (e) {
-            console.error(e)
+        }
+        catch (e) {
+            console.error(e);
         }
     }
 
     static async updateForRegistration(registration: RegistrationWithMember) {
         try {
-            console.log('Updating documents for registration', registration.id)
+            console.log('Updating documents for registration', registration.id);
 
-            const DocumentTemplate = (await import("./DocumentTemplate")).DocumentTemplate
-            const templates = await DocumentTemplate.where({updatesEnabled: 1, organizationId: registration.member.organizationId})
+            const DocumentTemplate = (await import('./DocumentTemplate')).DocumentTemplate;
+            const templates = await DocumentTemplate.where({ updatesEnabled: 1, organizationId: registration.member.organizationId });
 
             for (const template of templates) {
-                await template.createForRegistrationIfNeeded(registration)
+                await template.createForRegistrationIfNeeded(registration);
             }
-        } catch (e) {
-            console.error(e)
+        }
+        catch (e) {
+            console.error(e);
         }
     }
 
     static async updateForRegistrations(registrationIds: string[], organizationId: string) {
         try {
-            console.log('Updating documents for updateForRegistrations', registrationIds)
+            console.log('Updating documents for updateForRegistrations', registrationIds);
 
-            const DocumentTemplate = (await import("./DocumentTemplate")).DocumentTemplate
-            const templates = await DocumentTemplate.where({updatesEnabled: 1, organizationId})
+            const DocumentTemplate = (await import('./DocumentTemplate')).DocumentTemplate;
+            const templates = await DocumentTemplate.where({ updatesEnabled: 1, organizationId });
 
             if (templates.length) {
-                const Member = (await import("./Member")).Member
-                const registrations = await Member.getRegistrationWithMembersByIDs(registrationIds)
+                const Member = (await import('./Member')).Member;
+                const registrations = await Member.getRegistrationWithMembersByIDs(registrationIds);
 
                 for (const template of templates) {
                     for (const registration of registrations) {
-                        await template.createForRegistrationIfNeeded(registration)
+                        await template.createForRegistrationIfNeeded(registration);
                     }
                 }
             }
-        } catch (e) {
-            console.error(e)
+        }
+        catch (e) {
+            console.error(e);
         }
     }
 
     // Rander handlebars template
     async getRenderedHtml(organization: Organization): Promise<string | null> {
-        const DocumentTemplate = (await import("./DocumentTemplate")).DocumentTemplate
-        const template = await DocumentTemplate.getByID(this.templateId)
+        const DocumentTemplate = (await import('./DocumentTemplate')).DocumentTemplate;
+        const template = await DocumentTemplate.getByID(this.templateId);
         if (!template) {
-            return null
+            return null;
         }
 
-        return this.getRenderedHtmlForTemplate(organization, template.html)
+        return this.getRenderedHtmlForTemplate(organization, template.html);
     }
 
     // Rander handlebars template
     private getRenderedHtmlForTemplate(organization: Organization, htmlTemplate: string): string | null {
         try {
-            const context = this.buildContext(organization)
+            const context = this.buildContext(organization);
             const renderedHtml = render(htmlTemplate, context);
             return renderedHtml;
-        } catch (e) {
-            console.error('Failed to render document html', e)
+        }
+        catch (e) {
+            console.error('Failed to render document html', e);
             return null;
         }
     }