@stamhoofd/backend 2.85.3 → 2.85.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.85.3",
+    "version": "2.85.4",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -43,14 +43,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.85.3",
-        "@stamhoofd/backend-middleware": "2.85.3",
-        "@stamhoofd/email": "2.85.3",
-        "@stamhoofd/models": "2.85.3",
-        "@stamhoofd/queues": "2.85.3",
-        "@stamhoofd/sql": "2.85.3",
-        "@stamhoofd/structures": "2.85.3",
-        "@stamhoofd/utility": "2.85.3",
+        "@stamhoofd/backend-i18n": "2.85.4",
+        "@stamhoofd/backend-middleware": "2.85.4",
+        "@stamhoofd/email": "2.85.4",
+        "@stamhoofd/models": "2.85.4",
+        "@stamhoofd/queues": "2.85.4",
+        "@stamhoofd/sql": "2.85.4",
+        "@stamhoofd/structures": "2.85.4",
+        "@stamhoofd/utility": "2.85.4",
         "archiver": "^7.0.1",
         "axios": "1.6.8",
         "cookie": "^0.5.0",
@@ -69,5 +69,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "5a80111e83be35a396c48ba30d0569d9376b953a"
+    "gitHead": "ecceacc395d167a6761f1425e77cfc06a31fe8a9"
 }

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -17,6 +17,7 @@ import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
 import { RegistrationService } from '../../../services/RegistrationService';
 import { shouldCheckIfMemberIsDuplicateForPatch } from './shouldCheckIfMemberIsDuplicate';
+import { MemberNumberService } from '../../../services/MemberNumberService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -534,6 +535,17 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 // Save if okay
                 await membership.save();
 
+                if (member.details.memberNumber === null) {
+                    try {
+                        await MemberNumberService.assignMemberNumber(member, membership);
+                    }
+                    catch (error) {
+                        console.error(`Failed to assign member number for id ${member.id}: ${error.message}`);
+                        // If the assignment of the member number fails the membership is not created but the member is registered
+                        continue;
+                    }
+                }
+
                 updateMembershipMemberIds.add(member.id);
             }
 

package/src/seeds/1750090030-records-configuration.ts

@@ -0,0 +1,22 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Organization } from '@stamhoofd/models';
+
+export async function startRecordsConfigurationMigration() {
+    for await (const organization of Organization.select().all()) {
+        await organization.save();
+    }
+}
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    if (STAMHOOFD.platformName.toLowerCase() !== 'stamhoofd') {
+        console.log('skipped for platform (only runs for Stamhoofd): ' + STAMHOOFD.platformName);
+        return;
+    }
+
+    await startRecordsConfigurationMigration();
+});

package/src/services/BalanceItemService.ts

@@ -182,29 +182,14 @@ export const BalanceItemService = {
 
     async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
         await this.markDue(balanceItem);
+        let shouldMarkUpdated = true;
 
-        if (balanceItem.paidAt) {
-            // Already ran side effects
-            // If we for example deleted a related order or registration - and we still have the balance item, mark it as paid again, we don't want to reactivate the order or registration
-            await this.markUpdated(balanceItem, payment, organization);
-            return;
-        }
-
-        // 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'
-        // in that case, we should be careful not to mark the registration as valid again
-
-        // If registration
-        if (balanceItem.registrationId) {
-            if (balanceItem.type === BalanceItemType.Registration) {
-                await RegistrationService.markValid(balanceItem.registrationId);
-            }
-        }
-
-        // If order
+        // For orders, we should always call markPaid on the order - it is safe to call this multiple times
+        // we need to call it multiple times, in case the order was previously marked unpaid, and then paid again - then we'll need to recreate the tickets
         if (balanceItem.orderId) {
             const order = await Order.getByID(balanceItem.orderId);
             if (order) {
+                shouldMarkUpdated = false;
                 await order.markPaid(payment, organization);
 
                 // Save number in balance description
@@ -219,6 +204,26 @@ export const BalanceItemService = {
             }
         }
 
+        if (balanceItem.paidAt) {
+            // Already ran side effects
+            // If we for example deleted a related order or registration - and we still have the balance item, mark it as paid again, we don't want to reactivate the order or registration
+            if (shouldMarkUpdated) {
+                await this.markUpdated(balanceItem, payment, organization);
+            }
+            return;
+        }
+
+        // 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'
+        // in that case, we should be careful not to mark the registration as valid again
+
+        // If registration
+        if (balanceItem.registrationId) {
+            if (balanceItem.type === BalanceItemType.Registration) {
+                await RegistrationService.markValid(balanceItem.registrationId);
+            }
+        }
+
         balanceItem.paidAt = new Date();
         await balanceItem.save();
     },

package/src/services/PlatformMembershipService.ts

@@ -280,6 +280,18 @@ export class PlatformMembershipService {
                     // 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: MemberPlatformMembership | null = null;
+
+                    // First, try to find any undeletable membership - use this as the priority one and delete all others that can be deleted
+                    // Check if we do have the same membership for a different organization that cannot be deleted (locked)
+                    // This is to prevent creating duplicate memberships
+                    for (const m of activeMemberships) {
+                        if (m.membershipTypeId === cheapestMembership.membership.id && m.locked) {
+                            didFind = m;
+                            break;
+                        }
+                    }
+
+                    // Then update all memberships from the same organization for the selected registration date range
                     for (const m of activeMemberships) {
                         if (m.membershipTypeId === cheapestMembership.membership.id && m.organizationId === cheapestMembership.registration.organizationId) {
                             if (!m.locked) {
@@ -295,12 +307,14 @@ export class PlatformMembershipService {
                                 }
                                 await m.save();
                             }
-                            didFind = m;
-                            break;
+
+                            if (!didFind) {
+                                didFind = m;
+                            }
                         }
                     }
 
-                    // Delete all other generated memberships that are not the cheapest one
+                    // Delete all other generated memberships that are not the chosen one
                     for (const m of activeMemberships) {
                         if (m.id !== didFind?.id) {
                             if (!m.locked && (m.generated || m.membershipTypeId === cheapestMembership.membership.id)) {
@@ -327,6 +341,7 @@ export class PlatformMembershipService {
                         }
                     }
 
+                    // We already have a membership, don't create a new one
                     if (didFind) {
                         continue;
                     }