@stamhoofd/backend 2.8.0 → 2.9.0

package/.env.template.json

@@ -22,6 +22,7 @@
         "rendererApi": "renderer.stamhoofd"
     },
     "translationNamespace": "stamhoofd",
+    "platformName": "stamhoofd",
     "userMode": "organization",
     
     "PORT": 9091,
@@ -59,5 +60,6 @@
 
     "NOLT_SSO_SECRET_KEY": "",
     "INTERNAL_SECRET_KEY": "",
-    "CRONS_DISABLED": false
+    "CRONS_DISABLED": false,
+    "WHITELISTED_EMAIL_DESTINATIONS": ["*"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.8.0",
+    "version": "2.9.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -9,7 +9,7 @@
     },
     "license": "UNLICENCED",
     "scripts": {
-        "dev": "concurrently -r \"rm -rf ./dist && wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --delay 200ms --exec node --enable-source-maps ./dist/index.js --signal SIGTERM\" 'yarn build --watch --preserveWatchOutput'",
+        "dev": "echo 'Waiting for shared backend packages...' && wait-on ../../shared/env/dist/index.js && echo 'Start building backend API' && concurrently -r 'yarn build --watch --preserveWatchOutput' \"wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --watch '../../../shared/*/dist/' --watch '../../shared/*/dist/' --ext .ts,.json,.sql,.js --watch .env.json --delay 1000ms --exec 'node --enable-source-maps ./dist/index.js' --signal SIGTERM\"",
         "dev:backend": "yarn dev",
         "build": "rm -rf ./dist/src/migrations && rm -rf ./dist/src/seeds && tsc -b",
         "build:full": "yarn clear && yarn build",
@@ -50,5 +50,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "1e0e1853f8dea6b47718433b2890907042c17ddc"
+    "gitHead": "d1959fa457e81e41797c4f7fe216095505f50aeb"
 }

package/src/crons.ts

@@ -140,7 +140,7 @@ async function checkWebshopDNS() {
 }
 
 async function checkReplies() {
-    if (STAMHOOFD.environment === "development") {
+    if (STAMHOOFD.environment !== "production") {
         return;
     }
 
@@ -200,7 +200,7 @@ async function checkReplies() {
 let lastPostmarkCheck: Date | null = null
 let lastPostmarkId: string | null = null
 async function checkPostmarkBounces() {
-    if (STAMHOOFD.environment === "development") {
+    if (STAMHOOFD.environment !== "production") {
         return;
     }
     
@@ -842,4 +842,4 @@ export const crons = async () => {
         }
     }
     schedulingJobs = false;
-};
+};

package/src/decoders/StringArrayDecoder.ts

@@ -0,0 +1,24 @@
+import { Data, Decoder } from "@simonbackx/simple-encoding";
+
+export class StringArrayDecoder<T> implements Decoder<T[]> {
+    decoder: Decoder<T>;
+
+    constructor(decoder: Decoder<T>) {
+        this.decoder = decoder;
+    }
+
+    decode(data: Data): T[] {
+        const strValue = data.string;
+
+        // Split on comma
+        const parts = strValue.split(",");
+        return parts
+            .map((v, index) => {
+                return data.clone({ 
+                    data: v, 
+                    context: data.context, 
+                    field: data.addToCurrentField(index) 
+                }).decode(this.decoder)
+            });
+    }
+}

package/src/decoders/StringNullableDecoder.ts

@@ -0,0 +1,18 @@
+import { Decoder, Data } from "@simonbackx/simple-encoding";
+
+export class StringNullableDecoder<T> implements Decoder<T | null> {
+    decoder: Decoder<T>;
+
+    constructor(decoder: Decoder<T>) {
+        this.decoder = decoder;
+    }
+
+    decode(data: Data): T | null {
+        if (data.value === 'null') {
+            return null;
+        }
+
+        return data.decode(this.decoder);
+    }
+}
+

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.ts

@@ -19,6 +19,9 @@ export const filterCompilers: SQLFilterDefinitions = {
     id: createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'id')
     ),
+    uri: createSQLExpressionFilterCompiler(
+        SQL.column('organizations', 'uri')
+    ),
     name: createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'name')
     ),
@@ -160,6 +163,17 @@ const sorters: SQLSortDefinitions<Organization> = {
             })
         }
     },
+    'uri': {
+        getValue(a) {
+            return a.uri
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('uri'),
+                direction
+            })
+        }
+    },
     'type': {
         getValue(a) {
             return a.meta.type

package/src/endpoints/global/email/PatchEmailEndpoint.ts

@@ -100,6 +100,7 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         }
 
         if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent) {
+            model.throwIfNotReadyToSend()
             model.send().catch(console.error)
         }
 

package/src/endpoints/global/events/PatchEventsEndpoint.ts

@@ -1,7 +1,7 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { Event, Group, Organization, Platform, RegistrationPeriod } from '@stamhoofd/models';
-import { Event as EventStruct, GroupType, PermissionLevel } from "@stamhoofd/structures";
+import { Event as EventStruct, GroupType, NamedObject, PermissionLevel } from "@stamhoofd/structures";
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
@@ -81,6 +81,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.endDate = put.endDate
             event.meta = put.meta
             event.typeId = await PatchEventsEndpoint.validateEventType(put.typeId)
+            event.meta.organizationCache = eventOrganization ? NamedObject.create({id: eventOrganization.id, name: eventOrganization.name}) : null
             await PatchEventsEndpoint.checkEventLimits(event)
 
             if (!(await Context.auth.canAccessEvent(event, PermissionLevel.Full))) {
@@ -128,6 +129,16 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.name = patch.name ?? event.name
             event.startDate = patch.startDate ?? event.startDate
             event.endDate = patch.endDate ?? event.endDate
+
+            if (patch.meta?.organizationCache) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Cannot patch organizationCache',
+                    human: 'Je kan de organizationCache niet aanpassen via een patch',
+                    field: 'meta.organizationCache'
+                })
+            }
+
             event.meta = patchObject(event.meta, patch.meta)
 
             if (patch.organizationId !== undefined) {
@@ -156,6 +167,15 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     })
                 }
                 event.organizationId = patch.organizationId
+                event.meta.organizationCache = eventOrganization ? NamedObject.create({id: eventOrganization.id, name: eventOrganization.name}) : null
+            } else {
+                // Update cache
+                if (event.organizationId) {
+                    const eventOrganization = await Organization.getByID(event.organizationId)
+                    if (eventOrganization) {
+                        event.meta.organizationCache = NamedObject.create({id: eventOrganization.id, name: eventOrganization.name})
+                    }
+                }
             }
 
             event.typeId = patch.typeId ? (await PatchEventsEndpoint.validateEventType(patch.typeId)) : event.typeId

package/src/endpoints/global/groups/GetGroupsEndpoint.ts

@@ -0,0 +1,79 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { Group, Organization } from '@stamhoofd/models';
+import { GroupsWithOrganizations } from "@stamhoofd/structures";
+
+import { AutoEncoder, Decoder, field, StringDecoder } from "@simonbackx/simple-encoding";
+import { Formatter } from "@stamhoofd/utility";
+import { StringArrayDecoder } from "../../../decoders/StringArrayDecoder";
+import { AuthenticatedStructures } from "../../../helpers/AuthenticatedStructures";
+import { Context } from "../../../helpers/Context";
+import { SimpleError } from "@simonbackx/simple-errors";
+type Params = Record<string, never>;
+
+class Query extends AutoEncoder {
+    @field({ decoder: new StringArrayDecoder(StringDecoder) })
+    ids: string[]
+
+    /**
+     * List of organizations the requester already knows and doesn't need to be included in the response
+     */
+    @field({ decoder: new StringArrayDecoder(StringDecoder), optional: true })
+    excludeOrganizationIds: string[] = []
+}
+
+type Body = undefined
+type ResponseBody = GroupsWithOrganizations
+
+/**
+ * Get the members of the user
+ */
+export class GetGroupsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/groups", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOptionalOrganizationScope();
+        await Context.optionalAuthenticate()
+
+        if (request.query.ids.length === 0) {
+            return new Response(
+                GroupsWithOrganizations.create({
+                    groups: [],
+                    organizations: []
+                })
+            );
+        }
+
+        if (request.query.ids.length > 100) {
+            throw new SimpleError({
+                code: "too_many_ids",
+                message: "You can't request more than 100 groups at once"
+            })
+        }
+
+        const groups = await Group.getByIDs(...request.query.ids)
+        const organizationIds = Formatter.uniqueArray(groups.map(g => g.organizationId).filter(id => !request.query.excludeOrganizationIds.includes(id)));
+
+        const organizations = organizationIds.length > 0 ? (await Organization.getByIDs(...organizationIds)) : [];
+        
+        return new Response(
+            GroupsWithOrganizations.create({
+                groups: await AuthenticatedStructures.groups(groups),
+                organizations: await AuthenticatedStructures.organizations(organizations)
+            })
+        );
+    }
+}

package/src/endpoints/global/members/GetMembersEndpoint.ts

@@ -252,37 +252,6 @@ const filterCompilers: SQLFilterDefinitions = {
         }
     ),
 
-    /**
-     * @deprecated?
-     */
-    activeRegistrations: createSQLRelationFilterCompiler(
-        SQL.select()
-        .from(
-            SQL.table('registrations')
-        ).join(
-            SQL.join(
-                SQL.table('groups')
-            ).where(
-                SQL.column('groups', 'id'),
-                SQL.column('registrations', 'groupId')
-            )
-        )
-        .where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        ).whereNot(
-            SQL.column('registeredAt'),
-            null,
-        ).where(
-            SQL.column('deactivatedAt'),
-            null,
-        ).where(
-            SQL.column('groups', 'deletedAt'),
-            null
-        ),
-        registrationFilterCompilers
-    ),
-
     organizations: createSQLRelationFilterCompiler(
         SQL.select()
         .from(

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -2,8 +2,8 @@ import { OneToManyRelation } from '@simonbackx/simple-database';
 import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from "@simonbackx/simple-errors";
-import { BalanceItem, BalanceItemPayment, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Payment, Platform, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
-import { BalanceItemStatus, MemberWithRegistrationsBlob, MembersBlob, PaymentMethod, PaymentStatus, PermissionLevel, Registration as RegistrationStruct, User as UserStruct } from "@stamhoofd/structures";
+import { BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Platform, Registration, User } from '@stamhoofd/models';
+import { MemberWithRegistrationsBlob, MembersBlob, PermissionLevel } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';

package/src/endpoints/global/registration/GetUserBalanceEndpoint.ts

@@ -1,13 +1,13 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { BalanceItem, Member } from "@stamhoofd/models";
-import { MemberBalanceItem } from "@stamhoofd/structures";
+import { BalanceItemWithPayments } from "@stamhoofd/structures";
 
 import { Context } from "../../../helpers/Context";
 
 type Params = Record<string, never>;
 type Query = undefined
 type Body = undefined
-type ResponseBody = MemberBalanceItem[]
+type ResponseBody = BalanceItemWithPayments[]
 
 export class GetUserBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -33,7 +33,7 @@ export class GetUserBalanceEndpoint extends Endpoint<Params, Query, Body, Respon
         const balanceItems = await BalanceItem.balanceItemsForUsersAndMembers(organization?.id ?? null, [user.id], members.map(m => m.id))
 
         return new Response(
-            await BalanceItem.getMemberStructure(balanceItems)
+            await BalanceItem.getStructureWithPayments(balanceItems)
         );
     }
 }

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -6,7 +6,7 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { I18n } from '@stamhoofd/backend-i18n';
 import { Email } from '@stamhoofd/email';
 import { BalanceItem, BalanceItemPayment, Group, Member, MemberWithRegistrations, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
-import { BalanceItemStatus, IDRegisterCheckout, MemberBalanceItem, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PermissionLevel, PlatformFamily, PlatformMember, RegisterItem, RegisterResponse, Version } from "@stamhoofd/structures";
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, IDRegisterCheckout, BalanceItemWithPayments, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PermissionLevel, PlatformFamily, PlatformMember, RegisterItem, RegisterResponse, Version } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -102,10 +102,10 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         const deleteRegistrationModels = (deleteRegistrationIds.length ? (await Registration.getByIDs(...deleteRegistrationIds)) : []).filter(r => r.organizationId === organization.id)
 
         const memberIds = Formatter.uniqueArray(
-            [...request.body.cart.items.map(i => i.memberId), ...deleteRegistrationModels.map(i => i.memberId)]
+            [...request.body.memberIds, ...deleteRegistrationModels.map(i => i.memberId)]
         )
         const members = await Member.getBlobByIds(...memberIds)
-        const groupIds = Formatter.uniqueArray(request.body.cart.items.map(i => i.groupId))
+        const groupIds = request.body.groupIds
         const groups = await Group.getByIDs(...groupIds)
 
         for (const group of groups) {
@@ -177,7 +177,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
         // Validate balance items (can only happen serverside)
         const balanceItemIds = request.body.cart.balanceItems.map(i => i.item.id)
-        let memberBalanceItemsStructs: MemberBalanceItem[] = []
+        let memberBalanceItemsStructs: BalanceItemWithPayments[] = []
         let balanceItemsModels: BalanceItem[] = []
         if (balanceItemIds.length > 0) {
             balanceItemsModels = await BalanceItem.where({ id: { sign:'IN', value: balanceItemIds }, organizationId: organization.id })
@@ -187,11 +187,9 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     message: "Oeps, één of meerdere openstaande bedragen in jouw winkelmandje zijn aangepast. Herlaad de pagina en probeer opnieuw."
                 })
             }
-            memberBalanceItemsStructs = await BalanceItem.getMemberStructure(balanceItemsModels)
+            memberBalanceItemsStructs = await BalanceItem.getStructureWithPayments(balanceItemsModels)
         }
 
-        console.log('isAdminFromSameOrganization', checkout.isAdminFromSameOrganization)
-
         // Validate the cart
         checkout.validate({memberBalanceItems: memberBalanceItemsStructs})
 
@@ -365,33 +363,17 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
         }
 
-        // Save registrations and add extra data if needed
-        for (const bundle of payRegistrations) {
-            const registration = bundle.registration;
-
-            registration.reservedUntil = null
-
-            if (shouldMarkValid) {
-                await registration.markValid()
-            } else {
-                // Reserve registration for 30 minutes (if needed)
-                const group = groups.find(g => g.id === registration.groupId)
-
-                if (group && group.settings.maxMembers !== null) {
-                    registration.reservedUntil = new Date(new Date().getTime() + 1000*60*30)
-                }
-                await registration.save()
-            }
-
-            if (bundle.item.calculatedPrice === 0) {
-                continue;
-            }
+        async function createBalanceItem({registration, amount, unitPrice, description, type, relations}: {amount?: number, registration: RegistrationWithMemberAndGroup, unitPrice: number, description: string, relations: Map<BalanceItemRelationType, BalanceItemRelation>, type: BalanceItemType}) {
+            // NOTE: We also need to save zero-price balance items because for online payments, we need to know which registrations to activate after payment
 
             // Create balance item
             const balanceItem = new BalanceItem();
             balanceItem.registrationId = registration.id;
-            balanceItem.price = bundle.item.calculatedPrice
-            balanceItem.description = `Inschrijving ${registration.group.settings.name}`
+            balanceItem.unitPrice = unitPrice
+            balanceItem.amount = amount ?? 1
+            balanceItem.description = description
+            balanceItem.relations = relations
+            balanceItem.type = type
 
             // Who needs to receive this money?
             balanceItem.organizationId = organization.id;
@@ -410,8 +392,11 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                 // because otherwise the total price and pricePaid for the registration would be incorrect
                 //balanceItem2.registrationId = registration.id;
 
-                balanceItem2.price = bundle.item.calculatedPrice
-                balanceItem2.description = `Inschrijving ${registration.group.settings.name}`
+                balanceItem2.unitPrice = unitPrice
+                balanceItem2.amount = amount ?? 1
+                balanceItem2.description = description
+                balanceItem2.relations = relations
+                balanceItem2.type = type
 
                 // Who needs to receive this money?
                 balanceItem2.organizationId = request.body.asOrganizationId;
@@ -438,12 +423,106 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             await balanceItem.save();
             createdBalanceItems.push(balanceItem)
         }
+
+        // Save registrations and add extra data if needed
+        for (const bundle of payRegistrations) {
+            const {item, registration} = bundle;
+            registration.reservedUntil = null
+
+            if (shouldMarkValid) {
+                await registration.markValid({skipEmail: bundle.item.replaceRegistrations.length > 0})
+            } else {
+                // Reserve registration for 30 minutes (if needed)
+                const group = groups.find(g => g.id === registration.groupId)
+
+                if (group && group.settings.maxMembers !== null) {
+                    registration.reservedUntil = new Date(new Date().getTime() + 1000*60*30)
+                }
+                await registration.save()
+            }
+
+            // Note: we should always create the balance items: even when the price is zero
+            // Otherwise we don't know which registrations to activate after payment
+            
+            if (shouldMarkValid && item.calculatedPrice === 0) {
+                continue;
+            }
+
+            // Create balance items
+            const sharedRelations: [BalanceItemRelationType, BalanceItemRelation][] = [
+                [
+                    BalanceItemRelationType.Member, 
+                    BalanceItemRelation.create({
+                        id: item.member.id,
+                        name: item.member.patchedMember.name
+                    })
+                ],
+                [
+                    BalanceItemRelationType.Group, 
+                    BalanceItemRelation.create({
+                        id: item.group.id,
+                        name: item.group.settings.name
+                    })
+                ]
+            ]
+
+            if (item.group.settings.prices.length > 1) {
+                sharedRelations.push([
+                    BalanceItemRelationType.GroupPrice, 
+                    BalanceItemRelation.create({
+                        id: item.groupPrice.id,
+                        name: item.groupPrice.name
+                    })
+                ])
+            }
+
+            // Base price
+            await createBalanceItem({
+                registration, 
+                unitPrice: item.groupPrice.price.forMember(item.member),
+                type: BalanceItemType.Registration,
+                description: `${item.member.patchedMember.name} bij ${item.group.settings.name}`,
+                relations: new Map([
+                    ...sharedRelations
+                ])
+            })
+
+            // Options
+            for (const option of item.options) {
+                await createBalanceItem({
+                    registration, 
+                    amount: option.amount,
+                    unitPrice: option.option.price.forMember(item.member),
+                    type: BalanceItemType.Registration,
+                    description: `${option.optionMenu.name}: ${option.option.name}`,
+                    relations: new Map([
+                        ...sharedRelations,
+                        [
+                            BalanceItemRelationType.GroupOptionMenu, 
+                            BalanceItemRelation.create({
+                                id: option.optionMenu.id,
+                                name: option.optionMenu.name,
+                            })
+                        ],
+                        [
+                            BalanceItemRelationType.GroupOption, 
+                            BalanceItemRelation.create({
+                                id: option.option.id,
+                                name: option.option.name,
+                            })
+                        ]
+                    ])
+                })
+            }
+
+        }
         
         const oldestMember = members.slice().sort((a, b) => b.details.defaultAge - a.details.defaultAge)[0]
         if (checkout.freeContribution && !request.body.asOrganizationId) {
             // Create balance item
             const balanceItem = new BalanceItem();
-            balanceItem.price = checkout.freeContribution
+            balanceItem.type = BalanceItemType.FreeContribution
+            balanceItem.unitPrice = checkout.freeContribution
             balanceItem.description = `Vrije bijdrage`
             balanceItem.pricePaid = 0;
             balanceItem.userId = user.id
@@ -462,7 +541,8 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         if (checkout.administrationFee && whoWillPayNow !== 'nobody') {
             // Create balance item
             const balanceItem = new BalanceItem();
-            balanceItem.price = checkout.administrationFee
+            balanceItem.type = BalanceItemType.AdministrationFee
+            balanceItem.unitPrice = checkout.administrationFee
             balanceItem.description = `Administratiekosten`
             balanceItem.pricePaid = 0;
             balanceItem.organizationId = organization.id;

package/src/endpoints/organization/dashboard/email-templates/GetEmailTemplatesEndpoint.ts

@@ -1,36 +1,24 @@
-import { AutoEncoder, Data, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import { AutoEncoder, Data, Decoder, EnumDecoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { EmailTemplate } from '@stamhoofd/models';
 import { EmailTemplate as EmailTemplateStruct, EmailTemplateType } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
+import { StringNullableDecoder } from '../../../../decoders/StringNullableDecoder';
+import { StringArrayDecoder } from '../../../../decoders/StringArrayDecoder';
 
 type Params = Record<string, never>;
 type Body = undefined;
 
-export class StringNullableDecoder<T> implements Decoder<T | null> {
-    decoder: Decoder<T>;
-
-    constructor(decoder: Decoder<T>) {
-        this.decoder = decoder;
-    }
-
-    decode(data: Data): T | null {
-        if (data.value === 'null') {
-            return null;
-        }
-
-        return data.decode(this.decoder);
-    }
-}
-
-
 class Query extends AutoEncoder {
     @field({ decoder: new StringNullableDecoder(StringDecoder), optional: true, nullable: true })
     webshopId: string|null = null
 
-    @field({ decoder: new StringNullableDecoder(StringDecoder), optional: true, nullable: true})
-    groupId: string|null = null
+    @field({ decoder: new StringNullableDecoder(new StringArrayDecoder(StringDecoder)), optional: true, nullable: true})
+    groupIds: string[]|null = null
+
+    @field({ decoder: new StringNullableDecoder(new StringArrayDecoder(new EnumDecoder(EmailTemplateType))), optional: true, nullable: true})
+    types: EmailTemplateType[]|null = null
 }
 
 type ResponseBody = EmailTemplateStruct[];
@@ -65,15 +53,24 @@ export class GetEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, Res
             } 
         }
 
-        const types = [...Object.values(EmailTemplateType)].filter(type => {
+        const types = (request.query.types ?? [...Object.values(EmailTemplateType)]).filter(type => {
             if (!organization) {
-                return true;
+                return EmailTemplateStruct.allowPlatformLevel(type)
             }
             return EmailTemplateStruct.allowOrganizationLevel(type)
         })
 
         
-        const templates = organization ? (await EmailTemplate.where({ organizationId: organization.id, webshopId: request.query.webshopId ?? null, groupId: request.query.groupId ?? null, type: {sign: 'IN', value: types}})) : [];        
+        const templates = organization ? 
+            (
+                await EmailTemplate.where({ organizationId: organization.id, webshopId: request.query.webshopId ?? null, groupId: request.query.groupIds ? {sign: 'IN', value: request.query.groupIds} : null, type: {sign: 'IN', value: types}})
+            ) 
+            : (
+                // Required for event emails when logged in as the platform admin
+                (request.query.webshopId || request.query.groupIds) ? 
+                    await EmailTemplate.where({ webshopId: request.query.webshopId ?? null, groupId: request.query.groupIds ? {sign: 'IN', value: request.query.groupIds} : null, type: {sign: 'IN', value: types}}) 
+                    : []
+            );        
         const defaultTemplates = await EmailTemplate.where({ organizationId: null, type: {sign: 'IN', value: types} });
         return new Response([...templates, ...defaultTemplates].map(template => EmailTemplateStruct.create(template)))
     }