@stamhoofd/backend 2.8.0 → 2.13.0

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, BalanceItemWithPayments, IDRegisterCheckout, PaymentCustomer, 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;
@@ -598,11 +678,61 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         }
 
         const payment = new Payment()
-        payment.userId = user.id
 
         // Who will receive this money?
         payment.organizationId = organization.id
 
+        // Who paid
+        payment.payingUserId = user.id
+        payment.payingOrganizationId = checkout.asOrganizationId ?? null
+
+        // Fill in customer:
+        payment.customer = PaymentCustomer.create({
+            firstName: user.firstName,
+            lastName: user.lastName,
+            email: user.email,
+        })
+
+        if (checkout.asOrganizationId) {
+            if (!checkout.customer) {
+                throw new SimpleError({
+                    code: "missing_fields",
+                    message: "customer is required when paying as an organization",
+                    human: "Vul je facturatiegegevens in om verder te gaan."
+                })
+            }
+
+            if (!checkout.customer.company) {
+                throw new SimpleError({
+                    code: "missing_fields",
+                    message: "customer.company is required when paying as an organization",
+                    human: "Als je een betaling uitvoert in naam van je vereniging, is het noodzakelijk om facturatiegegevens met bedrijfsgegevens in te vullen."
+                })
+            }
+
+            const payingOrganization = await Organization.getByID(checkout.asOrganizationId);
+            if (!payingOrganization) {
+                throw new SimpleError({
+                    code: "invalid_data",
+                    message: "Oeps, de organisatie waarvoor je probeert te betalen lijkt niet meer te bestaan. Herlaad de pagina en probeer opnieuw."
+                })
+            }
+
+            // Search company id
+            // this avoids needing to check the VAT number every time
+            const id = checkout.customer.company.id
+            const foundCompany = payingOrganization.meta.companies.find(c => c.id === id)
+
+            if (!foundCompany) {
+                throw new SimpleError({
+                    code: "invalid_data",
+                    message: "Oeps, de facturatiegegevens die je probeerde te selecteren lijken niet meer te bestaan. Herlaad de pagina en probeer opnieuw."
+                })
+            }
+
+            payment.customer.company = foundCompany
+        }
+
         payment.method = checkout.paymentMethod
         payment.status = PaymentStatus.Created
         payment.price = totalPrice

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)))
     }

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

@@ -1,9 +1,10 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { EmailTemplate } from '@stamhoofd/models';
+import { EmailTemplate, Group, Webshop } from '@stamhoofd/models';
 import { EmailTemplate as EmailTemplateStruct, PermissionLevel } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
+import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;
 type Body = PatchableArrayAutoEncoder<EmailTemplateStruct>;
@@ -67,12 +68,32 @@ export class PatchEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, R
                 throw Context.auth.error();
             }
 
+            if (!EmailTemplateStruct.allowPlatformLevel(struct.type) && !organization) {
+                throw Context.auth.error();
+            }
+
             const template = new EmailTemplate()
             template.id = struct.id
             template.organizationId = organization?.id ?? null
             template.webshopId = struct.webshopId
             template.groupId = struct.groupId
 
+            if (struct.groupId) {
+                const group = await Group.getByID(struct.groupId)
+                if (!group || !await Context.auth.canAccessGroup(group, PermissionLevel.Full)) {
+                    throw Context.auth.error();
+                }
+                template.organizationId = group.organizationId
+            }
+
+            if (struct.webshopId) {
+                const webshop = await Webshop.getByID(struct.webshopId)
+                if (!webshop || !await Context.auth.canAccessWebshop(webshop, PermissionLevel.Full)) {
+                    throw Context.auth.error();
+                }
+                template.organizationId = webshop.organizationId
+            }
+
             template.html = struct.html
             template.subject = struct.subject
             template.text = struct.text

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -1,13 +1,14 @@
-import { AutoEncoderPatchType, Decoder, ObjectData, patchObject } from '@simonbackx/simple-encoding';
+import { AutoEncoderPatchType, Decoder, isPatchableArray, ObjectData, PatchableArrayAutoEncoder, patchObject } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
-import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, StripeAccount, User, Webshop } from '@stamhoofd/models';
-import { BuckarooSettings, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, UserPermissions } from "@stamhoofd/structures";
+import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, StripeAccount, Webshop } from '@stamhoofd/models';
+import { BuckarooSettings, Company, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { BuckarooHelper } from '../../../../helpers/BuckarooHelper';
 import { Context } from '../../../../helpers/Context';
+import { ViesHelper } from '../../../../helpers/ViesHelper';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -98,6 +99,7 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
 
             if (request.body.privateMeta && request.body.privateMeta.isPatch()) {
                 organization.privateMeta.emails = request.body.privateMeta.emails.applyTo(organization.privateMeta.emails)
+                organization.privateMeta.premises = patchObject(organization.privateMeta.premises, request.body.privateMeta.premises);
                 organization.privateMeta.roles = request.body.privateMeta.roles.applyTo(organization.privateMeta.roles)
                 organization.privateMeta.responsibilities = request.body.privateMeta.responsibilities.applyTo(organization.privateMeta.responsibilities)
                 organization.privateMeta.inheritedResponsibilityRoles = request.body.privateMeta.inheritedResponsibilityRoles.applyTo(organization.privateMeta.inheritedResponsibilityRoles)
@@ -207,6 +209,10 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
             }
 
             if (request.body.meta) {
+                if (request.body.meta.companies) {
+                   await this.validateCompanies(organization, request.body.meta.companies)
+                }
+
                 const savedPackages = organization.meta.packages
                 organization.meta.patchOrPut(request.body.meta)
                 organization.meta.packages = savedPackages
@@ -365,5 +371,52 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
         errors.throwIfNotEmpty()
         return new Response(await AuthenticatedStructures.organization(organization));
     }
+
+    async validateCompanies(organization: Organization, companies: PatchableArrayAutoEncoder<Company>|Company[]) {
+        if (isPatchableArray(companies)) {
+            for (const patch of companies.getPatches()) {
+                // Changed VAT number
+                const original = organization.meta.companies.find(c => c.id === patch.id)
+
+                if (!original) {
+                    throw new Error('Could not find company')
+                }
+                
+                // Changed VAT number
+                const prepatched = original.patch(patch)
+                await ViesHelper.checkCompany(prepatched, patch)
+            }
+
+            let c = 0;
+            for (const {put} of companies.getPuts()) {
+                c++;
+                
+                if ((organization.meta.companies.length + c) > 5) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "Too many companies",
+                        human: "Je kan maximaal 5 bedrijven toevoegen",
+                        field: "companies"
+                    })
+                }
+
+                await ViesHelper.checkCompany(put, put)
+            }
+
+        } else {
+            if (companies.length > 5) {
+                throw new SimpleError({
+                    code: "invalid_field",
+                    message: "Too many companies",
+                    human: "Je kan maximaal 5 bedrijven toevoegen",
+                    field: "companies"
+                })
+            }
+
+            for (const company of companies) {
+                await ViesHelper.checkCompany(company, company)
+            }
+        }
+    }
 }
 

package/src/endpoints/organization/dashboard/organization/SetOrganizationDomainEndpoint.ts

@@ -6,6 +6,7 @@ import NodeRSA from 'node-rsa';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
+import { Formatter } from '@stamhoofd/utility';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -98,7 +99,7 @@ export class SetOrganizationDomainEndpoint extends Endpoint<Params, Query, Body,
             organization.privateMeta.dnsRecords = []
 
             if (organization.privateMeta.pendingMailDomain !== null) {
-                const defaultFromDomain = "stamhoofd." + organization.privateMeta.pendingMailDomain;
+                const defaultFromDomain = Formatter.slug(STAMHOOFD.platformName) + "." + organization.privateMeta.pendingMailDomain;
                 if (organization.privateMeta.pendingRegisterDomain === null || !organization.privateMeta.pendingRegisterDomain.endsWith('.' + organization.privateMeta.pendingMailDomain)) {
                     // We set a custom domainname for webshops already
                     // This is not used at this moment
@@ -109,8 +110,7 @@ export class SetOrganizationDomainEndpoint extends Endpoint<Params, Query, Body,
                 }
 
                 if (organization.privateMeta.mailFromDomain !== organization.privateMeta.pendingRegisterDomain) {
-                        
-                    organization.privateMeta.dnsRecords.push(DNSRecord.create({
+                        organization.privateMeta.dnsRecords.push(DNSRecord.create({
                             type: DNSRecordType.CNAME,
                             name: organization.privateMeta.mailFromDomain + ".",
                             // Use shops for mail domain, to allow reuse

package/src/endpoints/organization/dashboard/payments/GetMemberBalanceEndpoint.ts

@@ -1,14 +1,14 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from "@simonbackx/simple-errors";
 import { BalanceItem, Group, Member } from "@stamhoofd/models";
-import { MemberBalanceItem } from "@stamhoofd/structures";
+import { BalanceItemWithPayments } from "@stamhoofd/structures";
 
 import { Context } from "../../../../helpers/Context";
 
 type Params = { id: string };
 type Query = undefined
 type Body = undefined
-type ResponseBody = MemberBalanceItem[]
+type ResponseBody = BalanceItemWithPayments[]
 
 export class GetMemberBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -42,7 +42,7 @@ export class GetMemberBalanceEndpoint extends Endpoint<Params, Query, Body, Resp
         const balanceItems = await BalanceItem.balanceItemsForUsersAndMembers(organization.id, member.users.map(u => u.id), [member.id])
 
         return new Response(
-            await BalanceItem.getMemberStructure(balanceItems)
+            await BalanceItem.getStructureWithPayments(balanceItems)
         );
     }
 }

package/src/endpoints/organization/dashboard/payments/GetPaymentsCountEndpoint.ts

@@ -0,0 +1,43 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
+
+import { Context } from '../../../../helpers/Context';
+import { GetPaymentsEndpoint } from './GetPaymentsEndpoint';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetPaymentsCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/payments/count", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope();
+        await Context.authenticate()
+        const query = await GetPaymentsEndpoint.buildQuery(request.query)
+        
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count
+            })
+        );
+    }
+}