@stamhoofd/backend 2.39.1 → 2.40.0

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

@@ -1,11 +1,11 @@
 import { createMollieClient, PaymentMethod as molliePaymentMethod } from '@mollie/api-client';
 import { ManyToOneRelation } from '@simonbackx/simple-database';
 import { Decoder } 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 { Email } from '@stamhoofd/email';
 import { BalanceItem, BalanceItemPayment, Group, Member, MemberWithRegistrations, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
-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 { 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';
@@ -14,46 +14,46 @@ import { Context } from '../../../helpers/Context';
 import { StripeHelper } from '../../../helpers/StripeHelper';
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = IDRegisterCheckout
-type ResponseBody = RegisterResponse
+type Body = IDRegisterCheckout;
+type ResponseBody = RegisterResponse;
 
 export const demoLimiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Max 10 per hour
             limit: 10,
-            duration: 60 * 1000 * 60
+            duration: 60 * 1000 * 60,
         },
-        {   
+        {
             // Max 20 a day
             limit: 20,
-            duration: 24 * 60 * 1000 * 60
-        }
-    ]
+            duration: 24 * 60 * 1000 * 60,
+        },
+    ],
 });
 
-export type RegistrationWithMemberAndGroup = Registration & { member: Member } & { group: Group }
+export type RegistrationWithMemberAndGroup = Registration & { member: Member } & { group: Group };
 
 /**
  * Allow to add, patch and delete multiple members simultaneously, which is needed in order to sync relational data that is saved encrypted in multiple members (e.g. parents)
  */
 export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = IDRegisterCheckout as Decoder<IDRegisterCheckout>
+    bodyDecoder = IDRegisterCheckout as Decoder<IDRegisterCheckout>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/members/register", {});
+        const params = Endpoint.parseParameters(request.url, '/members/register', {});
 
         if (params) {
             if (request.getVersion() < 257) {
                 throw new SimpleError({
-                    code: "not_supported",
-                    message: "This version is no longer supported",
-                    human: "Oops! Je gebruikt een oude versie van de applicatie om in te schrijven. Herlaad de website en verwijder indien nodig de cache van jouw browser."
-                })
+                    code: 'not_supported',
+                    message: 'This version is no longer supported',
+                    human: 'Oops! Je gebruikt een oude versie van de applicatie om in te schrijven. Herlaad de website en verwijder indien nodig de cache van jouw browser.',
+                });
             }
             return [true, params as Params];
         }
@@ -62,171 +62,173 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        const {user} = await Context.authenticate()
+        const { user } = await Context.authenticate();
 
         if (request.body.asOrganizationId && request.body.asOrganizationId !== organization.id) {
             if (!await Context.auth.hasFullAccess(request.body.asOrganizationId)) {
                 throw new SimpleError({
-                    code: "forbidden",
-                    message: "No permission to register as this organization for a different organization",
+                    code: 'forbidden',
+                    message: 'No permission to register as this organization for a different organization',
                     human: 'Je hebt niet de juiste toegangsrechten om leden in te schrijven bij een andere organisatie.',
-                    statusCode: 403
+                    statusCode: 403,
                 });
             }
         }
 
         // For non paid organizations, limit amount of tests
         if (!organization.meta.packages.isPaid) {
-            const limiter = demoLimiter
+            const limiter = demoLimiter;
 
             try {
                 limiter.track(organization.id, 1);
-            } catch (e) {
+            }
+            catch (e) {
                 Email.sendWebmaster({
-                    subject: "[Limiet] Limiet bereikt voor aantal inschrijvingen",
-                    text: "Beste, \nDe limiet werd bereikt voor het aantal inschrijvingen per dag. \nVereniging: "+organization.id+" ("+organization.name+")" + "\n\n" + e.message + "\n\nStamhoofd"
-                })
+                    subject: '[Limiet] Limiet bereikt voor aantal inschrijvingen',
+                    text: 'Beste, \nDe limiet werd bereikt voor het aantal inschrijvingen per dag. \nVereniging: ' + organization.id + ' (' + organization.name + ')' + '\n\n' + e.message + '\n\nStamhoofd',
+                });
 
                 throw new SimpleError({
-                    code: "too_many_emails_period",
-                    message: "Too many e-mails limited",
-                    human: "Oeps! Om spam te voorkomen limiteren we het aantal test inschrijvingen die je per uur of dag kan plaatsen. Probeer over een uur opnieuw of schakel over naar een betaald abonnement.",
-                    field: "recipients"
-                })
+                    code: 'too_many_emails_period',
+                    message: 'Too many e-mails limited',
+                    human: 'Oeps! Om spam te voorkomen limiteren we het aantal test inschrijvingen die je per uur of dag kan plaatsen. Probeer over een uur opnieuw of schakel over naar een betaald abonnement.',
+                    field: 'recipients',
+                });
             }
         }
 
-        const deleteRegistrationIds = request.body.cart.deleteRegistrationIds
-        const deleteRegistrationModels = (deleteRegistrationIds.length ? (await Registration.getByIDs(...deleteRegistrationIds)) : []).filter(r => r.organizationId === organization.id)
+        const deleteRegistrationIds = request.body.cart.deleteRegistrationIds;
+        const deleteRegistrationModels = (deleteRegistrationIds.length ? (await Registration.getByIDs(...deleteRegistrationIds)) : []).filter(r => r.organizationId === organization.id);
 
         // Validate balance items (can only happen serverside)
-        const balanceItemIds = request.body.cart.balanceItems.map(i => i.item.id)
-        let memberBalanceItemsStructs: BalanceItemWithPayments[] = []
-        let balanceItemsModels: BalanceItem[] = []
+        const balanceItemIds = request.body.cart.balanceItems.map(i => i.item.id);
+        let memberBalanceItemsStructs: BalanceItemWithPayments[] = [];
+        let balanceItemsModels: BalanceItem[] = [];
         if (balanceItemIds.length > 0) {
-            balanceItemsModels = await BalanceItem.where({ id: { sign:'IN', value: balanceItemIds }, organizationId: organization.id })
-            if (balanceItemsModels.length != balanceItemIds.length) {
+            balanceItemsModels = await BalanceItem.where({ id: { sign: 'IN', value: balanceItemIds }, organizationId: organization.id });
+            if (balanceItemsModels.length !== balanceItemIds.length) {
                 throw new SimpleError({
-                    code: "invalid_data",
-                    message: "Oeps, één of meerdere openstaande bedragen in jouw winkelmandje zijn aangepast. Herlaad de pagina en probeer opnieuw."
-                })
+                    code: 'invalid_data',
+                    message: 'Oeps, één of meerdere openstaande bedragen in jouw winkelmandje zijn aangepast. Herlaad de pagina en probeer opnieuw.',
+                });
             }
-            memberBalanceItemsStructs = await BalanceItem.getStructureWithPayments(balanceItemsModels)
+            memberBalanceItemsStructs = await BalanceItem.getStructureWithPayments(balanceItemsModels);
         }
 
         const memberIds = Formatter.uniqueArray(
-            [...request.body.memberIds, ...deleteRegistrationModels.map(i => i.memberId), ...balanceItemsModels.map(i => i.memberId).filter(m => m !== null)]
-        )
-        const members = await Member.getBlobByIds(...memberIds)
-        const groupIds = request.body.groupIds
-        const groups = await Group.getByIDs(...groupIds)
+            [...request.body.memberIds, ...deleteRegistrationModels.map(i => i.memberId), ...balanceItemsModels.map(i => i.memberId).filter(m => m !== null)],
+        );
+        const members = await Member.getBlobByIds(...memberIds);
+        const groupIds = request.body.groupIds;
+        const groups = await Group.getByIDs(...groupIds);
 
         for (const group of groups) {
             if (group.organizationId !== organization.id) {
                 throw new SimpleError({
-                    code: "invalid_data",
-                    message: "Oeps, één of meerdere groepen waarin je probeert in te schrijven lijken niet meer te bestaan. Herlaad de pagina en probeer opnieuw."
-                })
+                    code: 'invalid_data',
+                    message: 'Oeps, één of meerdere groepen waarin je probeert in te schrijven lijken niet meer te bestaan. Herlaad de pagina en probeer opnieuw.',
+                });
             }
         }
 
         for (const member of members) {
             if (!await Context.auth.canAccessMember(member, PermissionLevel.Write)) {
                 throw new SimpleError({
-                    code: "forbidden",
-                    message: "No permission to register this member",
+                    code: 'forbidden',
+                    message: 'No permission to register this member',
                     human: 'Je hebt niet de juiste toegangsrechten om dit lid in te schrijven. Je kan enkel leden inschrijven als je minstens bewerkrechten hebt voor dat lid.',
-                    statusCode: 403
+                    statusCode: 403,
                 });
             }
         }
 
-        const blob = await AuthenticatedStructures.membersBlob(members, true)
-        const platformMembers: PlatformMember[] = []
+        const blob = await AuthenticatedStructures.membersBlob(members, true);
+        const platformMembers: PlatformMember[] = [];
 
         if (request.body.asOrganizationId) {
             const _m = PlatformFamily.createSingles(blob, {
                 platform: await Platform.getSharedStruct(),
-                contextOrganization: await AuthenticatedStructures.organization(organization)
-            })
-            platformMembers.push(..._m)
-        } else {
+                contextOrganization: await AuthenticatedStructures.organization(organization),
+            });
+            platformMembers.push(..._m);
+        }
+        else {
             const family = PlatformFamily.create(blob, {
                 platform: await Platform.getSharedStruct(),
-                contextOrganization: await AuthenticatedStructures.organization(organization)
-            })
-            platformMembers.push(...family.members)
+                contextOrganization: await AuthenticatedStructures.organization(organization),
+            });
+            platformMembers.push(...family.members);
         }
 
-        const organizationStruct = await AuthenticatedStructures.organization(organization)
+        const organizationStruct = await AuthenticatedStructures.organization(organization);
         const checkout = request.body.hydrate({
             members: platformMembers,
             groups: await AuthenticatedStructures.groups(groups),
-            organizations: [organizationStruct]
-        })
+            organizations: [organizationStruct],
+        });
 
         // Set circular references
         for (const member of platformMembers) {
-            member.family.checkout = checkout
+            member.family.checkout = checkout;
         }
 
-        checkout.setDefaultOrganization(organizationStruct)
-        
-        const registrations: RegistrationWithMemberAndGroup[] = []
-        const payRegistrations: {registration: RegistrationWithMemberAndGroup, item: RegisterItem}[] = []
+        checkout.setDefaultOrganization(organizationStruct);
+
+        const registrations: RegistrationWithMemberAndGroup[] = [];
+        const payRegistrations: { registration: RegistrationWithMemberAndGroup; item: RegisterItem }[] = [];
         const deactivatedRegistrationGroupIds: string[] = [];
 
         if (checkout.cart.isEmpty) {
             throw new SimpleError({
-                code: "empty_data",
-                message: "Oeps, jouw mandje is leeg. Voeg eerst inschrijvingen toe voor je verder gaat."
-            })
+                code: 'empty_data',
+                message: 'Oeps, jouw mandje is leeg. Voeg eerst inschrijvingen toe voor je verder gaat.',
+            });
         }
 
         // Validate the cart
-        checkout.validate({memberBalanceItems: memberBalanceItemsStructs})
+        checkout.validate({ memberBalanceItems: memberBalanceItemsStructs });
 
         // Recalculate the price
-        checkout.updatePrices()
+        checkout.updatePrices();
 
-        const totalPrice = checkout.totalPrice
+        const totalPrice = checkout.totalPrice;
 
         if (totalPrice !== request.body.totalPrice) {
             throw new SimpleError({
-                code: "changed_price",
-                message: "Oeps! De prijs is gewijzigd terwijl je aan het afrekenen was (naar "+Formatter.price(totalPrice)+"). Herlaad de pagina even om ervoor te zorgen dat je alle aangepaste prijzen ziet. Contacteer de webmaster als je dit probleem blijft ondervinden na het te herladen."
-            })
+                code: 'changed_price',
+                message: 'Oeps! De prijs is gewijzigd terwijl je aan het afrekenen was (naar ' + Formatter.price(totalPrice) + '). Herlaad de pagina even om ervoor te zorgen dat je alle aangepaste prijzen ziet. Contacteer de webmaster als je dit probleem blijft ondervinden na het te herladen.',
+            });
         }
-        
+
         if (totalPrice < 0) {
             throw new SimpleError({
-                code: "empty_data",
-                message: "Oeps! De totaalprijs is negatief."
-            })
+                code: 'empty_data',
+                message: 'Oeps! De totaalprijs is negatief.',
+            });
         }
 
-        const registrationMemberRelation = new ManyToOneRelation(Member, "member")
-        registrationMemberRelation.foreignKey = "memberId"
+        const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
+        registrationMemberRelation.foreignKey = 'memberId';
 
         for (const item of checkout.cart.items) {
-            const member = members.find(m => m.id == item.memberId)
+            const member = members.find(m => m.id == item.memberId);
             if (!member) {
                 throw new SimpleError({
-                    code: "invalid_member",
-                    message: "Het lid dat je probeert in te schrijven konden we niet meer terugvinden. Je herlaadt best even de pagina om opnieuw te proberen."
-                })
+                    code: 'invalid_member',
+                    message: 'Het lid dat je probeert in te schrijven konden we niet meer terugvinden. Je herlaadt best even de pagina om opnieuw te proberen.',
+                });
             }
 
             const group = groups.find(g => g.id == item.groupId);
             if (!group) {
                 throw new SimpleError({
-                    code: "invalid_member",
-                    message: "De groep waarin je een lid probeert in te schrijven lijkt niet meer te bestaan. Je herlaadt best even de pagina om opnieuw te proberen."
-                })
+                    code: 'invalid_member',
+                    message: 'De groep waarin je een lid probeert in te schrijven lijkt niet meer te bestaan. Je herlaadt best even de pagina om opnieuw te proberen.',
+                });
             }
 
             // Check if this member is already registered in this group?
-            const existingRegistrations = await Registration.where({ memberId: member.id, groupId: item.groupId, cycle: group.cycle })
+            const existingRegistrations = await Registration.where({ memberId: member.id, groupId: item.groupId, cycle: group.cycle });
 
             for (const existingRegistration of existingRegistrations) {
                 if (item.replaceRegistrations.some(r => r.id === existingRegistration.id)) {
@@ -241,157 +243,159 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
                 if (existingRegistration.registeredAt !== null && existingRegistration.deactivatedAt === null) {
                     throw new SimpleError({
-                        code: "already_registered",
-                        message: `${member.firstName} is al ingeschreven voor ${group.settings.name}. Mogelijks heb je meerdere keren proberen in te schrijven en is het intussen wel gelukt. Herlaad de pagina best even om zeker te zijn.`
-                    })
+                        code: 'already_registered',
+                        message: `${member.firstName} is al ingeschreven voor ${group.settings.name}. Mogelijks heb je meerdere keren proberen in te schrijven en is het intussen wel gelukt. Herlaad de pagina best even om zeker te zijn.`,
+                    });
                 }
             }
 
             const registration = new Registration()
                 .setRelation(registrationMemberRelation, member as Member)
-                .setRelation(Registration.group, group)
-            registration.organizationId = organization.id
-            registration.periodId = group.periodId
+                .setRelation(Registration.group, group);
+            registration.organizationId = organization.id;
+            registration.periodId = group.periodId;
 
-            registration.memberId = member.id
-            registration.groupId = group.id
-            registration.price = 0 // will get filled by balance items themselves 
+            registration.memberId = member.id;
+            registration.groupId = group.id;
+            registration.price = 0; // will get filled by balance items themselves
             registration.groupPrice = item.groupPrice;
-            registration.options = item.options
+            registration.options = item.options;
 
             payRegistrations.push({
                 registration,
-                item
+                item,
             });
 
-            registrations.push(registration)
+            registrations.push(registration);
         }
 
         // Who is going to pay?
-        let whoWillPayNow: 'member'|'organization'|'nobody' = 'member' // if this is set to 'organization', there will also be created separate balance items so the member can pay back the paying organization
+        let whoWillPayNow: 'member' | 'organization' | 'nobody' = 'member'; // if this is set to 'organization', there will also be created separate balance items so the member can pay back the paying organization
 
         if (request.body.asOrganizationId && request.body.asOrganizationId === organization.id) {
             // Will get added to the outstanding amount of the member
-            whoWillPayNow = 'nobody'
-        } else if (request.body.asOrganizationId && request.body.asOrganizationId !== organization.id) {
+            whoWillPayNow = 'nobody';
+        }
+        else if (request.body.asOrganizationId && request.body.asOrganizationId !== organization.id) {
             // The organization will pay to the organizing organization, and it will get added to the outstanding amount of the member towards the paying organization
-            whoWillPayNow = 'organization'
+            whoWillPayNow = 'organization';
         }
 
         // Validate payment method
         if (totalPrice > 0 && whoWillPayNow !== 'nobody') {
-            const allowedPaymentMethods = organization.meta.registrationPaymentConfiguration.paymentMethods
+            const allowedPaymentMethods = organization.meta.registrationPaymentConfiguration.paymentMethods;
 
             if (!checkout.paymentMethod || !allowedPaymentMethods.includes(checkout.paymentMethod)) {
                 throw new SimpleError({
-                    code: "invalid_payment_method",
-                    message: "Oeps, je hebt geen geldige betaalmethode geselecteerd. Selecteer een betaalmethode en probeer opnieuw. Herlaad de pagina indien nodig."
-                })
+                    code: 'invalid_payment_method',
+                    message: 'Oeps, je hebt geen geldige betaalmethode geselecteerd. Selecteer een betaalmethode en probeer opnieuw. Herlaad de pagina indien nodig.',
+                });
             }
 
             if ((checkout.paymentMethod !== PaymentMethod.Transfer && checkout.paymentMethod !== PaymentMethod.PointOfSale) && (!request.body.redirectUrl || !request.body.cancelUrl)) {
                 throw new SimpleError({
                     code: 'missing_fields',
                     message: 'redirectUrl or cancelUrl is missing and is required for non-zero online payments',
-                    human: 'Er is iets mis. Contacteer de webmaster.'
-                })
+                    human: 'Er is iets mis. Contacteer de webmaster.',
+                });
             }
-        } else {
-            checkout.paymentMethod = PaymentMethod.Unknown
+        }
+        else {
+            checkout.paymentMethod = PaymentMethod.Unknown;
         }
 
-        console.log('Registering members using whoWillPayNow', whoWillPayNow, checkout.paymentMethod, totalPrice)
+        console.log('Registering members using whoWillPayNow', whoWillPayNow, checkout.paymentMethod, totalPrice);
+
+        const createdBalanceItems: BalanceItem[] = [];
+        const unrelatedCreatedBalanceItems: BalanceItem[] = [];
+        const shouldMarkValid = whoWillPayNow === 'nobody' || checkout.paymentMethod === PaymentMethod.Transfer || checkout.paymentMethod === PaymentMethod.PointOfSale || checkout.paymentMethod === PaymentMethod.Unknown;
 
-        const createdBalanceItems: BalanceItem[] = []
-        const unrelatedCreatedBalanceItems: BalanceItem[] = []
-        const shouldMarkValid = whoWillPayNow === 'nobody' || checkout.paymentMethod === PaymentMethod.Transfer || checkout.paymentMethod === PaymentMethod.PointOfSale || checkout.paymentMethod === PaymentMethod.Unknown
-        
         // Create negative balance items
         for (const registrationStruct of [...checkout.cart.deleteRegistrations, ...checkout.cart.items.flatMap(i => i.replaceRegistrations)]) {
             if (whoWillPayNow !== 'nobody') {
-                // this also fixes the issue that we cannot delete the registration right away if we would need to wait for a payment 
+                // this also fixes the issue that we cannot delete the registration right away if we would need to wait for a payment
                 throw new SimpleError({
-                    code: "forbidden",
-                    message: "Permission denied: you are not allowed to delete registrations",
-                    human: "Oeps, je hebt geen toestemming om inschrijvingen te verwijderen.",
-                    statusCode: 403
-                })
+                    code: 'forbidden',
+                    message: 'Permission denied: you are not allowed to delete registrations',
+                    human: 'Oeps, je hebt geen toestemming om inschrijvingen te verwijderen.',
+                    statusCode: 403,
+                });
             }
 
-            const existingRegistration = await Registration.getByID(registrationStruct.id)
+            const existingRegistration = await Registration.getByID(registrationStruct.id);
             if (!existingRegistration || existingRegistration.organizationId !== organization.id) {
                 throw new SimpleError({
-                    code: "invalid_data",
-                    message: "Oeps, één of meerdere inschrijvingen die je probeert te verwijderen lijken niet meer te bestaan. Herlaad de pagina en probeer opnieuw."
-                })
+                    code: 'invalid_data',
+                    message: 'Oeps, één of meerdere inschrijvingen die je probeert te verwijderen lijken niet meer te bestaan. Herlaad de pagina en probeer opnieuw.',
+                });
             }
 
             if (!await Context.auth.canAccessRegistration(existingRegistration, PermissionLevel.Write)) {
                 throw new SimpleError({
-                    code: "forbidden",
-                    message: "Je hebt geen toegaansrechten om deze inschrijving te verwijderen.",
-                    statusCode: 403
-                })
+                    code: 'forbidden',
+                    message: 'Je hebt geen toegaansrechten om deze inschrijving te verwijderen.',
+                    statusCode: 403,
+                });
             }
 
             if (existingRegistration.deactivatedAt || !existingRegistration.registeredAt) {
                 throw new SimpleError({
-                    code: "invalid_data",
-                    message: "Oeps, één of meerdere inschrijvingen die je probeert te verwijderen was al verwijderd. Herlaad de pagina en probeer opnieuw."
-                })
+                    code: 'invalid_data',
+                    message: 'Oeps, één of meerdere inschrijvingen die je probeert te verwijderen was al verwijderd. Herlaad de pagina en probeer opnieuw.',
+                });
             }
 
             // We can alter right away since whoWillPayNow is nobody, and shouldMarkValid will always be true
             // Find all balance items of this registration and set them to zero
-            await BalanceItem.deleteForDeletedRegistration(existingRegistration.id)
-            
+            await BalanceItem.deleteForDeletedRegistration(existingRegistration.id);
+
             // Clear the registration
-            await existingRegistration.deactivate()
+            await existingRegistration.deactivate();
             deactivatedRegistrationGroupIds.push(existingRegistration.groupId);
 
-            const group = groups.find(g => g.id === existingRegistration.groupId)
+            const group = groups.find(g => g.id === existingRegistration.groupId);
             if (!group) {
-                const g = await Group.getByID(existingRegistration.groupId)
+                const g = await Group.getByID(existingRegistration.groupId);
                 if (g) {
-                    groups.push(g)
+                    groups.push(g);
                 }
             }
         }
 
-        async function createBalanceItem({registration, amount, unitPrice, description, type, relations}: {amount?: number, registration: RegistrationWithMemberAndGroup, unitPrice: number, description: string, relations: Map<BalanceItemRelationType, BalanceItemRelation>, type: BalanceItemType}) {
+        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.unitPrice = unitPrice
-            balanceItem.amount = amount ?? 1
-            balanceItem.description = description
-            balanceItem.relations = relations
-            balanceItem.type = type
+            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;
 
             // Who is responsible for payment?
-            let balanceItem2: BalanceItem | null = null
+            let balanceItem2: BalanceItem | null = null;
             if (whoWillPayNow === 'organization' && request.body.asOrganizationId) {
                 // Create a separate balance item for this meber to pay back the paying organization
                 // this is not yet associated with a payment but will be added to the outstanding balance of the member
 
-                balanceItem.payingOrganizationId = request.body.asOrganizationId
+                balanceItem.payingOrganizationId = request.body.asOrganizationId;
 
                 balanceItem2 = new BalanceItem();
 
                 // NOTE: we don't connect the registrationId here
                 // because otherwise the total price and pricePaid for the registration would be incorrect
-                //balanceItem2.registrationId = registration.id;
+                // balanceItem2.registrationId = registration.id;
 
-                balanceItem2.unitPrice = unitPrice
-                balanceItem2.amount = amount ?? 1
-                balanceItem2.description = description
-                balanceItem2.relations = relations
-                balanceItem2.type = type
+                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;
@@ -400,46 +404,48 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                 balanceItem2.memberId = registration.memberId;
 
                 // If the paying organization hasn't paid yet, this should be hidden and move to pending as soon as the paying organization has paid
-                balanceItem2.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden
+                balanceItem2.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden;
                 await balanceItem2.save();
 
                 // do not add to createdBalanceItems array because we don't want to add this to the payment if we create a payment
-                unrelatedCreatedBalanceItems.push(balanceItem2)
-            } else {
+                unrelatedCreatedBalanceItems.push(balanceItem2);
+            }
+            else {
                 balanceItem.memberId = registration.memberId;
-                balanceItem.userId = user.id
+                balanceItem.userId = user.id;
             }
 
-            balanceItem.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden
-            balanceItem.pricePaid = 0
-            
+            balanceItem.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden;
+            balanceItem.pricePaid = 0;
+
             // Connect the 'pay back' balance item to this balance item. As soon as this balance item is paid, we'll mark the other one as pending so the outstanding balance for the member increases
-            balanceItem.dependingBalanceItemId = balanceItem2?.id ?? null
-            
+            balanceItem.dependingBalanceItemId = balanceItem2?.id ?? null;
+
             await balanceItem.save();
-            createdBalanceItems.push(balanceItem)
+            createdBalanceItems.push(balanceItem);
         }
 
         // Save registrations and add extra data if needed
         for (const bundle of payRegistrations) {
-            const {item, registration} = bundle;
-            registration.reservedUntil = null
+            const { item, registration } = bundle;
+            registration.reservedUntil = null;
 
             if (shouldMarkValid) {
-                await registration.markValid({skipEmail: bundle.item.replaceRegistrations.length > 0})
-            } else {
+                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)
+                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)
+                    registration.reservedUntil = new Date(new Date().getTime() + 1000 * 60 * 30);
                 }
-                await registration.save()
+                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;
             }
@@ -447,46 +453,46 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             // Create balance items
             const sharedRelations: [BalanceItemRelationType, BalanceItemRelation][] = [
                 [
-                    BalanceItemRelationType.Member, 
+                    BalanceItemRelationType.Member,
                     BalanceItemRelation.create({
                         id: item.member.id,
-                        name: item.member.patchedMember.name
-                    })
+                        name: item.member.patchedMember.name,
+                    }),
                 ],
                 [
-                    BalanceItemRelationType.Group, 
+                    BalanceItemRelationType.Group,
                     BalanceItemRelation.create({
                         id: item.group.id,
-                        name: item.group.settings.name
-                    })
-                ]
-            ]
+                        name: item.group.settings.name,
+                    }),
+                ],
+            ];
 
             if (item.group.settings.prices.length > 1) {
                 sharedRelations.push([
-                    BalanceItemRelationType.GroupPrice, 
+                    BalanceItemRelationType.GroupPrice,
                     BalanceItemRelation.create({
                         id: item.groupPrice.id,
-                        name: item.groupPrice.name
-                    })
-                ])
+                        name: item.groupPrice.name,
+                    }),
+                ]);
             }
 
             // Base price
             await createBalanceItem({
-                registration, 
+                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
-                ])
-            })
+                    ...sharedRelations,
+                ]),
+            });
 
             // Options
             for (const option of item.options) {
                 await createBalanceItem({
-                    registration, 
+                    registration,
                     amount: option.amount,
                     unitPrice: option.option.price.forMember(item.member),
                     type: BalanceItemType.Registration,
@@ -494,66 +500,66 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     relations: new Map([
                         ...sharedRelations,
                         [
-                            BalanceItemRelationType.GroupOptionMenu, 
+                            BalanceItemRelationType.GroupOptionMenu,
                             BalanceItemRelation.create({
                                 id: option.optionMenu.id,
                                 name: option.optionMenu.name,
-                            })
+                            }),
                         ],
                         [
-                            BalanceItemRelationType.GroupOption, 
+                            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]
+
+        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.type = BalanceItemType.FreeContribution
-            balanceItem.unitPrice = checkout.freeContribution
-            balanceItem.description = `Vrije bijdrage`
+            balanceItem.type = BalanceItemType.FreeContribution;
+            balanceItem.unitPrice = checkout.freeContribution;
+            balanceItem.description = `Vrije bijdrage`;
             balanceItem.pricePaid = 0;
-            balanceItem.userId = user.id
+            balanceItem.userId = user.id;
             balanceItem.organizationId = organization.id;
 
             // Connect this to the oldest member
-            
+
             if (oldestMember) {
                 balanceItem.memberId = oldestMember.id;
             }
-            balanceItem.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden
+            balanceItem.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden;
             await balanceItem.save();
-            createdBalanceItems.push(balanceItem)
+            createdBalanceItems.push(balanceItem);
         }
 
         if (checkout.administrationFee && whoWillPayNow !== 'nobody') {
             // Create balance item
             const balanceItem = new BalanceItem();
-            balanceItem.type = BalanceItemType.AdministrationFee
-            balanceItem.unitPrice = checkout.administrationFee
-            balanceItem.description = `Administratiekosten`
+            balanceItem.type = BalanceItemType.AdministrationFee;
+            balanceItem.unitPrice = checkout.administrationFee;
+            balanceItem.description = `Administratiekosten`;
             balanceItem.pricePaid = 0;
             balanceItem.organizationId = organization.id;
 
             if (request.body.asOrganizationId) {
-                balanceItem.payingOrganizationId = request.body.asOrganizationId
-            } else {
-                balanceItem.userId = user.id
+                balanceItem.payingOrganizationId = request.body.asOrganizationId;
+            }
+            else {
+                balanceItem.userId = user.id;
                 // Connect this to the oldest member
                 if (oldestMember) {
                     balanceItem.memberId = oldestMember.id;
                 }
             }
 
-            balanceItem.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden
+            balanceItem.status = shouldMarkValid ? BalanceItemStatus.Pending : BalanceItemStatus.Hidden;
             await balanceItem.save();
 
             createdBalanceItems.push(balanceItem);
@@ -563,105 +569,107 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             throw new SimpleError({
                 code: 'invalid_data',
                 message: 'Not possible to pay balance items as the organization',
-                statusCode: 400
-            })
+                statusCode: 400,
+            });
         }
 
-        let paymentUrl: string | null = null
-        let payment: Payment | null = null
+        let paymentUrl: string | null = null;
+        let payment: Payment | null = null;
 
         if (whoWillPayNow !== 'nobody') {
-            const mappedBalanceItems = new Map<BalanceItem, number>()
+            const mappedBalanceItems = new Map<BalanceItem, number>();
 
             for (const item of createdBalanceItems) {
-                mappedBalanceItems.set(item, item.price)
+                mappedBalanceItems.set(item, item.price);
             }
 
             for (const item of checkout.cart.balanceItems) {
-                const balanceItem = balanceItemsModels.find(i => i.id === item.item.id)
+                const balanceItem = balanceItemsModels.find(i => i.id === item.item.id);
                 if (!balanceItem) {
-                    throw new Error('Balance item not found')
+                    throw new Error('Balance item not found');
                 }
-                mappedBalanceItems.set(balanceItem, item.price)
-                createdBalanceItems.push(balanceItem)
+                mappedBalanceItems.set(balanceItem, item.price);
+                createdBalanceItems.push(balanceItem);
             }
 
             // Make sure every price is accurate before creating a payment
-            await BalanceItem.updateOutstanding([...createdBalanceItems, ...unrelatedCreatedBalanceItems])
+            await BalanceItem.updateOutstanding([...createdBalanceItems, ...unrelatedCreatedBalanceItems]);
             try {
                 const response = await this.createPayment({
                     balanceItems: mappedBalanceItems,
                     organization,
                     user,
                     checkout: request.body,
-                    members
-                })
+                    members,
+                });
 
                 if (response) {
-                    paymentUrl = response.paymentUrl
-                    payment = response.payment
+                    paymentUrl = response.paymentUrl;
+                    payment = response.payment;
                 }
-            } finally {
+            }
+            finally {
                 // Update cached balance items pending amount (only created balance items, because those are involved in the payment)
-                await BalanceItem.updateOutstanding(createdBalanceItems)
+                await BalanceItem.updateOutstanding(createdBalanceItems);
             }
-        } else {
-            await BalanceItem.updateOutstanding([...createdBalanceItems, ...unrelatedCreatedBalanceItems])
+        }
+        else {
+            await BalanceItem.updateOutstanding([...createdBalanceItems, ...unrelatedCreatedBalanceItems]);
         }
 
         // Update occupancy
         for (const group of groups) {
             if (registrations.some(r => r.groupId === group.id) || deactivatedRegistrationGroupIds.some(id => id === group.id)) {
-                await group.updateOccupancy()
-                await group.save()
+                await group.updateOccupancy();
+                await group.save();
             }
         }
 
-        const updatedMembers = await Member.getBlobByIds(...memberIds)
+        const updatedMembers = await Member.getBlobByIds(...memberIds);
 
         return new Response(RegisterResponse.create({
             payment: payment ? PaymentStruct.create(payment) : null,
             members: await AuthenticatedStructures.membersBlob(updatedMembers),
             registrations: registrations.map(r => Member.getRegistrationWithMemberStructure(r)),
-            paymentUrl
+            paymentUrl,
         }));
     }
 
-    async createPayment({balanceItems, organization, user, checkout, members}: {balanceItems: Map<BalanceItem, number>, organization: Organization, user: User, checkout: IDRegisterCheckout, members: MemberWithRegistrations[]}) {
+    async createPayment({ balanceItems, organization, user, checkout, members }: { balanceItems: Map<BalanceItem, number>; organization: Organization; user: User; checkout: IDRegisterCheckout; members: MemberWithRegistrations[] }) {
         // Calculate total price to pay
-        let totalPrice = 0
-        const payMembers: MemberWithRegistrations[] = []
+        let totalPrice = 0;
+        const payMembers: MemberWithRegistrations[] = [];
 
         for (const [balanceItem, price] of balanceItems) {
             if (organization.id !== balanceItem.organizationId) {
-                throw new Error('Unexpected balance item from other organization')
+                throw new Error('Unexpected balance item from other organization');
             }
 
             if (price > 0 && price > Math.max(balanceItem.priceOpen, balanceItem.price - balanceItem.pricePaid)) {
                 throw new SimpleError({
-                    code: "invalid_data",
-                    message: "Oeps, het bedrag dat je probeert te betalen is ongeldig (het bedrag is hoger dan het bedrag dat je moet betalen). Herlaad de pagina en probeer opnieuw."
-                })
+                    code: 'invalid_data',
+                    message: 'Oeps, het bedrag dat je probeert te betalen is ongeldig (het bedrag is hoger dan het bedrag dat je moet betalen). Herlaad de pagina en probeer opnieuw.',
+                });
             }
 
             if (price < 0 && price < Math.min(balanceItem.priceOpen, balanceItem.price - balanceItem.pricePaid)) {
                 throw new SimpleError({
-                    code: "invalid_data",
-                    message: "Oeps, het bedrag dat je probeert te betalen is ongeldig (het terug te krijgen bedrag is hoger dan het bedrag dat je kan terug krijgen). Herlaad de pagina en probeer opnieuw."
-                })
+                    code: 'invalid_data',
+                    message: 'Oeps, het bedrag dat je probeert te betalen is ongeldig (het terug te krijgen bedrag is hoger dan het bedrag dat je kan terug krijgen). Herlaad de pagina en probeer opnieuw.',
+                });
             }
 
-            totalPrice += price
+            totalPrice += price;
 
             if (price > 0 && balanceItem.memberId) {
-                const member = members.find(m => m.id === balanceItem.memberId)
+                const member = members.find(m => m.id === balanceItem.memberId);
                 if (!member) {
                     throw new SimpleError({
-                        code: "invalid_data",
-                        message: "Oeps, het lid dat je probeert in te schrijven konden we niet meer terugvinden. Je herlaadt best even de pagina om opnieuw te proberen."
-                    })
+                        code: 'invalid_data',
+                        message: 'Oeps, het lid dat je probeert in te schrijven konden we niet meer terugvinden. Je herlaadt best even de pagina om opnieuw te proberen.',
+                    });
                 }
-                payMembers.push(member)
+                payMembers.push(member);
             }
         }
 
@@ -680,150 +688,152 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
         if (!checkout.paymentMethod || checkout.paymentMethod === PaymentMethod.Unknown) {
             throw new SimpleError({
-                code: "invalid_data",
-                message: "Oeps, je hebt geen betaalmethode geselecteerd. Selecteer een betaalmethode en probeer opnieuw."
-            })
+                code: 'invalid_data',
+                message: 'Oeps, je hebt geen betaalmethode geselecteerd. Selecteer een betaalmethode en probeer opnieuw.',
+            });
         }
 
-        const payment = new Payment()
+        const payment = new Payment();
 
         // Who will receive this money?
-        payment.organizationId = organization.id
+        payment.organizationId = organization.id;
 
         // Who paid
-        payment.payingUserId = user.id
-        payment.payingOrganizationId = checkout.asOrganizationId ?? null
+        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."
-                })
+                    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."
-                })
+                    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."
-                })
+                    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)
+            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."
-                })
+                    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.customer.company = foundCompany;
         }
 
-        payment.method = checkout.paymentMethod
-        payment.status = PaymentStatus.Created
-        payment.price = totalPrice
+        payment.method = checkout.paymentMethod;
+        payment.status = PaymentStatus.Created;
+        payment.price = totalPrice;
 
         if (payment.method == PaymentMethod.Transfer) {
             // remark: we cannot add the lastnames, these will get added in the frontend when it is decrypted
-            payment.transferSettings = organization.mappedTransferSettings
+            payment.transferSettings = organization.mappedTransferSettings;
 
             if (!payment.transferSettings.iban) {
                 throw new SimpleError({
-                    code: "no_iban",
-                    message: "No IBAN",
-                    human: "Er is geen rekeningnummer ingesteld voor overschrijvingen. Contacteer de beheerder."
-                })
+                    code: 'no_iban',
+                    message: 'No IBAN',
+                    human: 'Er is geen rekeningnummer ingesteld voor overschrijvingen. Contacteer de beheerder.',
+                });
             }
 
-            const m = payMembers.map(r => r.details)
+            const m = payMembers.map(r => r.details);
             payment.generateDescription(
-                organization, 
+                organization,
                 Formatter.groupNamesByFamily(m),
                 {
                     name: Formatter.groupNamesByFamily(m),
-                    naam:  Formatter.groupNamesByFamily(m),
-                    email: user.email
-                }
-            )
+                    naam: Formatter.groupNamesByFamily(m),
+                    email: user.email,
+                },
+            );
         }
-        payment.paidAt = null
+        payment.paidAt = null;
 
         // Determine the payment provider
         // Throws if invalid
-        const {provider, stripeAccount} = await organization.getPaymentProviderFor(payment.method, organization.privateMeta.registrationPaymentConfiguration)
-        payment.provider = provider
-        payment.stripeAccountId = stripeAccount?.id ?? null
+        const { provider, stripeAccount } = await organization.getPaymentProviderFor(payment.method, organization.privateMeta.registrationPaymentConfiguration);
+        payment.provider = provider;
+        payment.stripeAccountId = stripeAccount?.id ?? null;
 
-        await payment.save()
+        await payment.save();
 
         // Create balance item payments
-        const balanceItemPayments: (BalanceItemPayment & { balanceItem: BalanceItem })[] = []
+        const balanceItemPayments: (BalanceItemPayment & { balanceItem: BalanceItem })[] = [];
 
         for (const [balanceItem, price] of balanceItems) {
             // Create one balance item payment to pay it in one payment
-            const balanceItemPayment = new BalanceItemPayment()
+            const balanceItemPayment = new BalanceItemPayment();
             balanceItemPayment.balanceItemId = balanceItem.id;
             balanceItemPayment.paymentId = payment.id;
             balanceItemPayment.organizationId = organization.id;
             balanceItemPayment.price = price;
             await balanceItemPayment.save();
 
-            balanceItemPayments.push(balanceItemPayment.setRelation(BalanceItemPayment.balanceItem, balanceItem))
+            balanceItemPayments.push(balanceItemPayment.setRelation(BalanceItemPayment.balanceItem, balanceItem));
         }
 
-        const description = 'Inschrijving '+organization.name
+        const description = 'Inschrijving ' + organization.name;
 
-        let paymentUrl: string | null = null
+        let paymentUrl: string | null = null;
 
         // Update balance items
         if (payment.method === PaymentMethod.Transfer) {
             // Send a small reminder email
             try {
-                await Registration.sendTransferEmail(user, organization, payment)
-            } catch (e) {
-                console.error("Failed to send transfer email")
-                console.error(e)
+                await Registration.sendTransferEmail(user, organization, payment);
+            }
+            catch (e) {
+                console.error('Failed to send transfer email');
+                console.error(e);
             }
-        } else if (payment.method !== PaymentMethod.PointOfSale) {
+        }
+        else if (payment.method !== PaymentMethod.PointOfSale) {
             if (!checkout.redirectUrl || !checkout.cancelUrl) {
-                throw new Error('Should have been caught earlier')
+                throw new Error('Should have been caught earlier');
             }
 
-            const _redirectUrl = new URL(checkout.redirectUrl)
+            const _redirectUrl = new URL(checkout.redirectUrl);
             _redirectUrl.searchParams.set('paymentId', payment.id);
             _redirectUrl.searchParams.set('organizationId', organization.id); // makes sure the client uses the token associated with this organization when fetching payment polling status
 
-            const _cancelUrl = new URL(checkout.cancelUrl)
+            const _cancelUrl = new URL(checkout.cancelUrl);
             _cancelUrl.searchParams.set('paymentId', payment.id);
             _cancelUrl.searchParams.set('cancel', 'true');
             _cancelUrl.searchParams.set('organizationId', organization.id); // makes sure the client uses the token associated with this organization when fetching payment polling status
 
-            const redirectUrl = _redirectUrl.href
-            const cancelUrl = _cancelUrl.href
+            const redirectUrl = _redirectUrl.href;
+            const cancelUrl = _cancelUrl.href;
 
-            const webhookUrl = 'https://'+organization.getApiHost()+"/v"+Version+"/payments/"+encodeURIComponent(payment.id)+"?exchange=true"
+            const webhookUrl = 'https://' + organization.getApiHost() + '/v' + Version + '/payments/' + encodeURIComponent(payment.id) + '?exchange=true';
 
             if (payment.provider === PaymentProvider.Stripe) {
                 const stripeResult = await StripeHelper.createPayment({
@@ -835,7 +845,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     metadata: {
                         organization: organization.id,
                         user: user.id,
-                        payment: payment.id
+                        payment: payment.id,
                     },
                     i18n: Context.i18n,
                     lineItems: balanceItemPayments,
@@ -843,34 +853,34 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     customer: {
                         name: user.name ?? payMembers[0]?.details.name ?? 'Onbekend',
                         email: user.email,
-                    }
+                    },
                 });
-                paymentUrl = stripeResult.paymentUrl
-            } else if (payment.provider === PaymentProvider.Mollie) {
-                
+                paymentUrl = stripeResult.paymentUrl;
+            }
+            else if (payment.provider === PaymentProvider.Mollie) {
                 // Mollie payment
-                const token = await MollieToken.getTokenFor(organization.id)
+                const token = await MollieToken.getTokenFor(organization.id);
                 if (!token) {
                     throw new SimpleError({
-                        code: "",
-                        message: "Betaling via " + PaymentMethodHelper.getName(payment.method) + " is onbeschikbaar"
-                    })
+                        code: '',
+                        message: 'Betaling via ' + PaymentMethodHelper.getName(payment.method) + ' is onbeschikbaar',
+                    });
                 }
-                const profileId = organization.privateMeta.mollieProfile?.id ?? await token.getProfileId(organization.getHost())
+                const profileId = organization.privateMeta.mollieProfile?.id ?? await token.getProfileId(organization.getHost());
                 if (!profileId) {
                     throw new SimpleError({
-                        code: "",
-                        message: "Betaling via " + PaymentMethodHelper.getName(payment.method) + " is tijdelijk onbeschikbaar"
-                    })
+                        code: '',
+                        message: 'Betaling via ' + PaymentMethodHelper.getName(payment.method) + ' is tijdelijk onbeschikbaar',
+                    });
                 }
                 const mollieClient = createMollieClient({ accessToken: await token.getAccessToken() });
                 const molliePayment = await mollieClient.payments.create({
                     amount: {
                         currency: 'EUR',
-                        value: (totalPrice / 100).toFixed(2)
+                        value: (totalPrice / 100).toFixed(2),
                     },
                     method: payment.method == PaymentMethod.Bancontact ? molliePaymentMethod.bancontact : (payment.method == PaymentMethod.iDEAL ? molliePaymentMethod.ideal : molliePaymentMethod.creditcard),
-                    testmode: organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production',
+                    testmode: organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production',
                     profileId,
                     description,
                     redirectUrl,
@@ -879,29 +889,31 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                         paymentId: payment.id,
                     },
                 });
-                paymentUrl = molliePayment.getCheckoutUrl()
+                paymentUrl = molliePayment.getCheckoutUrl();
 
                 // Save payment
-                const dbPayment = new MolliePayment()
-                dbPayment.paymentId = payment.id
-                dbPayment.mollieId = molliePayment.id
+                const dbPayment = new MolliePayment();
+                dbPayment.paymentId = payment.id;
+                dbPayment.mollieId = molliePayment.id;
                 await dbPayment.save();
-            } else if (payment.provider === PaymentProvider.Payconiq) {
-                paymentUrl = await PayconiqPayment.createPayment(payment, organization, description, redirectUrl, webhookUrl)
-            } else if (payment.provider == PaymentProvider.Buckaroo) {
+            }
+            else if (payment.provider === PaymentProvider.Payconiq) {
+                paymentUrl = await PayconiqPayment.createPayment(payment, organization, description, redirectUrl, webhookUrl);
+            }
+            else if (payment.provider == PaymentProvider.Buckaroo) {
                 // Increase request timeout because buckaroo is super slow (in development)
-                Context.request.request?.setTimeout(60 * 1000)
-                const buckaroo = new BuckarooHelper(organization.privateMeta?.buckarooSettings?.key ?? "", organization.privateMeta?.buckarooSettings?.secret ?? "", organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
-                const ip = Context.request.getIP()
-                paymentUrl = await buckaroo.createPayment(payment, ip, description, redirectUrl, webhookUrl)
-                await payment.save()
+                Context.request.request?.setTimeout(60 * 1000);
+                const buckaroo = new BuckarooHelper(organization.privateMeta?.buckarooSettings?.key ?? '', organization.privateMeta?.buckarooSettings?.secret ?? '', organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
+                const ip = Context.request.getIP();
+                paymentUrl = await buckaroo.createPayment(payment, ip, description, redirectUrl, webhookUrl);
+                await payment.save();
 
                 // TypeScript doesn't understand that the status can change and isn't a const....
                 if ((payment.status as any) === PaymentStatus.Failed) {
                     throw new SimpleError({
-                        code: "payment_failed",
-                        message: "Betaling via " + PaymentMethodHelper.getName(payment.method) + " is onbeschikbaar"
-                    })
+                        code: 'payment_failed',
+                        message: 'Betaling via ' + PaymentMethodHelper.getName(payment.method) + ' is onbeschikbaar',
+                    });
                 }
             }
         }
@@ -911,7 +923,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             balanceItemPayments,
             provider,
             stripeAccount,
-            paymentUrl
-        }
+            paymentUrl,
+        };
     }
 }