@stamhoofd/backend 2.120.5 → 2.121.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.120.5",
+    "version": "2.121.0",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -31,7 +31,7 @@
         "dev": "wait-on ../../shared/middleware/dist/index.js && concurrently -r 'yarn -s build --watch --preserveWatchOutput' \"yarn -s dev:watch\"",
         "dev:build": "yarn -s build",
         "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:watch": "wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --watch '../../../shared/*/dist/' --watch '../../../shared/*/package.json' --watch '../../shared/*/dist/' --watch '../../shared/*/package.json' --ext .ts,.json,.sql,.js,.html --delay 2000ms --exec 'echo \"Restarting API...\" && node --enable-source-maps ./dist/index.js' --signal SIGTERM",
         "dev:backend": "yarn -s dev",
         "build": "tsc --build tsconfig.build.json --clean && yarn -s copy-assets && tsc --build tsconfig.build.json",
         "copy-assets": "rsync --delete --mkpath --exclude='*.ts' --exclude='*.js' --exclude='*.map' -r --checksum ./src/ ./dist/src/",
@@ -60,19 +60,19 @@
         "@aws-sdk/client-sqs": "^3.839.0",
         "@aws-sdk/s3-request-presigner": "^3.839.0",
         "@bwip-js/node": "^4.5.1",
-        "@mollie/api-client": "4.3.3",
+        "@mollie/api-client": "4.5.0",
         "@simonbackx/simple-database": "1.36.12",
         "@simonbackx/simple-encoding": "2.26.6",
         "@simonbackx/simple-endpoints": "1.21.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.120.5",
-        "@stamhoofd/backend-middleware": "2.120.5",
-        "@stamhoofd/email": "2.120.5",
-        "@stamhoofd/models": "2.120.5",
-        "@stamhoofd/queues": "2.120.5",
-        "@stamhoofd/sql": "2.120.5",
-        "@stamhoofd/structures": "2.120.5",
-        "@stamhoofd/utility": "2.120.5",
+        "@stamhoofd/backend-i18n": "2.121.0",
+        "@stamhoofd/backend-middleware": "2.121.0",
+        "@stamhoofd/email": "2.121.0",
+        "@stamhoofd/models": "2.121.0",
+        "@stamhoofd/queues": "2.121.0",
+        "@stamhoofd/sql": "2.121.0",
+        "@stamhoofd/structures": "2.121.0",
+        "@stamhoofd/utility": "2.121.0",
         "archiver": "^7.0.1",
         "axios": "^1.13.2",
         "cookie": "^0.7.0",
@@ -90,5 +90,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "5c4a1e159033bd2bfb2f6f3c60c9b03bd89c9291"
+    "gitHead": "11a280f3924b9eaab5af78f265216c774df69266"
 }

package/src/audit-logs/RegistrationInvitationLogger.ts

@@ -0,0 +1,46 @@
+import { Group, Member, RegistrationInvitation } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger.js';
+
+const defaultGenerator = getDefaultGenerator<RegistrationInvitation>({
+        created: AuditLogType.RegistrationInvitationAdded,
+        deleted: AuditLogType.RegistrationInvitationDeleted,
+});
+
+export const RegistrationInvitationLogger = new ModelLogger(RegistrationInvitation, {
+        async optionsGenerator(event) {
+            const result = await defaultGenerator(event);
+            if (!result) {
+                return;
+            }
+    
+            const member = await Member.getByID(event.model.memberId);
+            const group = await Group.getByID(event.model.groupId);
+    
+            if (!member || !group) {
+                return;
+            }
+    
+            return {
+                ...result,
+                data: {
+                    member,
+                    group,
+                },
+            };
+        },
+        createReplacements(_, { data }) {
+        return new Map([
+            ['m', AuditLogReplacement.create({
+                id: data.member.id,
+                value: data.member.details.name,
+                type: AuditLogReplacementType.Member,
+            })],
+            ['g', AuditLogReplacement.create({
+                id: data.group.id,
+                value: data.group.settings.name.toString(),
+                type: AuditLogReplacementType.Group,
+            })],
+        ]);
+    },
+});

package/src/audit-logs/init.ts

@@ -18,6 +18,7 @@ import { StripeAccountLogger } from './StripeAccountLogger.js';
 import { UserLogger } from './UserLogger.js';
 import { WebshopLogger } from './WebshopLogger.js';
 import { modelLogDefinitions } from '../services/AuditLogService.js';
+import { RegistrationInvitationLogger } from './RegistrationInvitationLogger.js';
 
 modelLogDefinitions.set(RegistrationLogger.model, RegistrationLogger);
 modelLogDefinitions.set(GroupLogger.model, GroupLogger);
@@ -38,3 +39,4 @@ modelLogDefinitions.set(EmailLogger.model, EmailLogger);
 modelLogDefinitions.set(EmailTemplateLogger.model, EmailTemplateLogger);
 modelLogDefinitions.set(EmailAddressLogger.model, EmailAddressLogger);
 modelLogDefinitions.set(UserLogger.model, UserLogger);
+modelLogDefinitions.set(RegistrationInvitationLogger.model, RegistrationInvitationLogger);

package/src/crons/index.ts

@@ -5,3 +5,5 @@ import './update-cached-balances.js';
 import './balance-emails.js';
 import './delete-old-email-drafts.js';
 import './delete-archived-data.js';
+import './mollie-chargebacks.js';
+import './invoices.js';

package/src/crons/invoices.ts

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

package/src/crons/mollie-chargebacks.ts

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

package/src/crons.ts

@@ -123,19 +123,22 @@ async function checkWebshopDNS() {
 
 // 11 min - 2 hours
 async function checkPayments() {
+    let timeout = 60 * 1000 * 11;
+    const methods = [
+        PaymentMethod.Bancontact, PaymentMethod.iDEAL, PaymentMethod.Payconiq, PaymentMethod.CreditCard,
+    ];
+
     if (STAMHOOFD.environment === 'development') {
-        // return;
+        // For Mollie, webhooks won't work, so we poll in the backend
+        timeout = 0;
     }
 
-    const timeout = 60 * 1000 * 11;
     const timeout2 = 60 * 1000 * 60 * 2;
 
     // TODO: only select the ID + organizationId
     const payments = await Payment.select()
         .where(
-            SQL.where('method', [
-                PaymentMethod.Bancontact, PaymentMethod.iDEAL, PaymentMethod.Payconiq, PaymentMethod.CreditCard,
-            ])
+            SQL.where('method', methods)
                 .and('status', [PaymentStatus.Created, PaymentStatus.Pending])
                 .and('createdAt', '<', new Date(new Date().getTime() - timeout))
                 .and('createdAt', '>', new Date(new Date().getTime() - timeout2)),
@@ -152,9 +155,10 @@ async function checkPayments() {
         .orderBy('createdAt', 'ASC')
         .limit(500)
         .fetch();
-
-    console.log('[DELAYED PAYMENTS] Checking pending payments: ' + payments.length);
-    await doCheckPayments(payments);
+    if (payments.length) {
+        console.log('[DELAYED PAYMENTS] Checking pending payments: ' + payments.length);
+        await doCheckPayments(payments);
+    }
 }
 
 // 2 hours - 3 days
@@ -180,8 +184,40 @@ async function checkOldPayments() {
         .limit(500)
         .fetch();
 
-    console.log('[DELAYED PAYMENTS] Checking old pending payments: ' + payments.length);
-    await doCheckPayments(payments);
+    if (payments.length) {
+        console.log('[DELAYED PAYMENTS] Checking old pending payments: ' + payments.length);
+        await doCheckPayments(payments);
+    }
+}
+
+// 5 days - 10 days
+async function checkOldDirectDebitPayments() {
+    let timeout = 60 * 1000 * 60 * 24 * 5;
+    const timeout2 = 60 * 1000 * 60 * 24 * 10;
+
+    if (STAMHOOFD.environment === 'development') {
+        // For Mollie, webhooks won't work, so we poll in the backend
+        timeout = 0;
+    }
+
+    // TODO: only select the ID + organizationId
+    const payments = await Payment.select()
+        .where(
+            SQL.where('method', [
+                PaymentMethod.DirectDebit,
+            ])
+                .and('status', [PaymentStatus.Created, PaymentStatus.Pending])
+                .and('createdAt', '<', new Date(new Date().getTime() - timeout))
+                .and('createdAt', '>', new Date(new Date().getTime() - timeout2)),
+        )
+        .orderBy('createdAt', 'ASC')
+        .limit(500)
+        .fetch();
+
+    if (payments.length) {
+        console.log('[DELAYED PAYMENTS] Checking old direct debit pending payments: ' + payments.length);
+        await doCheckPayments(payments);
+    }
 }
 
 async function doCheckPayments(payments: Payment[]) {
@@ -382,6 +418,7 @@ registerCron('checkDNS', checkDNS);
 registerCron('checkWebshopDNS', checkWebshopDNS);
 registerCron('checkPayments', checkPayments);
 registerCron('checkOldPayments', checkOldPayments);
+registerCron('checkOldDirectDebitPayments', checkOldDirectDebitPayments);
 registerCron('checkDrips', checkDrips);
 
 // Register other crons

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

@@ -14,15 +14,6 @@ type BeforeFetchAllResult = {
     areAllPaymentsTransfers: boolean;
 };
 
-async function fetchPaymentRecipients(query: LimitedFilteredRequest, subfilter: StamhoofdFilter, beforeFetchAllResult?: BeforeFetchAllResult) {
-    const result = await GetPaymentsEndpoint.buildData(query);
-
-    return new PaginatedResponse({
-        results: await getRecipients(result, EmailRecipientFilterType.Payment, subfilter, beforeFetchAllResult),
-        next: result.next,
-    });
-}
-
 const paymentRecipientLoader: RecipientLoader<BeforeFetchAllResult> = {
     beforeFetchAll: async (query: LimitedFilteredRequest) => {
         const doesIncludePaymentWithoutOrders = await doesQueryIncludePaymentsWithoutOrder(query);
@@ -39,9 +30,9 @@ const paymentRecipientLoader: RecipientLoader<BeforeFetchAllResult> = {
         const q = await GetPaymentsEndpoint.buildQuery(query);
         const base = await q.count();
 
-        if (base < 1000) {
+        if (base < 100) {
             // Do full scan
-            query.limit = 1000;
+            query.limit = 100;
             const result = await fetchPaymentRecipients(query, _subfilter);
             return result.results.length;
         }
@@ -52,6 +43,36 @@ const paymentRecipientLoader: RecipientLoader<BeforeFetchAllResult> = {
 
 Email.recipientLoaders.set(EmailRecipientFilterType.Payment, paymentRecipientLoader);
 
+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) => {
+        const q = await GetPaymentsEndpoint.buildQuery(query);
+        const base = await q.count();
+
+        if (base < 100) {
+            // Do full scan
+            query.limit = 100;
+            const result = await fetchPaymentOrganizationRecipients(query, _subfilter);
+            return result.results.length;
+        }
+
+        return base;
+    },
+};
+
+Email.recipientLoaders.set(EmailRecipientFilterType.PaymentOrganization, paymentOrganizationRecipientLoader);
+
+async function fetchPaymentRecipients(query: LimitedFilteredRequest, subfilter: StamhoofdFilter, beforeFetchAllResult?: BeforeFetchAllResult) {
+    const result = await GetPaymentsEndpoint.buildData(query);
+
+    return new PaginatedResponse({
+        results: await getRecipients(result, EmailRecipientFilterType.Payment, subfilter, beforeFetchAllResult),
+        next: result.next,
+    });
+}
+
 async function doesQueryIncludePaymentsWithoutOrder(filterRequest: LimitedFilteredRequest) {
     // create count request (without limit and page filter)
     const countRequest = new CountFilteredRequest({
@@ -113,17 +134,6 @@ async function fetchPaymentOrganizationRecipients(query: LimitedFilteredRequest,
     });
 }
 
-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);
-        return await q.count();
-    },
-};
-
-Email.recipientLoaders.set(EmailRecipientFilterType.PaymentOrganization, paymentOrganizationRecipientLoader);
-
 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 }[] = [];
@@ -273,7 +283,7 @@ async function getMembersForOrganizations(organizationIds: string[], filter: Sta
 }
 
 async function getOrganizationRecipients(ids: { organizationId: string; payment: PaymentGeneral }[], replacementOptions: ReplacementsOptions, subFilter: StamhoofdFilter | null): Promise<EmailRecipient[]> {
-    if (ids.length === 0 || subFilter === null) {
+    if (ids.length === 0) {
         return [];
     }
 
@@ -287,32 +297,65 @@ async function getOrganizationRecipients(ids: { organizationId: string; payment:
         organizationMap.set(organization.id, organization);
     }
 
-    const membersForOrganizations = await getMembersForOrganizations(allOrganizationIds, subFilter);
-
     const results: EmailRecipient[] = [];
 
-    for (const { organizationId, payment } of ids) {
-        const organization = organizationMap.get(organizationId);
+    if (subFilter === null) {
+        // Use full admins instead
+        const admins = await User.getAdmins(allOrganizationIds, {verified: true});
+        for (const { organizationId, payment } of ids) {
+            const organization = organizationMap.get(organizationId);
+            if (!organization) {
+                continue;
+            }
+            const users = admins.filter(a => a.permissions?.forOrganization(organization)?.hasFullAccess());
 
-        if (organization) {
-            const members = membersForOrganizations.get(organizationId);
-            if (!members) {
+            if (users.length === 0) {
+                console.warn('No admins found for organization with id ', organizationId, ' while fetching email recipients for payment with id ', payment.id);
                 continue;
             }
 
             const replacements = getEmailReplacementsForPayment(payment, replacementOptions);
 
-            for (const member of members) {
-                for (const email of member.details.getNotificationEmails()) {
-                    results.push(EmailRecipient.create({
-                        objectId: payment.id,
-                        name: organization.name,
-                        memberId: member.id,
-                        firstName: member.details.firstName,
-                        lastName: member.details.lastName,
-                        email,
-                        replacements,
-                    }));
+            for (const user of users) {
+                results.push(EmailRecipient.create({
+                    objectId: payment.id,
+                    name: organization.name,
+                    userId: user.id,
+                    firstName: user.firstName,
+                    lastName: user.lastName,
+                    email: user.email,
+                    replacements,
+                }));
+            }
+        }
+    } else {
+        const membersForOrganizations = await getMembersForOrganizations(allOrganizationIds, subFilter);
+
+        for (const { organizationId, payment } of ids) {
+            const organization = organizationMap.get(organizationId);
+
+            if (organization) {
+                const members = membersForOrganizations.get(organizationId);
+                if (!members || members.length === 0) {
+                    // Use admins by default
+
+                    continue;
+                }
+
+                const replacements = getEmailReplacementsForPayment(payment, replacementOptions);
+
+                for (const member of members) {
+                    for (const email of member.details.getNotificationEmails()) {
+                        results.push(EmailRecipient.create({
+                            objectId: payment.id,
+                            name: organization.name,
+                            memberId: member.id,
+                            firstName: member.details.firstName,
+                            lastName: member.details.lastName,
+                            email,
+                            replacements,
+                        }));
+                    }
                 }
             }
         }