@stamhoofd/backend 2.120.6 → 2.122.0

package/src/crons/invoices.ts

@@ -0,0 +1,160 @@
+import { isSimpleError, isSimpleErrors } from '@simonbackx/simple-errors';
+import { registerCron } from '@stamhoofd/crons';
+import type { Invoice } from '@stamhoofd/models';
+import { Organization, Payment, sendEmailTemplate } from '@stamhoofd/models';
+import { EmailTemplateType, InvoiceStruct, PaymentStatus, Replacement } from '@stamhoofd/structures';
+import { Formatter, Sorter } from '@stamhoofd/utility';
+import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures.js';
+import { InvoiceService } from '../services/InvoiceService.js';
+import { useSavedIterator } from './helpers/useSavedIterator.js';
+import { isOutside } from './helpers/isOutside.js';
+
+registerCron('invoices', invoices);
+
+const { iterate, isHoursAgo } = useSavedIterator(() => {
+    return Organization.select();
+}, { limit: 10, maxQueries: 5 });
+
+const bootAt = new Date();
+
+async function invoices() {
+    // Do not run within 5 hours after boot
+    if (bootAt.getTime() > new Date().getTime() - 1000 * 60 * 60 * 5 && STAMHOOFD.environment !== 'development') {
+        return;
+    }
+
+    if (isOutside('03:00', '10:00')) {
+        return;
+    }
+
+    if (!isHoursAgo(12)) {
+        return;
+    }
+
+    // Get the next x organization to send e-mails for
+    for await (const organization of iterate()) {
+        if (!organization.meta.invoicesEnabled) {
+            continue;
+        }
+
+        // Create all invoices for this organization
+        await createInvoicesFor(organization);
+    }
+}
+
+async function createInvoicesFor(organization: Organization) {
+    const seller = organization.meta.companies[0];
+    if (!seller) {
+        return;
+    }
+
+    // Belgian rules: allowed to invoice up to the 15th day of the next month. We extend it with one month to fix mistakes.
+    const today = Formatter.luxon();
+    const startDate = today.day <= 15 ? today.minus({ month: 2 }).startOf('month') : today.minus({ month: 1 }).startOf('month');
+
+    // Don't invoice below 1 euro - unless we reached the timeout date for invoices (end of month + 15 days - 3 days margin)
+    const invoiceLimit = STAMHOOFD.environment === 'development' ? 0 : 1_0000;
+    function getPaymentTimeoutDate(p: Payment) {
+        return Formatter.luxon(p.paidAt ?? p.createdAt).plus({ month: 1 }).set({ day: 15 - 3 }).startOf('day').toJSDate();
+    }
+
+    console.log('Fetching all payments between ' + Formatter.dateTime(startDate.toJSDate()) + ' and now for ' + organization.name);
+
+    const payments = await Payment.select()
+        .where('organizationId', organization.id)
+        .where('status', PaymentStatus.Succeeded)
+        .where('paidAt', '>=', startDate.toJSDate())
+        .where('invoiceId', null)
+        .where('customer', '!=', null)
+        .where('payingOrganizationId', '!=', null)
+        .where('price', '!=', 0)
+        .limit(1_000)
+        .orderBy('payingOrganizationId')
+        .fetch();
+
+    console.log('Invoicing ' + payments.length + ' payments');
+
+    // Group by VATNumber, company number or company name
+    const groups = new Map<string, Payment[]>();
+    for (const payment of payments) {
+        const blob = {
+            // Grouping by payingOrganizationId avoid privacy issues and data leaks
+            payingOrganizationId: payment.payingOrganizationId ?? null,
+            vatNumber: payment.customer?.company?.VATNumber,
+            companyNumber: payment.customer?.company?.companyNumber,
+            // Name and adress is ignored, because subject to changes
+        };
+        const id = JSON.stringify(blob);
+        const existing = groups.get(id);
+        if (existing) {
+            existing.push(payment);
+        } else {
+            groups.set(id, [payment]);
+        }
+    }
+
+    console.log('Invoicing ' + groups.size + ' customers');
+
+    const errors: string[] = [];
+    const invoices: Invoice[] = [];
+    let skipped = 0;
+
+    for (const [_, payments] of groups) {
+        // Group from last to newest (so we use the last customer details if the address changed during the month)
+        payments.sort((a, b) => Sorter.byDateValue(a.createdAt, b.createdAt));
+        const customer = payments[0].customer!.dynamicName;
+        try {
+            const generalStructs = await AuthenticatedStructures.paymentsGeneral(payments, false);
+
+            const invoice = InvoiceStruct.create({
+                seller,
+                customer: payments[0].customer!,
+                payments: generalStructs,
+            });
+            invoice.buildFromPayments();
+
+            if (invoice.totalWithVAT >= 0 && invoice.totalWithVAT < invoiceLimit) {
+                const first = new Date(Math.min(...payments.map(p => getPaymentTimeoutDate(p).getTime())));
+                if (first > new Date()) {
+                    console.log('Delaying invoicing ' + customer + ' at ' + organization.id + ' until ' + Formatter.dateIso(first));
+                    skipped += 1;
+                    continue;
+                } else {
+                    console.log('Invoiced low priced invoice, because of date ' + Formatter.dateIso(first) + ' being in the past');
+                }
+            }
+
+            const model = await InvoiceService.createFrom(organization, invoice);
+            invoices.push(model);
+        } catch (e) {
+            console.error(payments.map(p => p.id), e);
+
+            const prefix = customer + ' (' + payments.map(p => '<a href="' + Formatter.escapeHtml('https://' + organization.getDashboardHost() + '/boekhouding/betalingen/' + p.id) + '">' + Formatter.escapeHtml($t('%14a') + ' ' + p.id.substring(0, 8)) + '</a>').join(', ') + '): ';
+
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                errors.push(prefix + Formatter.escapeHtml(e.getHuman()));
+            } else {
+                errors.push(prefix + Formatter.escapeHtml($t('%1ED')));
+            }
+        }
+    }
+
+    console.log('Created ' + invoices.length + ' invoices with ' + errors.length + ' errors and skipped ' + skipped);
+
+    if (errors.length) {
+        await sendEmailTemplate(organization, {
+            template: {
+                type: EmailTemplateType.InvoiceGenerationErrors,
+            },
+            recipients: await organization.getAdminRecipients(),
+            type: 'transactional',
+            fromStamhoofd: true,
+            defaultReplacements: [
+                Replacement.create({
+                    token: 'errors',
+                    html: '<ul><li>' + errors.join('</li><li>') + '</li></ul>' + (skipped > 0 ? '<p>' + Formatter.escapeHtml(skipped === 1 ? $t('%1U4') : $t('%1Sp', { count: skipped })) + '</p>' : ''),
+                }),
+            ],
+        });
+    }
+}

package/src/crons/members-fees.ts

@@ -0,0 +1,50 @@
+import { registerCron } from '@stamhoofd/crons';
+import { Organization, Platform } from '@stamhoofd/models';
+import { useSavedIterator } from './helpers/useSavedIterator.js';
+import { STPackageService } from '../services/STPackageService.js';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+
+// Charge manual service fees every night
+registerCron('members-fees', chargeMembers);
+
+const { iterate, isHoursAgo } = useSavedIterator(() => {
+    return Organization.select();
+}, { limit: 10, maxQueries: 5 });
+
+async function chargeMembers() {
+    if (STAMHOOFD.environment !== 'development' && (new Date().getHours() > 5 || new Date().getHours() < 2)) {
+        return;
+    }
+
+    if (!isHoursAgo(12)) {
+        return;
+    }
+
+    const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+    if (!membershipOrganizationId) {
+        return;
+    }
+
+    const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+    for await (const organization of iterate()) {
+        await chargeMemberFeesForOrganization(organization, membershipOrganization);
+    }
+}
+
+/**
+ * Charge the (increase in) per-member fees for every active package of an organization.
+ * For per-member packages this only charges the members that aren't paid/pending yet.
+ */
+export async function chargeMemberFeesForOrganization(organization: Organization, sellingOrganization: Organization) {
+    const packages = await STPackageService.getActivePackages(organization.id);
+
+    for (const pack of packages) {
+        const item = await STPackageService.chargePackage(pack, sellingOrganization, organization.defaultCompanies[0]);
+        if (item) {
+            item.status = BalanceItemStatus.Due;
+            await item.save();
+            console.log('Charged', item.id);
+        }
+    }
+}

package/src/crons/mollie-chargebacks.ts

@@ -0,0 +1,86 @@
+import { registerCron } from '@stamhoofd/crons';
+import { MolliePayment, MollieToken, Organization, Payment } from '@stamhoofd/models';
+import { MollieService } from '../services/MollieService.js';
+import { PaymentService } from '../services/PaymentService.js';
+
+registerCron('mollie-chargebacks', checkMollieChargebacks);
+
+let lastRun: Date | null = null;
+export async function checkMollieChargebacks() {
+    if (STAMHOOFD.environment !== 'development') {
+        if (lastRun && new Date().getTime() - lastRun.getTime() < 1000 * 60 * 60 * 24) {
+            return;
+        }
+        lastRun = new Date();
+    }
+    await doCheckMollieChargebacks(false);
+}
+
+export async function doCheckMollieChargebacks(checkAll = false) {
+    if (STAMHOOFD.environment !== 'development') {
+        console.log('Checking Mollie chargebacks');
+    }
+
+    // Loop all mollie tokens
+    for await (const token of MollieToken.select().limit(1).all({}, 'organizationId')) {
+        // todo
+        const sellingOrganization = await Organization.getByID(token.id);
+        if (sellingOrganization) {
+            const service = await MollieService.create({ sellingOrganization });
+            if (service) {
+                await checkMollieChargebacksFor(service, checkAll);
+            }
+        }
+    }
+}
+
+export async function checkMollieChargebacksFor(service: MollieService, checkAll = false) {
+    if (STAMHOOFD.environment !== 'development') {
+        console.log('Checking Mollie chargebacks for ' + service.sellingOrganization.name);
+    }
+
+    // Check last 3 days
+    const offset = new Date(Date.now() - 1000 * 60 * 60 * 24 * 4);
+
+    // due to a bug in mollie client code, testmode paramter is missing in the typescript definitions
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    for await (const chargeback of service.client.chargebacks.iterate({ sort: 'desc', testmode: service.testMode } as any)) {
+        if (!checkAll && new Date(chargeback.createdAt) < offset) {
+            break;
+        }
+
+        // Check if this chargeback has been handled
+        const existingChargeback = await MolliePayment.select().where('mollieId', chargeback.id).first(false);
+        if (existingChargeback) {
+            // We can break because all older chargebacks will also be handled
+            break;
+        }
+
+        if (chargeback.paymentId) {
+            const molliePayment = await MolliePayment.select().where('mollieId', chargeback.paymentId).first(false);
+            if (molliePayment) {
+                const payment = await Payment.getByID(molliePayment.paymentId);
+                if (payment) {
+                    try {
+                        const amount = Math.round(parseFloat(chargeback.amount.value) * 100) * 100;
+                        const createdPayment = await PaymentService.registerChargeback(payment, amount, new Date(chargeback.createdAt));
+
+                        // Link Mollie chargeback ID (so we can set settlement later in the settlements cron)
+                        const molliePayment = new MolliePayment();
+                        molliePayment.paymentId = createdPayment.id;
+                        molliePayment.mollieId = chargeback.id;
+                        await molliePayment.save();
+                    } catch (e) {
+                        console.error('Failed to register chargeback ' + chargeback.id, e);
+                    }
+                }
+            } else {
+                console.error('Invalid chargeback payment id ' + chargeback.paymentId + ', not found');
+            }
+        }
+    }
+
+    if (STAMHOOFD.environment !== 'development') {
+        console.log('Done checking Mollie chargebacks for ' + service.sellingOrganization.name);
+    }
+}

package/src/crons/service-fees.ts

@@ -0,0 +1,152 @@
+import { registerCron } from '@stamhoofd/crons';
+import { BalanceItem, Organization, Payment, Platform } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { BalanceItemStatus, BalanceItemType, PaymentMethod, PaymentStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { BalanceItemService } from '../services/BalanceItemService.js';
+import { PaymentService } from '../services/PaymentService.js';
+import { VATService } from '../services/VATService.js';
+
+// Charge manual service fees every night
+registerCron('service-fees', chargeServiceFees);
+
+async function chargeServiceFees() {
+    if (STAMHOOFD.environment !== 'development' && (new Date().getHours() > 5 || new Date().getHours() < 2)) {
+        return;
+    }
+    const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+    if (!membershipOrganizationId) {
+        return;
+    }
+
+    const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+    // Succeeded payments
+    const payments = await Payment.select()
+        .where('status', PaymentStatus.Succeeded)
+        .where('serviceFeeManual', '>', 0)
+        .where('serviceFeeManualCharged', 0)
+        .where('createdAt', '<', STAMHOOFD.environment !== 'development' ? new Date() : Formatter.dateIso(new Date(Date.now() + 1000 * 60 * 60 * 24)))
+        .limit(200)
+        .orderBy('createdAt', 'ASC')
+        .fetch();
+
+    // Pending payments older than 14 days with method = Transfer or PointOfSale
+    const pendingPayments = await Payment.select()
+        .where('status', [PaymentStatus.Pending, PaymentStatus.Created])
+        .where('method', [PaymentMethod.Transfer, PaymentMethod.PointOfSale, PaymentMethod.Unknown])
+        .where('serviceFeeManual', '>', 0)
+        .where('serviceFeeManualCharged', 0)
+        .where('createdAt', '<', Formatter.dateIso(new Date(Date.now() - 1000 * 60 * 60 * 24 * 14)))
+        .limit(200)
+        .orderBy('createdAt', 'ASC')
+        .fetch();
+
+    const allPayments = [...payments, ...pendingPayments];
+
+    console.log('Found ' + allPayments.length + ' payments to charge service fees for');
+
+    const mappedToOrganizationId = new Map<string, Payment[]>();
+    for (const payment of allPayments) {
+        if (!payment.organizationId) {
+            console.warn('Payment without organizationId, skipping', payment.id);
+            continue;
+        }
+        if (!mappedToOrganizationId.has(payment.organizationId)) {
+            mappedToOrganizationId.set(payment.organizationId, []);
+        }
+        mappedToOrganizationId.get(payment.organizationId)!.push(payment);
+    }
+
+    for (const [organizationId, payments] of mappedToOrganizationId.entries()) {
+        const organization = await Organization.getByID(organizationId);
+        if (!organization) {
+            console.warn('[chargeServiceFees] Organization not found for ID', organizationId);
+            continue;
+        }
+
+        // Group payments by Formatter.dateNumber(p.createdAt)
+        const groupedPayments: Map<string, Payment[]> = new Map();
+        for (const payment of payments) {
+            const date = Formatter.dateNumber(payment.createdAt);
+            if (!groupedPayments.has(date)) {
+                groupedPayments.set(date, []);
+            }
+            groupedPayments.get(date)!.push(payment);
+        }
+
+        for (const [_, payments] of groupedPayments) {
+            const totalFees = payments.reduce((sum, payment) => sum + payment.serviceFeeManual - payment.serviceFeeManualCharged, 0);
+            const groupedByDate = new Map<string, Payment[]>();
+
+            for (const p of payments) {
+                const date = Formatter.dateNumber(p.createdAt);
+                const existing = groupedByDate.get(date);
+                if (existing) {
+                    existing.push(p);
+                } else {
+                    groupedByDate.set(date, [p]);
+                }
+            }
+
+            for (const [day, payments] of groupedByDate) {
+                const date = new Date(Math.min(...payments.map(p => p.createdAt.getTime())));
+                const startOfDay = Formatter.luxon(date).startOf('day').toJSDate();
+                const endOfDay = Formatter.luxon(date).endOf('day').toJSDate();
+
+                // Ms don't work when querying MySQL, they get lost
+                startOfDay.setMilliseconds(0);
+                endOfDay.setMilliseconds(0);
+
+                const item = new BalanceItem();
+                item.type = BalanceItemType.ServiceFee;
+                item.description = $t('%1cJ', { date: day });
+                item.payingOrganizationId = organization.id;
+                item.organizationId = membershipOrganizationId;
+                item.VATPercentage = 21;
+                item.VATExcempt = VATService.getVATExcempt({
+                    company: organization.defaultCompanies[0] ?? null,
+                    sellingOrganization: membershipOrganization,
+                    type: 'services',
+                });
+                item.VATIncluded = false;
+                item.quantity = 1;
+                item.unitPrice = totalFees;
+                item.createdAt = new Date();
+                item.status = BalanceItemStatus.Due;
+                item.startDate = startOfDay;
+                item.endDate = endOfDay;
+
+                // Check if we find an existing one
+                const existing = await BalanceItem.select()
+                    .where('type', BalanceItemType.ServiceFee)
+                    .where('organizationId', membershipOrganizationId)
+                    .where('VATPercentage', item.VATPercentage)
+                    .where('VATIncluded', item.VATIncluded)
+                    .where('VATExcempt', item.VATExcempt)
+                    .where('payingOrganizationId', organization.id)
+                    .where('status', BalanceItemStatus.Due)
+                    .where('startDate', startOfDay)
+                    .where('endDate', endOfDay)
+                    .first(false);
+
+                if (existing) {
+                    existing.unitPrice += totalFees;
+                    await existing.save();
+                    BalanceItemService.scheduleUpdate(existing);
+                } else {
+                    await item.save();
+                    BalanceItemService.scheduleUpdate(item);
+                }
+
+                const { changedRows } = await Payment.update()
+                    .where('id', payments.map(p => p.id))
+                    .set('serviceFeeManualCharged', SQL.column('serviceFeeManual'))
+                    .update();
+                if (changedRows !== payments.length) {
+                    console.error('Unexpected change in serviceFeeManualCharged. Expected ' + payments.length + ', updated only ' + changedRows);
+                }
+            }
+        }
+    }
+}

package/src/crons/stripe-invoices.ts

@@ -0,0 +1,48 @@
+import { registerCron } from '@stamhoofd/crons';
+import { Formatter } from '@stamhoofd/utility';
+import { StripeInvoicer } from '../helpers/StripeInvoicer.js';
+import { Organization, Platform } from '@stamhoofd/models';
+
+registerCron('stripe-invoices', createStripeInvoices);
+
+let lastStripeInvoice: Date | null = null;
+
+async function createStripeInvoices() {
+    if (STAMHOOFD.environment !== 'production') {
+        // return;
+    }
+
+    if (STAMHOOFD.userMode === 'platform') {
+        return;
+    }
+
+    if (STAMHOOFD.STRIPE_CONNECT_METHOD === 'standard') {
+        return;
+    }
+
+    // Wait for the next day before doing a new check
+    const today = new Date();
+    if (lastStripeInvoice && Formatter.dateIso(lastStripeInvoice) === Formatter.dateIso(today)) {
+        console.log('Stripe check done for this day');
+        return;
+    }
+    console.log('Creating Stripe Invoices...');
+
+    if (!STAMHOOFD.STRIPE_SECRET_KEY) {
+        console.log('No stripe key set');
+        return;
+    }
+
+    const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+    if (!membershipOrganizationId) {
+        return;
+    }
+
+    const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+    const invoicer = new StripeInvoicer({
+        secretKey: STAMHOOFD.STRIPE_SECRET_KEY,
+    });
+    await invoicer.generateAllInvoices(membershipOrganization);
+    lastStripeInvoice = new Date();
+}

package/src/crons/transfer-fees.ts

@@ -0,0 +1,176 @@
+import { registerCron } from '@stamhoofd/crons';
+import { BalanceItem, Organization, Payment, Platform } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import type { PaymentProvider } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, getPaymentProviderName, PaymentMethod, PaymentStatus, TranslatedString } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { BalanceItemService } from '../services/BalanceItemService.js';
+import { PaymentService } from '../services/PaymentService.js';
+import { VATService } from '../services/VATService.js';
+
+// Charge manual service fees every night
+registerCron('transfer-fees', chargeTransferFees);
+
+async function chargeTransferFees() {
+    if (STAMHOOFD.environment !== 'development' && (new Date().getHours() > 5 || new Date().getHours() < 2)) {
+        return;
+    }
+    const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+    if (!membershipOrganizationId) {
+        return;
+    }
+
+    const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+    // Succeeded payments
+    const payments = await Payment.select()
+        .where('status', PaymentStatus.Succeeded)
+        .where('transferFeeManual', '>', 0)
+        .where('transferFeeManualCharged', 0)
+        .where('createdAt', '<', STAMHOOFD.environment !== 'development' ? new Date() : Formatter.dateIso(new Date(Date.now() + 1000 * 60 * 60 * 24)))
+        .limit(200)
+        .orderBy('createdAt', 'ASC')
+        .fetch();
+
+    // Pending payments older than 14 days with method = Transfer or PointOfSale
+    const pendingPayments = await Payment.select()
+        .where('status', [PaymentStatus.Pending, PaymentStatus.Created])
+        .where('method', [PaymentMethod.Transfer, PaymentMethod.PointOfSale, PaymentMethod.Unknown])
+        .where('transferFeeManual', '>', 0)
+        .where('transferFeeManualCharged', 0)
+        .where('createdAt', '<', Formatter.dateIso(new Date(Date.now() - 1000 * 60 * 60 * 24 * 14)))
+        .limit(200)
+        .orderBy('createdAt', 'ASC')
+        .fetch();
+
+    const allPayments = [...payments, ...pendingPayments];
+
+    console.log('Found ' + allPayments.length + ' payments to charge service fees for');
+
+    const mappedToOrganizationId = new Map<string, Payment[]>();
+    for (const payment of allPayments) {
+        if (!payment.organizationId) {
+            console.warn('Payment without organizationId, skipping', payment.id);
+            continue;
+        }
+        if (!mappedToOrganizationId.has(payment.organizationId)) {
+            mappedToOrganizationId.set(payment.organizationId, []);
+        }
+        mappedToOrganizationId.get(payment.organizationId)!.push(payment);
+    }
+
+    for (const [organizationId, payments] of mappedToOrganizationId.entries()) {
+        const organization = await Organization.getByID(organizationId);
+        if (!organization) {
+            console.warn('Organization not found for ID', organizationId);
+            continue;
+        }
+
+        // Group payments by Formatter.dateNumber(p.createdAt)
+        const groupedPayments: Map<string, Payment[]> = new Map();
+        for (const payment of payments) {
+            const date = Formatter.dateNumber(payment.createdAt);
+            if (!groupedPayments.has(date)) {
+                groupedPayments.set(date, []);
+            }
+            groupedPayments.get(date)!.push(payment);
+        }
+
+        for (const [_, payments] of groupedPayments) {
+            const totalFees = payments.reduce((sum, payment) => sum + payment.transferFeeManual - payment.transferFeeManualCharged, 0);
+            const groupedByDate = new Map<string, Payment[]>();
+
+            for (const p of payments) {
+                const date = Formatter.dateNumber(p.createdAt);
+                const existing = groupedByDate.get(date);
+                if (existing) {
+                    existing.push(p);
+                } else {
+                    groupedByDate.set(date, [p]);
+                }
+            }
+
+            for (const [day, payments] of groupedByDate) {
+                const groupedByProvider = new Map<PaymentProvider | null, Payment[]>();
+
+                for (const p of payments) {
+                    const provider = p.provider;
+                    const existing = groupedByProvider.get(provider);
+                    if (existing) {
+                        existing.push(p);
+                    } else {
+                        groupedByProvider.set(provider, [p]);
+                    }
+                }
+
+                for (const [provider, payments] of groupedByProvider) {
+                    const date = new Date(Math.min(...payments.map(p => p.createdAt.getTime())));
+                    const startOfDay = Formatter.luxon(date).startOf('day').toJSDate();
+                    const endOfDay = Formatter.luxon(date).endOf('day').toJSDate();
+
+                    // Ms don't work when querying MySQL, they get lost
+                    startOfDay.setMilliseconds(0);
+                    endOfDay.setMilliseconds(0);
+
+                    const item = new BalanceItem();
+                    item.type = BalanceItemType.TransferFee;
+                    item.description = $t('%1Yq', { date: day });
+
+                    if (provider) {
+                        item.relations.set(BalanceItemRelationType.PaymentProvider, BalanceItemRelation.create({
+                            id: provider,
+                            name: TranslatedString.create(getPaymentProviderName(provider)),
+                        }));
+                    }
+
+                    item.payingOrganizationId = organization.id;
+                    item.organizationId = membershipOrganizationId;
+                    item.VATPercentage = 21;
+                    item.VATExcempt = VATService.getVATExcempt({
+                        company: organization.defaultCompanies[0] ?? null,
+                        sellingOrganization: membershipOrganization,
+                        type: 'services',
+                    });
+                    item.VATIncluded = false;
+                    item.quantity = 1;
+                    item.unitPrice = totalFees;
+                    item.createdAt = new Date();
+                    item.status = BalanceItemStatus.Due;
+                    item.startDate = startOfDay;
+                    item.endDate = endOfDay;
+
+                    // Check if we find an existing one
+                    const existingAll = await BalanceItem.select()
+                        .where('type', BalanceItemType.TransferFee)
+                        .where('organizationId', membershipOrganizationId)
+                        .where('VATPercentage', item.VATPercentage)
+                        .where('VATIncluded', item.VATIncluded)
+                        .where('VATExcempt', item.VATExcempt)
+                        .where('payingOrganizationId', organization.id)
+                        .where('status', BalanceItemStatus.Due)
+                        .where('startDate', startOfDay)
+                        .where('endDate', endOfDay)
+                        .fetch();
+                    const existing = provider ? existingAll.find(e => e.relations.get(BalanceItemRelationType.PaymentProvider)?.id === provider) : existingAll.find(e => !e.relations.has(BalanceItemRelationType.PaymentProvider));
+
+                    if (existing) {
+                        existing.unitPrice += totalFees;
+                        await existing.save();
+                        BalanceItemService.scheduleUpdate(existing);
+                    } else {
+                        await item.save();
+                        BalanceItemService.scheduleUpdate(item);
+                    }
+
+                    const { changedRows } = await Payment.update()
+                        .where('id', payments.map(p => p.id))
+                        .set('transferFeeManualCharged', SQL.column('transferFeeManual'))
+                        .update();
+                    if (changedRows !== payments.length) {
+                        console.error('Unexpected change in transferFeeManualCharged. Expected ' + payments.length + ', updated only ' + changedRows);
+                    }
+                }
+            }
+        }
+    }
+}