@stamhoofd/backend 1.0.0

package/src/endpoints/organization/dashboard/webshops/PatchWebshopTicketsEndpoint.ts

@@ -0,0 +1,80 @@
+import { ArrayDecoder, AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { SimpleError, SimpleErrors } from "@simonbackx/simple-errors";
+import { Ticket, Token, Webshop } from '@stamhoofd/models';
+import { PermissionLevel, TicketPrivate } from "@stamhoofd/structures";
+
+import { Context } from '../../../../helpers/Context';
+
+type Params = { id: string };
+type Query = undefined;
+type Body = AutoEncoderPatchType<TicketPrivate>[]
+type ResponseBody = TicketPrivate[]
+
+export class PatchWebshopTicketsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    bodyDecoder = new ArrayDecoder(TicketPrivate.patchType() as Decoder<AutoEncoderPatchType<TicketPrivate>>)
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "PATCH") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/webshop/@id/tickets/private", { id: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate()
+
+        // Fast throw first (more in depth checking for patches later)
+        if (!await Context.auth.hasSomeAccess(organization.id)) {
+            throw Context.auth.error()
+        }
+
+        if (request.body.length == 0) {
+            return new Response([]);
+        }
+
+        const webshop = await Webshop.getByID(request.params.id)
+        if (!webshop || !await Context.auth.canAccessWebshopTickets(webshop, PermissionLevel.Write)) {
+            throw Context.auth.notFoundOrNoAccess("Je hebt geen toegang om tickets te wijzigen van deze webshop")
+        }
+
+        const tickets: Ticket[] = []
+        const errors = new SimpleErrors()
+
+        for (const patch of request.body) {
+            const model = await Ticket.getByID(patch.id)
+            if (!model || model.webshopId !== webshop.id) {
+                errors.addError(new SimpleError({
+                    code: "ticket_not_found",
+                    field: patch.id,
+                    message: "Ticket with id "+patch.id+" does not exist"
+                }))
+                continue
+            }
+
+            if (patch.scannedAt !== undefined) {
+                model.scannedAt = patch.scannedAt
+            }
+
+            if (patch.scannedBy !== undefined) {
+                model.scannedBy = patch.scannedBy
+            }
+
+            await model.save()
+
+            tickets.push(model)
+        }
+
+        errors.throwIfNotEmpty();
+        return new Response(
+            tickets.map(ticket => TicketPrivate.create(ticket))
+        );
+    }
+}

package/src/endpoints/organization/dashboard/webshops/VerifyWebshopDomainEndpoint.ts

@@ -0,0 +1,60 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Token, Webshop } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { PermissionLevel, PrivateWebshop, WebshopPrivateMetaData } from "@stamhoofd/structures";
+
+import { Context } from "../../../../helpers/Context";
+
+type Params = { id: string };
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = PrivateWebshop;
+
+/**
+ * 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 VerifyWebshopDomainEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "POST") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/webshop/@id/verify-domain", { id: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate()
+
+        // Fast throw first (more in depth checking for patches later)
+        if (!await Context.auth.hasSomeAccess(organization.id)) {
+            throw Context.auth.error()
+        }
+
+        return await QueueHandler.schedule("webshop-stock/"+request.params.id, async () => {
+            const webshop = await Webshop.getByID(request.params.id)
+            if (!webshop || !await Context.auth.canAccessWebshop(webshop, PermissionLevel.Full)) {
+                throw Context.auth.notFoundOrNoAccess()
+            }
+        
+            if (webshop.domain !== null) {
+                webshop.privateMeta.dnsRecords = WebshopPrivateMetaData.buildDNSRecords(webshop.domain)
+                await webshop.updateDNSRecords()
+            } else {
+                webshop.privateMeta.dnsRecords = []
+                webshop.meta.domainActive = false
+            }
+
+            await webshop.save()
+            return new Response(PrivateWebshop.create(webshop));
+        });
+    }
+}

package/src/endpoints/organization/shared/ExchangePaymentEndpoint.ts

@@ -0,0 +1,379 @@
+import { createMollieClient } from '@mollie/api-client';
+import { AutoEncoder, BooleanDecoder, Decoder, field } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { SimpleError } from "@simonbackx/simple-errors";
+import { BalanceItem, BalanceItemPayment, Member, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Registration, STPendingInvoice } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { Payment as PaymentStruct, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, STInvoiceItem } from "@stamhoofd/structures";
+import { Formatter } from '@stamhoofd/utility';
+
+import { BuckarooHelper } from '../../../helpers/BuckarooHelper';
+import { Context } from '../../../helpers/Context';
+import { StripeHelper } from '../../../helpers/StripeHelper';
+
+function calculateFee(totalPrice: number, fixed: number, percentageTimes100: number) {
+    return Math.round(fixed + Math.max(1, totalPrice * percentageTimes100 / 100 / 100)); // € 0,21 + 0,2%
+}
+
+type Params = {id: string};
+class Query extends AutoEncoder {
+    @field({ decoder: BooleanDecoder, optional: true })
+    exchange = false
+
+    /**
+     * If possible, cancel the payment if it is not yet paid/pending
+     */
+    @field({ decoder: BooleanDecoder, optional: true })
+    cancel = false
+}
+type Body = undefined
+type ResponseBody = PaymentStruct | undefined;
+
+/**
+ * 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 ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "POST") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/payments/@id", {id: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope()
+        
+        // Not method on payment because circular references (not supprted in ts)
+        const payment = await ExchangePaymentEndpoint.pollStatus(request.params.id, organization, request.query.cancel)
+        if (!payment) {
+            throw new SimpleError({
+                code: "",
+                message: "Deze link is ongeldig"
+            })
+        }
+
+        if (request.query.exchange) {
+            return new Response(undefined);
+        }
+        
+        return new Response( 
+            PaymentStruct.create({
+                id: payment.id,
+                method: payment.method,
+                provider: payment.provider,
+                status: payment.status,
+                price: payment.price,
+                transferDescription: payment.transferDescription,
+                paidAt: payment.paidAt,
+                createdAt: payment.createdAt,
+                updatedAt: payment.updatedAt
+            })
+        );
+    }
+    
+    static async updateOutstanding(items: BalanceItem[], organizationId: string) {
+        // Update outstanding amount of related members and registrations
+        const memberIds: string[] = Formatter.uniqueArray(items.map(p => p.memberId).filter(id => id !== null)) as any
+        await Member.updateOutstandingBalance(memberIds)
+
+        const registrationIds: string[] = Formatter.uniqueArray(items.map(p => p.registrationId).filter(id => id !== null)) as any
+        await Registration.updateOutstandingBalance(registrationIds, organizationId)
+    }
+
+    static async handlePaymentStatusUpdate(payment: Payment, organization: Organization, status: PaymentStatus) {
+        if (payment.status === status) {
+            return;
+        }
+        const wasPaid = payment.paidAt !== null
+        if (status === PaymentStatus.Succeeded) {
+            payment.status = PaymentStatus.Succeeded
+            payment.paidAt = new Date()
+            await payment.save();
+
+            // Prevent concurrency issues
+            await QueueHandler.schedule("balance-item-update/"+organization.id, async () => {
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    (await BalanceItemPayment.where({paymentId: payment.id})).map(r => r.setRelation(BalanceItemPayment.payment, payment))
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await balanceItemPayment.markPaid(organization);
+                }
+
+                await this.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
+            })
+
+            if (!wasPaid && payment.provider === PaymentProvider.Buckaroo && payment.method) {
+                // Charge transaction fees
+                let fee = 0
+
+                if (payment.method === PaymentMethod.iDEAL) {
+                    fee = calculateFee(payment.price, 21, 20); // € 0,21 + 0,2%
+                } else if (payment.method === PaymentMethod.Bancontact || payment.method === PaymentMethod.Payconiq) {
+                    fee = calculateFee(payment.price, 24, 20); // € 0,24 + 0,2%
+                } else {
+                    fee = calculateFee(payment.price, 25, 150); // € 0,25 + 1,5%
+                }
+
+                const name = "Transactiekosten voor "+PaymentMethodHelper.getName(payment.method)
+                const item = STInvoiceItem.create({
+                    name,
+                    description: "Via Buckaroo",
+                    amount: 1,
+                    unitPrice: fee,
+                    canUseCredits: false
+                })
+                console.log("Scheduling transaction fee charge for ", payment.id, item)
+                await QueueHandler.schedule("billing/invoices-"+organization.id, async () => {
+                    await STPendingInvoice.addItems(organization, [item])
+                });
+            }
+            return;
+        }
+
+        // If OLD status was succeeded, we need to revert the actions
+        if (payment.status === PaymentStatus.Succeeded) {
+            // No longer succeeded
+            await QueueHandler.schedule("balance-item-update/"+organization.id, async () => {
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    (await BalanceItemPayment.where({paymentId: payment.id})).map(r => r.setRelation(BalanceItemPayment.payment, payment))
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await balanceItemPayment.undoPaid(organization);
+                }
+
+                await this.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
+            })
+        }
+        
+        if (status == PaymentStatus.Failed) {
+            await QueueHandler.schedule("balance-item-update/"+organization.id, async () => {
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    (await BalanceItemPayment.where({paymentId: payment.id})).map(r => r.setRelation(BalanceItemPayment.payment, payment))
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await balanceItemPayment.markFailed(organization);
+                }
+
+                await this.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
+            })
+        }
+
+        // If OLD status was FAILED, we need to revert the actions
+        if (payment.status === PaymentStatus.Failed) { // OLD FAILED!! -> NOW PENDING
+            await QueueHandler.schedule("balance-item-update/"+organization.id, async () => {
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    (await BalanceItemPayment.where({paymentId: payment.id})).map(r => r.setRelation(BalanceItemPayment.payment, payment))
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await balanceItemPayment.undoFailed(organization);
+                }
+            })
+        }
+
+        payment.status = status
+        payment.paidAt = null
+        await payment.save();
+    }
+
+    /**
+     * ID of payment is needed because of race conditions (need to fetch payment in a race condition save queue)
+     */
+    static async pollStatus(paymentId: string, organization: Organization, cancel = false): Promise<Payment | undefined> {
+        // Prevent polling the same payment multiple times at the same time: create a queue to prevent races
+        return await QueueHandler.schedule("payments/"+paymentId, async () => {
+            // Get a new copy of the payment (is required to prevent concurreny bugs)
+            const payment = await Payment.getByID(paymentId)
+            if (!payment) {
+                return
+            }
+
+            const testMode = organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production'
+
+            if (payment.status == PaymentStatus.Pending || payment.status == PaymentStatus.Created || (payment.provider === PaymentProvider.Buckaroo && payment.status == PaymentStatus.Failed)) {
+                if (payment.provider === PaymentProvider.Stripe) {
+                    try {
+                        let status = await StripeHelper.getStatus(payment, cancel || this.shouldTryToCancel(payment.status, payment), testMode)
+
+                        if (this.isManualExpired(status, payment)) {
+                            console.error('Manually marking Stripe payment as expired', payment.id)
+                            status = PaymentStatus.Failed
+                        }
+
+                        await this.handlePaymentStatusUpdate(payment, organization, status)
+                    } catch (e) {
+                        console.error('Payment check failed Stripe', payment.id, e);
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking Stripe payment as expired', payment.id)
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                        }
+                    }
+                } else if (payment.provider === PaymentProvider.Mollie) {
+                    // check status via mollie
+                    const molliePayments = await MolliePayment.where({ paymentId: payment.id}, { limit: 1 })
+                    if (molliePayments.length == 1) {
+                        const molliePayment = molliePayments[0]
+                        // check status
+                        const token = await MollieToken.getTokenFor(organization.id)
+                        
+                        if (token) {
+                            try {
+                                const mollieClient = createMollieClient({ accessToken: await token.getAccessToken() });
+                                const mollieData = await mollieClient.payments.get(molliePayment.mollieId, {
+                                    testmode: organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production',
+                                })
+
+                                console.log(mollieData) // log to log files to check issues
+
+                                const details = (mollieData.details as any) 
+                                if (details?.consumerName) {
+                                    payment.ibanName = details.consumerName
+                                }
+                                if (details?.consumerAccount) {
+                                    payment.iban = details.consumerAccount
+                                }
+                                if (details?.cardHolder) {
+                                    payment.ibanName = details.cardHolder
+                                }
+                                if (details?.cardNumber) {
+                                    payment.iban = "xxxx xxxx xxxx "+details.cardNumber
+                                }
+
+                                if (mollieData.status == "paid") {
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Succeeded)
+                                } else if (mollieData.status == "failed" || mollieData.status == "expired" || mollieData.status == "canceled") {
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                                } else if (this.isManualExpired(payment.status, payment)) {
+                                    // Mollie still returning pending after 1 day: mark as failed
+                                    console.error('Manually marking Mollie payment as expired', payment.id)
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                                }
+                            } catch (e) {
+                                console.error('Payment check failed Mollie', payment.id, e);
+                                if (this.isManualExpired(payment.status, payment)) {
+                                    console.error('Manually marking Mollie payment as expired', payment.id)
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                                }
+                            }
+                        } else {
+                            console.warn("Mollie payment is missing for organization "+organization.id+" while checking payment status...")
+
+                            if (this.isManualExpired(payment.status, payment)) {
+                                console.error('Manually marking payment without mollie token as expired', payment.id)
+                                await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                            }
+                        }
+                    } else {
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking payment without mollie payments as expired', payment.id)
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                        }
+                    }
+                } else if (payment.provider == PaymentProvider.Buckaroo) {
+                    const helper = new BuckarooHelper(organization.privateMeta.buckarooSettings?.key ?? "", organization.privateMeta.buckarooSettings?.secret ?? "", organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
+                    try {
+                        let status = await helper.getStatus(payment)
+
+                        if (this.isManualExpired(status, payment)) {
+                            console.error('Manually marking Buckaroo payment as expired', payment.id)
+                            status = PaymentStatus.Failed
+                        }
+
+                        await this.handlePaymentStatusUpdate(payment, organization, status)
+                    } catch (e) {
+                        console.error('Payment check failed Buckaroo', payment.id, e);
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking Buckaroo payment as expired', payment.id)
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                        }
+                    }
+                   
+                } else if (payment.provider == PaymentProvider.Payconiq) {
+                    // Check status
+
+                    const payconiqPayments = await PayconiqPayment.where({ paymentId: payment.id}, { limit: 1 })
+                    if (payconiqPayments.length == 1) {
+                        const payconiqPayment = payconiqPayments[0]
+
+                        if (cancel) {
+                            console.error('Cancelling Payconiq payment on request', payment.id)
+                            await payconiqPayment.cancel(organization)
+                        }
+
+                        let status = await payconiqPayment.getStatus(organization)
+
+                        if (!cancel && this.shouldTryToCancel(status, payment)) {
+                            console.error('Manually cancelling Payconiq payment', payment.id)
+                            if (await payconiqPayment.cancel(organization)) {
+                                status = PaymentStatus.Failed
+                            }
+                        }
+
+                        if (this.isManualExpired(status, payment)) {
+                            console.error('Manually marking Payconiq payment as expired', payment.id)
+                            status = PaymentStatus.Failed
+                        }
+
+                        await this.handlePaymentStatusUpdate(payment, organization, status)
+                        
+                    } else {
+                        console.warn("Payconiq payment is missing for organization "+organization.id+" while checking payment status...")
+
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking Payconiq payment as expired because not found', payment.id)
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                        }
+                    }
+                } else {
+                    console.error('Invalid payment provider', payment.provider, 'for payment', payment.id);
+                    if (this.isManualExpired(payment.status, payment)) {
+                        console.error('Manually marking unknown payment as expired', payment.id)
+                        await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
+                    }
+                }
+            }
+            return payment
+        })
+    }
+
+    static isManualExpired(status: PaymentStatus, payment: Payment) {
+        if ((status == PaymentStatus.Pending || status === PaymentStatus.Created) && payment.method !== PaymentMethod.DirectDebit) {
+            // If payment is not succeeded after one day, mark as failed
+            if (payment.createdAt < new Date(new Date().getTime() - 60*1000*60*24)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Try to cancel a payment that is still pending
+     */
+    static shouldTryToCancel(status: PaymentStatus, payment: Payment) {
+        if ((status == PaymentStatus.Pending || status === PaymentStatus.Created) && payment.method !== PaymentMethod.DirectDebit) {
+            let timeout = STAMHOOFD.environment === 'development' ? 60*1000*2 : 60*1000*30;
+
+            // If payconiq and not yet 'identified' (scanned), cancel after 5 minutes
+            if (payment.provider === PaymentProvider.Payconiq && status === PaymentStatus.Created) {
+                timeout = STAMHOOFD.environment === 'development' ? 60*1000*1 : 60*1000*5;
+            }
+
+            if (payment.createdAt < new Date(new Date().getTime() - timeout)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/src/endpoints/organization/shared/GetDocumentHtml.ts

@@ -0,0 +1,54 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { SimpleError } from "@simonbackx/simple-errors";
+import { signInternal } from "@stamhoofd/backend-env";
+import { Document } from "@stamhoofd/models";
+
+import { Context } from "../../../helpers/Context";
+type Params = { id: string };
+type Query = undefined;
+type Body = undefined
+type ResponseBody = Buffer
+
+export class GetDocumentHtml extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/documents/@id/html", { id: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope()
+        await Context.authenticate()
+
+        const document = await Document.getByID(request.params.id)
+        if (!document || !(await Context.auth.canAccessDocument(document))) {
+            throw new SimpleError({
+                code: "not_found",
+                message: "Onbekend document"
+            })
+        }
+
+        const html = await document.getRenderedHtml(organization);
+        if (!html) {
+            throw new SimpleError({
+                code: "failed_generating",
+                message: "Er ging iets mis bij het aanmaken van het document. Probeer later opieuw en neem contact met ons op als het probleem blijft herhalen."
+            })
+        }
+
+        const response = new Response(Buffer.from(html, 'utf8'))
+        response.headers["content-type"] = "text/plain; charset=utf-8" // avoid JS execution
+        response.headers["content-length"] = Buffer.byteLength(html, 'utf8').toString()
+        response.headers["x-cache-id"] = 'document-' + document.id;
+        response.headers["x-cache-timestamp"] = document.updatedAt.getTime().toString();
+        response.headers["x-cache-signature"] = signInternal('document-' + document.id, document.updatedAt.getTime().toString(), html)
+        return response
+    }
+}

package/src/endpoints/organization/shared/GetPaymentEndpoint.ts

@@ -0,0 +1,45 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { SimpleError } from "@simonbackx/simple-errors";
+import { Payment } from "@stamhoofd/models";
+import { PaymentGeneral } from "@stamhoofd/structures";
+
+import { AuthenticatedStructures } from "../../../helpers/AuthenticatedStructures";
+import { Context } from "../../../helpers/Context";
+
+type Params = { id: string };
+type Query = undefined
+type Body = undefined
+type ResponseBody = PaymentGeneral
+
+export class GetPaymentEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/payments/@id", { id: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope()
+        await Context.authenticate()
+
+        const payment = await Payment.getByID(request.params.id);
+        if (!payment) {
+            throw new SimpleError({
+                code: "not_found",
+                message: "Payment not found",
+                human: "Je hebt geen toegang tot deze betaling"
+            })
+        }
+
+        return new Response(
+            await AuthenticatedStructures.paymentGeneral(payment, true)
+        );
+    }
+}