@stamhoofd/backend 2.64.0 → 2.65.1

package/src/helpers/MemberUserSyncer.ts

@@ -1,9 +1,10 @@
-import { Member, MemberResponsibilityRecord, MemberWithRegistrations, User } from '@stamhoofd/models';
+import { CachedBalance, Member, MemberResponsibilityRecord, MemberWithRegistrations, User } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
 import { AuditLogSource, MemberDetails, Permissions, UserPermissions } from '@stamhoofd/structures';
 import crypto from 'crypto';
 import basex from 'base-x';
 import { AuditLogService } from '../services/AuditLogService';
+import { Formatter } from '@stamhoofd/utility';
 
 const ALPHABET = '123456789ABCDEFGHJKMNPQRSTUVWXYZ'; // Note: we removed 0, O, I and l to make it easier for humans
 const customBase = basex(ALPHABET);
@@ -185,6 +186,9 @@ export class MemberUserSyncerStatic {
         console.log('Removing access for ' + user.id + ' to member ' + member.id);
         await Member.users.reverse('members').unlink(user, member);
 
+        // Update balance of this user, as it could have changed
+        await this.updateUserBalance(user.id, member.id);
+
         if (user.memberId === member.id) {
             user.memberId = null;
         }
@@ -305,6 +309,23 @@ export class MemberUserSyncerStatic {
         if (!member.users.find(u => u.id === user.id)) {
             await Member.users.reverse('members').link(user, [member]);
             member.users.push(user);
+
+            // Update balance of this user, as it could have changed
+            await this.updateUserBalance(user.id, member.id);
+        }
+    }
+
+    /**
+     * Update the balance after making a change in linked member/users
+     */
+    async updateUserBalance(userId: string, memberId: string) {
+        // Update balance of this user, as it could have changed
+        const memberBalances = await CachedBalance.getForObjects([memberId]);
+        if (memberBalances.length > 0) {
+            const organizationIds = Formatter.uniqueArray(memberBalances.map(b => b.organizationId));
+            for (const organizationId of organizationIds) {
+                await CachedBalance.updateForUsers(organizationId, [userId]);
+            }
         }
     }
 }

package/src/helpers/MembershipCharger.ts

@@ -36,6 +36,7 @@ export const MembershipCharger = {
                 .where('balanceItemId', null)
                 .where('deletedAt', null)
                 .whereNot('organizationId', chargeVia)
+                .where(SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date()))
                 .limit(chunkSize)
                 .orderBy(
                     new SQLOrderBy({

package/src/helpers/TagHelper.ts

@@ -1,7 +1,6 @@
 import { Organization, Platform } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { AuditLogSource, OrganizationTag, TagHelper as SharedTagHelper } from '@stamhoofd/structures';
-import { ModelHelper } from './ModelHelper';
 import { AuditLogService } from '../services/AuditLogService';
 
 export class TagHelper extends SharedTagHelper {
@@ -14,17 +13,15 @@ export class TagHelper extends SharedTagHelper {
                 let platform = await Platform.getShared();
 
                 const tagCounts = new Map<string, number>();
-                await this.loopOrganizations(async (organizations) => {
-                    for (const organization of organizations) {
-                        organization.meta.tags = this.getAllTagsFromHierarchy(organization.meta.tags, platform.config.tags);
 
-                        for (const tag of organization.meta.tags) {
-                            tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
-                        }
-                    }
+                for await (const organization of Organization.select().all()) {
+                    organization.meta.tags = this.getAllTagsFromHierarchy(organization.meta.tags, platform.config.tags);
 
-                    await Promise.all(organizations.map(organization => organization.save()));
-                });
+                    for (const tag of organization.meta.tags) {
+                        tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+                    }
+                    await organization.save();
+                }
 
                 // Reload platform to avoid race conditions
                 platform = await Platform.getShared();
@@ -39,10 +36,6 @@ export class TagHelper extends SharedTagHelper {
         });
     }
 
-    private static async loopOrganizations(onBatchReceived: (batch: Organization[]) => Promise<void>) {
-        await ModelHelper.loop(Organization, 'id', onBatchReceived, { limit: 10 });
-    }
-
     /**
      * Removes child tag ids that do not exist and sorts the tags.
      * @param platformTags

package/src/seeds/1728928974-update-cached-outstanding-balance-from-items.ts

@@ -2,6 +2,9 @@ import { Migration } from '@simonbackx/simple-database';
 import { logger } from '@simonbackx/simple-logging';
 import { BalanceItem } from '@stamhoofd/models';
 
+/**
+ * This migration is required to keep '1733994455-balance-item-status-open' working
+ */
 export default new Migration(async () => {
     if (STAMHOOFD.environment == 'test') {
         console.log('skipped in tests');
@@ -10,26 +13,13 @@ export default new Migration(async () => {
 
     process.stdout.write('\n');
     let c = 0;
-    let id: string = '';
 
     await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
-        while (true) {
-            const items = await BalanceItem.where({
-                id: {
-                    value: id,
-                    sign: '>',
-                },
-            }, { limit: 1000, sort: ['id'] });
-
+        for await (const items of BalanceItem.select().limit(1000).allBatched()) {
             await BalanceItem.updateOutstanding(items);
 
             c += items.length;
             process.stdout.write('.');
-
-            if (items.length < 1000) {
-                break;
-            }
-            id = items[items.length - 1].id;
         }
     });
 

package/src/seeds/1729253172-update-orders.ts

@@ -1,7 +1,5 @@
 import { Migration } from '@simonbackx/simple-database';
 import { Order } from '@stamhoofd/models';
-import { sleep } from '@stamhoofd/utility';
-import { ModelHelper } from '../helpers/ModelHelper';
 
 export default new Migration(async () => {
     if (STAMHOOFD.environment === 'test') {
@@ -11,22 +9,13 @@ export default new Migration(async () => {
 
     console.log('Start saving orders.');
 
-    const limit = 100;
-    let count = limit;
+    const batchSize = 100;
+    let count = 0;
 
-    await ModelHelper.loop(Order, 'id', async (batch: Order[]) => {
-        console.log('Saving orders...', `(${count})`);
-
-        // save all orders to update the new columns
-        for (const order of batch) {
-            await order.save();
-        }
-
-        count += limit;
-    },
-    { limit });
-
-    await sleep(1000);
+    for await (const order of Order.select().limit(batchSize).all()) {
+        await order.save();
+        count += 1;
+    }
 
-    console.log('Finished saving orders.');
+    console.log('Finished saving ' + count + ' orders.');
 });

package/src/seeds/{1726494420-update-cached-outstanding-balance-from-items.ts → 1735577912-update-cached-outstanding-balance-from-items.ts}

@@ -10,26 +10,13 @@ export default new Migration(async () => {
 
     process.stdout.write('\n');
     let c = 0;
-    let id: string = '';
 
     await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
-        while (true) {
-            const items = await BalanceItem.where({
-                id: {
-                    value: id,
-                    sign: '>',
-                },
-            }, { limit: 1000, sort: ['id'] });
-
+        for await (const items of BalanceItem.select().limit(1000).allBatched()) {
             await BalanceItem.updateOutstanding(items);
 
             c += items.length;
             process.stdout.write('.');
-
-            if (items.length < 1000) {
-                break;
-            }
-            id = items[items.length - 1].id;
         }
     });
 

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'

package/src/services/PlatformMembershipService.ts

@@ -225,12 +225,12 @@ export class PlatformMembershipService {
 
                     const shouldApplyReducedPrice = me.details.shouldApplyReducedPrice;
 
-                    const cheapestMembership = defaultMembershipsWithOrganization.sort(({ membership: a, registration: ar, organization: ao }, { membership: b, registration: br, organization: bo }) => {
-                        const tagIdsA = ao?.meta.tags ?? [];
-                        const tagIdsB = bo?.meta.tags ?? [];
-                        const diff = a.getPrice(period.id, ar.startDate ?? ar.registeredAt ?? now, tagIdsA, shouldApplyReducedPrice)! - b.getPrice(period.id, ar.startDate ?? ar.registeredAt ?? now, tagIdsB, shouldApplyReducedPrice)!;
+                    const cheapestMembership = defaultMembershipsWithOrganization.sort((a, b) => {
+                        const tagIdsA = a.organization?.meta.tags ?? [];
+                        const tagIdsB = b.organization?.meta.tags ?? [];
+                        const diff = a.membership.getPrice(period.id, a.registration.startDate ?? a.registration.registeredAt ?? now, tagIdsA, shouldApplyReducedPrice)! - b.membership.getPrice(period.id, a.registration.startDate ?? a.registration.registeredAt ?? now, tagIdsB, shouldApplyReducedPrice)!;
                         if (diff === 0) {
-                            return Sorter.byDateValue(br.createdAt, ar.createdAt);
+                            return Sorter.byDateValue(b.registration.startDate ?? b.registration.createdAt, a.registration.startDate ?? a.registration.createdAt);
                         }
                         return diff;
                     })[0];

package/src/sql-filters/members.ts

@@ -242,6 +242,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             startDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'startDate')),
             endDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'endDate')),
             expireDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'expireDate')),
+            trialUntil: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'trialUntil')),
         },
     ),
 

package/src/sql-filters/receivable-balances.ts

@@ -1,4 +1,5 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler } from '@stamhoofd/sql';
+import { SQL, SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler } from '@stamhoofd/sql';
+import { EmailRelationFilterCompilers } from './shared/EmailRelationFilterCompilers';
 
 /**
  * Defines how to filter cached balance items in the database from StamhoofdFilter objects
@@ -11,4 +12,17 @@ export const receivableBalanceFilterCompilers: SQLFilterDefinitions = {
     amountOpen: createSQLColumnFilterCompiler('amountOpen'),
     amountPending: createSQLColumnFilterCompiler('amountPending'),
     nextDueAt: createSQLColumnFilterCompiler('nextDueAt'),
+    lastReminderEmail: createSQLColumnFilterCompiler('lastReminderEmail'),
+    reminderEmailCount: createSQLColumnFilterCompiler('reminderEmailCount'),
+    reminderAmountIncreased: createSQLExpressionFilterCompiler(
+        SQL.if(
+            SQL.column('amountOpen'),
+            '>',
+            SQL.column('lastReminderAmountOpen'),
+        ).then(1).else(0),
+        { isJSONValue: false, isJSONObject: false },
+    ),
+
+    // Allowed to filter by recent emails
+    ...EmailRelationFilterCompilers,
 };

package/src/sql-filters/shared/EmailRelationFilterCompilers.ts

@@ -0,0 +1,19 @@
+import { createSQLRelationFilterCompiler, SQL, SQLParentNamespace, baseSQLFilterCompilers, createSQLColumnFilterCompiler } from '@stamhoofd/sql';
+
+export const EmailRelationFilterCompilers = {
+    emails: createSQLRelationFilterCompiler(
+        SQL.select()
+            .from(
+                SQL.table('email_recipients'),
+            )
+            .where(
+                SQL.column(SQLParentNamespace, 'id'),
+                SQL.column('objectId'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            emailType: createSQLColumnFilterCompiler('emailType'),
+            sentAt: createSQLColumnFilterCompiler('sentAt'),
+        },
+    ),
+};