@stamhoofd/backend 2.39.1 → 2.40.1

package/src/endpoints/organization/dashboard/documents/GetDocumentTemplatesEndpoint.ts

@@ -1,22 +1,22 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
-import { DocumentTemplate, Token } from "@stamhoofd/models";
-import { DocumentTemplatePrivate } from "@stamhoofd/structures";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { DocumentTemplate, Token } from '@stamhoofd/models';
+import { DocumentTemplatePrivate } from '@stamhoofd/structures';
 
-import { Context } from "../../../../helpers/Context";
+import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = undefined
-type ResponseBody = DocumentTemplatePrivate[]
+type Body = undefined;
+type ResponseBody = DocumentTemplatePrivate[];
 
 export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/document-templates", {});
+        const params = Endpoint.parseParameters(request.url, '/organization/document-templates', {});
 
         if (params) {
             return [true, params as Params];
@@ -26,25 +26,25 @@ export class GetDocumentTemplatesEndpoint extends Endpoint<Params, Query, Body,
 
     async handle(_: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.canManageDocuments(organization.id)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         const templates = await DocumentTemplate.where(
-            { 
-                organizationId: organization.id 
-            }, 
-            { 
+            {
+                organizationId: organization.id,
+            },
+            {
                 sort: [{
-                    column: "createdAt",
-                    direction: "ASC"
-                }] 
-            }
-        )
+                    column: 'createdAt',
+                    direction: 'ASC',
+                }],
+            },
+        );
         return new Response(
-            templates.map(t => t.getPrivateStructure())
+            templates.map(t => t.getPrivateStructure()),
         );
     }
 }

package/src/endpoints/organization/dashboard/documents/GetDocumentsEndpoint.ts

@@ -1,14 +1,14 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
-import { Document, DocumentTemplate } from "@stamhoofd/models";
-import { Document as DocumentStruct } from "@stamhoofd/structures";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Document, DocumentTemplate } from '@stamhoofd/models';
+import { Document as DocumentStruct } from '@stamhoofd/structures';
 
-import { Context } from "../../../../helpers/Context";
+import { Context } from '../../../../helpers/Context';
 
 type Params = { id: string };
 type Query = undefined;
-type Body = undefined
-type ResponseBody = DocumentStruct[]
+type Body = undefined;
+type ResponseBody = DocumentStruct[];
 
 /**
  * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
@@ -16,11 +16,11 @@ type ResponseBody = DocumentStruct[]
 
 export class GetDocumentsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/document-templates/@id/documents", { id: String});
+        const params = Endpoint.parseParameters(request.url, '/organization/document-templates/@id/documents', { id: String });
 
         if (params) {
             return [true, params as Params];
@@ -30,21 +30,21 @@ export class GetDocumentsEndpoint extends Endpoint<Params, Query, Body, Response
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.canManageDocuments(organization.id)) {
-            throw Context.auth.error()
-        }  
+            throw Context.auth.error();
+        }
 
-        const template = await DocumentTemplate.getByID(request.params.id)
+        const template = await DocumentTemplate.getByID(request.params.id);
         if (!template || !await Context.auth.canAccessDocumentTemplate(template)) {
-            throw Context.auth.notFoundOrNoAccess("Onbekend document")
+            throw Context.auth.notFoundOrNoAccess('Onbekend document');
         }
 
         const documents = await Document.where({ templateId: template.id });
 
         return new Response(
-            documents.map(t => t.getStructure())
+            documents.map(t => t.getStructure()),
         );
     }
 }

package/src/endpoints/organization/dashboard/documents/PatchDocumentEndpoint.ts

@@ -1,25 +1,25 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { Document, DocumentTemplate, Group, Member, Registration, Token } from '@stamhoofd/models';
-import { Document as DocumentStruct, DocumentStatus, DocumentTemplatePrivate, PermissionLevel } from "@stamhoofd/structures";
+import { Document as DocumentStruct, DocumentStatus, DocumentTemplatePrivate, PermissionLevel } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = PatchableArrayAutoEncoder<DocumentStruct>
-type ResponseBody = DocumentStruct[]
+type Body = PatchableArrayAutoEncoder<DocumentStruct>;
+type ResponseBody = DocumentStruct[];
 
 export class PatchDocumentEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = new PatchableArrayDecoder(DocumentStruct as Decoder<DocumentStruct>, DocumentStruct.patchType() as Decoder<AutoEncoderPatchType<DocumentStruct>>, StringDecoder)
+    bodyDecoder = new PatchableArrayDecoder(DocumentStruct as Decoder<DocumentStruct>, DocumentStruct.patchType() as Decoder<AutoEncoderPatchType<DocumentStruct>>, StringDecoder);
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "PATCH") {
+        if (request.method !== 'PATCH') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/documents", {});
+        const params = Endpoint.parseParameters(request.url, '/organization/documents', {});
 
         if (params) {
             return [true, params as Params];
@@ -29,101 +29,101 @@ export class PatchDocumentEndpoint extends Endpoint<Params, Query, Body, Respons
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
-        if (!await Context.auth.canManageDocuments(organization.id ,PermissionLevel.Write)) {
-            throw Context.auth.error()
+        if (!await Context.auth.canManageDocuments(organization.id, PermissionLevel.Write)) {
+            throw Context.auth.error();
         }
 
-        const updatedDocuments: DocumentStruct[] = []
+        const updatedDocuments: DocumentStruct[] = [];
 
         for (const patch of request.body.getPatches()) {
-            const document = await Document.getByID(patch.id)
+            const document = await Document.getByID(patch.id);
             if (!document || !(await Context.auth.canAccessDocument(document, PermissionLevel.Write))) {
-                throw Context.auth.notFoundOrNoAccess("Onbekend document")
+                throw Context.auth.notFoundOrNoAccess('Onbekend document');
             }
-           
+
             if (patch.data) {
-                document.data.patchOrPut(patch.data)
-            }          
+                document.data.patchOrPut(patch.data);
+            }
 
             if (patch.status && (document.status !== DocumentStatus.MissingData || patch.status === DocumentStatus.Deleted)) {
-                document.status = patch.status
+                document.status = patch.status;
             }
 
             if (document.status === DocumentStatus.Draft || document.status === DocumentStatus.Published) {
-                const template = await DocumentTemplate.getByID(document.templateId)
+                const template = await DocumentTemplate.getByID(document.templateId);
                 if (!template) {
                     throw new SimpleError({
-                        code: "not_found",
-                        message: "Document not found",
-                        human: "Document niet gevonden"
-                    })
+                        code: 'not_found',
+                        message: 'Document not found',
+                        human: 'Document niet gevonden',
+                    });
                 }
 
-                document.status = template.status
+                document.status = template.status;
             }
-            
+
             await document.updateData();
             await document.save();
 
             // Return in response
-            updatedDocuments.push(document.getStructure())
+            updatedDocuments.push(document.getStructure());
         }
 
-        for (const {put} of request.body.getPuts()) {
+        for (const { put } of request.body.getPuts()) {
             // Create a new document
-            const template = await DocumentTemplate.getByID(put.templateId)
+            const template = await DocumentTemplate.getByID(put.templateId);
             if (!template || !await Context.auth.canAccessDocumentTemplate(template, PermissionLevel.Write)) {
                 throw new SimpleError({
-                    code: "not_found",
-                    message: "Document template not found",
-                    human: "Document template niet gevonden"
-                })
+                    code: 'not_found',
+                    message: 'Document template not found',
+                    human: 'Document template niet gevonden',
+                });
             }
             const document = new Document();
-            document.organizationId = organization.id
-            document.templateId = template.id
-            document.status = put.status
-            document.data = put.data
+            document.organizationId = organization.id;
+            document.templateId = template.id;
+            document.status = put.status;
+            document.data = put.data;
 
             if (document.status === DocumentStatus.Draft || document.status === DocumentStatus.Published) {
-                document.status = template.status
+                document.status = template.status;
             }
 
             if (put.registrationId) {
-                const registration = await Registration.getByID(put.registrationId)
+                const registration = await Registration.getByID(put.registrationId);
                 if (!registration) {
                     throw new SimpleError({
-                        code: "not_found",
-                        message: "Registration not found",
-                        human: "Inschrijving niet gevonden"
-                    })
+                        code: 'not_found',
+                        message: 'Registration not found',
+                        human: 'Inschrijving niet gevonden',
+                    });
                 }
-                document.registrationId = put.registrationId
-                put.memberId = registration.memberId
+                document.registrationId = put.registrationId;
+                put.memberId = registration.memberId;
             }
             if (put.memberId) {
-                const member = await Member.getWithRegistrations(put.memberId)
+                const member = await Member.getWithRegistrations(put.memberId);
                 if (!member || !await Context.auth.canAccessMember(member, PermissionLevel.Read)) {
                     throw new SimpleError({
-                        code: "not_found",
-                        message: "Member not found",
-                        human: "Lid niet gevonden"
-                    })
+                        code: 'not_found',
+                        message: 'Member not found',
+                        human: 'Lid niet gevonden',
+                    });
                 }
-                document.memberId = put.memberId
+                document.memberId = put.memberId;
             }
 
             await document.updateData();
             await document.save();
 
             // Return in response
-            updatedDocuments.push(document.getStructure())
+            updatedDocuments.push(document.getStructure());
         }
 
         return new Response(
-            updatedDocuments
+            updatedDocuments,
         );
     }
 }

package/src/endpoints/organization/dashboard/documents/PatchDocumentTemplateEndpoint.ts

@@ -1,29 +1,29 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { DocumentTemplate, Token } from '@stamhoofd/models';
-import { DocumentTemplatePrivate, PermissionLevel } from "@stamhoofd/structures";
+import { DocumentTemplatePrivate, PermissionLevel } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = PatchableArrayAutoEncoder<DocumentTemplatePrivate>
-type ResponseBody = DocumentTemplatePrivate[]
+type Body = PatchableArrayAutoEncoder<DocumentTemplatePrivate>;
+type ResponseBody = DocumentTemplatePrivate[];
 
 /**
  * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
  */
 
 export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = new PatchableArrayDecoder(DocumentTemplatePrivate as Decoder<DocumentTemplatePrivate>, DocumentTemplatePrivate.patchType() as Decoder<AutoEncoderPatchType<DocumentTemplatePrivate>>, StringDecoder)
+    bodyDecoder = new PatchableArrayDecoder(DocumentTemplatePrivate as Decoder<DocumentTemplatePrivate>, DocumentTemplatePrivate.patchType() as Decoder<AutoEncoderPatchType<DocumentTemplatePrivate>>, StringDecoder);
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "PATCH") {
+        if (request.method !== 'PATCH') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/document-templates", {});
+        const params = Endpoint.parseParameters(request.url, '/organization/document-templates', {});
 
         if (params) {
             return [true, params as Params];
@@ -33,82 +33,82 @@ export class PatchDocumentTemplateEndpoint extends Endpoint<Params, Query, Body,
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.canManageDocuments(organization.id, PermissionLevel.Write)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
-        const updatedTemplates: DocumentTemplatePrivate[] = []
+        const updatedTemplates: DocumentTemplatePrivate[] = [];
 
-        for (const {put} of request.body.getPuts()) {
+        for (const { put } of request.body.getPuts()) {
             // Creating new templates
-            const template = new DocumentTemplate()
-            template.privateSettings = put.privateSettings
-            template.settings = put.settings
-            template.status = put.status
-            template.html = put.html
-            template.updatesEnabled = put.updatesEnabled
-            template.organizationId = organization.id
+            const template = new DocumentTemplate();
+            template.privateSettings = put.privateSettings;
+            template.settings = put.settings;
+            template.status = put.status;
+            template.html = put.html;
+            template.updatesEnabled = put.updatesEnabled;
+            template.organizationId = organization.id;
             await template.save();
 
             // todo: Generate documents (maybe in background)
-            template.buildAll().catch(console.error)
+            template.buildAll().catch(console.error);
 
             // Return in response
-            updatedTemplates.push(template.getPrivateStructure())
+            updatedTemplates.push(template.getPrivateStructure());
         }
 
         for (const patch of request.body.getPatches()) {
-            const template = await DocumentTemplate.getByID(patch.id)
+            const template = await DocumentTemplate.getByID(patch.id);
             if (!template || !await Context.auth.canAccessDocumentTemplate(template, PermissionLevel.Full)) {
-                throw Context.auth.notFoundOrNoAccess("Onbekende template")
+                throw Context.auth.notFoundOrNoAccess('Onbekende template');
             }
 
             if (patch.privateSettings) {
-                template.privateSettings.patchOrPut(patch.privateSettings)
+                template.privateSettings.patchOrPut(patch.privateSettings);
             }
 
             if (patch.settings) {
-                template.settings.patchOrPut(patch.settings)
+                template.settings.patchOrPut(patch.settings);
             }
 
             if (patch.status) {
-                template.status = patch.status
+                template.status = patch.status;
             }
 
             if (patch.updatesEnabled !== undefined) {
-                template.updatesEnabled = patch.updatesEnabled
+                template.updatesEnabled = patch.updatesEnabled;
             }
 
             if (patch.html) {
-                template.html = patch.html
+                template.html = patch.html;
             }
 
             await template.save();
 
             // Update documents
-            await template.buildAll()
+            await template.buildAll();
 
             // Return in response
-            updatedTemplates.push(template.getPrivateStructure())
+            updatedTemplates.push(template.getPrivateStructure());
         }
 
         for (const id of request.body.getDeletes()) {
-            const template = await DocumentTemplate.getByID(id)
+            const template = await DocumentTemplate.getByID(id);
             if (!template || !await Context.auth.canAccessDocumentTemplate(template, PermissionLevel.Full)) {
                 throw new SimpleError({
-                    code: "not_found",
-                    message: "Template not found",
-                    human: "Template niet gevonden"
-                })
+                    code: 'not_found',
+                    message: 'Template not found',
+                    human: 'Template niet gevonden',
+                });
             }
 
-            await template.delete()
+            await template.delete();
         }
 
         return new Response(
-            updatedTemplates
+            updatedTemplates,
         );
     }
 }

package/src/endpoints/organization/dashboard/email/CheckEmailBouncesEndpoint.ts

@@ -1,5 +1,5 @@
 import { ArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { EmailAddress } from '@stamhoofd/email';
 import { EmailInformation } from '@stamhoofd/structures';
@@ -8,18 +8,18 @@ import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = string[]
+type Body = string[];
 type ResponseBody = EmailInformation[];
 
 export class CheckEmailBouncesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = new ArrayDecoder(StringDecoder)
+    bodyDecoder = new ArrayDecoder(StringDecoder);
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/email/check-bounces", {});
+        const params = Endpoint.parseParameters(request.url, '/email/check-bounces', {});
 
         if (params) {
             return [true, params as Params];
@@ -29,22 +29,22 @@ export class CheckEmailBouncesEndpoint extends Endpoint<Params, Query, Body, Res
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.canAccessEmailBounces(organization.id)) {
-            throw Context.auth.error()
-        }  
+            throw Context.auth.error();
+        }
 
         if (request.body.length > 10000) {
             throw new SimpleError({
-                code: "too_many_recipients",
-                message: "Too many recipients",
-                human: "Je kan maar maximaal 10.000 adressen tergelijk controleren.",
-                field: "recipients"
-            })
+                code: 'too_many_recipients',
+                message: 'Too many recipients',
+                human: 'Je kan maar maximaal 10.000 adressen tergelijk controleren.',
+                field: 'recipients',
+            });
         }
 
-        const emails = await EmailAddress.getByEmails(request.body, organization.id)
+        const emails = await EmailAddress.getByEmails(request.body, organization.id);
         return new Response(emails.map(e => EmailInformation.create(e)));
     }
 }