@stamhoofd/backend 2.113.0 → 2.114.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.113.0",
+    "version": "2.114.1",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -54,14 +54,14 @@
         "@simonbackx/simple-encoding": "2.23.1",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.113.0",
-        "@stamhoofd/backend-middleware": "2.113.0",
-        "@stamhoofd/email": "2.113.0",
-        "@stamhoofd/models": "2.113.0",
-        "@stamhoofd/queues": "2.113.0",
-        "@stamhoofd/sql": "2.113.0",
-        "@stamhoofd/structures": "2.113.0",
-        "@stamhoofd/utility": "2.113.0",
+        "@stamhoofd/backend-i18n": "2.114.1",
+        "@stamhoofd/backend-middleware": "2.114.1",
+        "@stamhoofd/email": "2.114.1",
+        "@stamhoofd/models": "2.114.1",
+        "@stamhoofd/queues": "2.114.1",
+        "@stamhoofd/sql": "2.114.1",
+        "@stamhoofd/structures": "2.114.1",
+        "@stamhoofd/utility": "2.114.1",
         "archiver": "^7.0.1",
         "axios": "^1.13.2",
         "cookie": "^0.7.0",
@@ -79,5 +79,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "e90b56b0e379e4bc7f7138cef336c267fb5e9bcf"
+    "gitHead": "0394c203f4133023b2a813d96554ea8b4a0a73d8"
 }

package/src/boot.ts

@@ -132,6 +132,7 @@ export const boot = async (options: { killProcess: boolean }) => {
     await import('./email-recipient-loaders/receivable-balances');
     await import('./excel-loaders/registrations');
     await import('./email-recipient-loaders/documents');
+    await import ('./email-recipient-loaders/payments');
 
     productionLog('Opening port...');
     routerServer.listen(STAMHOOFD.PORT ?? 9090);

package/src/email-recipient-loaders/payments.ts

@@ -0,0 +1,325 @@
+import { Email, Member, MemberResponsibilityRecord, Order, Organization, User } from '@stamhoofd/models';
+import { compileToSQLFilter } from '@stamhoofd/sql';
+import { EmailRecipient, EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, Replacement, StamhoofdFilter } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { GetPaymentsEndpoint } from '../endpoints/organization/dashboard/payments/GetPaymentsEndpoint.js';
+import { memberResponsibilityRecordFilterCompilers } from '../sql-filters/member-responsibility-records.js';
+
+async function getRecipients(result: PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>, type: EmailRecipientFilterType.Payment | EmailRecipientFilterType.PaymentOrganization, subFilter: StamhoofdFilter | null) {
+    const recipients: EmailRecipient[] = [];
+    const userIds: { userId: string; payment: PaymentGeneral }[] = [];
+    const organizationIds: { organizationId: string; payment: PaymentGeneral }[] = [];
+    const memberIds: { memberId: string; payment: PaymentGeneral }[] = [];
+    const orderIds: { orderId: string; payment: PaymentGeneral }[] = [];
+
+    for (const payment of result.results) {
+        if (payment.payingOrganizationId) {
+            organizationIds.push({ organizationId: payment.payingOrganizationId, payment });
+            continue;
+        }
+
+        if (payment.payingUserId) {
+            userIds.push({ userId: payment.payingUserId, payment });
+            continue;
+        }
+
+        const balanceItemOrganizationIds = new Set<string>();
+        const balanceItemUserIds = new Set<string>();
+        const balanceItemMemberIds = new Set<string>();
+        const balanceItemOrderIds = new Set<string>();
+
+        for (const balanceItemPayment of payment.balanceItemPayments) {
+            const balanceItem = balanceItemPayment.balanceItem;
+
+            if (balanceItem.payingOrganizationId) {
+                balanceItemOrganizationIds.add(balanceItem.payingOrganizationId);
+                continue;
+            }
+
+            if (balanceItem.userId) {
+                balanceItemUserIds.add(balanceItem.userId);
+                continue;
+            }
+
+            if (balanceItem.memberId) {
+                balanceItemMemberIds.add(balanceItem.memberId);
+                continue;
+            }
+
+            if (balanceItem.orderId) {
+                balanceItemOrderIds.add(balanceItem.orderId);
+                continue;
+            }
+        }
+
+        const totalRecipientsForPayment = balanceItemOrganizationIds.size + balanceItemUserIds.size + balanceItemMemberIds.size + balanceItemOrderIds.size;
+        if (totalRecipientsForPayment > 1) {
+            console.warn('Multiple recipients found for payment: ', payment.id);
+        }
+
+        if (balanceItemOrganizationIds.size > 0) {
+            organizationIds.push(...Array.from(balanceItemOrganizationIds).map(organizationId => ({ organizationId, payment })));
+        }
+        if (balanceItemUserIds.size > 0) {
+            userIds.push(...Array.from(balanceItemUserIds).map(userId => ({ userId, payment })));
+        }
+        if (balanceItemMemberIds.size > 0) {
+            memberIds.push(...Array.from(balanceItemMemberIds).map(memberId => ({ memberId, payment })));
+        }
+        if (balanceItemOrderIds.size > 0) {
+            orderIds.push(...Array.from(balanceItemOrderIds).map(orderId => ({ orderId, payment })));
+        }
+    }
+
+    if (type === EmailRecipientFilterType.Payment) {
+        recipients.push(...await getUserRecipients(userIds));
+        recipients.push(...await getMemberRecipients(memberIds));
+        recipients.push(...await getUserRecipients(userIds));
+        recipients.push(...await getOrderRecipients(orderIds));
+    }
+    else {
+        recipients.push(...await getOrganizationRecipients(organizationIds, subFilter));
+    }
+
+    return recipients;
+}
+
+async function getUserRecipients(ids: { userId: string; payment: PaymentGeneral }[]): Promise<EmailRecipient[]> {
+    if (ids.length === 0) {
+        return [];
+    }
+
+    const allUserIds = Formatter.uniqueArray(ids.map(i => i.userId));
+    const users = await User.getByIDs(...allUserIds);
+
+    const results: EmailRecipient[] = [];
+
+    for (const { userId, payment } of ids) {
+        const user = users.find(u => u.id === userId);
+
+        if (user) {
+            results.push(EmailRecipient.create({
+                objectId: payment.id,
+                userId,
+                firstName: user.firstName,
+                lastName: user.lastName,
+                email: user.email,
+                replacements: getEmailReplacementsForPayment(payment),
+            }));
+        }
+    }
+
+    return results;
+}
+
+async function getMembersForOrganizations(organizationIds: string[], filter: StamhoofdFilter | null): Promise<Map<string, Member[]>> {
+    const query = MemberResponsibilityRecord.select()
+        .where('organizationId', organizationIds)
+        .where('endDate', null)
+        .where(await compileToSQLFilter(filter,
+            memberResponsibilityRecordFilterCompilers));
+
+    const responsibilites = await query
+        .fetch();
+
+    const allMemberIds = Formatter.uniqueArray(responsibilites.map(r => r.memberId));
+    const members = await Member.getByIDs(...allMemberIds);
+
+    const result = new Map<string, Member[]>();
+
+    for (const responsibility of responsibilites) {
+        const organizationId = responsibility.organizationId;
+
+        if (!organizationId) {
+            continue;
+        }
+
+        const member = members.find(m => m.id === responsibility.memberId);
+
+        if (!member) {
+            continue;
+        }
+
+        const membersForOrganization = result.get(organizationId);
+        if (membersForOrganization) {
+            membersForOrganization.push(member);
+        }
+        else {
+            result.set(organizationId, [member]);
+        }
+    }
+
+    return result;
+}
+
+async function getOrganizationRecipients(ids: { organizationId: string; payment: PaymentGeneral }[], subFilter: StamhoofdFilter | null): Promise<EmailRecipient[]> {
+    if (ids.length === 0 || subFilter === null) {
+        return [];
+    }
+
+    const allOrganizationIds = Formatter.uniqueArray(ids.map(i => i.organizationId));
+    const organizations = await Organization.getByIDs(...allOrganizationIds);
+    if (!organizations.length) {
+        return [];
+    }
+
+    const membersForOrganizations = await getMembersForOrganizations(allOrganizationIds, subFilter);
+
+    const results: EmailRecipient[] = [];
+
+    for (const { organizationId, payment } of ids) {
+        const organization = organizations.find(o => o.id === organizationId);
+
+        if (organization) {
+            const members = membersForOrganizations.get(organizationId);
+            if (!members) {
+                continue;
+            }
+
+            const replacements = getEmailReplacementsForPayment(payment);
+
+            for (const member of members) {
+                for (const email of member.details.getMemberEmails()) {
+                    results.push(EmailRecipient.create({
+                        objectId: payment.id,
+                        name: organization.name,
+                        memberId: member.id,
+                        firstName: member.details.firstName,
+                        lastName: member.details.lastName,
+                        email,
+                        replacements,
+                    }));
+                }
+            }
+        }
+    }
+
+    return results;
+}
+
+async function getMemberRecipients(ids: { memberId: string; payment: PaymentGeneral }[]): Promise<EmailRecipient[]> {
+    if (ids.length === 0) {
+        return [];
+    }
+
+    const allMemberIds = Formatter.uniqueArray(ids.map(i => i.memberId));
+    const members = await Member.getBlobByIds(...allMemberIds);
+
+    const results: EmailRecipient[] = [];
+
+    for (const { memberId, payment } of ids) {
+        const member = members.find(m => m.id === memberId);
+
+        if (member) {
+            const emails = member.details.getNotificationEmails();
+
+            for (const user of member.users) {
+                if (!emails.includes(user.email.toLocaleLowerCase())) {
+                    continue;
+                }
+
+                const recipient = EmailRecipient.create({
+                    objectId: payment.id,
+                    userId: user.id,
+                    memberId,
+                    firstName: user.firstName,
+                    lastName: user.lastName,
+                    email: user.email,
+                    replacements: getEmailReplacementsForPayment(payment),
+                });
+                results.push(recipient);
+            }
+        }
+    }
+
+    return results;
+}
+
+async function getOrderRecipients(ids: { orderId: string; payment: PaymentGeneral }[]): Promise<EmailRecipient[]> {
+    if (ids.length === 0) {
+        return [];
+    }
+
+    const allOrderIds = Formatter.uniqueArray(ids.map(i => i.orderId));
+    const orders = await Order.getByIDs(...allOrderIds);
+
+    const results: EmailRecipient[] = [];
+
+    for (const { orderId, payment } of ids) {
+        const order = orders.find(o => o.id === orderId);
+
+        if (order) {
+            const { firstName, lastName, email } = order.data.customer;
+
+            results.push(EmailRecipient.create({
+                objectId: payment.id,
+                userId: order.userId,
+                firstName,
+                lastName,
+                email,
+                replacements: getEmailReplacementsForPayment(payment),
+            }));
+        }
+    }
+
+    return results;
+}
+
+function getEmailReplacementsForPayment(payment: PaymentGeneral): Replacement[] {
+    // todo
+    return [];
+}
+
+async function fetchPaymentRecipients(query: LimitedFilteredRequest) {
+    const result = await GetPaymentsEndpoint.buildData(query);
+
+    return new PaginatedResponse({
+        results: await getRecipients(result, EmailRecipientFilterType.Payment, null),
+        next: result.next,
+    });
+}
+
+Email.recipientLoaders.set(EmailRecipientFilterType.Payment, {
+    fetch: fetchPaymentRecipients,
+    // For now: only count the number of payments - not the amount of emails
+    count: async (query: LimitedFilteredRequest) => {
+        const q = await GetPaymentsEndpoint.buildQuery(query);
+        const base = await q.count();
+
+        if (base < 1000) {
+            // Do full scan
+            query.limit = 1000;
+            const result = await fetchPaymentRecipients(query);
+            return result.results.length;
+        }
+
+        return base;
+    },
+});
+
+async function fetchPaymentOrganizationRecipients(query: LimitedFilteredRequest, subfilter: StamhoofdFilter | null) {
+    const result = await GetPaymentsEndpoint.buildData(query);
+
+    return new PaginatedResponse({
+        results: await getRecipients(result, EmailRecipientFilterType.PaymentOrganization, subfilter),
+        next: result.next,
+    });
+}
+
+Email.recipientLoaders.set(EmailRecipientFilterType.PaymentOrganization, {
+    fetch: fetchPaymentOrganizationRecipients,
+    // For now: only count the number of payments - not the amount of emails
+    count: async (query: LimitedFilteredRequest, subfilter: StamhoofdFilter | null) => {
+        const q = await GetPaymentsEndpoint.buildQuery(query);
+        const base = await q.count();
+
+        if (base < 1000) {
+            // Do full scan
+            query.limit = 1000;
+            const result = await fetchPaymentOrganizationRecipients(query, subfilter);
+            return result.results.length;
+        }
+
+        return base;
+    },
+});

package/src/email-recipient-loaders/registrations.ts

@@ -1,8 +1,8 @@
 import { Email, Member } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
 import { EmailRecipient, EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, RegistrationsBlob, mergeFilters } from '@stamhoofd/structures';
-import { GetRegistrationsEndpoint } from '../endpoints/global/registration/GetRegistrationsEndpoint';
-import { memberJoin } from '../sql-filters/registrations';
+import { GetRegistrationsEndpoint } from '../endpoints/global/registration/GetRegistrationsEndpoint.js';
+import { memberJoin } from '../sql-filters/registrations.js';
 
 async function getRecipients(result: PaginatedResponse<RegistrationsBlob, LimitedFilteredRequest>, type: 'member' | 'parents' | 'unverified') {
     const recipients: EmailRecipient[] = [];
@@ -81,7 +81,7 @@ Email.recipientLoaders.set(EmailRecipientFilterType.RegistrationUnverified, {
         const q = (await GetRegistrationsEndpoint.buildQuery(query)).join(memberJoin);
 
         return await q.sum(
-            SQL.jsonLength(SQL.column('details'), '$.value.unverifiedEmails'),
+            SQL.jsonLength(SQL.column(Member.table, 'details'), '$.value.unverifiedEmails'),
         );
     },
 });

package/src/endpoints/global/email/CreateEmailEndpoint.ts

@@ -3,7 +3,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { Email, Platform, RateLimiter } from '@stamhoofd/models';
 import { EmailPreview, EmailStatus, Email as EmailStruct, EmailTemplate as EmailTemplateStruct } from '@stamhoofd/structures';
 
-import { Context } from '../../../helpers/Context';
+import { Context } from '../../../helpers/Context.js';
 import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;
@@ -128,7 +128,7 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
 
         await model.save();
         await model.buildExampleRecipient();
-        model.updateCount();
+        await model.updateCount();
 
         if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent || request.body.status === EmailStatus.Queued) {
             if (!await Context.auth.canSendEmail(model)) {

package/src/endpoints/global/email/PatchEmailEndpoint.ts

@@ -1,10 +1,10 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Email, Platform } from '@stamhoofd/models';
-import { EmailPreview, EmailStatus, Email as EmailStruct, PermissionLevel } from '@stamhoofd/structures';
+import { EmailPreview, EmailRecipientsStatus, EmailStatus, Email as EmailStruct, PermissionLevel } from '@stamhoofd/structures';
 
 import { AutoEncoderPatchType, Decoder, patchObject } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Context } from '../../../helpers/Context';
+import { Context } from '../../../helpers/Context.js';
 
 type Params = { id: string };
 type Query = undefined;
@@ -124,6 +124,15 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                 });
             }
 
+            if (model.recipientsStatus === EmailRecipientsStatus.Created) {
+                throw new SimpleError({
+                    code: 'already_created',
+                    message: 'Recipients already created',
+                    human: $t(`457ecdaf-d1de-4136-9e82-682c18c5fa76`),
+                    statusCode: 400,
+                });
+            }
+
             model.recipientFilter = patchObject(model.recipientFilter, request.body.recipientFilter);
             rebuild = true;
         }
@@ -168,10 +177,7 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
 
         if (rebuild) {
             await model.buildExampleRecipient();
-
-            // Force null - because we have stale data
-            model.emailRecipientsCount = null;
-            model.updateCount();
+            await model.updateCount();
         }
 
         if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent || request.body.status === EmailStatus.Queued) {

package/src/helpers/CheckSettlements.ts

@@ -2,7 +2,7 @@ import { MolliePayment, MollieToken, Order, Organization, PayconiqPayment, Payme
 import { Settlement } from '@stamhoofd/structures';
 import axios from 'axios';
 
-import { StripePayoutChecker } from './StripePayoutChecker';
+import { StripePayoutChecker } from './StripePayoutChecker.js';
 
 type MollieSettlement = {
     id: string;
@@ -179,7 +179,7 @@ async function updateSettlement(token: string, settlement: MollieSettlement, fro
                         id: settlement.id,
                         reference: settlement.reference,
                         settledAt: new Date(settlement.settledAt),
-                        amount: Math.round(parseFloat(settlement.amount.value) * 100),
+                        amount: Math.round(parseFloat(settlement.amount.value) * 100) * 100,
                     });
                     const saved = await payment.save();
 

package/src/helpers/StripePayoutChecker.ts

@@ -171,8 +171,8 @@ export class StripePayoutChecker {
             return;
         }
 
-        if (payment.price !== balanceItem.amount) {
-            console.log('Amount mismatch for payment ' + payment.id + ': ' + payment.price + ' !== ' + balanceItem.amount);
+        if (payment.price !== balanceItem.amount * 100) {
+            console.log('Amount mismatch for payment ' + payment.id + ': ' + payment.price + ' !== ' + (balanceItem.amount * 100));
             return;
         }
 
@@ -180,13 +180,13 @@ export class StripePayoutChecker {
             id: payout.id,
             reference: payout.statement_descriptor ?? '',
             settledAt: new Date(payout.arrival_date * 1000),
-            amount: payout.amount,
+            amount: payout.amount * 100,
             // Set only if application fee is witheld
-            fee: totalFees,
+            fee: totalFees * 100,
         });
 
         payment.settlement = settlement;
-        payment.transferFee = totalFees - payment.serviceFeePayout;
+        payment.transferFee = totalFees * 100 - payment.serviceFeePayout;
 
         // Force an updatedAt timestamp of the related order
         // Mark order as 'updated', or the frontend won't pull in the updates

package/src/{seeds → seeds-temporary}/1769088653-uitpas-status.ts

@@ -91,14 +91,9 @@ async function migrateMember(member: Member) {
             if (error.hasCode('https://api.publiq.be/probs/uitpas/pass-not-found') || error.hasCode('https://api.publiq.be/probs/uitpas/invalid-uitpas-number')) {
                 console.log(`Uitpas number ${member.details.uitpasNumberDetails?.uitpasNumber} is not known by the uitpas api for member with id ${member.id}.`);
 
-                // set updated at
-                if (member.details.uitpasNumberDetails) {
-                    member.details.uitpasNumberDetails.socialTariff = UitpasSocialTariff.create({
-                        status: UitpasSocialTariffStatus.Unknown,
-                    });
-                }
-
-                // remove review
+                // remove the uitpas number
+                member.details.uitpasNumberDetails = null;
+                member.details.cleanData();
                 member.details.reviewTimes.removeReview('uitpasNumber');
                 await member.save();
 
@@ -113,6 +108,9 @@ async function migrateMember(member: Member) {
                 // remove the uitpas number
                 member.details.uitpasNumberDetails = null;
                 member.details.cleanData();
+
+                // remove review
+                member.details.reviewTimes.removeReview('uitpasNumber');
                 await member.save();
 
                 // do not throw

package/src/sql-filters/balance-item-payments.ts

@@ -24,5 +24,10 @@ export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
             type: SQLValueType.String,
             nullable: false,
         }),
+        payingOrganizationId: createColumnFilter({
+            expression: SQL.column('balance_items', 'payingOrganizationId'),
+            type: SQLValueType.String,
+            nullable: true,
+        }),
     },
 };

package/src/sql-filters/member-responsibility-records.ts

@@ -0,0 +1,16 @@
+import { MemberResponsibilityRecord } from '@stamhoofd/models';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+
+const baseTable = SQL.table(MemberResponsibilityRecord.table);
+
+/**
+ * Defines how to filter member responsibility records in the database from StamhoofdFilter objects
+ */
+export const memberResponsibilityRecordFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    responsibilityId: createColumnFilter({
+        expression: SQL.column(baseTable, 'responsibilityId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+};

package/src/sql-filters/members.ts

@@ -68,34 +68,20 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: false,
     }),
+    'details.uitpasNumberDetails.socialTariff.status': createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.uitpasNumberDetails.socialTariff.status'),
+        type: SQLValueType.JSONString,
+        nullable: true,
+        checkPermission: async () => {
+            await throwIfNoFinancialReadAccess();
+        },
+    }),
     'details.requiresFinancialSupport': createColumnFilter({
         expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.requiresFinancialSupport.value'),
         type: SQLValueType.JSONBoolean,
         nullable: true,
         checkPermission: async () => {
-            const organization = Context.organization;
-            if (!organization) {
-                if (!Context.auth.hasPlatformFullAccess()) {
-                    throw new SimpleError({
-                        code: 'permission_denied',
-                        message: 'No permissions for financial support filter.',
-                        human: $t(`64d658fa-0727-4924-9448-b243fe8e10a1`),
-                        statusCode: 400,
-                    });
-                }
-                return;
-            }
-
-            const permissions = await Context.auth.getOrganizationPermissions(organization);
-
-            if (!permissions || !permissions.hasAccessRight(AccessRight.MemberReadFinancialData)) {
-                throw new SimpleError({
-                    code: 'permission_denied',
-                    message: 'No permissions for financial support filter (organization scope).',
-                    human: $t(`64d658fa-0727-4924-9448-b243fe8e10a1`),
-                    statusCode: 400,
-                });
-            }
+            await throwIfNoFinancialReadAccess();
         },
     }),
     'email': createColumnFilter({
@@ -512,3 +498,29 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         ),
     },
 };
+
+async function throwIfNoFinancialReadAccess() {
+    const organization = Context.organization;
+    if (!organization) {
+        if (!Context.auth.hasPlatformFullAccess()) {
+            throw new SimpleError({
+                code: 'permission_denied',
+                message: 'No permissions for financial support filter.',
+                human: $t(`64d658fa-0727-4924-9448-b243fe8e10a1`),
+                statusCode: 400,
+            });
+        }
+        return;
+    }
+
+    const permissions = await Context.auth.getOrganizationPermissions(organization);
+
+    if (!permissions || !permissions.hasAccessRight(AccessRight.MemberReadFinancialData)) {
+        throw new SimpleError({
+            code: 'permission_denied',
+            message: 'No permissions for financial support filter (organization scope).',
+            human: $t(`64d658fa-0727-4924-9448-b243fe8e10a1`),
+            statusCode: 400,
+        });
+    }
+}

package/src/sql-filters/payments.ts

@@ -31,6 +31,11 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    payingOrganizationId: createColumnFilter({
+        expression: SQL.column('payingOrganizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     createdAt: createColumnFilter({
         expression: SQL.column('createdAt'),
         type: SQLValueType.Datetime,