@stamhoofd/backend 2.83.1 → 2.83.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.83.1",
+    "version": "2.83.2",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -38,14 +38,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.19.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.83.1",
-        "@stamhoofd/backend-middleware": "2.83.1",
-        "@stamhoofd/email": "2.83.1",
-        "@stamhoofd/models": "2.83.1",
-        "@stamhoofd/queues": "2.83.1",
-        "@stamhoofd/sql": "2.83.1",
-        "@stamhoofd/structures": "2.83.1",
-        "@stamhoofd/utility": "2.83.1",
+        "@stamhoofd/backend-i18n": "2.83.2",
+        "@stamhoofd/backend-middleware": "2.83.2",
+        "@stamhoofd/email": "2.83.2",
+        "@stamhoofd/models": "2.83.2",
+        "@stamhoofd/queues": "2.83.2",
+        "@stamhoofd/sql": "2.83.2",
+        "@stamhoofd/structures": "2.83.2",
+        "@stamhoofd/utility": "2.83.2",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -65,5 +65,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "97bf928ed008f1a992380b25385c86caecc43d42"
+    "gitHead": "b2f1dbec97a98ef6bc1f04ddeb28f7455078c3bb"
 }

package/src/services/PlatformMembershipService.ts

@@ -214,7 +214,6 @@ export class PlatformMembershipService {
                         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
@@ -233,23 +232,6 @@ export class PlatformMembershipService {
                         continue;
                     }
 
-                    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();
-                        }
-                        continue;
-                    }
-
                     // Add the cheapest available membership
                     const organizations = await Organization.getByIDs(...Formatter.uniqueArray(defaultMemberships.map(m => m.registration.organizationId)));
 
@@ -286,28 +268,58 @@ export class PlatformMembershipService {
                     })[0];
 
                     if (!cheapestMembership) {
+                        // Technically not possible, but for type checking
                         console.error('No membership found');
                         continue;
                     }
 
                     // Check if already have the same membership
                     // if that is the case, we'll keep that one and update the price + dates if the organization matches the cheapest/earliest membership
-                    let didFind = false;
+                    let didFind: MemberPlatformMembership | null = null;
                     for (const m of activeMemberships) {
                         if (m.membershipTypeId === cheapestMembership.membership.id && m.organizationId === cheapestMembership.registration.organizationId) {
-                            // Update the price of this active membership (could have changed)
-                            try {
-                                await m.calculatePrice(me, cheapestMembership.registration);
+                            if (!m.locked) {
+                                // Update the price and dates 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();
                             }
-                            catch (e) {
-                                // Ignore error: membership might not be available anymore
+                            didFind = m;
+                            break;
+                        }
+                    }
+
+                    // Delete all other generated memberships that are not the cheapest one
+                    for (const m of activeMemberships) {
+                        if (m.id !== didFind?.id) {
+                            if (!m.locked && (m.generated || m.membershipTypeId === cheapestMembership.membership.id)) {
                                 if (!silent) {
-                                    console.error('Failed to calculate price for active membership', m.id, e);
+                                    console.log('Removing membership because cheaper membership found or duplicate, for: ' + me.id + ' - membership ' + m.id);
+                                }
+                                await m.doDelete();
+                            }
+                            else {
+                                // Update price
+                                if (!m.locked) {
+                                    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();
-                            didFind = true;
-                            break;
                         }
                     }
 
@@ -315,6 +327,8 @@ export class PlatformMembershipService {
                         continue;
                     }
 
+                    // Otherwise make sure we create a new membership
+
                     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);
@@ -351,16 +365,6 @@ export class PlatformMembershipService {
 
                     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);
-                            }
-                            await toDelete.doDelete();
-                        }
-                    }
                 }
             });
         });