@stamhoofd/backend 2.139.0 → 2.141.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.139.0",
+    "version": "2.141.0",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -65,20 +65,20 @@
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
         "@simplewebauthn/server": "13.3.2",
-        "@stamhoofd/backend-env": "2.139.0",
-        "@stamhoofd/backend-i18n": "2.139.0",
-        "@stamhoofd/backend-middleware": "2.139.0",
-        "@stamhoofd/crons": "2.139.0",
-        "@stamhoofd/email": "2.139.0",
-        "@stamhoofd/excel-writer": "2.139.0",
-        "@stamhoofd/logging": "2.139.0",
-        "@stamhoofd/models": "2.139.0",
-        "@stamhoofd/object-differ": "2.139.0",
-        "@stamhoofd/queues": "2.139.0",
-        "@stamhoofd/sql": "2.139.0",
-        "@stamhoofd/structures": "2.139.0",
-        "@stamhoofd/types": "2.139.0",
-        "@stamhoofd/utility": "2.139.0",
+        "@stamhoofd/backend-env": "2.141.0",
+        "@stamhoofd/backend-i18n": "2.141.0",
+        "@stamhoofd/backend-middleware": "2.141.0",
+        "@stamhoofd/crons": "2.141.0",
+        "@stamhoofd/email": "2.141.0",
+        "@stamhoofd/excel-writer": "2.141.0",
+        "@stamhoofd/logging": "2.141.0",
+        "@stamhoofd/models": "2.141.0",
+        "@stamhoofd/object-differ": "2.141.0",
+        "@stamhoofd/queues": "2.141.0",
+        "@stamhoofd/sql": "2.141.0",
+        "@stamhoofd/structures": "2.141.0",
+        "@stamhoofd/types": "2.141.0",
+        "@stamhoofd/utility": "2.141.0",
         "archiver": "7.0.1",
         "argon2": "0.44.0",
         "axios": "1.18.1",
@@ -102,7 +102,7 @@
         "uuid": "14.0.1"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.139.0",
+        "@stamhoofd/test-utils": "2.141.0",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.2",
         "@types/mailparser": "3.4.6",
@@ -117,5 +117,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "8c2cb66c10f96ca53aa07c20f410d6b8fa5a3291"
+    "gitHead": "cf38053fe1507022767148347f436100a7ef07ed"
 }

package/src/crons/fake-settlements.test.ts

@@ -1,6 +1,12 @@
 import type { Organization } from '@stamhoofd/models';
-import { OrganizationFactory, Payment, StripeAccount } from '@stamhoofd/models';
-import { PaymentMethod, PaymentProvider, PaymentStatus, PaymentType, Settlement } from '@stamhoofd/structures';
+import { OrganizationFactory, Payment, Platform, StripeAccount } from '@stamhoofd/models';
+import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
+import { PaymentSettlement } from '@stamhoofd/models/models/PaymentSettlement.js';
+import { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import { SettlementCharge } from '@stamhoofd/models/models/SettlementCharge.js';
+import { PaymentMethod, PaymentProvider, PaymentStatus, PaymentType, SettlementReference } from '@stamhoofd/structures';
+import { ApplicationFeeType } from '@stamhoofd/structures/settlements/ApplicationFeeType.js';
+import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
 import { TestUtils } from '@stamhoofd/test-utils';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
@@ -8,10 +14,20 @@ import { createFakeSettlements } from './fake-settlements.js';
 
 describe('Cron.fake-settlements', () => {
     let organization: Organization;
+    let membershipOrganization: Organization;
+
+    beforeAll(async () => {
+        membershipOrganization = await new OrganizationFactory({}).create();
+    });
 
     beforeEach(async () => {
         TestUtils.setEnvironment('environment', 'development');
         organization = await new OrganizationFactory({}).create();
+
+        // The platform's own accounts belong to the membership organization
+        const platform = await Platform.getForEditing();
+        platform.membershipOrganizationId = membershipOrganization.id;
+        await platform.save();
     });
 
     /**
@@ -22,7 +38,7 @@ describe('Cron.fake-settlements', () => {
         return Formatter.luxon(new Date()).startOf('week').minus({ weeks: weeksAgo }).plus({ days: 2, hours: 12 }).toJSDate();
     };
 
-    const createPayment = async ({ price = 50_0000, paidAt = inWeek(2), provider = PaymentProvider.Mollie as PaymentProvider | null, status = PaymentStatus.Succeeded, method = PaymentMethod.Bancontact, type = PaymentType.Payment, organizationId = undefined as string | undefined, stripeAccountId = null as string | null }: {
+    const createPayment = async ({ price = 50_0000, paidAt = inWeek(2), provider = PaymentProvider.Mollie as PaymentProvider | null, status = PaymentStatus.Succeeded, method = PaymentMethod.Bancontact, type = PaymentType.Payment, organizationId = undefined as string | undefined, stripeAccountId = null as string | null, serviceFeePayout = 0, transferFee = 0 }: {
         price?: number;
         paidAt?: Date | null;
         provider?: PaymentProvider | null;
@@ -31,6 +47,8 @@ describe('Cron.fake-settlements', () => {
         type?: PaymentType;
         organizationId?: string;
         stripeAccountId?: string | null;
+        serviceFeePayout?: number;
+        transferFee?: number;
     } = {}) => {
         const payment = new Payment();
         payment.organizationId = organizationId ?? organization.id;
@@ -41,6 +59,8 @@ describe('Cron.fake-settlements', () => {
         payment.price = price;
         payment.paidAt = paidAt;
         payment.stripeAccountId = stripeAccountId;
+        payment.serviceFeePayout = serviceFeePayout;
+        payment.transferFee = transferFee;
         await payment.save();
         return payment;
     };
@@ -69,8 +89,9 @@ describe('Cron.fake-settlements', () => {
         expect(settlement).toMatchObject({
             settledAt: Formatter.luxon(inWeek(2)).startOf('week').plus({ weeks: 1, days: 2 }).toJSDate(),
 
-            // Refunds are taken out of the payout, just like the provider does
-            amount: 65_0000,
+            // Refunds are taken out of the payout, just like the provider does, and so are the
+            // fake Mollie costs: 3 payments x 0.30 + 21% VAT
+            amount: 65_0000 - 90_00 - 18_90,
         });
 
         // All payments of the week point to the same payout
@@ -113,8 +134,10 @@ describe('Cron.fake-settlements', () => {
             await getSettlement(otherStripe),
         ];
 
-        // Same week, but four accounts: four payouts, each holding only its own money
-        expect(settlements.map(s => s!.amount)).toEqual([50_0000, 30_0000, 20_0000, 15_0000]);
+        // Same week, but four accounts: four payouts, each holding only its own money. The Mollie
+        // payouts are reduced by the fake cost of one payment (0.30 + 21% VAT); the Stripe payments
+        // carry no fees here
+        expect(settlements.map(s => s!.amount)).toEqual([50_0000 - 36_30, 30_0000 - 36_30, 20_0000, 15_0000]);
         expect(new Set(settlements.map(s => s!.id)).size).toBe(4);
         expect(new Set(settlements.map(s => s!.reference)).size).toBe(4);
     });
@@ -138,7 +161,7 @@ describe('Cron.fake-settlements', () => {
     });
 
     test('A payment that was already paid out keeps its own payout', async () => {
-        const settlement = Settlement.create({
+        const settlement = SettlementReference.create({
             id: 'stl_1',
             reference: '1234.1234.1234',
             settledAt: inWeek(1),
@@ -162,4 +185,102 @@ describe('Cron.fake-settlements', () => {
 
         expect(await getSettlement(payment)).toBeNull();
     });
+
+    describe('Settlement rows', () => {
+        const getSettlementRow = async (payment: Payment) => {
+            const reference = await getSettlement(payment);
+            return await Settlement.select().where('externalId', reference!.id).first(true);
+        };
+
+        test('A Mollie payout stores payment lines and cost rows, and reconciles to zero', async () => {
+            const first = await createPayment({ price: 50_0000 });
+            const second = await createPayment({ price: -10_0000, type: PaymentType.Refund });
+
+            await createFakeSettlements();
+
+            const settlement = await getSettlementRow(first);
+            expect(settlement.provider).toBe(PaymentProvider.Mollie);
+            expect(settlement.organizationId).toBe(organization.id);
+            expect(settlement.amount).toBe(40_0000 - 60_00 - 12_60);
+            expect(settlement.unexplainedAmount).toBe(0);
+            expect(settlement.syncedAt).not.toBeNull();
+
+            const lines = await PaymentSettlement.select().where('settlementId', settlement.id).fetch();
+            expect(lines.map(l => [l.paymentId, l.amount]).sort()).toEqual([
+                [first.id, 50_0000],
+                [second.id, -10_0000],
+            ].sort());
+
+            const settledMonth = settlement.settledAt.getFullYear() + '-' + (settlement.settledAt.getMonth() + 1).toString().padStart(2, '0');
+            const charges = await SettlementCharge.select().where('settlementId', settlement.id).fetch();
+            expect(charges.map(c => ({ type: c.type, amount: c.amount, providerInvoiceId: c.providerInvoiceId })).sort((a, b) => a.amount - b.amount)).toEqual([
+                { type: SettlementChargeType.ProviderTransactionFee, amount: -60_00, providerInvoiceId: 'fake-invoice-mollie-' + settledMonth },
+                { type: SettlementChargeType.Tax, amount: -12_60, providerInvoiceId: 'fake-invoice-mollie-' + settledMonth },
+            ]);
+        });
+
+        test('A Stripe application fee is mirrored on the payout and a monthly platform payout', async () => {
+            const stripeAccount = await createStripeAccount(organization);
+            const payment = await createPayment({
+                price: 20_0000,
+                provider: PaymentProvider.Stripe,
+                stripeAccountId: stripeAccount.id,
+                serviceFeePayout: 2_0000,
+                transferFee: 50_00,
+            });
+
+            await createFakeSettlements();
+
+            const settlement = await getSettlementRow(payment);
+            expect(settlement.amount).toBe(20_0000 - 2_0000 - 50_00);
+            expect(settlement.unexplainedAmount).toBe(0);
+            expect(settlement.stripeAccountId).toBe(stripeAccount.id);
+
+            const applicationFeeId = 'fake-fee-' + payment.id;
+            const feeRows = await SettlementCharge.select().where('applicationFeeId', applicationFeeId).fetch();
+
+            const byType = new Map(feeRows.map(row => [row.type, row]));
+            expect(byType.get(SettlementChargeType.ApplicationFeeService)).toMatchObject({
+                amount: -2_0000, settlementId: settlement.id, paymentId: payment.id, stripeAccountId: stripeAccount.id,
+            });
+            expect(byType.get(SettlementChargeType.ApplicationFeeTransfer)).toMatchObject({
+                amount: -50_00, settlementId: settlement.id,
+            });
+
+            // The platform side receives the same fee: per application fee both sides of one kind
+            // sum to zero
+            const fees = await ApplicationFee.select().where('externalId', applicationFeeId).fetch();
+            const feeByType = new Map(fees.map(fee => [fee.type, fee]));
+            expect(feeByType.get(ApplicationFeeType.Service)).toMatchObject({
+                amount: 2_0000,
+                organizationId: membershipOrganization.id,
+                payingOrganizationId: organization.id,
+                payingStripeAccountId: stripeAccount.id,
+                payingPaymentId: payment.id,
+            });
+            expect(feeByType.get(ApplicationFeeType.Transfer)!.amount).toBe(50_00);
+
+            const platformSettlement = await Settlement.getByID(feeByType.get(ApplicationFeeType.Service)!.settlementId!);
+            expect(platformSettlement!.stripeAccountId).toBeNull();
+            expect(platformSettlement!.organizationId).toBe(membershipOrganization.id);
+            expect(platformSettlement!.externalId).toContain('fake-settlement-Stripe-platform-');
+
+            // The monthly platform settlement is shared: unsettled payments of other tests in the
+            // same database land in it too, so only the identity is asserted, not the exact amount
+            expect(platformSettlement!.amount).toBeGreaterThanOrEqual(2_5000);
+            expect(platformSettlement!.unexplainedAmount).toBe(0);
+        });
+
+        test('Payments without fees write no charge rows', async () => {
+            const stripeAccount = await createStripeAccount(organization);
+            const payment = await createPayment({ price: 20_0000, provider: PaymentProvider.Stripe, stripeAccountId: stripeAccount.id });
+
+            await createFakeSettlements();
+
+            const settlement = await getSettlementRow(payment);
+            expect(settlement.amount).toBe(20_0000);
+            expect(settlement.unexplainedAmount).toBe(0);
+            expect(await SettlementCharge.select().where('settlementId', settlement.id).count()).toBe(0);
+        });
+    });
 });

package/src/crons/fake-settlements.ts

@@ -5,12 +5,20 @@
  */
 
 import { registerCron } from '@stamhoofd/crons';
-import { Order, Payment } from '@stamhoofd/models';
+import { Order, Payment, Platform } from '@stamhoofd/models';
+import { ApplicationFee } from '@stamhoofd/models/models/ApplicationFee.js';
+import { PaymentSettlement } from '@stamhoofd/models/models/PaymentSettlement.js';
+import { Settlement } from '@stamhoofd/models/models/Settlement.js';
+import { SettlementCharge } from '@stamhoofd/models/models/SettlementCharge.js';
 import { SQL } from '@stamhoofd/sql';
-import { PaymentStatus, Settlement } from '@stamhoofd/structures';
+import { PaymentProvider, PaymentStatus, SettlementReference } from '@stamhoofd/structures';
 import { SETTLING_PAYMENT_PROVIDERS } from '@stamhoofd/structures/PaymentSettlement.js';
+import { ApplicationFeeType } from '@stamhoofd/structures/settlements/ApplicationFeeType.js';
+import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
 import { Formatter } from '@stamhoofd/utility';
 import type { DateTime } from 'luxon';
+import { ApplicationFeeService } from '../services/ApplicationFeeService.js';
+import { SettlementService } from '../services/SettlementService.js';
 
 registerCron('fake-settlements', createFakeSettlements);
 
@@ -25,6 +33,12 @@ const PAYOUT_DELAY_DAYS = 2;
  */
 const BATCH_SIZE = 1000;
 
+/**
+ * Fake Mollie transaction fee per settled payment, excluding VAT.
+ */
+const MOLLIE_FEE_PER_PAYMENT = 30_00;
+const MOLLIE_FEE_VAT_PERCENTAGE = 21;
+
 export async function createFakeSettlements() {
     if (STAMHOOFD.environment !== 'development') {
         return;
@@ -32,9 +46,21 @@ export async function createFakeSettlements() {
 
     const now = new Date();
 
+    // The platform's own accounts belong to the membership organization; without one, their
+    // payouts can't be attributed and are skipped
+    const platformOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+
+    // Payments that couldn't be attributed to an organization are scanned past instead of
+    // reselected forever, so they can't stall the payout of later weeks
+    let scanAfter: Date | null = null;
+
     // Pay out week per week, oldest first, until we reach a week that isn't paid out yet
     for (;;) {
-        const oldest = await selectUnsettledPayments().orderBy('paidAt', 'ASC').first(false);
+        let oldestQuery = selectUnsettledPayments();
+        if (scanAfter) {
+            oldestQuery = oldestQuery.where('paidAt', '>', scanAfter);
+        }
+        const oldest = await oldestQuery.orderBy('paidAt', 'ASC').first(false);
         if (!oldest?.paidAt) {
             break;
         }
@@ -51,8 +77,17 @@ export async function createFakeSettlements() {
 
         // Nothing is left before this week, so this selects exactly the payments of this week. What
         // doesn't fit in one batch is picked up by the next round, in the same payout
-        const payments = await selectUnsettledPayments().where('paidAt', '<', weekEnd.toJSDate()).limit(BATCH_SIZE).fetch();
-        await settleWeek(payments, weekStart, settledAt);
+        let batchQuery = selectUnsettledPayments().where('paidAt', '<', weekEnd.toJSDate());
+        if (scanAfter) {
+            batchQuery = batchQuery.where('paidAt', '>', scanAfter);
+        }
+        const payments = await batchQuery.limit(BATCH_SIZE).fetch();
+        const settledCount = await settleWeek(payments, weekStart, settledAt, platformOrganizationId);
+
+        if (settledCount === 0) {
+            // Everything in this batch was skipped: continue behind it
+            scanAfter = new Date(Math.max(...payments.map(p => p.paidAt!.getTime())));
+        }
     }
 }
 
@@ -76,7 +111,40 @@ function getPayoutAccount(payment: Payment): string {
     return payment.provider + '-' + (payment.stripeAccountId ?? payment.organizationId ?? 'platform');
 }
 
-async function settleWeek(payments: Payment[], weekStart: DateTime, settledAt: Date) {
+function getStripeFakeFees(payment: Payment) {
+    return { serviceFee: payment.serviceFeePayout, transferFee: payment.transferFee };
+}
+
+/**
+ * Upsert a settlement while accumulating the amount: a week larger than one batch settles in
+ * multiple rounds, all in the same payout.
+ */
+async function upsertFakeSettlement(data: { provider: PaymentProvider; externalId: string; stripeAccountId: string | null; organizationId: string; reference: string; settledAt: Date; addedAmount: number }) {
+    const existing = await Settlement.select()
+        .where('provider', data.provider)
+        .where('externalId', data.externalId)
+        .first(false);
+
+    return await SettlementService.upsertSettlement({
+        provider: data.provider,
+        externalId: data.externalId,
+        stripeAccountId: data.stripeAccountId,
+        organizationId: data.organizationId,
+        reference: data.reference,
+        amount: (existing?.amount ?? 0) + data.addedAmount,
+        settledAt: data.settledAt,
+    });
+}
+
+async function finishFakeSync(settlement: Settlement) {
+    const lineCount = await PaymentSettlement.select().where('settlementId', settlement.id).count();
+    const chargeCount = await SettlementCharge.select().where('settlementId', settlement.id).count();
+    const feeCount = await ApplicationFee.select().where('settlementId', settlement.id).count();
+    await SettlementService.finishSync(settlement, { transactionCount: lineCount + chargeCount + feeCount });
+}
+
+async function settleWeek(payments: Payment[], weekStart: DateTime, settledAt: Date, platformOrganizationId: string | null): Promise<number> {
+    let settledCount = 0;
     const groups = new Map<string, Payment[]>();
 
     for (const payment of payments) {
@@ -97,10 +165,50 @@ async function settleWeek(payments: Payment[], weekStart: DateTime, settledAt: D
 
         // Every account gets its own payout, so the reference has to tell them apart
         const reference = 'DEV ' + week + ' (' + account.slice(-8) + ')';
-        const amount = group.reduce((total, payment) => total + payment.price, 0);
+        const provider = group[0].provider!;
+
+        // Payments without an organization arrived on the platform's own account
+        const organizationId = group[0].organizationId ?? platformOrganizationId;
+        if (!organizationId) {
+            console.log('Skipped fake settlement ' + reference + ': no platform membership organization configured');
+            continue;
+        }
+
+        // Fees are deducted from the payout, so the identity
+        // amount = sum of payment lines + sum of charges closes
+        let fees = 0;
+        if (provider === PaymentProvider.Stripe) {
+            fees = group.reduce((total, payment) => {
+                const { serviceFee, transferFee } = getStripeFakeFees(payment);
+                return total + serviceFee + transferFee;
+            }, 0);
+        } else if (provider === PaymentProvider.Mollie) {
+            const net = MOLLIE_FEE_PER_PAYMENT * group.length;
+            fees = net + Math.round(net * MOLLIE_FEE_VAT_PERCENTAGE / 100);
+        }
+
+        const grossAmount = group.reduce((total, payment) => total + payment.price, 0);
+        const amount = grossAmount - fees;
+
+        const settlement = await upsertFakeSettlement({
+            provider,
+            externalId: id,
+            stripeAccountId: group[0].stripeAccountId,
+            organizationId,
+            reference,
+            settledAt,
+            addedAmount: amount,
+        });
 
         for (const payment of group) {
-            payment.settlement = Settlement.create({ id, reference, settledAt, amount });
+            await SettlementService.upsertPaymentLine(settlement, {
+                paymentId: payment.id,
+                amount: payment.price,
+                externalId: 'fake-txn-' + payment.id,
+                occurredAt: payment.paidAt!,
+            });
+
+            payment.settlement = SettlementReference.create({ id, reference, settledAt, amount: settlement.amount });
             await payment.save();
 
             // Mark order as 'updated', or the frontend won't pull in the updates
@@ -112,6 +220,145 @@ async function settleWeek(payments: Payment[], weekStart: DateTime, settledAt: D
             }
         }
 
-        console.log('Created settlement ' + reference + ' of ' + Formatter.price(amount) + ' for ' + group.length + ' payments');
+        if (provider === PaymentProvider.Stripe) {
+            await createStripeFeeRows(settlement, group, settledAt, platformOrganizationId);
+        } else if (provider === PaymentProvider.Mollie) {
+            await createMollieCostRows(settlement, group, settledAt);
+        }
+
+        await finishFakeSync(settlement);
+        settledCount += group.length;
+
+        console.log('Created settlement ' + reference + ' of ' + Formatter.price(settlement.amount) + ' for ' + group.length + ' payments');
     }
+
+    return settledCount;
+}
+
+/**
+ * The application fee of a Stripe payment is mirrored, like Stripe mirrors it: two negative
+ * deduction rows on the organization payout, and two application fee rows received in a fake
+ * monthly platform payout.
+ */
+async function createStripeFeeRows(settlement: Settlement, group: Payment[], settledAt: Date, platformOrganizationId: string | null) {
+    const month = SettlementService.getPeriodKey(settledAt);
+    let addedFees = 0;
+    const feeRows: { payment: Payment; applicationFeeId: string; parts: { type: ApplicationFeeType; amount: number; charge: SettlementCharge }[] }[] = [];
+
+    for (const payment of group) {
+        const { serviceFee, transferFee } = getStripeFakeFees(payment);
+        if ((serviceFee === 0 && transferFee === 0) || !payment.organizationId || !payment.stripeAccountId) {
+            continue;
+        }
+
+        const applicationFeeId = 'fake-fee-' + payment.id;
+        const parts: { type: ApplicationFeeType; amount: number; charge: SettlementCharge }[] = [];
+        addedFees += serviceFee + transferFee;
+
+        for (const [chargeType, feeType, feeAmount] of [
+            [SettlementChargeType.ApplicationFeeService, ApplicationFeeType.Service, serviceFee],
+            [SettlementChargeType.ApplicationFeeTransfer, ApplicationFeeType.Transfer, transferFee],
+        ] as const) {
+            if (feeAmount === 0) {
+                continue;
+            }
+            const charge = await SettlementService.upsertCharge({
+                type: chargeType,
+                externalId: applicationFeeId + ':' + chargeType,
+                amount: -feeAmount,
+                settlementId: settlement.id,
+                applicationFeeId,
+                paymentId: payment.id,
+                organizationId: payment.organizationId,
+                stripeAccountId: payment.stripeAccountId,
+                occurredAt: payment.paidAt!,
+            });
+            parts.push({ type: feeType, amount: feeAmount, charge });
+        }
+
+        feeRows.push({ payment, applicationFeeId, parts });
+    }
+
+    if (feeRows.length === 0) {
+        return;
+    }
+
+    if (!platformOrganizationId) {
+        console.log('Skipped the fake platform fee payout: no platform membership organization configured');
+        return;
+    }
+
+    // One fake platform payout per month receives all fees of that month
+    const platformSettlement = await upsertFakeSettlement({
+        provider: PaymentProvider.Stripe,
+        externalId: 'fake-settlement-Stripe-platform-' + month,
+        stripeAccountId: null,
+        organizationId: platformOrganizationId,
+        reference: 'DEV STRIPE FEES ' + month,
+        settledAt,
+        addedAmount: addedFees,
+    });
+
+    const invoicedFeeBalanceItemIds = new Set<string>();
+    for (const { payment, applicationFeeId, parts } of feeRows) {
+        for (const { type, amount, charge } of parts) {
+            const fee = await ApplicationFeeService.upsertFee({
+                externalId: applicationFeeId,
+                type,
+                amount,
+                organizationId: platformOrganizationId,
+                payingOrganizationId: payment.organizationId!,
+                payingStripeAccountId: payment.stripeAccountId!,
+                payingPaymentId: payment.id,
+                settlementChargeId: charge.id,
+                settlementId: platformSettlement.id,
+                occurredAt: payment.paidAt!,
+            });
+            if (fee.balanceItemId) {
+                invoicedFeeBalanceItemIds.add(fee.balanceItemId);
+            }
+        }
+    }
+
+    // A dev database can contain fee payments (e.g. copied history): keep their derived lines
+    // in sync like a real payout walk does
+    await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]);
+
+    await finishFakeSync(platformSettlement);
+}
+
+/**
+ * Mollie deducts its own costs from the settlement: one fake transaction fee line plus its VAT, so
+ * the settlement reconciles to 0 like a real one.
+ */
+async function createMollieCostRows(settlement: Settlement, group: Payment[], settledAt: Date) {
+    const externalId = settlement.externalId + ':cost:0';
+    const existing = await SettlementCharge.select().where('externalId', externalId).first(false);
+
+    const addedNet = MOLLIE_FEE_PER_PAYMENT * group.length;
+    const net = (existing ? -existing.amount : 0) + addedNet;
+    const vat = Math.round(net * MOLLIE_FEE_VAT_PERCENTAGE / 100);
+    const providerInvoiceId = 'fake-invoice-mollie-' + SettlementService.getPeriodKey(settledAt);
+
+    await SettlementService.upsertCharge({
+        type: SettlementChargeType.ProviderTransactionFee,
+        externalId,
+        amount: -net,
+        settlementId: settlement.id,
+        organizationId: settlement.organizationId,
+        providerInvoiceId,
+        description: 'DEV Mollie transactiekosten',
+        occurredAt: settledAt,
+    });
+
+    await SettlementService.upsertCharge({
+        type: SettlementChargeType.Tax,
+        externalId: externalId + ':tax',
+        amount: -vat,
+        settlementId: settlement.id,
+        organizationId: settlement.organizationId,
+        providerInvoiceId,
+        description: 'DEV BTW op Mollie transactiekosten',
+        occurredAt: settledAt,
+    });
 }

package/src/crons/index.ts

@@ -13,8 +13,8 @@ import './fake-settlements.js';
 import './invoices.js';
 import './service-fees.js';
 import './members-fees.js';
+import './settlement-sync.js';
 import './stripe-invoices.js';
-import './stripe-payout-reports.js';
 import './transfer-fees.js';
 import './drip-emails.js';
 import './update-organization-future-events.js';

package/src/crons/invoices.ts

@@ -7,6 +7,7 @@ import { EmailTemplateType, InvoiceStruct, PaymentStatus, Replacement } from '@s
 import { Formatter, Sorter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures.js';
 import { InvoiceService } from '../services/InvoiceService.js';
+import { WebmasterReport } from '../helpers/WebmasterReport.js';
 import { useSavedIterator } from './helpers/useSavedIterator.js';
 import { isOutside } from './helpers/isOutside.js';
 import { OrganizationAdminService } from '../services/OrganizationAdminService.js';
@@ -33,15 +34,19 @@ async function invoices() {
         return;
     }
 
-    // Get the next x organization to send e-mails for
-    for await (const organization of iterate()) {
-        if (!organization.meta.invoicesEnabled) {
-            continue;
-        }
+    // A problem in one invoice usually repeats in every invoice of this run: one email for all of
+    // them
+    await WebmasterReport.group('Aanmaken facturen', async () => {
+        // 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);
-    }
+            // Create all invoices for this organization
+            await createInvoicesFor(organization);
+        }
+    });
 }
 
 async function createInvoicesFor(organization: Organization) {

package/src/crons/settlement-sync.test.ts

@@ -0,0 +1,39 @@
+import { EmailMocker } from '@stamhoofd/email';
+import type { Organization } from '@stamhoofd/models';
+import { OrganizationFactory } from '@stamhoofd/models';
+import { PaymentProvider } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from 'uuid';
+
+import { SettlementService } from '../services/SettlementService.js';
+import { reportProblemSettlements } from './settlement-sync.js';
+
+describe('Cron.settlement-sync', () => {
+    let organization: Organization;
+
+    beforeAll(async () => {
+        organization = await new OrganizationFactory({}).create();
+    });
+
+    const createUnsyncedSettlement = async (failureCount: number) => {
+        const settlement = await SettlementService.upsertSettlement({
+            provider: PaymentProvider.Stripe,
+            externalId: 'po_' + uuidv4(),
+            organizationId: organization.id,
+            amount: 100_00_00,
+            settledAt: new Date(1990, 0, 5),
+        });
+        for (let i = 0; i < failureCount; i++) {
+            await SettlementService.markSyncFailed(settlement);
+        }
+        return settlement;
+    };
+
+    test('problem settlements are reported to the webmaster', async () => {
+        await createUnsyncedSettlement(5);
+
+        await reportProblemSettlements();
+
+        const emails = await EmailMocker.transactional.getSucceededEmails();
+        expect(emails.find(e => e.subject.startsWith('Uitbetalingen met problemen'))).toBeDefined();
+    });
+});