@stamhoofd/backend 2.65.0 → 2.65.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.65.0",
+    "version": "2.65.2",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -37,14 +37,14 @@
         "@simonbackx/simple-encoding": "2.19.0",
         "@simonbackx/simple-endpoints": "1.15.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.65.0",
-        "@stamhoofd/backend-middleware": "2.65.0",
-        "@stamhoofd/email": "2.65.0",
-        "@stamhoofd/models": "2.65.0",
-        "@stamhoofd/queues": "2.65.0",
-        "@stamhoofd/sql": "2.65.0",
-        "@stamhoofd/structures": "2.65.0",
-        "@stamhoofd/utility": "2.65.0",
+        "@stamhoofd/backend-i18n": "2.65.2",
+        "@stamhoofd/backend-middleware": "2.65.2",
+        "@stamhoofd/email": "2.65.2",
+        "@stamhoofd/models": "2.65.2",
+        "@stamhoofd/queues": "2.65.2",
+        "@stamhoofd/sql": "2.65.2",
+        "@stamhoofd/structures": "2.65.2",
+        "@stamhoofd/utility": "2.65.2",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "16bb6a7ce183c964158cee5d1581de6e7575133d"
+    "gitHead": "2db24a133a1f990d69cafc26f0425f473bc42ae2"
 }

package/src/crons/balance-emails.ts

@@ -37,7 +37,6 @@ async function balanceEmails() {
     const platform = await Platform.getSharedPrivateStruct();
 
     if (!platform.config.featureFlags.includes('balance-emails')) {
-        console.log('Feature flag not enabled, skipping.');
         return;
     }
     const systemUser = await User.getSystem();

package/src/seeds/1736266448-recall-balance-item-price-paid.ts

@@ -0,0 +1,70 @@
+import { Migration } from '@simonbackx/simple-database';
+import { logger } from '@simonbackx/simple-logging';
+import { BalanceItem, BalanceItemPayment, Organization, Payment } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { AuditLogSource, PaymentStatus } from '@stamhoofd/structures';
+import { AuditLogService } from '../services/AuditLogService';
+import { BalanceItemPaymentService } from '../services/BalanceItemPaymentService';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    process.stdout.write('\n');
+    let c = 0;
+
+    await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
+        const q = Payment.select()
+            .where('status', PaymentStatus.Succeeded)
+            .where('createdAt', '>=', new Date('2024-12-12'))
+            .limit(100);
+        for await (const payment of q.all()) {
+            await fix(payment);
+
+            c += 1;
+
+            if (c % 1000 === 0) {
+                process.stdout.write('.');
+            }
+        }
+    });
+
+    console.log('Updated ' + c + ' payments');
+
+    // Do something here
+    return Promise.resolve();
+});
+
+async function fix(payment: Payment) {
+    if (payment.status !== PaymentStatus.Succeeded) {
+        return;
+    }
+
+    if (!payment.organizationId) {
+        return;
+    }
+
+    const organization = await Organization.getByID(payment.organizationId);
+
+    if (!organization) {
+        return;
+    }
+
+    await AuditLogService.setContext({ fallbackUserId: payment.payingUserId, source: AuditLogSource.Payment, fallbackOrganizationId: payment.organizationId }, async () => {
+        // Prevent concurrency issues
+        await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+            const unloaded = (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment));
+            const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                unloaded,
+            );
+
+            for (const balanceItemPayment of balanceItemPayments) {
+                await BalanceItemPaymentService.markPaidRepeated(balanceItemPayment, organization);
+            }
+
+            await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+        });
+    });
+}

package/src/services/BalanceItemPaymentService.ts

@@ -7,7 +7,7 @@ type Loaded<T> = (T) extends ManyToOneRelation<infer Key, infer Model> ? Record<
 
 export const BalanceItemPaymentService = {
     async markPaid(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
-        const wasPaid = balanceItemPayment.balanceItem.priceOpen === 0;
+        const wasPaid = balanceItemPayment.balanceItem.isPaid;
 
         // Update cached amountPaid of the balance item (balanceItemPayment will get overwritten later, but we need it to calculate the status)
         balanceItemPayment.balanceItem.pricePaid += balanceItemPayment.price;
@@ -17,7 +17,7 @@ export const BalanceItemPaymentService = {
         }
 
         await balanceItemPayment.balanceItem.save();
-        const isPaid = balanceItemPayment.balanceItem.priceOpen === 0;
+        const isPaid = balanceItemPayment.balanceItem.isPaid;
 
         // Do logic of balance item
         if (isPaid && !wasPaid && balanceItemPayment.price >= 0 && balanceItemPayment.balanceItem.status === BalanceItemStatus.Due) {
@@ -29,6 +29,18 @@ export const BalanceItemPaymentService = {
         }
     },
 
+    /**
+     * Safe method to correct balance items that missed a markPaid call, but avoid double marking an order as valid.
+     */
+    async markPaidRepeated(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        const isPaid = balanceItemPayment.balanceItem.isPaid;
+
+        // Do logic of balance item
+        if (isPaid && balanceItemPayment.price >= 0 && balanceItemPayment.balanceItem.status === BalanceItemStatus.Due) {
+            await BalanceItemService.markPaidRepeated(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+        }
+    },
+
     /**
      * Call balanceItemPayment once a earlier succeeded payment is no longer succeeded
      */

package/src/services/BalanceItemService.ts

@@ -6,7 +6,43 @@ import { PaymentReallocationService } from './PaymentReallocationService';
 import { Formatter } from '@stamhoofd/utility';
 
 export const BalanceItemService = {
-    async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+    /**
+     * Safe method to correct balance items that missed a markPaid call, but avoid double marking an order as valid.
+     */
+    async markPaidRepeated(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+        if (balanceItem.pricePaid <= 0) {
+            return;
+        }
+
+        await this.markDue(balanceItem);
+
+        // Registrations are safe to mark valid multiple times
+        if (balanceItem.registrationId) {
+            await RegistrationService.markValid(balanceItem.registrationId);
+        }
+
+        // Orders aren't safe to mark paid twice - so only mark paid if not yet valid
+        // The only downside of this is that we won't send a paid email for transfer orders
+        // we should fix that in the future by introducing a paidAt timestamp for orders
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order && !order.validAt) {
+                await order.markPaid(payment, organization);
+
+                // Save number in balance description
+                if (order.number !== null) {
+                    const webshop = await Webshop.getByID(order.webshopId);
+
+                    if (webshop) {
+                        balanceItem.description = order.generateBalanceDescription(webshop);
+                        await balanceItem.save();
+                    }
+                }
+            }
+        }
+    },
+
+    async markDue(balanceItem: BalanceItem) {
         if (balanceItem.status === BalanceItemStatus.Hidden) {
             await BalanceItem.reactivateItems([balanceItem]);
         }
@@ -18,6 +54,10 @@ export const BalanceItemService = {
                 await BalanceItem.reactivateItems([depending]);
             }
         }
+    },
+
+    async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+        await this.markDue(balanceItem);
 
         // It is possible this balance item was earlier paid
         // and later the regigstration / order has been canceled and it became a negative balance item - which as some point has been reembursed and marked as 'paid'