@stamhoofd/backend 2.121.0 → 2.122.0

package/src/services/PaymentService.ts

@@ -1,11 +1,10 @@
-import { createMollieClient, PaymentStatus as MolliePaymentStatus } from '@mollie/api-client';
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import type { Member, User } from '@stamhoofd/models';
-import { BalanceItem } from '@stamhoofd/models';
-import { BalanceItemPayment, Group, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, sendEmailTemplate } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, Group, Organization, PayconiqPayment, Payment, Platform, sendEmailTemplate, UsedRegisterCode } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import type { Checkoutable, PaymentConfiguration, PrivatePaymentConfiguration } from '@stamhoofd/structures';
-import { AuditLogSource, BalanceItemPaymentDetailed, BalanceItemType, EmailTemplateType, Invoice, PaymentCustomer, PaymentGeneral, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, PaymentType, Recipient, VATExcemptReason, Version } from '@stamhoofd/structures';
+import { AuditLogSource, BalanceItemPaymentDetailed, BalanceItemType, EmailTemplateType, Invoice, PaymentCustomer, PaymentGeneral, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, PaymentType, Recipient, Replacement, VATExcemptReason, Version } from '@stamhoofd/structures';
+import type { CreateMandateSettings } from '@stamhoofd/structures/checkout/CreateMandateSettings.js';
 import type { PaymentMandate } from '@stamhoofd/structures/PaymentMandate.js';
 import { PaymentMandateStatus, PaymentMandateType } from '@stamhoofd/structures/PaymentMandate.js';
 import { Formatter } from '@stamhoofd/utility';
@@ -20,10 +19,22 @@ import { BalanceItemPaymentService } from './BalanceItemPaymentService.js';
 import { BalanceItemService } from './BalanceItemService.js';
 import { MollieService } from './MollieService.js';
 import { PaymentMandateService } from './PaymentMandateService.js';
-import type { CreateMandateSettings } from '@stamhoofd/structures/checkout/CreateMandateSettings.js';
+import { ReferralService } from './ReferralService.js';
+import { VATService } from './VATService.js';
+import { STPackageService } from './STPackageService.js';
 
 export class PaymentService {
-    static async handlePaymentStatusUpdate(payment: Payment, organization: Organization, status: PaymentStatus) {
+    static async updateReversedPaymentsFor(payment: Payment) {
+        if (payment.reversingPaymentId) {
+            // Update refund amount of that payment
+            const reversingPayment = await Payment.getByID(payment.reversingPaymentId);
+            if (reversingPayment) {
+                await reversingPayment.updateRefundedAmount();
+            }
+        }
+    }
+
+    static async handlePaymentStatusUpdate(payment: Payment, organization: Organization, status: PaymentStatus, paidAt?: Date) {
         if (payment.status === status) {
             return;
         }
@@ -32,14 +43,19 @@ export class PaymentService {
             throw new SimpleError({
                 code: 'cannot_fail',
                 message: 'A payment that has been invoiced cannot be marked as failed. Instead create a separate chargeback payment with a negative amount.',
-                human: $t('%1RI')
-            })
+                human: $t('%1RI'),
+            });
+        }
+
+        if (organization.id !== payment.organizationId) {
+            throw new Error('Unexpected organization, expected ' + payment.organizationId + ', received ' + organization.id);
         }
 
         await AuditLogService.setContext({ fallbackUserId: payment.payingUserId, source: AuditLogSource.Payment, fallbackOrganizationId: payment.organizationId }, async () => {
             if (status === PaymentStatus.Succeeded) {
+                console.log('Marking as succeeded', payment.id);
                 payment.status = PaymentStatus.Succeeded;
-                payment.paidAt = new Date();
+                payment.paidAt = paidAt ?? new Date();
                 await payment.save();
 
                 // Prevent concurrency issues
@@ -57,15 +73,30 @@ export class PaymentService {
 
                     // Flush caches so data is up to date in response
                     await BalanceItemService.flushCaches(organization.id);
+
+                    await this.updateReversedPaymentsFor(payment);
                 });
 
+                if (payment.price >= 100_00 && payment.organizationId && payment.payingOrganizationId && payment.organizationId === ((await Platform.getShared()).membershipOrganizationId)) {
+                    // We spend some money
+                    const code = await UsedRegisterCode.getFor(payment.payingOrganizationId);
+                    if (code && !code.balanceItemId) {
+                        console.log('Rewarding code ' + code.id + ' for payment');
+
+                        // Deze code werd nog niet beloond
+                        await ReferralService.reward(code);
+                    }
+                }
+
                 // It is possible the mandate succeeds immediately, in which case we might
                 // need to save it as the default payment method
-                if (payment.status === PaymentStatus.Succeeded) {
-                    await this.saveMandateIfNeeded({
-                        payment,
-                        sellingOrganization: organization,
-                    })
+                await this.saveMandateIfNeeded({
+                    payment,
+                    sellingOrganizationId: organization.id,
+                });
+
+                if (payment.type === PaymentType.Chargeback) {
+                    await this.handleChargebackCreated(payment, organization);
                 }
                 return;
             }
@@ -93,11 +124,14 @@ export class PaymentService {
 
                     // Flush caches so data is up to date in response
                     await BalanceItemService.flushCaches(organization.id);
+
+                    await this.updateReversedPaymentsFor(payment);
                 });
             }
 
             // Moved to failed
             if (status === PaymentStatus.Failed) {
+                console.log('Marking as failed', payment.id);
                 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)),
@@ -112,6 +146,10 @@ export class PaymentService {
                     // Flush caches so data is up to date in response
                     await BalanceItemService.flushCaches(organization.id);
                 });
+
+                if (payment.type === PaymentType.Payment) {
+                    await this.handlePaymentFailed(payment, organization);
+                }
             }
 
             // If OLD status was FAILED, we need to revert the actions
@@ -134,7 +172,84 @@ export class PaymentService {
         });
     }
 
-    static async saveMandateIfNeeded({payment, sellingOrganization}: {payment: Payment, sellingOrganization: Organization}) {
+    private static async handleChargebackCreated(payment: Payment, organization: Organization) {
+        if (!payment.payingOrganizationId) {
+            // For now only for B2B
+            return;
+        }
+
+        const payingOrganization = await Organization.getByID(payment.payingOrganizationId, true);
+
+        await sendEmailTemplate(organization, {
+            recipients: await payingOrganization.getFinanceAdminRecipients(),
+            defaultReplacements: [
+                Replacement.create({
+                    token: 'payingOrganizationName',
+                    value: payingOrganization.name,
+                }),
+                Replacement.create({
+                    token: 'paymentUrl',
+                    value: 'https://' + payingOrganization.getDashboardHost() + '/boekhouding/openstaand/' + organization.uri,
+                }),
+            ],
+            template: {
+                type: EmailTemplateType.ChargebackPayingOrganization,
+            },
+            type: 'transactional',
+        });
+
+        await this.deactivatePackagesIfNeeded(payment, organization);
+    }
+
+    private static async handlePaymentFailed(payment: Payment, organization: Organization) {
+        if (!payment.payingOrganizationId) {
+            // For now only for B2B
+            return;
+        }
+
+        if (!payment.mandateId) {
+            return;
+        }
+
+        if (!payment.adminUserId && payment.method !== PaymentMethod.DirectDebit) {
+            return;
+        }
+
+        const payingOrganization = await Organization.getByID(payment.payingOrganizationId, true);
+
+        await sendEmailTemplate(organization, {
+            recipients: await payingOrganization.getFinanceAdminRecipients(),
+            defaultReplacements: [
+                Replacement.create({
+                    token: 'payingOrganizationName',
+                    value: payingOrganization.name,
+                }),
+                Replacement.create({
+                    token: 'paymentUrl',
+                    value: 'https://' + payingOrganization.getDashboardHost() + '/boekhouding/openstaand/' + organization.uri,
+                }),
+            ],
+            template: {
+                type: EmailTemplateType.AutomaticChargeFailedPayingOrganization,
+            },
+            type: 'transactional',
+        });
+
+        await this.deactivatePackagesIfNeeded(payment, organization);
+    }
+
+    private static async deactivatePackagesIfNeeded(payment: Payment, organization: Organization) {
+        // If admin initiated mandate, then mark packages as failed only
+        if ((payment.adminUserId || payment.type === PaymentType.Chargeback) && payment.mandateId && STAMHOOFD.userMode === 'organization') {
+            const platform = await Platform.getShared();
+            const payingOrganizationId = payment.payingOrganizationId;
+            if (payingOrganizationId && organization.id === platform.membershipOrganizationId) {
+                await STPackageService.markFailedPayment(payingOrganizationId);
+            }
+        }
+    }
+
+    static async saveMandateIfNeeded({ payment, sellingOrganizationId }: { payment: Payment; sellingOrganizationId: string }) {
         // Save as default
         if (payment.createMandate && payment.createMandate.saveAsDefault) {
             if (payment.mandateId && payment.status === PaymentStatus.Succeeded) {
@@ -142,9 +257,9 @@ export class PaymentService {
                     await PaymentMandateService.setDefaultMandate({
                         mandateId: payment.mandateId,
                         payingOrganizationId: payment.payingOrganizationId,
-                        sellingOrganization,
-                        payingUserId: payment.payingUserId
-                    })
+                        sellingOrganizationId,
+                        payingUserId: payment.payingUserId,
+                    });
                 } catch (e) {
                     // Ignore as setting the payment status is more important
                     console.error(e);
@@ -165,6 +280,11 @@ export class PaymentService {
                 return;
             }
 
+            if (org && payment.organizationId !== org.id && org.id !== payment.payingOrganizationId) {
+                console.error('Non-matching organization found for payment', payment.id, 'org', org.id);
+                return;
+            }
+
             // Explicitly set userId to null, because all actions caused by a poll are not caused by the currently signed in user, but the paying user id
             return await AuditLogService.setContext({ userId: payment.payingUserId ?? null, source: AuditLogSource.Payment }, async () => {
                 if (!payment.organizationId) {
@@ -194,29 +314,29 @@ export class PaymentService {
                                 status = PaymentStatus.Failed;
                             }
 
+                            console.log('Stripe setting status to', status);
                             await this.handlePaymentStatusUpdate(payment, organization, status);
-                        }
-                        catch (e) {
+                        } 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) {
+                    } else if (payment.provider === PaymentProvider.Mollie) {
                         try {
                             const mollieClient = await MollieService.create({
-                                sellingOrganization: organization
-                            }); 
+                                sellingOrganization: organization,
+                            });
                             if (mollieClient) {
-                                let {status} = await mollieClient.getStatus(payment, cancel || this.shouldTryToCancel(payment.status, payment));
+                                let { status } = await mollieClient.getStatus(payment, cancel || this.shouldTryToCancel(payment.status, payment));
 
                                 if (this.isManualExpired(status, payment)) {
                                     console.error('Manually marking Mollie payment as expired', payment.id);
                                     status = PaymentStatus.Failed;
                                 }
 
+                                console.log('Mollie setting status to', status);
                                 await this.handlePaymentStatusUpdate(payment, organization, status);
                             } else {
                                 console.error('Missing Mollie Credentials for payment', payment.id);
@@ -225,7 +345,6 @@ export class PaymentService {
                                     await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
                                 }
                             }
-
                         } catch (e) {
                             console.error('Payment check failed Mollie', payment.id, e);
                             if (this.isManualExpired(payment.status, payment)) {
@@ -233,9 +352,8 @@ export class PaymentService {
                                 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');
+                    } else if (payment.provider === PaymentProvider.Buckaroo) {
+                        const helper = new BuckarooHelper(organization.privateMeta.buckarooSettings?.key ?? '', organization.privateMeta.buckarooSettings?.secret ?? '', testMode);
                         try {
                             let status = await helper.getStatus(payment);
 
@@ -244,17 +362,16 @@ export class PaymentService {
                                 status = PaymentStatus.Failed;
                             }
 
+                            console.log('Buckaroo setting status to', status);
                             await this.handlePaymentStatusUpdate(payment, organization, status);
-                        }
-                        catch (e) {
+                        } 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) {
+                    } else if (payment.provider == PaymentProvider.Payconiq) {
                         // Check status
 
                         const payconiqPayments = await PayconiqPayment.where({ paymentId: payment.id }, { limit: 1 });
@@ -272,8 +389,7 @@ export class PaymentService {
                                 console.error('Manually cancelling Payconiq payment', payment.id);
                                 if (await payconiqPayment.cancel(organization)) {
                                     status = PaymentStatus.Failed;
-                                }
-                                else {
+                                } else {
                                     console.error('Failed to manually cancel payment');
                                 }
                             }
@@ -284,8 +400,7 @@ export class PaymentService {
                             }
 
                             await this.handlePaymentStatusUpdate(payment, organization, status);
-                        }
-                        else {
+                        } else {
                             console.warn('Payconiq payment is missing for organization ' + organization.id + ' while checking payment status...');
 
                             if (this.isManualExpired(payment.status, payment)) {
@@ -293,19 +408,17 @@ export class PaymentService {
                                 await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
                             }
                         }
-                    }
-                    else {
+                    } 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);
                         }
                     }
-                }
-                else {
+                } else {
                     // Do a manual update if needed
                     if (payment.status === PaymentStatus.Succeeded) {
-                        if ( (payment.provider === PaymentProvider.Mollie && STAMHOOFD.environment === 'development')) {
+                        if ((payment.provider === PaymentProvider.Mollie && STAMHOOFD.environment === 'development')) {
                             // Update the status
                             await StripeHelper.getStatus(payment, false, testMode);
                         }
@@ -370,7 +483,7 @@ export class PaymentService {
         // should be subtracted, not added
         const balanceItemsTotalPrice = payment.price - payment.roundingAmount;
 
-        const {roundingAmount, price} = this.round(balanceItemsTotalPrice);
+        const { roundingAmount, price } = this.round(balanceItemsTotalPrice);
         payment.roundingAmount = roundingAmount;
         payment.price = price;
     }
@@ -382,7 +495,7 @@ export class PaymentService {
         if (difference === 0) {
             return {
                 price: amount,
-                roundingAmount: 0
+                roundingAmount: 0,
             };
         }
 
@@ -392,11 +505,11 @@ export class PaymentService {
 
         return {
             price: amount + difference,
-            roundingAmount: difference
-        }
+            roundingAmount: difference,
+        };
     }
 
-    static calculateTotalPrice({ balanceItems, organization, members}: {
+    static calculateTotalPrice({ balanceItems, organization, members }: {
         balanceItems: Map<BalanceItem, number>;
         organization: Organization;
         members?: Member[];
@@ -458,19 +571,19 @@ export class PaymentService {
             });
         }
 
-        return { hasNegative, price, roundingAmount, names }
+        return { hasNegative, price, roundingAmount, names };
     }
 
-    static validateTotalPrice({ price, roundingAmount, checkout}: {
-        price: number, // already rounded
-        roundingAmount: number,
+    static validateTotalPrice({ price, roundingAmount, checkout }: {
+        price: number; // already rounded
+        roundingAmount: number;
         checkout: Pick<Checkoutable<never>, 'totalPrice'>;
     }) {
         // total price without rounding
-        const balanceItemsPrice = price - roundingAmount; 
+        const balanceItemsPrice = price - roundingAmount;
 
         // also accept rounding that might have happend in the frontend and that was correct
-        if (checkout.totalPrice !== null && checkout.totalPrice !== balanceItemsPrice && checkout.totalPrice !== price) { 
+        if (checkout.totalPrice !== null && checkout.totalPrice !== balanceItemsPrice && checkout.totalPrice !== price) {
             throw new SimpleError({
                 code: 'changed_price',
                 message: $t(`%vk`, { total: Formatter.price(price) }),
@@ -478,9 +591,7 @@ export class PaymentService {
         }
     }
 
-    static async validateCustomer({ price, hasNegative, user, checkout, payingOrganization}: {
-        price: number,
-        hasNegative: boolean,
+    static async validateCustomer({ user, checkout, payingOrganization }: {
         user: User | null;
         checkout: Pick<Checkoutable<never>, 'customer'>;
         payingOrganization?: Organization | null;
@@ -490,84 +601,82 @@ export class PaymentService {
             firstName: user?.firstName,
             lastName: user?.lastName,
             email: user?.email,
-            phone: checkout.customer?.phone
+            phone: checkout.customer?.phone,
         });
 
         // Use structured transfer description prefix
         let prefix = '';
 
         if (payingOrganization) {
-            if (price !== 0 || hasNegative || checkout.customer) {
-                if (!checkout.customer) {
-                    throw new SimpleError({
-                        code: 'missing_fields',
-                        message: 'customer is required when paying as an organization',
-                        human: $t(`%vz`),
-                    });
-                }
+            if (!checkout.customer) {
+                throw new SimpleError({
+                    code: 'missing_fields',
+                    message: 'customer is required when paying as an organization',
+                    human: $t(`%vz`),
+                });
+            }
 
-                if (!checkout.customer.company) {
-                    throw new SimpleError({
-                        code: 'missing_fields',
-                        message: 'customer.company is required when paying as an organization',
-                        human: $t(`%w0`),
-                    });
-                }
+            if (!checkout.customer.company) {
+                throw new SimpleError({
+                    code: 'missing_fields',
+                    message: 'customer.company is required when paying as an organization',
+                    human: $t(`%w0`),
+                });
+            }
 
-                // 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);
+            // Search company id
+            // this avoids needing to check the VAT number every time
+            const id = checkout.customer.company.id;
+            let foundCompany = payingOrganization.meta.companies.find(c => c.id === id);
 
-                if (!foundCompany) {
+            if (!foundCompany) {
+                if (payingOrganization.meta.companies.length > 0) {
                     throw new SimpleError({
                         code: 'invalid_data',
-                        message: $t(`%w1`),
+                        message: 'Cannot set company data. Please save the company data to the paying organization meta data before using it.',
+                        human: $t(`%w1`),
                     });
                 }
 
-                if (!checkout.customer.company.equals(foundCompany)) {
-                    throw new SimpleError({
-                        code: 'invalid_data',
-                        message: 'Cannot change company data. Please save the company data to the paying organization meta data before using it.'
-                    });
-                }
+                // In case of no organizations, we ignore the id of the default, as this changes every time
+                // we'll only compare the contents
+                foundCompany = payingOrganization.defaultCompanies[0];
+            }
 
-                customer.company = foundCompany;
+            if (!checkout.customer.company.equals(foundCompany)) {
+                throw new SimpleError({
+                    code: 'invalid_data',
+                    message: 'Cannot change company data. Please save the company data to the paying organization meta data before using it.',
+                    human: $t(`%w1`),
+                });
+            }
 
-                const orgNumber = parseInt(payingOrganization.uri);
+            customer.company = foundCompany;
 
-                if (orgNumber !== 0 && !isNaN(orgNumber)) {
-                    prefix = orgNumber + '';
-                }
-            }
-            else {
-                // Zero amount payment (without refunds) without specifying a company will just use the default company to link to the payment
-                // It doesn't really matter since the price is zero and we won't invoice it.
-                const company = this.getDefaultCompanyForOrganization(payingOrganization);
-                if (company) {
-                    customer.company = company;
-                }
+            const orgNumber = parseInt(payingOrganization.uri);
+
+            if (orgNumber !== 0 && !isNaN(orgNumber)) {
+                prefix = orgNumber + '';
             }
         } else {
             if (checkout.customer && checkout.customer.company) {
-                customer.company = checkout.customer.company.clone()
+                customer.company = checkout.customer.company.clone();
                 await ViesHelper.checkCompany(checkout.customer.company, customer.company);
             }
         }
 
-        if (price !== 0 && customer.company?.VATNumber !== checkout.customer?.company?.VATNumber) {
+        if (customer.company?.VATNumber !== checkout.customer?.company?.VATNumber) {
             // Security check: because previous validation and generation might have used the VATNumber from the checkout
             throw new SimpleError({
                 code: 'changed_VAT_number',
-                message: 'Unexpected VAT number change'
-            })
+                message: 'Unexpected VAT number change',
+            });
         }
 
         return { customer, prefix };
     }
 
-    static async createProForma({ balanceItems, organization, user, members, checkout, payingOrganization}: {
+    static async createProForma({ balanceItems, organization, user, members, checkout, payingOrganization }: {
         balanceItems: Map<BalanceItem, number>;
         organization: Organization;
         user: User;
@@ -576,12 +685,12 @@ export class PaymentService {
         payingOrganization?: Organization | null;
     }) {
         // Calculate total price to pay
-        const { price, hasNegative, roundingAmount } = PaymentService.calculateTotalPrice({ balanceItems, organization, members })
-        PaymentService.validateTotalPrice({ price, roundingAmount, checkout })
+        const { price, roundingAmount } = PaymentService.calculateTotalPrice({ balanceItems, organization, members });
+        PaymentService.validateTotalPrice({ price, roundingAmount, checkout });
+
+        const { customer } = await PaymentService.validateCustomer({ user, checkout, payingOrganization });
+        const { seller } = PaymentService.validateVATRates({ customer, sellingOrganization: organization, balanceItems });
 
-        const { customer, } = await PaymentService.validateCustomer({ user, checkout, payingOrganization, price, hasNegative })
-        const { seller } = PaymentService.validateVATRates({ customer, organization, balanceItems });
-        
         // Create invoice instead from fictive PaymentGeneral
         const fakePaymentGeneral = PaymentGeneral.create({
             id: 'pro-forma',
@@ -592,15 +701,15 @@ export class PaymentService {
                 return BalanceItemPaymentDetailed.create({
                     id: 'pro-forma-' + balanceItem.id,
                     balanceItem: balanceItem.getStructure(),
-                    price
-                })
-            })
-        })
+                    price,
+                });
+            }),
+        });
 
         let invoice: Invoice | null = null;
 
         try {
-             invoice = Invoice.create({
+            invoice = Invoice.create({
                 seller,
                 customer,
                 payments: [fakePaymentGeneral],
@@ -617,46 +726,46 @@ export class PaymentService {
 
         return {
             invoice,
-            payment: fakePaymentGeneral
-        }
+            payment: fakePaymentGeneral,
+        };
     }
 
-    static async registerChargeback(payment: Payment, amount: number) {
+    static async registerChargeback(payment: Payment, amount: number, date: Date) {
         if (amount !== payment.price) {
             // Creates issues to know what balance item was paid and what was not.
-            throw new Error('Cannot register chargeback with different amount than the payment for payment ' + payment.id)
+            throw new Error('Cannot register chargeback with different amount than the payment for payment ' + payment.id);
         }
-        const balanceItemPayments = await BalanceItemPayment.select().where('paymentId', payment.id).fetch()
-        const items = await BalanceItem.getByIDs(...Formatter.uniqueArray(balanceItemPayments.map(b => b.balanceItemId)))
+        const balanceItemPayments = await BalanceItemPayment.select().where('paymentId', payment.id).fetch();
+        const items = await BalanceItem.getByIDs(...Formatter.uniqueArray(balanceItemPayments.map(b => b.balanceItemId)));
 
-         // Done validation
+        // Done validation
         const chargeback = new Payment();
 
         // Who will receive this money?
         chargeback.organizationId = payment.organizationId!;
 
         // Who paid
-        chargeback.payingUserId = payment.payingUserId
-        chargeback.payingOrganizationId = payment.payingOrganizationId
+        chargeback.payingUserId = payment.payingUserId;
+        chargeback.payingOrganizationId = payment.payingOrganizationId;
         chargeback.customer = payment.customer;
 
-        chargeback.status = PaymentStatus.Succeeded;
-        chargeback.paidAt = new Date();
+        chargeback.status = PaymentStatus.Created;
         chargeback.price = -payment.price;
         chargeback.roundingAmount = -payment.roundingAmount;
         chargeback.method = payment.method;
         chargeback.type = PaymentType.Chargeback;
+        chargeback.mandateId = payment.mandateId; ;
+        chargeback.adminUserId = payment.adminUserId;
 
         chargeback.provider = payment.provider;
-        chargeback.stripeAccountId = payment.stripeAccountId
-
+        chargeback.stripeAccountId = payment.stripeAccountId;
+        chargeback.reversingPaymentId = payment.id;
         await chargeback.save();
 
-
         for (const original of balanceItemPayments) {
             // Create one balance item payment to pay it in one payment
             const balanceItemPayment = new BalanceItemPayment();
-            balanceItemPayment.balanceItemId = original.balanceItemId
+            balanceItemPayment.balanceItemId = original.balanceItemId;
             balanceItemPayment.paymentId = chargeback.id;
             balanceItemPayment.organizationId = chargeback.organizationId;
             balanceItemPayment.price = -original.price;
@@ -666,10 +775,19 @@ export class PaymentService {
         // Update cached balance items pending amount (only created balance items, because those are involved in the payment)
         await BalanceItemService.updatePaidAndPending(items);
 
+        const organization = await Organization.getByID(chargeback.organizationId, true);
+
+        try {
+            await this.handlePaymentStatusUpdate(chargeback, organization, PaymentStatus.Succeeded, date);
+        } catch (e) {
+            console.error('Failed to mark chargeback as succeeded', e);
+            await chargeback.delete();
+            throw e;
+        }
         return chargeback;
     }
 
-    static async createPayment({ balanceItems, organization, user, members, checkout, payingOrganization, serviceFeeType, createMandate, useMandate, paymentConfiguration, privatePaymentConfiguration}: {
+    static async createPayment({ balanceItems, organization, user, members, checkout, payingOrganization, serviceFeeType, createMandate, useMandate, paymentConfiguration, privatePaymentConfiguration, adminUserId }: {
         balanceItems: Map<BalanceItem, number>;
         organization: Organization;
         user: User | null;
@@ -677,34 +795,35 @@ export class PaymentService {
         checkout: Pick<Checkoutable<never>, 'paymentMethod' | 'totalPrice' | 'customer' | 'cancelUrl' | 'redirectUrl'>;
         payingOrganization?: Organization | null;
         serviceFeeType: 'webshop' | 'members' | 'tickets' | 'system';
-        createMandate: CreateMandateSettings | null,
-        useMandate: PaymentMandate | null,
-        paymentConfiguration: PaymentConfiguration,
-        privatePaymentConfiguration: PrivatePaymentConfiguration,
+        createMandate: CreateMandateSettings | null;
+        useMandate: PaymentMandate | null;
+        paymentConfiguration: PaymentConfiguration;
+        privatePaymentConfiguration: PrivatePaymentConfiguration;
+        adminUserId?: string | null;
     }) {
         if (balanceItems.size === 0) {
             return null;
         }
 
         // Calculate total price to pay
-        const { price, roundingAmount, hasNegative, names } = this.calculateTotalPrice({ balanceItems, organization, members })
-        PaymentService.validateTotalPrice({ price, roundingAmount, checkout })
+        const { price, roundingAmount, hasNegative, names } = this.calculateTotalPrice({ balanceItems, organization, members });
+        PaymentService.validateTotalPrice({ price, roundingAmount, checkout });
 
-        const { customer, prefix } = await this.validateCustomer({ user, checkout, payingOrganization, price, hasNegative })
-        this.validateVATRates({ customer, organization, balanceItems });
-        
-        const {method, type, mandate} = await this.validatePaymentMethod({ 
+        const { customer, prefix } = await this.validateCustomer({ user, checkout, payingOrganization });
+        this.validateVATRates({ customer, sellingOrganization: organization, balanceItems });
+
+        const { method, type, mandate } = await this.validatePaymentMethod({
             method: checkout.paymentMethod ?? PaymentMethod.Unknown,
             mandate: useMandate,
             createMandate: !!createMandate,
             customer,
             price,
             hasNegative,
-            balanceItems, 
+            balanceItems,
             paymentConfiguration,
             user,
             payingOrganization: payingOrganization ?? null,
-            sellingOrganization: organization
+            sellingOrganization: organization,
         });
 
         // Check URL's set fro online payments
@@ -724,8 +843,8 @@ export class PaymentService {
                 throw new SimpleError({
                     code: 'cannot_create_mandate_for_provider',
                     message: 'Saving a payment method is not yet supported for this payment method',
-                    human: $t('%1U0')
-                })
+                    human: $t('%1U0'),
+                });
             }
         }
 
@@ -746,7 +865,9 @@ export class PaymentService {
         payment.roundingAmount = roundingAmount;
         payment.method = method;
         payment.type = type;
-        payment.createMandate = createMandate
+        payment.createMandate = createMandate;
+        payment.mandateId = mandate?.id ?? null;
+        payment.adminUserId = adminUserId ?? null;
 
         if (price === 0) {
             payment.status = PaymentStatus.Succeeded;
@@ -755,7 +876,8 @@ export class PaymentService {
 
         payment.provider = provider;
         payment.stripeAccountId = stripeAccount?.id ?? null;
-        ServiceFeeHelper.setServiceFee(payment, organization, serviceFeeType, [...balanceItems.entries()].map(([_, p]) => p));
+        await ServiceFeeHelper.setServiceFee(payment, organization, serviceFeeType, [...balanceItems.entries()].map(([_, p]) => p));
+        await ServiceFeeHelper.setTransferFee({ payment, organization, stripeAccount });
 
         // Add transfer description
         if (payment.method === PaymentMethod.Transfer) {
@@ -810,13 +932,11 @@ export class PaymentService {
                 // Send a small reminder email
                 try {
                     await this.sendTransferEmail(customer, user?.id ?? null, organization, payment);
-                }
-                catch (e) {
+                } catch (e) {
                     console.error('Failed to send transfer email');
                     console.error(e);
                 }
-            }
-            else if (payment.method !== PaymentMethod.PointOfSale && payment.method !== PaymentMethod.Unknown) {
+            } else if (payment.method !== PaymentMethod.PointOfSale && payment.method !== PaymentMethod.Unknown) {
                 if ((!checkout.redirectUrl || !checkout.cancelUrl) && !mandate) {
                     throw new Error('Should have been caught earlier');
                 }
@@ -825,7 +945,7 @@ export class PaymentService {
                 _redirectUrl.searchParams.set('paymentId', payment.id);
                 _redirectUrl.searchParams.set('organizationId', payment.payingOrganizationId ?? organization.id); // makes sure the client uses the token associated with this organization when fetching payment polling status
 
-                const _cancelUrl = new URL(checkout.cancelUrl?? ('https://' + STAMHOOFD.domains.dashboard));
+                const _cancelUrl = new URL(checkout.cancelUrl ?? ('https://' + STAMHOOFD.domains.dashboard));
                 _cancelUrl.searchParams.set('paymentId', payment.id);
                 _cancelUrl.searchParams.set('cancel', 'true');
                 _cancelUrl.searchParams.set('organizationId', payment.payingOrganizationId ?? organization.id); // makes sure the client uses the token associated with this organization when fetching payment polling status
@@ -834,18 +954,18 @@ export class PaymentService {
                 const cancelUrl = _cancelUrl.href;
 
                 const webhookUrl = 'https://' + organization.getApiHost() + '/v' + Version + '/payments/' + encodeURIComponent(payment.id) + '?exchange=true';
-                
+
                 if (payment.provider === PaymentProvider.Stripe) {
                     if (createMandate || mandate) {
                         // Already checked, but for security
-                        throw new Error('Unsupported')
+                        throw new Error('Unsupported');
                     }
                     if (!customer.email) {
                         throw new SimpleError({
                             code: 'missing_email',
                             message: 'Email address is required for online payments via Stripe',
-                            human: $t('%1SJ')
-                        })
+                            human: $t('%1SJ'),
+                        });
                     }
                     const stripeResult = await StripeHelper.createPayment({
                         payment,
@@ -866,8 +986,7 @@ export class PaymentService {
                         },
                     });
                     paymentUrl = stripeResult.paymentUrl;
-                }
-                else if (payment.provider === PaymentProvider.Mollie) {
+                } else if (payment.provider === PaymentProvider.Mollie) {
                     const mollieResult = await MollieService.createPayment({
                         payment,
                         redirectUrl,
@@ -886,18 +1005,16 @@ export class PaymentService {
                         mandate,
                     });
                     paymentUrl = mollieResult.paymentUrl;
-                }
-                else if (payment.provider === PaymentProvider.Payconiq) {
+                } else if (payment.provider === PaymentProvider.Payconiq) {
                     if (createMandate || mandate) {
                         // Already checked, but for security
-                        throw new Error('Unsupported')
+                        throw new Error('Unsupported');
                     }
                     ({ paymentUrl, paymentQRCode } = await PayconiqPayment.createPayment(payment, organization, description, redirectUrl, webhookUrl));
-                }
-                else if (payment.provider === PaymentProvider.Buckaroo) {
+                } else if (payment.provider === PaymentProvider.Buckaroo) {
                     if (createMandate || mandate) {
                         // Already checked, but for security
-                        throw new Error('Unsupported')
+                        throw new Error('Unsupported');
                     }
 
                     // Increase request timeout because buckaroo is super slow (in development)
@@ -916,20 +1033,18 @@ export class PaymentService {
                     }
                 }
             }
-        }
-        catch (e) {
+        } catch (e) {
             await PaymentService.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
             throw e;
         }
 
         // TypeScript thinks status cannot change to Failed, but it can.
-        if (payment.status === PaymentStatus.Succeeded || (payment.status as PaymentStatus) === PaymentStatus.Failed) { 
+        if (payment.status === PaymentStatus.Succeeded || (payment.status as PaymentStatus) === PaymentStatus.Failed) {
             // force update
-            const updateTo = payment.status
-            payment.status = PaymentStatus.Created
+            const updateTo = payment.status;
+            payment.status = PaymentStatus.Created;
             await PaymentService.handlePaymentStatusUpdate(payment, organization, updateTo);
-        }
-        else if (payment.method === PaymentMethod.Transfer || payment.method === PaymentMethod.PointOfSale || payment.method === PaymentMethod.Unknown || (payment.method === PaymentMethod.DirectDebit && mandate)) {
+        } else if (payment.method === PaymentMethod.Transfer || payment.method === PaymentMethod.PointOfSale || payment.method === PaymentMethod.Unknown || (payment.method === PaymentMethod.DirectDebit && mandate)) {
             // Mark valid (not same as paid) if needed
             let hasBundleDiscount = false;
             for (const [balanceItem] of balanceItems) {
@@ -959,7 +1074,7 @@ export class PaymentService {
     static async sendTransferEmail(customer: PaymentCustomer, userId: string | null, organization: Organization, payment: Payment) {
         const email = customer.dynamicEmail;
         if (!email) {
-            console.warn('Skipped sending transfer email because of missing email address', payment.id)
+            console.warn('Skipped sending transfer email because of missing email address', payment.id);
             return;
         }
         const paymentGeneral = await payment.getGeneralStructure();
@@ -994,37 +1109,110 @@ export class PaymentService {
         });
     }
 
-    static async validatePaymentMethod({ 
+    static async validateMandate({
+        method,
+        paymentConfiguration,
+        mandate,
+        payingOrganization,
+        sellingOrganization,
+        user,
+    }: {
+        method: PaymentMethod;
+        paymentConfiguration: PaymentConfiguration;
+        mandate: PaymentMandate;
+        payingOrganization: Organization | null;
+        sellingOrganization: Organization;
+        user: User | null;
+    }) {
+        if (!paymentConfiguration.enableMandates) {
+            throw new SimpleError({
+                code: 'mandates_disabled',
+                message: 'Cannot pay with mandate',
+                human: $t('%1SK'),
+            });
+        }
+
+        // Validate mandate + update payment method based on the mandate
+        if (method !== PaymentMethod.Unknown) {
+            throw new SimpleError({
+                code: 'invalid_data',
+                message: 'Cannot combine setting mandate with method',
+            });
+        }
+
+        const allMandates = await PaymentMandateService.getMandates({
+            payingOrganization,
+            sellingOrganization,
+            user,
+        });
+
+        const existingMandate = allMandates.find(m => m.id === mandate.id && m.provider === mandate.provider);
+        if (!existingMandate) {
+            throw new SimpleError({
+                code: 'not_found',
+                message: 'Mandate not found',
+                human: $t('%1TQ'),
+                field: 'mandateId',
+            });
+        }
+
+        if (existingMandate.status !== PaymentMandateStatus.Valid) {
+            throw new SimpleError({
+                code: 'mandate_not_valid',
+                message: 'Mandate not valid',
+                human: $t('%1QA'),
+                field: 'mandateId',
+            });
+        }
+        return existingMandate;
+    }
+
+    static async validatePaymentMethod({
         method,
         customer,
         price,
         hasNegative,
-        balanceItems, 
+        balanceItems,
         paymentConfiguration,
         mandate,
         payingOrganization,
         sellingOrganization,
         user,
-        createMandate
-    }: { 
-        method: PaymentMethod,
-        customer: PaymentCustomer,
-        price: number,
-        hasNegative: boolean,
-        balanceItems: Map<BalanceItem, number>; 
-        paymentConfiguration: PaymentConfiguration,
-        mandate: PaymentMandate | null,
-        payingOrganization: Organization | null,
-        sellingOrganization: Organization,
-        user: User | null,
-        createMandate: boolean
+        createMandate,
+    }: {
+        method: PaymentMethod;
+        customer: PaymentCustomer;
+        price: number;
+        hasNegative: boolean;
+        balanceItems: Map<BalanceItem, number>;
+        paymentConfiguration: PaymentConfiguration;
+        mandate: PaymentMandate | null;
+        payingOrganization: Organization | null;
+        sellingOrganization: Organization;
+        user: User | null;
+        createMandate: boolean;
     }) {
         if (price === 0) {
             if (balanceItems.size === 0) {
-                throw new Error('Empty payment')
+                throw new Error('Empty payment');
             }
 
-            if (createMandate) {
+            // We still need to validate the mandate, because
+            // we still allow setting a new default payment method
+            // for zero payments
+            // - e.g. activating a new package with an existing mandate
+            const existingMandate = mandate
+                ? await this.validateMandate({
+                        method,
+                        mandate,
+                        paymentConfiguration,
+                        payingOrganization,
+                        sellingOrganization,
+                        user,
+                    })
+                : null;
+
+            if (createMandate && !existingMandate) {
                 throw new SimpleError({
                     code: 'cannot_create_mandate_without_payment',
                     message: 'Cannot create saved payment method without payment of a small amount',
@@ -1037,88 +1225,56 @@ export class PaymentService {
                 return {
                     method: PaymentMethod.Unknown,
                     type: PaymentType.Reallocation,
-                    mandate: null
-                }
+                    mandate: existingMandate,
+                };
             }
 
             return {
                 // Free purchase
                 method: PaymentMethod.Unknown,
                 type: PaymentType.Payment,
-                mandate: null
-            }
+                mandate: existingMandate,
+            };
         }
 
         if (mandate) {
-            if (!paymentConfiguration.enableMandates) {
-                 throw new SimpleError({
-                    code: 'mandates_disabled',
-                    message: 'Cannot pay with mandate',
-                    human: $t('%1SK')
-                });
-            }
-            
-            // Validate mandate + update payment method based on the mandate
-            if (method !== PaymentMethod.Unknown) {
-                throw new SimpleError({
-                    code: 'invalid_data',
-                    message: 'Cannot combine setting mandate with method'
-                });
-            }
-
-            const allMandates = await PaymentMandateService.getMandates({
+            const existingMandate = await this.validateMandate({
+                method,
+                mandate,
+                paymentConfiguration,
                 payingOrganization,
                 sellingOrganization,
                 user,
             });
 
-            const existingMandate = allMandates.find(m => m.id === mandate.id && m.provider === mandate.provider);
-            if (!existingMandate) {
-                throw new SimpleError({
-                    code: 'not_found',
-                    message: 'Mandate not found',
-                    human: $t('%1TQ'),
-                    field: 'mandateId'
-                });
-            }
-
-            if (existingMandate.status !== PaymentMandateStatus.Valid) {
-                throw new SimpleError({
-                    code: 'mandate_not_valid',
-                    message: 'Mandate not valid',
-                    human: $t('%1QA'),
-                    field: 'mandateId'
-                });
-            }
-
             switch (existingMandate.type) {
                 case PaymentMandateType.CreditCard:
                     return {
                         mandate: existingMandate,
                         method: PaymentMethod.CreditCard,
-                        type: PaymentType.Payment
-                    }
+                        type: PaymentType.Payment,
+                    };
                 case PaymentMandateType.DirectDebit:
                     return {
                         mandate: existingMandate,
                         method: PaymentMethod.DirectDebit,
-                        type: PaymentType.Payment
-                    }
+                        type: PaymentType.Payment,
+                    };
             }
 
-            throw new Error('Unsupported mandate type')
+            throw new Error('Unsupported mandate type');
         }
 
         if (createMandate) {
             if (!paymentConfiguration.enableMandates) {
-                 throw new SimpleError({
+                throw new SimpleError({
                     code: 'mandates_disabled',
                     message: 'Cannot pay with mandate',
-                    human: $t('%1R1')
+                    human: $t('%1R1'),
                 });
             }
         }
-        
+
         if (method === PaymentMethod.Unknown) {
             throw new SimpleError({
                 code: 'invalid_data',
@@ -1130,7 +1286,7 @@ export class PaymentService {
         const allowedPaymentMethods = paymentConfiguration.getAvailablePaymentMethods({
             amount: price,
             customer: customer,
-            forMandate: createMandate
+            forMandate: createMandate,
         });
 
         if (!allowedPaymentMethods.includes(method)) {
@@ -1143,41 +1299,64 @@ export class PaymentService {
         return {
             method,
             type: PaymentType.Payment,
-            mandate: null
-        }
-    }
-
-    static getDefaultCompanyForOrganization(sellingOrganization: Organization) {
-        return sellingOrganization.meta.companies[0];
+            mandate: null,
+        };
     }
 
-    static getVATExcempt({ customer, sellingOrganization }: { customer: PaymentCustomer | null; sellingOrganization: Organization; }) {
+    static validateVATRates({ customer, sellingOrganization, balanceItems }: { customer: PaymentCustomer; sellingOrganization: Organization; balanceItems: Map<BalanceItem, number> }) {
         // Validate VAT rates for this customer
-        const seller = this.getDefaultCompanyForOrganization(sellingOrganization)
-        if (seller && seller.VATNumber && seller.address && customer && customer.company) {
-            // B2B validation
-            if (!customer.company.address) {
-                throw new SimpleError({
-                    code: 'missing_field',
-                    message: 'Company address missing',
-                    human: $t('%1LH'),
-                    field: 'customer.company.address',
-                });
+        const seller = VATService.getDefaultCompanyForOrganization(sellingOrganization);
+        const excempt = VATService.isVATExcempt({
+            company: customer.company,
+            sellingOrganization,
+        });
+
+        // Reverse charged vat applicable?
+        if (excempt) {
+            // Check VAT Exempt is set on each an every balance item with a non-zero price
+            for (const [item] of balanceItems) {
+                if (item.VATExcempt !== VATExcemptReason.IntraCommunityServices && item.VATExcempt !== VATExcemptReason.IntraCommunityGoods) {
+                    throw new SimpleError({
+                        code: 'VAT_error',
+                        message: 'Intra community VAT reverse charge not supported for this purchase',
+                        human: $t('%1LI'),
+                    });
+                }
+
+                // We also need to know the VAT rate exactly to be sure the VAT is removed from the purchase
+                // If VAT is not included, we don't need to know the VAT percentage until the payment is invoiced
+                if (item.VATPercentage === null && item.VATIncluded) {
+                    throw new SimpleError({
+                        code: 'VAT_error',
+                        message: 'Intra community VAT reverse charge is not supported for this purchase because of missing VAT rates',
+                        human: $t('%1LJ'),
+                    });
+                }
             }
+        } else {
+            // Fine to just not have setup VAT rates yet if the price is guaranteed to include VAT
+            for (const [item] of balanceItems) {
+                if (item.VATExcempt === VATExcemptReason.IntraCommunityGoods || item.VATExcempt === VATExcemptReason.IntraCommunityServices) {
+                    throw new SimpleError({
+                        code: 'VAT_error',
+                        message: 'Unexpected reverse charge applied',
+                        human: $t('%1LK'),
+                    });
+                }
 
-            // Reverse charged vat applicable?
-            if (customer.company.address.country !== seller.address.country && customer.company.VATNumber) {
-                return VATExcemptReason.IntraCommunity;
+                if (seller && seller.VATNumber) {
+                    if (!item.VATIncluded && item.VATPercentage === null) {
+                        throw new SimpleError({
+                            code: 'VAT_error',
+                            message: 'Missing VAT percentage',
+                            human: $t('%1LL'),
+                        });
+                    }
+                }
             }
         }
 
-        return null
-    }
-
-    static validateVATRates({ customer, organization, balanceItems }: { customer: PaymentCustomer; organization: Organization; balanceItems: Map<BalanceItem, number> }) {
-        // Validate VAT rates for this customer
-        const seller = this.getDefaultCompanyForOrganization(organization)
-        if (seller && seller.VATNumber && seller.address && customer.company) {
+        /* if (seller && seller.VATNumber && seller.address && customer.company) {
             // B2B validation
             if (!customer.company.address) {
                 throw new SimpleError({
@@ -1188,56 +1367,13 @@ export class PaymentService {
                 });
             }
 
-            // Reverse charged vat applicable?
-            if (customer.company.address.country !== seller.address.country && customer.company.VATNumber) {
-                // Check VAT Exempt is set on each an every balance item with a non-zero price
-                for (const [item] of balanceItems) {
-                    if (item.VATExcempt !== VATExcemptReason.IntraCommunity) {
-                        throw new SimpleError({
-                            code: 'VAT_error',
-                            message: 'Intra community VAT reverse charge not supported for this purchase',
-                            human: $t('%1LI'),
-                        });
-                    }
-
-                    // We also need to know the VAT rate exactly to be sure the VAT is removed from the purchase
-                    // If VAT is not included, we don't need to know the VAT percentage until the payment is invoiced
-                    if (item.VATPercentage === null && item.VATIncluded) {
-                        throw new SimpleError({
-                            code: 'VAT_error',
-                            message: 'Intra community VAT reverse charge is not supported for this purchase because of missing VAT rates',
-                            human: $t('%1LJ'),
-                        });
-                    }
-                }
-            }
-            else {
-                // Fine to just not have setup VAT rates yet if the price is guaranteed to include VAT
-                for (const [item] of balanceItems) {
-                    if (item.VATExcempt === VATExcemptReason.IntraCommunity) {
-                        throw new SimpleError({
-                            code: 'VAT_error',
-                            message: 'Unexpected reverse charge applied',
-                            human: $t('%1LK'),
-                        });
-                    }
-
-                    if (!item.VATIncluded && item.VATPercentage === null) {
-                        throw new SimpleError({
-                            code: 'VAT_error',
-                            message: 'Missing VAT percentage',
-                            human: $t('%1LL'),
-                        });
-                    }
-                }
-            }
         }
         else {
             // B2C / C2B / C2C
 
             // You cannot buy balance items with VAT if you didn't set up a VAT number.
             for (const [item] of balanceItems) {
-                if (item.VATExcempt === VATExcemptReason.IntraCommunity) {
+                if (item.VATExcempt === VATExcemptReason.IntraCommunityGoods || item.VATExcempt === VATExcemptReason.IntraCommunityServices) {
                     throw new SimpleError({
                         code: 'VAT_error',
                         message: 'Unexpected reverse charge applied',
@@ -1255,8 +1391,8 @@ export class PaymentService {
                     }
                 }
             }
-        }
+        } */
 
-        return {seller}
+        return { seller };
     }
 };