@stamhoofd/backend 2.62.0 → 2.64.0

package/src/services/PlatformMembershipService.ts

@@ -1,15 +1,19 @@
 import { Model } from '@simonbackx/simple-database';
 import { logger } from '@simonbackx/simple-logging';
-import { Group, Member, MemberPlatformMembership, Organization, Platform, Registration } from '@stamhoofd/models';
+import { Group, Member, MemberPlatformMembership, Organization, Platform, Registration, RegistrationPeriod } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { SQL } from '@stamhoofd/sql';
-import { AuditLogSource } from '@stamhoofd/structures';
+import { SQL, SQLWhereSign } from '@stamhoofd/sql';
+import { AuditLogSource, PlatformMembershipTypeBehaviour } from '@stamhoofd/structures';
 import { Formatter, Sorter } from '@stamhoofd/utility';
 import { AuditLogService } from './AuditLogService';
 import { MemberNumberService } from './MemberNumberService';
 
 export class PlatformMembershipService {
     static listen() {
+        if (STAMHOOFD.userMode === 'organization') {
+            return;
+        }
+
         // Listen for group changes
         Model.modelEventBus.addListener(this, (event) => {
             if (!(event.model instanceof Group)) {
@@ -24,6 +28,10 @@ export class PlatformMembershipService {
     }
 
     static async updateAll() {
+        if (STAMHOOFD.userMode === 'organization') {
+            return;
+        }
+
         console.log('Scheduling updateAllMemberships');
 
         let c = 0;
@@ -73,6 +81,9 @@ export class PlatformMembershipService {
     }
 
     static updateMembershipsForGroupId(id: string) {
+        if (STAMHOOFD.userMode === 'organization') {
+            return;
+        }
         QueueHandler.schedule('bulk-update-memberships', async () => {
             console.log('Bulk updating memberships for group id ', id);
 
@@ -102,6 +113,10 @@ export class PlatformMembershipService {
     }
 
     static async updateMembershipsForId(id: string, silent = false) {
+        if (STAMHOOFD.userMode === 'organization') {
+            return;
+        }
+
         return await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
             await QueueHandler.schedule('updateMemberships-' + id, async function (this: undefined) {
                 if (!silent) {
@@ -115,167 +130,182 @@ export class PlatformMembershipService {
                     }
                     return;
                 }
-                const platform = await Platform.getShared();
-                const registrations = me.registrations.filter(r => r.group.periodId === platform.periodId && r.registeredAt && !r.deactivatedAt);
-                const now = new Date();
-
-                const defaultMemberships = registrations.flatMap((r) => {
-                    if (!r.group.defaultAgeGroupId) {
-                        return [];
-                    }
-                    const defaultAgeGroup = platform.config.defaultAgeGroups.find(g => g.id === r.group.defaultAgeGroupId);
-                    if (!defaultAgeGroup || !defaultAgeGroup.defaultMembershipTypeId) {
-                        return [];
-                    }
-
-                    const defaultMembership = platform.config.membershipTypes.find(m => m.id === defaultAgeGroup.defaultMembershipTypeId);
-                    if (!defaultMembership) {
-                        return [];
-                    }
-                    const periodConfig = defaultMembership.periods.get(platform.periodId);
+                const platform = await Platform.getSharedStruct();
+                const periods = await RegistrationPeriod.select()
+                    .where('locked', false)
+                    .where('organizationId', me.organizationId)
+                    .where('endDate', SQLWhereSign.GreaterEqual, new Date()) // Avoid updating the price of past periods that were not yet locked
+                    .fetch();
+
+                // Every (not-locked) period can have a generated membership
+                for (const period of periods) {
+                    const registrations = me.registrations.filter(r => r.group.periodId === period.id && r.registeredAt && !r.deactivatedAt);
+                    const now = new Date();
+
+                    const defaultMemberships = registrations.flatMap((r) => {
+                        if (!r.group.defaultAgeGroupId) {
+                            return [];
+                        }
+                        const defaultAgeGroup = platform.config.defaultAgeGroups.find(g => g.id === r.group.defaultAgeGroupId);
+                        if (!defaultAgeGroup || !defaultAgeGroup.defaultMembershipTypeId) {
+                            return [];
+                        }
 
-                    if (periodConfig === undefined) {
-                        console.warn('Found default membership without period configuration', defaultMembership.id, platform.periodId);
-                        return [];
-                    }
+                        const defaultMembership = platform.config.membershipTypes.find(m => m.id === defaultAgeGroup.defaultMembershipTypeId);
+                        if (!defaultMembership) {
+                            return [];
+                        }
+                        const periodConfig = defaultMembership.periods.get(period.id);
 
-                    if (!(periodConfig.startDate <= now && periodConfig.endDate >= now)) {
-                        // Do not add this membership automatically because it won't match as an active membership
-                        // later on (edge case but otherwise we'll get duplicate memberships and add a new one every time)
-                        return [];
-                    }
+                        if (periodConfig === undefined) {
+                            console.warn('Found default membership without period configuration', defaultMembership.id, period.id);
+                            return [];
+                        }
 
-                    return [{
-                        registration: r,
-                        membership: defaultMembership,
-                    }];
-                });
-
-                // Get active memberships for this member that
-                const memberships = await MemberPlatformMembership.where({ memberId: me.id, periodId: platform.periodId });
-                const activeMemberships = memberships.filter(m => m.startDate <= now && m.endDate >= now && m.deletedAt === null);
-                const activeMembershipsUndeletable = activeMemberships.filter(m => !m.canDelete() || !m.generated);
-
-                if (defaultMemberships.length === 0) {
-                    // Stop all active memberships that were added automatically
-                    for (const membership of activeMemberships) {
-                        if (membership.canDelete() && membership.generated) {
-                            if (!silent) {
-                                console.log('Removing membership because no longer registered member and not yet invoiced for: ' + me.id + ' - membership ' + membership.id);
+                        return [{
+                            registration: r,
+                            membership: defaultMembership,
+                        }];
+                    });
+
+                    const types = platform.config.membershipTypes.filter(m => m.behaviour === PlatformMembershipTypeBehaviour.Period).map(m => m.id);
+
+                    // Get active memberships for this member that
+                    const activeMemberships = await MemberPlatformMembership.where({
+                        memberId: me.id,
+                        periodId: period.id,
+                        membershipTypeId: { sign: 'IN', value: types },
+                        deletedAt: null,
+                    });
+                    const activeMembershipsUndeletable = activeMemberships.filter(m => !m.canDelete() || !m.generated);
+
+                    if (defaultMemberships.length === 0) {
+                        // Stop all active memberships that were added automatically
+                        for (const membership of activeMemberships) {
+                            if (membership.canDelete() && membership.generated) {
+                                if (!silent) {
+                                    console.log('Removing membership because no longer registered member and not yet invoiced for: ' + me.id + ' - membership ' + membership.id);
+                                }
+                                membership.deletedAt = new Date();
+                                await membership.save();
                             }
-                            membership.deletedAt = new Date();
-                            await membership.save();
                         }
-                    }
 
-                    if (!silent) {
-                        console.log('Skipping automatic membership for: ' + me.id, ' - no default memberships found');
+                        if (!silent) {
+                            console.log('Skipping automatic membership for: ' + me.id, ' - no default memberships found');
+                        }
+                        continue;
                     }
-                    return;
-                }
 
-                if (activeMembershipsUndeletable.length) {
-                    // Skip automatic additions
-                    for (const m of activeMembershipsUndeletable) {
-                        try {
-                            await m.calculatePrice(me);
-                        }
-                        catch (e) {
-                            // Ignore error: membership might not be available anymore
-                            if (!silent) {
-                                console.error('Failed to calculate price for undeletable membership', m.id, e);
+                    if (activeMembershipsUndeletable.length) {
+                        // Skip automatic additions
+                        for (const m of activeMembershipsUndeletable) {
+                            try {
+                                await m.calculatePrice(me);
+                            }
+                            catch (e) {
+                                // Ignore error: membership might not be available anymore
+                                if (!silent) {
+                                    console.error('Failed to calculate price for undeletable membership', m.id, e);
+                                }
                             }
+                            await m.save();
                         }
-                        await m.save();
+                        continue;
                     }
-                    return;
-                }
 
-                // Add the cheapest available membership
-                const organizations = await Organization.getByIDs(...Formatter.uniqueArray(defaultMemberships.map(m => m.registration.organizationId)));
+                    // Add the cheapest available membership
+                    const organizations = await Organization.getByIDs(...Formatter.uniqueArray(defaultMemberships.map(m => m.registration.organizationId)));
 
-                const defaultMembershipsWithOrganization = defaultMemberships.map(({ membership, registration }) => {
-                    const organizationId = registration.organizationId;
-                    const organization = organizations.find(o => o.id === organizationId);
-                    return { membership, registration, organization };
-                });
+                    const defaultMembershipsWithOrganization = defaultMemberships.map(({ membership, registration }) => {
+                        const organizationId = registration.organizationId;
+                        const organization = organizations.find(o => o.id === organizationId);
+                        return { membership, registration, organization };
+                    });
 
-                const shouldApplyReducedPrice = me.details.shouldApplyReducedPrice;
+                    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(platform.periodId, now, tagIdsA, shouldApplyReducedPrice)! - b.getPrice(platform.periodId, now, tagIdsB, shouldApplyReducedPrice)!;
-                    if (diff == 0) {
-                        return Sorter.byDateValue(br.createdAt, ar.createdAt);
+                    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)!;
+                        if (diff === 0) {
+                            return Sorter.byDateValue(br.createdAt, ar.createdAt);
+                        }
+                        return diff;
+                    })[0];
+                    if (!cheapestMembership) {
+                        console.error('No membership found');
+                        continue;
                     }
-                    return diff;
-                })[0];
-                if (!cheapestMembership) {
-                    throw new Error('No membership found');
-                }
 
-                // Check if already have the same membership
-                for (const m of activeMemberships) {
-                    if (m.membershipTypeId === cheapestMembership.membership.id) {
-                        // Update the price of this active membership (could have changed)
-                        try {
-                            await m.calculatePrice(me);
-                        }
-                        catch (e) {
-                            // Ignore error: membership might not be available anymore
-                            if (!silent) {
-                                console.error('Failed to calculate price for active membership', m.id, e);
+                    // Check if already have the same membership
+                    for (const m of activeMemberships) {
+                        let didFind = false;
+                        if (m.membershipTypeId === cheapestMembership.membership.id) {
+                            // Update the price of this active membership (could have changed)
+                            try {
+                                await m.calculatePrice(me, cheapestMembership.registration);
+                            }
+                            catch (e) {
+                                // Ignore error: membership might not be available anymore
+                                if (!silent) {
+                                    console.error('Failed to calculate price for active membership', m.id, e);
+                                }
                             }
+                            await m.save();
+                            didFind = true;
+                            break;
+                        }
+
+                        if (didFind) {
+                            continue;
                         }
-                        await m.save();
-                        return;
                     }
-                }
 
-                const periodConfig = cheapestMembership.membership.periods.get(platform.periodId);
-                if (!periodConfig) {
-                    console.error('Missing membership prices for membership type ' + cheapestMembership.membership.id + ' and period ' + platform.periodId);
-                    return;
-                }
+                    const periodConfig = cheapestMembership.membership.periods.get(period.id);
+                    if (!periodConfig) {
+                        console.error('Missing membership prices for membership type ' + cheapestMembership.membership.id + ' and period ' + period.id);
+                        continue;
+                    }
 
-                // Can we revive an earlier deleted membership?
-                if (!silent) {
-                    console.log('Creating automatic membership for: ' + me.id + ' - membership type ' + cheapestMembership.membership.id);
-                }
-                const membership = new MemberPlatformMembership();
-                membership.memberId = me.id;
-                membership.membershipTypeId = cheapestMembership.membership.id;
-                membership.organizationId = cheapestMembership.registration.organizationId;
-                membership.periodId = platform.periodId;
-
-                membership.startDate = periodConfig.startDate;
-                membership.endDate = periodConfig.endDate;
-                membership.expireDate = periodConfig.expireDate;
-                membership.generated = true;
-
-                if (me.details.memberNumber === null) {
-                    try {
-                        await MemberNumberService.assignMemberNumber(me, membership);
+                    // Can we revive an earlier deleted membership?
+                    if (!silent) {
+                        console.log('Creating automatic membership for: ' + me.id + ' - membership type ' + cheapestMembership.membership.id);
                     }
-                    catch (error) {
-                        console.error(`Failed to assign member number for id ${me.id}: ${error.message}`);
-                        // If the assignment of the member number fails the membership is not created but the member is registered
-                        return;
+                    const membership = new MemberPlatformMembership();
+                    membership.memberId = me.id;
+                    membership.membershipTypeId = cheapestMembership.membership.id;
+                    membership.organizationId = cheapestMembership.registration.organizationId;
+                    membership.periodId = period.id;
+                    membership.startDate = periodConfig.startDate;
+                    membership.endDate = periodConfig.endDate;
+                    membership.expireDate = periodConfig.expireDate;
+                    membership.generated = true;
+
+                    if (me.details.memberNumber === null) {
+                        try {
+                            await MemberNumberService.assignMemberNumber(me, membership);
+                        }
+                        catch (error) {
+                            console.error(`Failed to assign member number for id ${me.id}: ${error.message}`);
+                            // If the assignment of the member number fails the membership is not created but the member is registered
+                            continue;
+                        }
                     }
-                }
 
-                await membership.calculatePrice(me);
-                await membership.save();
+                    await membership.calculatePrice(me, cheapestMembership.registration);
+                    await membership.save();
 
-                // This reasoning allows us to replace an existing membership with a cheaper one (not date based ones, but type based ones)
-                for (const toDelete of activeMemberships) {
-                    if (toDelete.canDelete() && toDelete.generated) {
-                        if (!silent) {
-                            console.log('Removing membership because cheaper membership found for: ' + me.id + ' - membership ' + toDelete.id);
+                    // This reasoning allows us to replace an existing membership with a cheaper one (not date based ones, but type based ones)
+                    for (const toDelete of activeMemberships) {
+                        if (toDelete.canDelete() && toDelete.generated) {
+                            if (!silent) {
+                                console.log('Removing membership because cheaper membership found for: ' + me.id + ' - membership ' + toDelete.id);
+                            }
+                            toDelete.deletedAt = new Date();
+                            await toDelete.save();
                         }
-                        toDelete.deletedAt = new Date();
-                        await toDelete.save();
                     }
                 }
             });

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

@@ -8,6 +8,7 @@ export const receivableBalanceFilterCompilers: SQLFilterDefinitions = {
     id: createSQLColumnFilterCompiler('id'),
     organizationId: createSQLColumnFilterCompiler('organizationId'),
     objectType: createSQLColumnFilterCompiler('objectType'),
-    amount: createSQLColumnFilterCompiler('amount'),
+    amountOpen: createSQLColumnFilterCompiler('amountOpen'),
     amountPending: createSQLColumnFilterCompiler('amountPending'),
+    nextDueAt: createSQLColumnFilterCompiler('nextDueAt'),
 };

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

@@ -21,13 +21,13 @@ export const receivableBalanceSorters: SQLSortDefinitions<CachedBalance> = {
             });
         },
     },
-    amount: {
+    amountOpen: {
         getValue(a) {
-            return a.amount;
+            return a.amountOpen;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
-                column: SQL.column('amount'),
+                column: SQL.column('amountOpen'),
                 direction,
             });
         },