@stamhoofd/backend 2.126.2 → 2.127.0

package/src/endpoints/organization/dashboard/payments/PatchPaymentsEndpoint.ts

@@ -3,6 +3,7 @@ import { PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/s
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
+import type { Organization } from '@stamhoofd/models';
 import { BalanceItem, BalanceItemPayment, Payment, User } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { PaymentCustomer, PaymentGeneral, PaymentMethod, PaymentStatus, Payment as PaymentStruct, PaymentType, PermissionLevel } from '@stamhoofd/structures';
@@ -60,6 +61,13 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
                 });
             }
 
+            // A put with a reversingPaymentId creates a refund via the API of the payment
+            // provider of that payment (instead of registering a manual payment)
+            if (put.reversingPaymentId !== null) {
+                changedPayments.push(await this.createOnlineRefund(organization, user, put));
+                continue;
+            }
+
             if (![PaymentMethod.Unknown, PaymentMethod.Transfer, PaymentMethod.PointOfSale].includes(put.method)) {
                 throw new SimpleError({
                     code: 'invalid_field',
@@ -227,16 +235,9 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
 
             // Mark paid or failed
             if (put.status !== PaymentStatus.Created && put.status !== PaymentStatus.Pending) {
-                await PaymentService.handlePaymentStatusUpdate(payment, organization, put.status);
-
-                if (put.status === PaymentStatus.Succeeded) {
-                    payment.paidAt = put.paidAt;
-                    await payment.save();
-                }
+                await PaymentService.handlePaymentStatusUpdate(payment, organization, put.status, put.status === PaymentStatus.Succeeded ? (put.paidAt ?? undefined) : undefined);
             } else {
-                for (const balanceItem of balanceItems) {
-                    await BalanceItemService.markUpdated(balanceItem, payment, organization);
-                }
+                await PaymentService.handlePaymentCreated(payment, organization);
             }
 
             changedPayments.push(payment);
@@ -344,6 +345,8 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
 
                 if (patch.status && patch.status !== payment.status) {
                     await PaymentService.handlePaymentStatusUpdate(payment, organization, patch.status);
+                } else {
+                    await PaymentService.handlePaymentUpdated(payment, organization);
                 }
 
                 changedPayments.push(
@@ -359,4 +362,64 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
             await AuthenticatedStructures.paymentsGeneral(changedPayments, true),
         );
     }
+
+    /**
+     * Create a refund via the API of the payment provider (currently only Mollie).
+     *
+     * The put contains the new (negative) payment to create, with `reversingPaymentId` set to the
+     * existing online payment that will be (partially) refunded via the payment provider. The
+     * balance items of the new payment can differ from the balance items of the source payment.
+     */
+    private async createOnlineRefund(organization: Organization, user: User, put: PaymentGeneral): Promise<Payment> {
+        if (put.type !== PaymentType.Refund) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Only payments of type Refund can reverse another payment',
+                human: $t('%Zab'),
+                field: 'type',
+            });
+        }
+
+        const sourcePayment = await Payment.getByID(put.reversingPaymentId!);
+        if (!sourcePayment || sourcePayment.organizationId !== organization.id || !(await Context.auth.canAccessPayment(sourcePayment, PermissionLevel.Write))) {
+            throw new SimpleError({
+                code: 'not_found',
+                message: 'Payment not found',
+                human: $t('%ZZy'),
+                field: 'reversingPaymentId',
+            });
+        }
+
+        if (sourcePayment.type !== PaymentType.Payment) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Can only refund payments of type Payment',
+                human: $t('%ZaJ'),
+                field: 'reversingPaymentId',
+            });
+        }
+
+        const balanceItems = new Map<BalanceItem, number>();
+
+        for (const item of put.balanceItemPayments) {
+            const balanceItem = await BalanceItem.getByID(item.balanceItem.id);
+            if (!balanceItem || balanceItem.organizationId !== organization.id) {
+                throw Context.auth.notFoundOrNoAccess($t('%Za2'));
+            }
+            balanceItems.set(balanceItem, (balanceItems.get(balanceItem) ?? 0) + item.price);
+        }
+
+        // Check permissions
+        if (!(await Context.auth.canAccessBalanceItems([...balanceItems.keys()], PermissionLevel.Write))) {
+            throw Context.auth.error($t('%Za9'));
+        }
+
+        return await PaymentService.createRefund({
+            organization,
+            sourcePayment,
+            balanceItems,
+            adminUserId: user.id,
+            customer: put.customer,
+        });
+    }
 }

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint.test.ts

@@ -0,0 +1,209 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import type { BalanceItem, Organization, User } from '@stamhoofd/models';
+import { BalanceItemFactory, BalanceItemPayment, Invoice, InvoicedBalanceItem, MemberFactory, OrganizationFactory, Payment, Token, UserFactory } from '@stamhoofd/models';
+import type { DetailedReceivableBalance } from '@stamhoofd/structures';
+import { PaymentMethod, PaymentStatus, PermissionLevel, Permissions, ReceivableBalanceType } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { GetReceivableBalanceEndpoint } from './GetReceivableBalanceEndpoint.js';
+
+describe('Endpoint.GetReceivableBalanceEndpoint', () => {
+    const endpoint = new GetReceivableBalanceEndpoint();
+
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    const createPayment = async ({ organization, balanceItems, invoiceId }: { organization: Organization; balanceItems: BalanceItem[]; invoiceId?: string | null }) => {
+        const payment = new Payment();
+        payment.method = PaymentMethod.Transfer;
+        payment.status = PaymentStatus.Succeeded;
+        payment.organizationId = organization.id;
+        payment.price = balanceItems.reduce((sum, b) => sum + b.price, 0);
+        payment.invoiceId = invoiceId ?? null;
+        await payment.save();
+
+        for (const balanceItem of balanceItems) {
+            const balanceItemPayment = new BalanceItemPayment();
+            balanceItemPayment.balanceItemId = balanceItem.id;
+            balanceItemPayment.paymentId = payment.id;
+            balanceItemPayment.price = balanceItem.price;
+            balanceItemPayment.organizationId = organization.id;
+            await balanceItemPayment.save();
+        }
+
+        return payment;
+    };
+
+    const createInvoice = async ({ organization, balanceItems, payingOrganizationId }: { organization: Organization; balanceItems?: BalanceItem[]; payingOrganizationId?: string | null }) => {
+        const invoice = new Invoice();
+        invoice.organizationId = organization.id;
+        invoice.payingOrganizationId = payingOrganizationId ?? null;
+        await invoice.save();
+
+        for (const balanceItem of balanceItems ?? []) {
+            const item = new InvoicedBalanceItem();
+            item.organizationId = organization.id;
+            item.invoiceId = invoice.id;
+            item.balanceItemId = balanceItem.id;
+            item.name = 'Test item';
+            item.unitPrice = balanceItem.unitPrice;
+            item.balanceInvoicedAmount = balanceItem.price;
+            await item.save();
+        }
+
+        return invoice;
+    };
+
+    const getReceivableBalance = async ({ type, id, organization, user }: { type: ReceivableBalanceType; id: string; organization: Organization; user: User }) => {
+        const token = await Token.createToken(user);
+
+        const request = Request.get({
+            path: `/receivable-balances/${type}/${id}`,
+            host: organization.getApiHost(),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+
+        return testServer.test<DetailedReceivableBalance>(endpoint, request);
+    };
+
+    const createAdmin = async (organization: Organization) => {
+        return await new UserFactory({
+            organization,
+            permissions: Permissions.create({ level: PermissionLevel.Full }),
+        }).create();
+    };
+
+    describe('Invoices of a member receivable balance', () => {
+        test('returns invoices that invoiced a balance item of the member, and marks the payments as invoiced', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const admin = await createAdmin(organization);
+            const member = await new MemberFactory({ organization }).create();
+            const otherMember = await new MemberFactory({ organization }).create();
+
+            const balanceItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                memberId: member.id,
+                amount: 1,
+                unitPrice: 50_00,
+            }).create();
+
+            const otherBalanceItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                memberId: otherMember.id,
+                amount: 1,
+                unitPrice: 10_00,
+            }).create();
+
+            const invoice = await createInvoice({ organization, balanceItems: [balanceItem] });
+            const otherInvoice = await createInvoice({ organization, balanceItems: [otherBalanceItem] });
+
+            const invoicedPayment = await createPayment({ organization, balanceItems: [balanceItem], invoiceId: invoice.id });
+            const notInvoicedPayment = await createPayment({ organization, balanceItems: [balanceItem] });
+
+            const response = await getReceivableBalance({
+                type: ReceivableBalanceType.member,
+                id: member.id,
+                organization,
+                user: admin,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.invoices.map(i => i.id)).toEqual([invoice.id]);
+            expect(response.body.invoices.map(i => i.id)).not.toContain(otherInvoice.id);
+
+            const payments = response.body.payments;
+            expect(payments.find(p => p.id === invoicedPayment.id)?.invoiceId).toBe(invoice.id);
+            expect(payments.find(p => p.id === notInvoicedPayment.id)?.invoiceId).toBeNull();
+        });
+    });
+
+    describe('Invoices of an organization receivable balance', () => {
+        test('returns invoices via the paying organization and via invoiced balance items, without duplicates', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const payingOrganization = await new OrganizationFactory({}).create();
+            const admin = await createAdmin(organization);
+
+            const balanceItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                payingOrganizationId: payingOrganization.id,
+                amount: 1,
+                unitPrice: 50_00,
+            }).create();
+
+            // Linked both directly and via the invoiced balance item: should only be returned once
+            const invoiceViaBoth = await createInvoice({ organization, balanceItems: [balanceItem], payingOrganizationId: payingOrganization.id });
+
+            // Only linked via the invoiced balance item: the invoice itself has no payingOrganizationId,
+            // so it can only be found through the balance item that belongs to the paying organization
+            const invoiceViaItemOnly = await createInvoice({ organization, balanceItems: [balanceItem], payingOrganizationId: null });
+
+            // Only linked directly to the paying organization (no invoiced balance items)
+            const directInvoice = await createInvoice({ organization, payingOrganizationId: payingOrganization.id });
+
+            // Invoice of another paying organization
+            const otherPayingOrganization = await new OrganizationFactory({}).create();
+            const otherInvoice = await createInvoice({ organization, payingOrganizationId: otherPayingOrganization.id });
+
+            const response = await getReceivableBalance({
+                type: ReceivableBalanceType.organization,
+                id: payingOrganization.id,
+                organization,
+                user: admin,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.invoices.map(i => i.id).sort()).toEqual([invoiceViaBoth.id, invoiceViaItemOnly.id, directInvoice.id].sort());
+            expect(response.body.invoices.map(i => i.id)).not.toContain(otherInvoice.id);
+        });
+
+        test('does not return invoices of a different selling organization', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const otherOrganization = await new OrganizationFactory({}).create();
+            const payingOrganization = await new OrganizationFactory({}).create();
+            const admin = await createAdmin(organization);
+
+            await createInvoice({ organization: otherOrganization, payingOrganizationId: payingOrganization.id });
+
+            const response = await getReceivableBalance({
+                type: ReceivableBalanceType.organization,
+                id: payingOrganization.id,
+                organization,
+                user: admin,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.invoices).toHaveLength(0);
+        });
+    });
+
+    describe('Invoices of a user receivable balance', () => {
+        test('returns invoices that invoiced a balance item of the user', async () => {
+            const organization = await new OrganizationFactory({}).create();
+            const admin = await createAdmin(organization);
+            const user = await new UserFactory({ organization }).create();
+
+            const balanceItem = await new BalanceItemFactory({
+                organizationId: organization.id,
+                userId: user.id,
+                amount: 1,
+                unitPrice: 25_00,
+            }).create();
+
+            const invoice = await createInvoice({ organization, balanceItems: [balanceItem] });
+            await createPayment({ organization, balanceItems: [balanceItem], invoiceId: invoice.id });
+
+            const response = await getReceivableBalance({
+                type: ReceivableBalanceType.user,
+                id: user.id,
+                organization,
+                user: admin,
+            });
+
+            expect(response.status).toBe(200);
+            expect(response.body.invoices.map(i => i.id)).toEqual([invoice.id]);
+        });
+    });
+});

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint.ts

@@ -3,12 +3,13 @@ import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { DetailedReceivableBalance, PaymentStatus, PermissionLevel, ReceivableBalanceType } from '@stamhoofd/structures';
 
 import type { MemberWithUsersAndRegistrations } from '@stamhoofd/models';
-import { BalanceItem, BalanceItemPayment, CachedBalance, Member, MemberUser, Payment, Registration } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, CachedBalance, Invoice, InvoicedBalanceItem, Member, MemberUser, Payment, Registration } from '@stamhoofd/models';
 import { Context } from '../../../../helpers/Context.js';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import type { SQLWhere } from '@stamhoofd/sql';
 import { SQL } from '@stamhoofd/sql';
 import { BalanceItemService } from '../../../../services/BalanceItemService.js';
-import { Formatter } from '@stamhoofd/utility';
+import { Formatter, Sorter } from '@stamhoofd/utility';
 
 type Params = { id: string; type: ReceivableBalanceType };
 type Query = undefined;
@@ -53,146 +54,36 @@ export class GetReceivableBalanceEndpoint extends Endpoint<Params, Query, Body,
             }
         }
 
-        let paymentModels: Payment[] = [];
-
-        switch (request.params.type) {
-            case ReceivableBalanceType.organization: {
-                // Force cache updates, because sometimes the cache could be out of date
-                // BalanceItemService.scheduleOrganizationUpdate(organization.id, request.params.id);
-
-                paymentModels = await Payment.select()
-                    .where('organizationId', organization.id)
-                    .andWhere(
-                        SQL.whereNot('status', PaymentStatus.Failed),
-                    )
-                    .join(
-                        SQL.join(BalanceItemPayment.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'paymentId'), SQL.column(Payment.table, 'id')),
-                    )
-                    .join(
-                        SQL.join(BalanceItem.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
-                    )
-                    .where(SQL.column(BalanceItem.table, 'payingOrganizationId'), request.params.id)
-                    .groupBy(SQL.column(Payment.table, 'id'))
-                    .fetch();
-                break;
-            }
-
-            case ReceivableBalanceType.member: {
-                // Force cache updates, because sometimes the cache could be out of date
-                // BalanceItemService.scheduleMemberUpdate(organization.id, request.params.id);
-
-                paymentModels = await Payment.select()
-                    .where('organizationId', organization.id)
-                    .join(
-                        SQL.join(BalanceItemPayment.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'paymentId'), SQL.column(Payment.table, 'id')),
-                    )
-                    .join(
-                        SQL.join(BalanceItem.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
-                    )
-                    .where(SQL.column(BalanceItem.table, 'memberId'), request.params.id)
-                    .andWhere(
-                        SQL.whereNot('status', PaymentStatus.Failed),
-                    )
-                    .groupBy(SQL.column(Payment.table, 'id'))
-                    .fetch();
-                break;
-            }
-
-            case ReceivableBalanceType.user: {
-                const memberUsers = await MemberUser.select().where('usersId', request.params.id).fetch();
-                const memberIds = Formatter.uniqueArray(memberUsers.map(mu => mu.membersId));
-
-                // Force cache updates, because sometimes the cache could be out of date
-                // BalanceItemService.scheduleUserUpdate(organization.id, request.params.id);
-                //
-                // for (const memberId of memberIds) {
-                //    BalanceItemService.scheduleMemberUpdate(organization.id, memberId);
-                // }
-
-                const q = Payment.select()
-                    .where('organizationId', organization.id)
-                    .join(
-                        SQL.join(BalanceItemPayment.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'paymentId'), SQL.column(Payment.table, 'id')),
-                    )
-                    .join(
-                        SQL.join(BalanceItem.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
-                    );
-
-                if (memberIds.length === 0) {
-                    q.where(SQL.column(BalanceItem.table, 'userId'), request.params.id);
-                } else {
-                    q.where(
-                        SQL.where(SQL.column(BalanceItem.table, 'userId'), request.params.id)
-                            .or(SQL.column(BalanceItem.table, 'memberId'), memberIds),
-                    );
-                }
-
-                paymentModels = await q
-                    .andWhere(
-                        SQL.whereNot('status', PaymentStatus.Failed),
-                    )
-                    .groupBy(SQL.column(Payment.table, 'id'))
-                    .fetch();
-                break;
-            }
-
-            case ReceivableBalanceType.userWithoutMembers: {
-                // Force cache updates, because sometimes the cache could be out of date
-                // BalanceItemService.scheduleUserUpdate(organization.id, request.params.id);
-
-                const q = Payment.select()
-                    .where('organizationId', organization.id)
-                    .join(
-                        SQL.join(BalanceItemPayment.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'paymentId'), SQL.column(Payment.table, 'id')),
-                    )
-                    .join(
-                        SQL.join(BalanceItem.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
-                    )
-                    .where(SQL.column(BalanceItem.table, 'userId'), request.params.id);
-
-                paymentModels = await q
-                    .andWhere(
-                        SQL.whereNot('status', PaymentStatus.Failed),
-                    )
-                    .groupBy(SQL.column(Payment.table, 'id'))
-                    .fetch();
-                break;
-            }
-
-            case ReceivableBalanceType.registration: {
-                paymentModels = await Payment.select()
-                    .where('organizationId', organization.id)
-                    .join(
-                        SQL.join(BalanceItemPayment.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'paymentId'), SQL.column(Payment.table, 'id')),
-                    )
-                    .join(
-                        SQL.join(BalanceItem.table)
-                            .where(SQL.column(BalanceItemPayment.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
-                    )
-                    .where(SQL.column(BalanceItem.table, 'registrationId'), request.params.id)
-                    .andWhere(
-                        SQL.whereNot('status', PaymentStatus.Failed),
-                    )
-                    .groupBy(SQL.column(Payment.table, 'id'))
-                    .fetch();
-                break;
-            }
-        }
+        // Note: the cache updates are disabled because they caused performance issues
+        // BalanceItemService.scheduleOrganizationUpdate / scheduleMemberUpdate / scheduleUserUpdate
+
+        const balanceItemWhere = await GetReceivableBalanceEndpoint.getBalanceItemWhere(request.params.type, request.params.id);
+
+        const paymentModels = await Payment.select()
+            .where('organizationId', organization.id)
+            .andWhere(
+                SQL.whereNot('status', PaymentStatus.Failed),
+            )
+            .join(
+                SQL.join(BalanceItemPayment.table)
+                    .where(SQL.column(BalanceItemPayment.table, 'paymentId'), SQL.column(Payment.table, 'id')),
+            )
+            .join(
+                SQL.join(BalanceItem.table)
+                    .where(SQL.column(BalanceItemPayment.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
+            )
+            .andWhere(balanceItemWhere)
+            .groupBy(SQL.column(Payment.table, 'id'))
+            .fetch();
+
+        const invoiceModels = await GetReceivableBalanceEndpoint.getInvoices(organization.id, request.params.type, request.params.id, balanceItemWhere);
 
         // Flush caches (this makes sure that we do a reload in the frontend after a registration or change, we get the newest balances)
         // await BalanceItemService.flushCaches(organization.id);
         const balanceItemModels = await CachedBalance.balanceForObjects(organization.id, [request.params.id], request.params.type);
         const balanceItems = await BalanceItem.getStructureWithPayments(balanceItemModels);
         const payments = await AuthenticatedStructures.paymentsGeneral(paymentModels, false);
+        const invoices = await AuthenticatedStructures.invoices(invoiceModels);
 
         const balances = await CachedBalance.getForObjects([request.params.id], organization.id, request.params.type);
 
@@ -211,7 +102,77 @@ export class GetReceivableBalanceEndpoint extends Endpoint<Params, Query, Body,
                 ...base,
                 balanceItems,
                 payments,
+                invoices,
             }),
         );
     }
+
+    /**
+     * Builds the condition that matches all balance items that belong to this receivable balance.
+     * Requires the balance_items table to be joined in the query.
+     */
+    private static async getBalanceItemWhere(type: ReceivableBalanceType, id: string): Promise<SQLWhere> {
+        switch (type) {
+            case ReceivableBalanceType.organization:
+                return SQL.where(SQL.column(BalanceItem.table, 'payingOrganizationId'), id);
+
+            case ReceivableBalanceType.member:
+                return SQL.where(SQL.column(BalanceItem.table, 'memberId'), id);
+
+            case ReceivableBalanceType.user: {
+                const memberUsers = await MemberUser.select().where('usersId', id).fetch();
+                const memberIds = Formatter.uniqueArray(memberUsers.map(mu => mu.membersId));
+
+                if (memberIds.length === 0) {
+                    return SQL.where(SQL.column(BalanceItem.table, 'userId'), id);
+                }
+                return SQL.where(SQL.column(BalanceItem.table, 'userId'), id)
+                    .or(SQL.column(BalanceItem.table, 'memberId'), memberIds);
+            }
+
+            case ReceivableBalanceType.userWithoutMembers:
+                return SQL.where(SQL.column(BalanceItem.table, 'userId'), id);
+
+            case ReceivableBalanceType.registration:
+                return SQL.where(SQL.column(BalanceItem.table, 'registrationId'), id);
+        }
+    }
+
+    /**
+     * All invoices that are related to this receivable balance: invoices that invoiced one of the
+     * balance items of this receivable balance, and for organizations also invoices that are
+     * directly addressed to the paying organization.
+     */
+    private static async getInvoices(organizationId: string, type: ReceivableBalanceType, id: string, balanceItemWhere: SQLWhere): Promise<Invoice[]> {
+        const invoiceModels = await Invoice.select()
+            .where('organizationId', organizationId)
+            .join(
+                SQL.join(InvoicedBalanceItem.table)
+                    .where(SQL.column(InvoicedBalanceItem.table, 'invoiceId'), SQL.column(Invoice.table, 'id')),
+            )
+            .join(
+                SQL.join(BalanceItem.table)
+                    .where(SQL.column(InvoicedBalanceItem.table, 'balanceItemId'), SQL.column(BalanceItem.table, 'id')),
+            )
+            .andWhere(balanceItemWhere)
+            .groupBy(SQL.column(Invoice.table, 'id'))
+            .fetch();
+
+        if (type === ReceivableBalanceType.organization) {
+            const directInvoices = await Invoice.select()
+                .where('organizationId', organizationId)
+                .where('payingOrganizationId', id)
+                .fetch();
+
+            for (const invoice of directInvoices) {
+                if (!invoiceModels.some(i => i.id === invoice.id)) {
+                    invoiceModels.push(invoice);
+                }
+            }
+        }
+
+        // Oldest first
+        invoiceModels.sort((a, b) => Sorter.byDateValue(b.invoicedAt ?? b.createdAt, a.invoicedAt ?? a.createdAt));
+        return invoiceModels;
+    }
 }