@stamhoofd/backend 2.121.0 → 2.122.0

package/src/crons/invoices.ts

@@ -2,50 +2,43 @@ 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';
+import { useSavedIterator } from './helpers/useSavedIterator.js';
+import { isOutside } from './helpers/isOutside.js';
 
 registerCron('invoices', invoices);
 
-let lastFullRun = new Date(0);
-let savedIterator: IterableSQLSelect<Organization> | null = null;
+const { iterate, isHoursAgo } = useSavedIterator(() => {
+    return Organization.select();
+}, { limit: 10, maxQueries: 5 });
 
 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') {
+    // Do not run within 5 hours after boot
+    if (bootAt.getTime() > new Date().getTime() - 1000 * 60 * 60 * 5 && STAMHOOFD.environment !== 'development') {
         return;
     }
 
-    if (lastFullRun.getTime() > new Date().getTime() - 1000 * 60 * 60 * 12) {
+    if (isOutside('03:00', '10:00')) {
         return;
     }
 
-    if ((new Date().getHours() > 10 || new Date().getHours() < 3) && STAMHOOFD.environment !== 'development') {
+    if (!isHoursAgo(12)) {
         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)) {
+    for await (const organization of iterate()) {
         if (!organization.meta.invoicesEnabled) {
             continue;
         }
 
         // Create all invoices for this organization
-        await createInvoicesFor(organization)
-    }
-
-    if (savedIterator.isDone) {
-        savedIterator = null;
-        lastFullRun = new Date();
+        await createInvoicesFor(organization);
     }
 }
 
@@ -57,12 +50,12 @@ async function createInvoicesFor(organization: Organization) {
 
     // 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');
+    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
+    const invoiceLimit = STAMHOOFD.environment === 'development' ? 0 : 1_0000;
     function getPaymentTimeoutDate(p: Payment) {
-        return Formatter.luxon(p.paidAt ?? p.createdAt).plus({month: 1}).set({day: 15 - 3}).startOf('day').toJSDate()
+        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);
@@ -74,6 +67,7 @@ async function createInvoicesFor(organization: Organization) {
         .where('invoiceId', null)
         .where('customer', '!=', null)
         .where('payingOrganizationId', '!=', null)
+        .where('price', '!=', 0)
         .limit(1_000)
         .orderBy('payingOrganizationId')
         .fetch();
@@ -93,21 +87,21 @@ async function createInvoicesFor(organization: Organization) {
         const id = JSON.stringify(blob);
         const existing = groups.get(id);
         if (existing) {
-            existing.push(payment)
+            existing.push(payment);
         } else {
-            groups.set(id, [payment])
+            groups.set(id, [payment]);
         }
     }
 
     console.log('Invoicing ' + groups.size + ' customers');
 
-    const errors: string[] = []
-    const invoices: Invoice[] = []
+    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))
+        payments.sort((a, b) => Sorter.byDateValue(a.createdAt, b.createdAt));
         const customer = payments[0].customer!.dynamicName;
         try {
             const generalStructs = await AuthenticatedStructures.paymentsGeneral(payments, false);
@@ -119,28 +113,28 @@ async function createInvoicesFor(organization: Organization) {
             });
             invoice.buildFromPayments();
 
-            if (invoice.totalWithVAT < invoiceLimit) {
+            if (invoice.totalWithVAT >= 0 && 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))
+                    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')
+                    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)
+            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(', ') + '): ';
+            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()))
+                errors.push(prefix + Formatter.escapeHtml(e.getHuman()));
             } else {
-                errors.push(prefix + Formatter.escapeHtml($t('%1ED')))
+                errors.push(prefix + Formatter.escapeHtml($t('%1ED')));
             }
         }
     }
@@ -150,7 +144,7 @@ async function createInvoicesFor(organization: Organization) {
     if (errors.length) {
         await sendEmailTemplate(organization, {
             template: {
-                type: EmailTemplateType.InvoiceGenerationErrors
+                type: EmailTemplateType.InvoiceGenerationErrors,
             },
             recipients: await organization.getAdminRecipients(),
             type: 'transactional',
@@ -158,9 +152,9 @@ async function createInvoicesFor(organization: Organization) {
             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>' : '')
-                })
-            ]
-        })
+                    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/members-fees.ts

@@ -0,0 +1,50 @@
+import { registerCron } from '@stamhoofd/crons';
+import { Organization, Platform } from '@stamhoofd/models';
+import { useSavedIterator } from './helpers/useSavedIterator.js';
+import { STPackageService } from '../services/STPackageService.js';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+
+// Charge manual service fees every night
+registerCron('members-fees', chargeMembers);
+
+const { iterate, isHoursAgo } = useSavedIterator(() => {
+    return Organization.select();
+}, { limit: 10, maxQueries: 5 });
+
+async function chargeMembers() {
+    if (STAMHOOFD.environment !== 'development' && (new Date().getHours() > 5 || new Date().getHours() < 2)) {
+        return;
+    }
+
+    if (!isHoursAgo(12)) {
+        return;
+    }
+
+    const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+    if (!membershipOrganizationId) {
+        return;
+    }
+
+    const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+    for await (const organization of iterate()) {
+        await chargeMemberFeesForOrganization(organization, membershipOrganization);
+    }
+}
+
+/**
+ * Charge the (increase in) per-member fees for every active package of an organization.
+ * For per-member packages this only charges the members that aren't paid/pending yet.
+ */
+export async function chargeMemberFeesForOrganization(organization: Organization, sellingOrganization: Organization) {
+    const packages = await STPackageService.getActivePackages(organization.id);
+
+    for (const pack of packages) {
+        const item = await STPackageService.chargePackage(pack, sellingOrganization, organization.defaultCompanies[0]);
+        if (item) {
+            item.status = BalanceItemStatus.Due;
+            await item.save();
+            console.log('Charged', item.id);
+        }
+    }
+}

package/src/crons/mollie-chargebacks.ts

@@ -5,15 +5,15 @@ import { PaymentService } from '../services/PaymentService.js';
 
 registerCron('mollie-chargebacks', checkMollieChargebacks);
 
-let lastRun: Date | null = null
+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
+            return;
         }
-        lastRun = new Date()
+        lastRun = new Date();
     }
-    await doCheckMollieChargebacks(false)
+    await doCheckMollieChargebacks(false);
 }
 
 export async function doCheckMollieChargebacks(checkAll = false) {
@@ -24,11 +24,11 @@ export async function doCheckMollieChargebacks(checkAll = false) {
     // Loop all mollie tokens
     for await (const token of MollieToken.select().limit(1).all({}, 'organizationId')) {
         // todo
-        const sellingOrganization = await Organization.getByID(token.id)
+        const sellingOrganization = await Organization.getByID(token.id);
         if (sellingOrganization) {
-            const service = await MollieService.create({ sellingOrganization })
+            const service = await MollieService.create({ sellingOrganization });
             if (service) {
-                await checkMollieChargebacksFor(service, checkAll)
+                await checkMollieChargebacksFor(service, checkAll);
             }
         }
     }
@@ -40,11 +40,11 @@ export async function checkMollieChargebacksFor(service: MollieService, checkAll
     }
 
     // Check last 3 days
-    const offset = new Date(Date.now() - 1000 * 60 * 60 * 24 * 4)
+    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)) {
+    for await (const chargeback of service.client.chargebacks.iterate({ sort: 'desc', testmode: service.testMode } as any)) {
         if (!checkAll && new Date(chargeback.createdAt) < offset) {
             break;
         }
@@ -63,22 +63,21 @@ export async function checkMollieChargebacksFor(service: MollieService, checkAll
                 if (payment) {
                     try {
                         const amount = Math.round(parseFloat(chargeback.amount.value) * 100) * 100;
-                        const createdPayment = await PaymentService.registerChargeback(payment, amount)
+                        const createdPayment = await PaymentService.registerChargeback(payment, amount, new Date(chargeback.createdAt));
 
                         // Link Mollie chargeback ID (so we can set settlement later in the settlements cron)
                         const molliePayment = new MolliePayment();
-                        molliePayment.paymentId = createdPayment.id
+                        molliePayment.paymentId = createdPayment.id;
                         molliePayment.mollieId = chargeback.id;
-                        await molliePayment.save()
+                        await molliePayment.save();
                     } catch (e) {
-                        console.error('Failed to register chargeback ' + chargeback.id, e)
+                        console.error('Failed to register chargeback ' + chargeback.id, e);
                     }
                 }
             } else {
-                console.error('Invalid chargeback payment id '+chargeback.paymentId + ', not found')
+                console.error('Invalid chargeback payment id ' + chargeback.paymentId + ', not found');
             }
         }
-
     }
 
     if (STAMHOOFD.environment !== 'development') {

package/src/crons/service-fees.ts

@@ -0,0 +1,152 @@
+import { registerCron } from '@stamhoofd/crons';
+import { BalanceItem, Organization, Payment, Platform } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { BalanceItemStatus, BalanceItemType, PaymentMethod, PaymentStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { BalanceItemService } from '../services/BalanceItemService.js';
+import { PaymentService } from '../services/PaymentService.js';
+import { VATService } from '../services/VATService.js';
+
+// Charge manual service fees every night
+registerCron('service-fees', chargeServiceFees);
+
+async function chargeServiceFees() {
+    if (STAMHOOFD.environment !== 'development' && (new Date().getHours() > 5 || new Date().getHours() < 2)) {
+        return;
+    }
+    const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+    if (!membershipOrganizationId) {
+        return;
+    }
+
+    const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+    // Succeeded payments
+    const payments = await Payment.select()
+        .where('status', PaymentStatus.Succeeded)
+        .where('serviceFeeManual', '>', 0)
+        .where('serviceFeeManualCharged', 0)
+        .where('createdAt', '<', STAMHOOFD.environment !== 'development' ? new Date() : Formatter.dateIso(new Date(Date.now() + 1000 * 60 * 60 * 24)))
+        .limit(200)
+        .orderBy('createdAt', 'ASC')
+        .fetch();
+
+    // Pending payments older than 14 days with method = Transfer or PointOfSale
+    const pendingPayments = await Payment.select()
+        .where('status', [PaymentStatus.Pending, PaymentStatus.Created])
+        .where('method', [PaymentMethod.Transfer, PaymentMethod.PointOfSale, PaymentMethod.Unknown])
+        .where('serviceFeeManual', '>', 0)
+        .where('serviceFeeManualCharged', 0)
+        .where('createdAt', '<', Formatter.dateIso(new Date(Date.now() - 1000 * 60 * 60 * 24 * 14)))
+        .limit(200)
+        .orderBy('createdAt', 'ASC')
+        .fetch();
+
+    const allPayments = [...payments, ...pendingPayments];
+
+    console.log('Found ' + allPayments.length + ' payments to charge service fees for');
+
+    const mappedToOrganizationId = new Map<string, Payment[]>();
+    for (const payment of allPayments) {
+        if (!payment.organizationId) {
+            console.warn('Payment without organizationId, skipping', payment.id);
+            continue;
+        }
+        if (!mappedToOrganizationId.has(payment.organizationId)) {
+            mappedToOrganizationId.set(payment.organizationId, []);
+        }
+        mappedToOrganizationId.get(payment.organizationId)!.push(payment);
+    }
+
+    for (const [organizationId, payments] of mappedToOrganizationId.entries()) {
+        const organization = await Organization.getByID(organizationId);
+        if (!organization) {
+            console.warn('[chargeServiceFees] Organization not found for ID', organizationId);
+            continue;
+        }
+
+        // Group payments by Formatter.dateNumber(p.createdAt)
+        const groupedPayments: Map<string, Payment[]> = new Map();
+        for (const payment of payments) {
+            const date = Formatter.dateNumber(payment.createdAt);
+            if (!groupedPayments.has(date)) {
+                groupedPayments.set(date, []);
+            }
+            groupedPayments.get(date)!.push(payment);
+        }
+
+        for (const [_, payments] of groupedPayments) {
+            const totalFees = payments.reduce((sum, payment) => sum + payment.serviceFeeManual - payment.serviceFeeManualCharged, 0);
+            const groupedByDate = new Map<string, Payment[]>();
+
+            for (const p of payments) {
+                const date = Formatter.dateNumber(p.createdAt);
+                const existing = groupedByDate.get(date);
+                if (existing) {
+                    existing.push(p);
+                } else {
+                    groupedByDate.set(date, [p]);
+                }
+            }
+
+            for (const [day, payments] of groupedByDate) {
+                const date = new Date(Math.min(...payments.map(p => p.createdAt.getTime())));
+                const startOfDay = Formatter.luxon(date).startOf('day').toJSDate();
+                const endOfDay = Formatter.luxon(date).endOf('day').toJSDate();
+
+                // Ms don't work when querying MySQL, they get lost
+                startOfDay.setMilliseconds(0);
+                endOfDay.setMilliseconds(0);
+
+                const item = new BalanceItem();
+                item.type = BalanceItemType.ServiceFee;
+                item.description = $t('%1cJ', { date: day });
+                item.payingOrganizationId = organization.id;
+                item.organizationId = membershipOrganizationId;
+                item.VATPercentage = 21;
+                item.VATExcempt = VATService.getVATExcempt({
+                    company: organization.defaultCompanies[0] ?? null,
+                    sellingOrganization: membershipOrganization,
+                    type: 'services',
+                });
+                item.VATIncluded = false;
+                item.quantity = 1;
+                item.unitPrice = totalFees;
+                item.createdAt = new Date();
+                item.status = BalanceItemStatus.Due;
+                item.startDate = startOfDay;
+                item.endDate = endOfDay;
+
+                // Check if we find an existing one
+                const existing = await BalanceItem.select()
+                    .where('type', BalanceItemType.ServiceFee)
+                    .where('organizationId', membershipOrganizationId)
+                    .where('VATPercentage', item.VATPercentage)
+                    .where('VATIncluded', item.VATIncluded)
+                    .where('VATExcempt', item.VATExcempt)
+                    .where('payingOrganizationId', organization.id)
+                    .where('status', BalanceItemStatus.Due)
+                    .where('startDate', startOfDay)
+                    .where('endDate', endOfDay)
+                    .first(false);
+
+                if (existing) {
+                    existing.unitPrice += totalFees;
+                    await existing.save();
+                    BalanceItemService.scheduleUpdate(existing);
+                } else {
+                    await item.save();
+                    BalanceItemService.scheduleUpdate(item);
+                }
+
+                const { changedRows } = await Payment.update()
+                    .where('id', payments.map(p => p.id))
+                    .set('serviceFeeManualCharged', SQL.column('serviceFeeManual'))
+                    .update();
+                if (changedRows !== payments.length) {
+                    console.error('Unexpected change in serviceFeeManualCharged. Expected ' + payments.length + ', updated only ' + changedRows);
+                }
+            }
+        }
+    }
+}

package/src/crons/stripe-invoices.ts

@@ -0,0 +1,48 @@
+import { registerCron } from '@stamhoofd/crons';
+import { Formatter } from '@stamhoofd/utility';
+import { StripeInvoicer } from '../helpers/StripeInvoicer.js';
+import { Organization, Platform } from '@stamhoofd/models';
+
+registerCron('stripe-invoices', createStripeInvoices);
+
+let lastStripeInvoice: Date | null = null;
+
+async function createStripeInvoices() {
+    if (STAMHOOFD.environment !== 'production') {
+        // return;
+    }
+
+    if (STAMHOOFD.userMode === 'platform') {
+        return;
+    }
+
+    if (STAMHOOFD.STRIPE_CONNECT_METHOD === 'standard') {
+        return;
+    }
+
+    // Wait for the next day before doing a new check
+    const today = new Date();
+    if (lastStripeInvoice && Formatter.dateIso(lastStripeInvoice) === Formatter.dateIso(today)) {
+        console.log('Stripe check done for this day');
+        return;
+    }
+    console.log('Creating Stripe Invoices...');
+
+    if (!STAMHOOFD.STRIPE_SECRET_KEY) {
+        console.log('No stripe key set');
+        return;
+    }
+
+    const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+    if (!membershipOrganizationId) {
+        return;
+    }
+
+    const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+    const invoicer = new StripeInvoicer({
+        secretKey: STAMHOOFD.STRIPE_SECRET_KEY,
+    });
+    await invoicer.generateAllInvoices(membershipOrganization);
+    lastStripeInvoice = new Date();
+}