@stamhoofd/backend 2.114.1 → 2.115.0

package/index.ts

@@ -1,5 +1,6 @@
 import backendEnv from '@stamhoofd/backend-env';
 
+process.title = 'stamhoofd-api';
 backendEnv.load({ service: 'api' }).catch((error) => {
     console.error('Failed to load environment:', error);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.114.1",
+    "version": "2.115.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -19,6 +19,7 @@
     "license": "UNLICENCED",
     "scripts": {
         "dev": "wait-on ../../shared/middleware/dist/index.js && concurrently -r 'yarn -s build --watch --preserveWatchOutput' \"yarn -s dev:watch\"",
+        "dev:full": "yarn -s dev",
         "dev:watch": "wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --watch '../../../shared/*/dist/' --watch '../../shared/*/dist/' --ext .ts,.json,.sql,.js --delay 2000ms --exec 'node --enable-source-maps ./dist/index.js' --signal SIGTERM",
         "dev:backend": "yarn -s dev",
         "build": "rm -rf ./dist/src/migrations && rm -rf ./dist/src/seeds && yarn -s copy-assets && tsc -b",
@@ -54,14 +55,14 @@
         "@simonbackx/simple-encoding": "2.23.1",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@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",
+        "@stamhoofd/backend-i18n": "2.115.0",
+        "@stamhoofd/backend-middleware": "2.115.0",
+        "@stamhoofd/email": "2.115.0",
+        "@stamhoofd/models": "2.115.0",
+        "@stamhoofd/queues": "2.115.0",
+        "@stamhoofd/sql": "2.115.0",
+        "@stamhoofd/structures": "2.115.0",
+        "@stamhoofd/utility": "2.115.0",
         "archiver": "^7.0.1",
         "axios": "^1.13.2",
         "cookie": "^0.7.0",
@@ -79,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "0394c203f4133023b2a813d96554ea8b4a0a73d8"
+    "gitHead": "b68983abee843a6d4f4460b7818d66a8780587cc"
 }

package/src/boot.ts

@@ -10,17 +10,19 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { startCrons, stopCrons, waitForCrons } from '@stamhoofd/crons';
 import { Platform } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { resumeEmails } from './helpers/EmailResumer';
-import { GlobalHelper } from './helpers/GlobalHelper';
-import { SetupStepUpdater } from './helpers/SetupStepUpdater';
-import { ContextMiddleware } from './middleware/ContextMiddleware';
-import { AuditLogService } from './services/AuditLogService';
-import { BalanceItemService } from './services/BalanceItemService';
-import { DocumentService } from './services/DocumentService';
-import { FileSignService } from './services/FileSignService';
-import { PlatformMembershipService } from './services/PlatformMembershipService';
-import { UitpasService } from './services/uitpas/UitpasService';
-import { UniqueUserService } from './services/UniqueUserService';
+import { resumeEmails } from './helpers/EmailResumer.js';
+import { GlobalHelper } from './helpers/GlobalHelper.js';
+import { SetupStepUpdater } from './helpers/SetupStepUpdater.js';
+import { ContextMiddleware } from './middleware/ContextMiddleware.js';
+import { AuditLogService } from './services/AuditLogService.js';
+import { BalanceItemService } from './services/BalanceItemService.js';
+import { DocumentService } from './services/DocumentService.js';
+import { FileSignService } from './services/FileSignService.js';
+import { PlatformMembershipService } from './services/PlatformMembershipService.js';
+import { UitpasService } from './services/uitpas/UitpasService.js';
+import { UniqueUserService } from './services/UniqueUserService.js';
+import { CpuService } from './services/CpuService.js';
+import { SQLLogger } from '@stamhoofd/sql';
 
 process.on('unhandledRejection', (error: Error) => {
     console.error('unhandledRejection');
@@ -123,16 +125,16 @@ export const boot = async (options: { killProcess: boolean }) => {
     productionLog('Loading loaders...');
 
     // Register Excel loaders
-    await import('./excel-loaders');
+    await import('./excel-loaders/index.js');
 
     // Register Email Recipient loaders
-    await import('./email-recipient-loaders/members');
-    await import('./email-recipient-loaders/registrations');
-    await import('./email-recipient-loaders/orders');
-    await import('./email-recipient-loaders/receivable-balances');
-    await import('./excel-loaders/registrations');
-    await import('./email-recipient-loaders/documents');
-    await import ('./email-recipient-loaders/payments');
+    await import('./email-recipient-loaders/members.js');
+    await import('./email-recipient-loaders/registrations.js');
+    await import('./email-recipient-loaders/orders.js');
+    await import('./email-recipient-loaders/receivable-balances.js');
+    await import('./excel-loaders/registrations.js');
+    await import('./email-recipient-loaders/documents.js');
+    await import ('./email-recipient-loaders/payments.js');
 
     productionLog('Opening port...');
     routerServer.listen(STAMHOOFD.PORT ?? 9090);
@@ -142,6 +144,14 @@ export const boot = async (options: { killProcess: boolean }) => {
 
     resumeEmails().catch(console.error);
 
+    if (STAMHOOFD.environment !== 'development' && STAMHOOFD.environment !== 'test') {
+        CpuService.startMonitoring();
+    }
+    else if (STAMHOOFD.environment === 'development') {
+        SQLLogger.slowQueryThresholdMs = 200;
+        SQLLogger.explainAllAndLogInefficient = true;
+    }
+
     if (routerServer.server) {
         // Default timeout is a bit too short
         routerServer.server.timeout = 61000;
@@ -235,7 +245,7 @@ export const boot = async (options: { killProcess: boolean }) => {
     }
 
     // Register crons
-    await import('./crons');
+    await import('./crons.js');
 
     AuditLogService.listen();
     PlatformMembershipService.listen();

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

@@ -47,20 +47,7 @@ async function fetch(query: LimitedFilteredRequest) {
 async function count(request: LimitedFilteredRequest) {
     const query = await GetDocumentsEndpoint.buildQuery(request);
     const uniqueMemberIds = await query.count(SQL.distinct(SQL.column('memberId')));
-
-    if (uniqueMemberIds > 100 || uniqueMemberIds === 0) {
-        return uniqueMemberIds; // rough estimate
-    }
-    // do full count
-    request.limit = 100;
-    let count = 0;
-    let req: LimitedFilteredRequest | null = request;
-    while (req) {
-        const result = await fetch(request);
-        count += result.results.length;
-        req = result.next ?? null;
-    }
-    return count;
+    return uniqueMemberIds;
 };
 
 Email.recipientLoaders.set(EmailRecipientFilterType.Documents, { fetch, count });

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

@@ -1,11 +1,20 @@
-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 { BalanceItem, BalanceItemPayment, Email, Member, MemberResponsibilityRecord, Order, Organization, Payment, RecipientLoader, User, Webshop } from '@stamhoofd/models';
+import { compileToSQLFilter, SQL } from '@stamhoofd/sql';
+import { BalanceItemRelationType, BalanceItemType, CountFilteredRequest, EmailRecipient, EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, PaymentMethod, PaymentMethodHelper, Replacement, StamhoofdFilter, Webshop as WebshopStruct } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { GetPaymentsEndpoint } from '../endpoints/organization/dashboard/payments/GetPaymentsEndpoint.js';
+import { createOrderDataHTMLTable, createPaymentDataHTMLTable } from '../helpers/email-html-helpers.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) {
+type ReplacementsOptions = {
+    shouldAddReplacementsForOrder: boolean;
+    shouldAddReplacementsForTransfers: boolean;
+    orderMap: Map<string, Order>;
+    webshopMap: Map<string, Webshop>;
+    organizationMap: Map<string, Organization>;
+};
+
+async function getRecipients(result: PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>, type: EmailRecipientFilterType.Payment | EmailRecipientFilterType.PaymentOrganization, subFilter: StamhoofdFilter | null, beforeFetchAllResult: BeforeFetchAllResult | undefined) {
     const recipients: EmailRecipient[] = [];
     const userIds: { userId: string; payment: PaymentGeneral }[] = [];
     const organizationIds: { organizationId: string; payment: PaymentGeneral }[] = [];
@@ -71,20 +80,58 @@ async function getRecipients(result: PaginatedResponse<PaymentGeneral[], Limited
         }
     }
 
+    // get all orders linked to the payments
+    const allOrderIdsSet = new Set<string>();
+    const allWebshopIdsSet = new Set<string>();
+    const organizationIdsForOrdersSet = new Set<string>();
+
+    for (const payment of result.results) {
+        payment.webshopIds.forEach(id => allWebshopIdsSet.add(id));
+
+        for (const balanceItemPayment of payment.balanceItemPayments) {
+            const balanceItem = balanceItemPayment.balanceItem;
+            if (balanceItem.orderId) {
+                allOrderIdsSet.add(balanceItem.orderId);
+
+                // only important if balance item has order
+                organizationIdsForOrdersSet.add(balanceItem.organizationId);
+            }
+        }
+    }
+
+    // get all orders (for replacements later)
+    const orders = await Order.getByIDs(...allOrderIdsSet);
+    const orderMap = new Map<string, Order>(orders.map(o => [o.id, o] as [string, Order]));
+
+    // get all webshops (for replacements later)
+    const webshops = await Webshop.getByIDs(...allWebshopIdsSet);
+    const webshopMap = new Map<string, Webshop>(webshops.map(w => [w.id, w] as [string, Webshop]));
+
+    // get all organizations (for replacements later)
+    const organizations = await Organization.getByIDs(...organizationIdsForOrdersSet);
+    const organizationMap = new Map<string, Organization>(organizations.map(o => [o.id, o] as [string, Organization]));
+
+    const replacementOptions: ReplacementsOptions = {
+        shouldAddReplacementsForOrder: beforeFetchAllResult ? !beforeFetchAllResult.doesIncludePaymentWithoutOrders : false,
+        shouldAddReplacementsForTransfers: beforeFetchAllResult ? beforeFetchAllResult.areAllPaymentsTransfers : false,
+        orderMap,
+        webshopMap,
+        organizationMap,
+    };
+
     if (type === EmailRecipientFilterType.Payment) {
-        recipients.push(...await getUserRecipients(userIds));
-        recipients.push(...await getMemberRecipients(memberIds));
-        recipients.push(...await getUserRecipients(userIds));
-        recipients.push(...await getOrderRecipients(orderIds));
+        recipients.push(...await getUserRecipients(userIds, replacementOptions));
+        recipients.push(...await getMemberRecipients(memberIds, replacementOptions));
+        recipients.push(...await getOrderRecipients(orderIds, replacementOptions));
     }
     else {
-        recipients.push(...await getOrganizationRecipients(organizationIds, subFilter));
+        recipients.push(...await getOrganizationRecipients(organizationIds, replacementOptions, subFilter));
     }
 
     return recipients;
 }
 
-async function getUserRecipients(ids: { userId: string; payment: PaymentGeneral }[]): Promise<EmailRecipient[]> {
+async function getUserRecipients(ids: { userId: string; payment: PaymentGeneral }[], replacementOptions: ReplacementsOptions): Promise<EmailRecipient[]> {
     if (ids.length === 0) {
         return [];
     }
@@ -104,7 +151,7 @@ async function getUserRecipients(ids: { userId: string; payment: PaymentGeneral
                 firstName: user.firstName,
                 lastName: user.lastName,
                 email: user.email,
-                replacements: getEmailReplacementsForPayment(payment),
+                replacements: getEmailReplacementsForPayment(payment, replacementOptions),
             }));
         }
     }
@@ -152,15 +199,19 @@ async function getMembersForOrganizations(organizationIds: string[], filter: Sta
     return result;
 }
 
-async function getOrganizationRecipients(ids: { organizationId: string; payment: PaymentGeneral }[], subFilter: StamhoofdFilter | null): Promise<EmailRecipient[]> {
+async function getOrganizationRecipients(ids: { organizationId: string; payment: PaymentGeneral }[], replacementOptions: ReplacementsOptions, 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 organizationMap = replacementOptions.organizationMap;
+
+    // fetch organizations that are not in map yet
+    const fetchedOrganizations = await Organization.getByIDs(...allOrganizationIds.filter(id => !organizationMap.has(id)));
+
+    for (const organization of fetchedOrganizations) {
+        organizationMap.set(organization.id, organization);
     }
 
     const membersForOrganizations = await getMembersForOrganizations(allOrganizationIds, subFilter);
@@ -168,7 +219,7 @@ async function getOrganizationRecipients(ids: { organizationId: string; payment:
     const results: EmailRecipient[] = [];
 
     for (const { organizationId, payment } of ids) {
-        const organization = organizations.find(o => o.id === organizationId);
+        const organization = organizationMap.get(organizationId);
 
         if (organization) {
             const members = membersForOrganizations.get(organizationId);
@@ -176,7 +227,7 @@ async function getOrganizationRecipients(ids: { organizationId: string; payment:
                 continue;
             }
 
-            const replacements = getEmailReplacementsForPayment(payment);
+            const replacements = getEmailReplacementsForPayment(payment, replacementOptions);
 
             for (const member of members) {
                 for (const email of member.details.getMemberEmails()) {
@@ -197,7 +248,7 @@ async function getOrganizationRecipients(ids: { organizationId: string; payment:
     return results;
 }
 
-async function getMemberRecipients(ids: { memberId: string; payment: PaymentGeneral }[]): Promise<EmailRecipient[]> {
+async function getMemberRecipients(ids: { memberId: string; payment: PaymentGeneral }[], replacementOptions: ReplacementsOptions): Promise<EmailRecipient[]> {
     if (ids.length === 0) {
         return [];
     }
@@ -225,7 +276,7 @@ async function getMemberRecipients(ids: { memberId: string; payment: PaymentGene
                     firstName: user.firstName,
                     lastName: user.lastName,
                     email: user.email,
-                    replacements: getEmailReplacementsForPayment(payment),
+                    replacements: getEmailReplacementsForPayment(payment, replacementOptions),
                 });
                 results.push(recipient);
             }
@@ -235,18 +286,16 @@ async function getMemberRecipients(ids: { memberId: string; payment: PaymentGene
     return results;
 }
 
-async function getOrderRecipients(ids: { orderId: string; payment: PaymentGeneral }[]): Promise<EmailRecipient[]> {
+async function getOrderRecipients(ids: { orderId: string; payment: PaymentGeneral }[], replacementOptions: ReplacementsOptions): Promise<EmailRecipient[]> {
     if (ids.length === 0) {
         return [];
     }
 
-    const allOrderIds = Formatter.uniqueArray(ids.map(i => i.orderId));
-    const orders = await Order.getByIDs(...allOrderIds);
-
+    const orderMap = replacementOptions.orderMap;
     const results: EmailRecipient[] = [];
 
     for (const { orderId, payment } of ids) {
-        const order = orders.find(o => o.id === orderId);
+        const order = orderMap.get(orderId);
 
         if (order) {
             const { firstName, lastName, email } = order.data.customer;
@@ -257,7 +306,7 @@ async function getOrderRecipients(ids: { orderId: string; payment: PaymentGenera
                 firstName,
                 lastName,
                 email,
-                replacements: getEmailReplacementsForPayment(payment),
+                replacements: getEmailReplacementsForPayment(payment, replacementOptions),
             }));
         }
     }
@@ -265,24 +314,223 @@ async function getOrderRecipients(ids: { orderId: string; payment: PaymentGenera
     return results;
 }
 
-function getEmailReplacementsForPayment(payment: PaymentGeneral): Replacement[] {
-    // todo
-    return [];
+function getEmailReplacementsForPayment(payment: PaymentGeneral, options: ReplacementsOptions): Replacement[] {
+    const { orderMap, webshopMap, organizationMap, shouldAddReplacementsForOrder, shouldAddReplacementsForTransfers } = options;
+    const orderIds = new Set<string>();
+
+    for (const balanceItemPayment of payment.balanceItemPayments) {
+        const orderId = balanceItemPayment.balanceItem.orderId;
+        if (orderId) {
+            orderIds.add(orderId);
+        }
+    }
+
+    // will be set if only 1 order is linked
+    let singleOrder: Order | null = null;
+
+    if (orderIds.size === 1) {
+        const singleOrderId = [...orderIds][0];
+        if (singleOrderId) {
+            const order = orderMap.get(singleOrderId);
+
+            if (order) {
+                singleOrder = order;
+            }
+        }
+    }
+
+    let orderUrlReplacement: Replacement | null = null;
+
+    // add replacement for order url if only 1 order is linked
+    if (singleOrder && shouldAddReplacementsForOrder) {
+        const webshop = webshopMap.get(singleOrder.webshopId);
+        const organization = organizationMap.get(singleOrder.organizationId);
+
+        if (webshop && organization) {
+            const webshopStruct = WebshopStruct.create(webshop);
+
+            orderUrlReplacement = Replacement.create({
+                token: 'orderUrl',
+                value: 'https://' + webshopStruct.getUrl(organization) + '/order/' + (singleOrder.id),
+            });
+        }
+    }
+
+    const createPaymentDataHtml = () => {
+        if (singleOrder) {
+            const webshop = webshopMap.get(singleOrder.webshopId);
+            if (webshop) {
+                return createOrderDataHTMLTable(singleOrder, webshop);
+            }
+        }
+
+        return createPaymentDataHTMLTable(payment);
+    };
+
+    const paymentDataHtml = createPaymentDataHtml();
+    const paymentDataReplacement = paymentDataHtml
+        ? Replacement.create({
+                token: 'paymentData',
+                value: '',
+                html: paymentDataHtml,
+            })
+        : null;
+
+    return ([
+        Replacement.create({
+            token: 'paymentPrice',
+            value: Formatter.price(payment.price),
+        }),
+        Replacement.create({
+            token: 'paymentMethod',
+            value: PaymentMethodHelper.getName(payment.method ?? PaymentMethod.Unknown),
+        }),
+        ...(shouldAddReplacementsForTransfers
+            ? [
+                    Replacement.create({
+                        token: 'transferDescription',
+                        value: (payment.transferDescription ?? ''),
+                    }),
+                    Replacement.create({
+                        token: 'transferBankAccount',
+                        value: payment.transferSettings?.iban ?? '',
+                    }),
+                    Replacement.create({
+                        token: 'transferBankCreditor',
+                        // todo?
+                        value: payment.transferSettings?.creditor ?? (payment.organizationId ? organizationMap.get(payment.organizationId)?.name : ''),
+                    }),
+                ]
+            : []),
+
+        Replacement.create({
+            token: 'balanceItemPaymentsTable',
+            value: '',
+            // todo: unbox orders?
+            html: payment.getBalanceItemPaymentsHtmlTable(),
+        }),
+        Replacement.create({
+            token: 'paymentTable',
+            value: '',
+            html: payment.getHTMLTable(),
+        }),
+        Replacement.create({
+            token: 'overviewContext',
+            value: getPaymentContext(payment, options),
+        }),
+        orderUrlReplacement,
+        paymentDataReplacement,
+    ]).filter(replacementOrNull => replacementOrNull !== null);
+}
+
+function getPaymentContext(payment: PaymentGeneral, { orderMap, webshopMap }: ReplacementsOptions) {
+    const overviewContext = new Set<string>();
+    const registrationMemberNames = new Set<string>();
+
+    // only add to context if type is order or registration
+    for (const balanceItemPayment of payment.balanceItemPayments) {
+        const balanceItem = balanceItemPayment.balanceItem;
+        const type = balanceItem.type;
+
+        switch (type) {
+            case BalanceItemType.Order: {
+                if (balanceItem.orderId) {
+                    const order = orderMap.get(balanceItem.orderId);
+
+                    if (order) {
+                        const webshop = webshopMap.get(order.webshopId);
+                        if (webshop) {
+                            overviewContext.add($t('{webshop} (bestelling {orderNumber})', {
+                                webshop: webshop.meta.name,
+                                orderNumber: order.number ?? '',
+                            }));
+                        }
+                        else {
+                            overviewContext.add($t('Bestelling {orderNumber}', {
+                                orderNumber: order.number ?? '',
+                            }));
+                        }
+                    }
+                }
+                break;
+            }
+            case BalanceItemType.Registration: {
+                const memberName = balanceItem.relations.get(BalanceItemRelationType.Member)?.name.toString();
+                if (memberName) {
+                    registrationMemberNames.add(memberName);
+                }
+                else {
+                    overviewContext.add(balanceItem.itemTitle);
+                }
+
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+    }
+
+    if (registrationMemberNames.size > 0) {
+        const memberNames = Formatter.joinLast([...registrationMemberNames], ', ', ' ' + $t(`6a156458-b396-4d0f-b562-adb3e38fc51b`) + ' ');
+        overviewContext.add($t(`01d5fd7e-2960-4eb4-ab3a-2ac6dcb2e39c`) + ' ' + memberNames);
+    }
+
+    if (overviewContext.size === 0) {
+        // add item title if no balance items with type order or registration
+        if (payment.balanceItemPayments.length === 1) {
+            const balanceItem = payment.balanceItemPayments[0].balanceItem;
+            return balanceItem.itemTitle;
+        }
+
+        if (payment.balanceItemPayments.length > 1) {
+            // return title if all balance items have the same title
+            const firstTitle = payment.balanceItemPayments[0].balanceItem.itemTitle;
+            const haveAllSameTitle = payment.balanceItemPayments.every(p => p.balanceItem.itemTitle === firstTitle);
+
+            if (haveAllSameTitle) {
+                return `${firstTitle} (${payment.balanceItemPayments.length}x)`;
+            }
+
+            // else return default text for multiple items
+            return $t('Betaling voor {count} items', { count: payment.balanceItemPayments.length });
+        }
+
+        // else return default text for single item
+        return $t('Betaling voor 1 item');
+    }
+
+    // join texts for balance items with type order or registration
+    return [...overviewContext].join(', ');
 }
 
-async function fetchPaymentRecipients(query: LimitedFilteredRequest) {
+type BeforeFetchAllResult = {
+    doesIncludePaymentWithoutOrders: boolean;
+    areAllPaymentsTransfers: boolean;
+};
+
+async function fetchPaymentRecipients(query: LimitedFilteredRequest, beforeFetchAllResult?: BeforeFetchAllResult) {
     const result = await GetPaymentsEndpoint.buildData(query);
 
     return new PaginatedResponse({
-        results: await getRecipients(result, EmailRecipientFilterType.Payment, null),
+        results: await getRecipients(result, EmailRecipientFilterType.Payment, null, beforeFetchAllResult),
         next: result.next,
     });
 }
 
-Email.recipientLoaders.set(EmailRecipientFilterType.Payment, {
-    fetch: fetchPaymentRecipients,
+const paymentRecipientLoader: RecipientLoader<BeforeFetchAllResult> = {
+    beforeFetchAll: async (query: LimitedFilteredRequest) => {
+        const doesIncludePaymentWithoutOrders = await doesQueryIncludePaymentsWithoutOrder(query);
+        const areAllPaymentsTransfers = await doesQueryIncludePaymentsOtherThanTransfers(query);
+
+        return {
+            doesIncludePaymentWithoutOrders,
+            areAllPaymentsTransfers,
+        };
+    },
+    fetch: async (query: LimitedFilteredRequest, _subfilter, beforeFetchAllResult) => fetchPaymentRecipients(query, beforeFetchAllResult),
     // For now: only count the number of payments - not the amount of emails
-    count: async (query: LimitedFilteredRequest) => {
+    count: async (query: LimitedFilteredRequest, _subfilter) => {
         const q = await GetPaymentsEndpoint.buildQuery(query);
         const base = await q.count();
 
@@ -295,31 +543,78 @@ Email.recipientLoaders.set(EmailRecipientFilterType.Payment, {
 
         return base;
     },
-});
+};
 
-async function fetchPaymentOrganizationRecipients(query: LimitedFilteredRequest, subfilter: StamhoofdFilter | null) {
+Email.recipientLoaders.set(EmailRecipientFilterType.Payment, paymentRecipientLoader);
+
+async function doesQueryIncludePaymentsWithoutOrder(filterRequest: LimitedFilteredRequest) {
+    // create count request (without limit and page filter)
+    const countRequest = new CountFilteredRequest({
+        filter: filterRequest.filter,
+        search: filterRequest.search,
+    });
+
+    const baseQuery = await GetPaymentsEndpoint.buildQuery(countRequest);
+
+    const balanceItemPaymentsJoin = SQL.innerJoin(BalanceItemPayment.table)
+        .where(
+            SQL.column(BalanceItemPayment.table, 'paymentId'),
+            SQL.column(Payment.table, 'id'),
+        );
+
+    const balanceItemJoin = SQL.innerJoin(BalanceItem.table)
+        .where(
+            SQL.column(BalanceItem.table, 'id'),
+            SQL.column(BalanceItemPayment.table, 'balanceItemId'),
+        );
+
+    // check if 1 payment without order
+    const results = await baseQuery
+        .join(balanceItemPaymentsJoin)
+        .join(balanceItemJoin)
+        // where no order
+        .where(SQL.column(BalanceItem.table, 'orderId'), null)
+        .limit(1)
+        .count();
+
+    return results > 0;
+}
+
+async function doesQueryIncludePaymentsOtherThanTransfers(filterRequest: LimitedFilteredRequest) {
+    // create count request (without limit and page filter)
+    const countRequest = new CountFilteredRequest({
+        filter: filterRequest.filter,
+        search: filterRequest.search,
+    });
+
+    const baseQuery = await GetPaymentsEndpoint.buildQuery(countRequest);
+
+    // check if 1 payment with other method than transfer
+    const results = await baseQuery
+        // where method is not transfer
+        .whereNot(SQL.column(Payment.table, 'method'), PaymentMethod.Transfer)
+        .limit(1)
+        .count();
+
+    return results === 0;
+}
+
+async function fetchPaymentOrganizationRecipients(query: LimitedFilteredRequest, subfilter: StamhoofdFilter | null, beforeFetchAllResult?: BeforeFetchAllResult) {
     const result = await GetPaymentsEndpoint.buildData(query);
 
     return new PaginatedResponse({
-        results: await getRecipients(result, EmailRecipientFilterType.PaymentOrganization, subfilter),
+        results: await getRecipients(result, EmailRecipientFilterType.PaymentOrganization, subfilter, beforeFetchAllResult),
         next: result.next,
     });
 }
 
-Email.recipientLoaders.set(EmailRecipientFilterType.PaymentOrganization, {
-    fetch: fetchPaymentOrganizationRecipients,
+const paymentOrganizationRecipientLoader: RecipientLoader<BeforeFetchAllResult> = {
+    fetch: async (query: LimitedFilteredRequest, subfilter: StamhoofdFilter | null, beforeFetchAllResult) => fetchPaymentOrganizationRecipients(query, subfilter, beforeFetchAllResult),
     // 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;
+        return await q.count();
     },
-});
+};
+
+Email.recipientLoaders.set(EmailRecipientFilterType.PaymentOrganization, paymentOrganizationRecipientLoader);