@stamhoofd/backend 2.78.1 → 2.78.3

package/src/services/MemberRecordStore.ts

@@ -0,0 +1,155 @@
+import { Model } from '@simonbackx/simple-database';
+import { Organization, Platform } from '@stamhoofd/models';
+import { RecordSettings } from '@stamhoofd/structures';
+
+export type RecordCacheEntry = { record: RecordSettings; rootCategoryId: string; organizationId: string | null };
+
+/**
+ * Service that caches all available member records in the system.
+ * - It verified whether ids are unique system wide
+ * - It allows fast retrieving of record settings by id (for permission checking)
+ */
+export class MemberRecordStore {
+    private static cache = new Map<string, RecordCacheEntry>();
+
+    constructor() {
+
+    }
+
+    static init() {
+        // Load initial data
+        this.loadIfNeeded().catch(console.error);
+
+        // Create listeners to update data as organizations and platform is updated
+        this.listen();
+    }
+
+    private static listening = false;
+
+    private static listen() {
+        // Create listeners to update data as organizations and platform is updated
+        if (this.listening) {
+            return;
+        }
+
+        this.listening = true;
+        Model.modelEventBus.addListener(this, async (event) => {
+            if (event.type === 'deleted') {
+                if (event.model instanceof Platform || event.model instanceof Organization) {
+                    // Reload
+                    this._didLoadAll = false;
+                    this._loadAllPromise = null;
+                }
+                return;
+            }
+
+            if (event.model instanceof Platform) {
+                // Delete all records with organizationId = null
+                for (const [id, entry] of this.cache) {
+                    if (entry.organizationId === null) {
+                        this.cache.delete(id);
+                    }
+                }
+
+                // Readd of this model
+                for (const recordCategory of event.model.config.recordsConfiguration.recordCategories) {
+                    for (const record of recordCategory.getAllRecords()) {
+                        // Add to cache
+                        this.cache.set(record.id, {
+                            record: record.clone(),
+                            organizationId: null,
+                            rootCategoryId: recordCategory.id,
+                        });
+                    }
+                }
+            }
+
+            if (event.model instanceof Organization) {
+                // Delete all records with organizationId = null
+                for (const [id, entry] of this.cache) {
+                    if (entry.organizationId === event.model.id) {
+                        this.cache.delete(id);
+                    }
+                }
+
+                // Readd of this model
+                for (const recordCategory of event.model.meta.recordsConfiguration.recordCategories) {
+                    for (const record of recordCategory.getAllRecords()) {
+                        // Add to cache
+                        this.cache.set(record.id, {
+                            record: record.clone(),
+                            organizationId: event.model.id,
+                            rootCategoryId: recordCategory.id,
+                        });
+                    }
+                }
+            }
+        });
+    }
+
+    static _loadAllPromise: Promise<void> | null = null;
+    static _didLoadAll = false;
+
+    static async loadIfNeeded() {
+        if (this._didLoadAll) {
+            return;
+        }
+
+        if (this._loadAllPromise) {
+            await this._loadAllPromise;
+        }
+        else {
+            this._loadAllPromise = (async () => {
+                try {
+                    await this.loadAll();
+                }
+                catch (e) {
+                    // Failed to load
+                    this._loadAllPromise = null;
+                    throw e;
+                }
+                this._didLoadAll = true;
+                this._loadAllPromise = null;
+            })();
+            await this._loadAllPromise;
+        }
+    }
+
+    static async loadAll() {
+        this.cache = new Map<string, RecordCacheEntry>();
+
+        const platform = await Platform.getShared();
+        for (const recordCategory of platform.config.recordsConfiguration.recordCategories) {
+            for (const record of recordCategory.getAllRecords()) {
+                // Add to cache
+                this.cache.set(record.id, {
+                    record: record.clone(),
+                    organizationId: null,
+                    rootCategoryId: recordCategory.id,
+                });
+            }
+        }
+
+        for await (const organization of Organization.select().all()) {
+            for (const recordCategory of organization.meta.recordsConfiguration.recordCategories) {
+                for (const record of recordCategory.getAllRecords()) {
+                    if (this.cache.has(record.id)) {
+                        console.error(`Duplicate record id ${record.id} found in organization ${organization.id} for record ${record.name} (${record.id}) in ${recordCategory.name}`);
+                        continue;
+                    }
+                    // Add to cache
+                    this.cache.set(record.id, {
+                        record: record.clone(),
+                        organizationId: organization.id,
+                        rootCategoryId: recordCategory.id,
+                    });
+                }
+            }
+        }
+    }
+
+    static async getRecord(id: string): Promise<RecordCacheEntry | null> {
+        await this.loadIfNeeded();
+        return this.cache.get(id) ?? null;
+    }
+}

package/src/services/PlatformMembershipService.ts

@@ -138,6 +138,9 @@ export class PlatformMembershipService {
 
     static async updateMembershipsForId(id: string, silent = false) {
         if (STAMHOOFD.userMode === 'organization') {
+            if (!silent) {
+                console.warn('Skipping automatic membership for: ' + id, ' - organization mode');
+            }
             return;
         }
 
@@ -161,6 +164,12 @@ export class PlatformMembershipService {
                     .where('endDate', SQLWhereSign.GreaterEqual, new Date()) // Avoid updating the price of past periods that were not yet locked
                     .fetch();
 
+                if (periods.length === 0) {
+                    if (!silent) {
+                        console.warn('No periods found for member ' + me.id);
+                    }
+                }
+
                 // 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);
@@ -252,16 +261,16 @@ export class PlatformMembershipService {
                         const tagIdsA = a.organization?.meta.tags ?? [];
                         const tagIdsB = b.organization?.meta.tags ?? [];
                         const aPrice = a.membership.getPrice(
-                            period.id, 
-                            a.registration.startDate ?? a.registration.registeredAt ?? a.registration.createdAt, 
-                            tagIdsA, 
-                            shouldApplyReducedPrice
+                            period.id,
+                            a.registration.startDate ?? a.registration.registeredAt ?? a.registration.createdAt,
+                            tagIdsA,
+                            shouldApplyReducedPrice,
                         ) ?? 10000000;
                         const bPrice = b.membership.getPrice(
-                            period.id, 
-                            b.registration.startDate ?? b.registration.registeredAt ?? b.registration.createdAt, 
-                            tagIdsB, 
-                            shouldApplyReducedPrice
+                            period.id,
+                            b.registration.startDate ?? b.registration.registeredAt ?? b.registration.createdAt,
+                            tagIdsB,
+                            shouldApplyReducedPrice,
                         ) ?? 10000000;
 
                         const diff = aPrice - bPrice;

package/tests/e2e/register.test.ts

@@ -6,7 +6,9 @@ import { GetMemberFamilyEndpoint } from '../../src/endpoints/global/members/GetM
 import { RegisterMembersEndpoint } from '../../src/endpoints/global/registration/RegisterMembersEndpoint';
 import { GetMemberBalanceEndpoint } from '../../src/endpoints/organization/dashboard/payments/GetMemberBalanceEndpoint';
 import { GetReceivableBalanceEndpoint } from '../../src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint';
+import { PlatformMembershipService } from '../../src/services/PlatformMembershipService';
 import { testServer } from '../helpers/TestServer';
+import { TestUtils } from '@stamhoofd/test-utils';
 
 describe('E2E.Register', () => {
     // #region global
@@ -45,6 +47,11 @@ describe('E2E.Register', () => {
 
     // #endregion
 
+    beforeEach(async () => {
+        // These tests should run in platform mode
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
     beforeAll(async () => {
         const previousPeriod = await new RegistrationPeriodFactory({
             startDate: new Date(2022, 0, 1),
@@ -108,7 +115,7 @@ describe('E2E.Register', () => {
     beforeEach(async () => {
     });
 
-    describe('Register', () => {
+    describe('Register prices and balances', () => {
         test('Register by member should create balance for member', async () => {
             // #region arrange
             const { organization, group, groupPrice, token, member } = await initData();
@@ -150,6 +157,7 @@ describe('E2E.Register', () => {
             expect(balance.body.length).toBe(1);
             expect(balance.body[0].price).toBe(25);
             expect(balance.body[0].pricePaid).toBe(0);
+            expect(balance.body[0].pricePending).toBe(25);
             // #endregion
         });
 
@@ -622,23 +630,29 @@ describe('E2E.Register', () => {
             const balance = await getBalance(member.id, organization, token);
             expect(balance).toBeDefined();
             expect(balance.body.length).toBe(3);
-            expect.arrayContaining([
+            expect(balance.body).toEqual(expect.arrayContaining([
                 expect.objectContaining({
-                    price: 6,
+                    unitPrice: 3,
+                    amount: 2,
+                    pricePending: 6,
                     pricePaid: 0,
                     status: BalanceItemStatus.Due,
                 }),
                 expect.objectContaining({
-                    price: 5,
+                    unitPrice: 21,
                     pricePaid: 0,
+                    pricePending: 21,
+                    amount: 1,
                     status: BalanceItemStatus.Due,
                 }),
                 expect.objectContaining({
-                    price: 25,
+                    unitPrice: 1,
                     pricePaid: 0,
+                    pricePending: 5,
+                    amount: 5,
                     status: BalanceItemStatus.Due,
                 }),
-            ]);
+            ]));
             // #endregion
         });
     });
@@ -726,18 +740,18 @@ describe('E2E.Register', () => {
             expect(balance).toBeDefined();
             expect(balance.body.length).toBe(2);
 
-            expect.arrayContaining([
+            expect(balance.body).toEqual(expect.arrayContaining([
                 expect.objectContaining({
-                    price: 25,
+                    unitPrice: 25,
                     pricePaid: 0,
                     status: BalanceItemStatus.Canceled,
                 }),
                 expect.objectContaining({
-                    price: 30,
+                    unitPrice: 30,
                     pricePaid: 0,
                     status: BalanceItemStatus.Due,
                 }),
-            ]);
+            ]));
             // #endregion
         });
 
@@ -860,28 +874,32 @@ describe('E2E.Register', () => {
             expect(balance).toBeDefined();
             expect(balance.body.length).toBe(4);
 
-            expect.arrayContaining([
+            expect(balance.body).toEqual(expect.arrayContaining([
                 expect.objectContaining({
-                    price: 10,
+                    unitPrice: 5,
+                    amount: 2,
                     pricePaid: 0,
                     status: BalanceItemStatus.Canceled,
                 }),
                 expect.objectContaining({
-                    price: 15,
+                    unitPrice: 3,
                     pricePaid: 0,
+                    amount: 5,
                     status: BalanceItemStatus.Canceled,
                 }),
                 expect.objectContaining({
-                    price: 25,
+                    unitPrice: 25,
                     pricePaid: 0,
+                    amount: 1,
                     status: BalanceItemStatus.Canceled,
                 }),
                 expect.objectContaining({
-                    price: 30,
+                    unitPrice: 30,
                     pricePaid: 0,
+                    amount: 1,
                     status: BalanceItemStatus.Due,
                 }),
-            ]);
+            ]));
             // #endregion
         });
 
@@ -968,24 +986,32 @@ describe('E2E.Register', () => {
             expect(balance).toBeDefined();
             expect(balance.body.length).toBe(3);
 
-            expect.arrayContaining([
+            expect(balance.body).toEqual(expect.arrayContaining([
                 expect.objectContaining({
-                    price: 25,
+                    unitPrice: 25,
                     pricePaid: 0,
+                    pricePending: 0,
+                    amount: 1,
                     status: BalanceItemStatus.Canceled,
+                    type: BalanceItemType.Registration,
                 }),
                 expect.objectContaining({
-                    price: 30,
+                    unitPrice: 30,
                     pricePaid: 0,
+                    pricePending: 0,
+                    amount: 1,
                     status: BalanceItemStatus.Due,
+                    type: BalanceItemType.Registration,
                 }),
                 expect.objectContaining({
-                    price: 5,
+                    unitPrice: 5,
                     pricePaid: 0,
+                    pricePending: 0,
+                    amount: 1,
                     type: BalanceItemType.CancellationFee,
                     status: BalanceItemStatus.Due,
                 }),
-            ]);
+            ]));
             // #endregion
         });
     });
@@ -1076,6 +1102,8 @@ describe('E2E.Register', () => {
                 expect(response.body).toBeDefined();
                 expect(response.body.registrations.length).toBe(1);
 
+                await PlatformMembershipService.updateMembershipsForId(member.id, false);
+
                 const familyAfter = await getMemberFamily(member.id, organization, token);
                 expect(familyAfter).toBeDefined();
                 expect(familyAfter.body.members.length).toBe(1);

package/tests/helpers/StripeMocker.ts

@@ -24,6 +24,10 @@ export class StripeMocker {
     }
 
     start() {
+        if (!STAMHOOFD.STRIPE_SECRET_KEY || !STAMHOOFD.STRIPE_SECRET_KEY.startsWith('sk_test_')) {
+            throw new Error('Invalid STRIPE_SECRET_KEY. Even in test mode it should start with sk_test_');
+        }
+
         nock('https://api.stripe.com')
             .persist()
             .get(/v1\/.*/)
@@ -162,8 +166,8 @@ export class StripeMocker {
 
         const r = Request.buildJson('POST', `/stripe/webhooks`, undefined, payload);
         r.headers['stripe-signature'] = stripe.webhooks.generateTestHeaderString({
-            payload: JSON.stringify(payload),
-            secret: STAMHOOFD.STRIPE_ENDPOINT_SECRET,
+            payload: await r.body,
+            secret: payload.account ? STAMHOOFD.STRIPE_CONNECT_ENDPOINT_SECRET : STAMHOOFD.STRIPE_ENDPOINT_SECRET,
         });
         await testServer.test(endpoint, r);
     }
@@ -206,6 +210,7 @@ export class StripeMocker {
 
     stop() {
         nock.cleanAll();
+        nock.disableNetConnect();
     }
 }
 

package/tests/jest.global.setup.ts

@@ -2,10 +2,13 @@ import backendEnv from '@stamhoofd/backend-env';
 backendEnv.load({ path: __dirname + '/../../.env.test.json' });
 
 import { Database, Migration } from '@simonbackx/simple-database';
+import * as jose from 'jose';
+import nock from 'nock';
 import path from 'path';
+import { GlobalHelper } from '../src/helpers/GlobalHelper';
 const emailPath = require.resolve('@stamhoofd/email');
 const modelsPath = require.resolve('@stamhoofd/models');
-import nock from 'nock';
+import { TestUtils } from '@stamhoofd/test-utils';
 
 // Disable network requests
 nock.disableNetConnect();
@@ -27,4 +30,6 @@ export default async () => {
     await Migration.runAll(__dirname + '/src/migrations');
 
     await Database.end();
+
+    await TestUtils.globalSetup();
 };

package/tests/jest.setup.ts

@@ -9,6 +9,7 @@ import { sleep } from '@stamhoofd/utility';
 import nock from 'nock';
 import { GlobalHelper } from '../src/helpers/GlobalHelper';
 import * as jose from 'jose';
+import { TestUtils } from '@stamhoofd/test-utils';
 
 // Set version of saved structures
 Column.setJSONVersion(Version);
@@ -30,6 +31,9 @@ if (new Date().getTimezoneOffset() !== 0) {
 console.log = jest.fn();
 
 beforeAll(async () => {
+    nock.cleanAll();
+    nock.disableNetConnect();
+
     await Database.delete('DELETE FROM `tokens`');
     await Database.delete('DELETE FROM `users`');
     await Database.delete('DELETE FROM `registrations`');
@@ -37,6 +41,8 @@ beforeAll(async () => {
     await Database.delete('DELETE FROM `postal_codes`');
     await Database.delete('DELETE FROM `cities`');
     await Database.delete('DELETE FROM `provinces`');
+    await Database.delete('DELETE FROM `email_recipients`');
+    await Database.delete('DELETE FROM `emails`');
 
     await Database.delete('DELETE FROM `webshop_orders`');
     await Database.delete('DELETE FROM `webshops`');
@@ -57,8 +63,8 @@ beforeAll(async () => {
     const exportedPublicKey = await jose.exportJWK(publicKey);
     const exportedPrivateKey = await jose.exportJWK(privateKey);
 
-    (STAMHOOFD as any).FILE_SIGNING_PUBLIC_KEY = exportedPublicKey;
-    (STAMHOOFD as any).FILE_SIGNING_PRIVATE_KEY = exportedPrivateKey;
+    TestUtils.setPermanentEnvironment('FILE_SIGNING_PUBLIC_KEY', exportedPublicKey);
+    TestUtils.setPermanentEnvironment('FILE_SIGNING_PRIVATE_KEY', exportedPrivateKey);
 
     await GlobalHelper.load();
 });
@@ -71,3 +77,5 @@ afterAll(async () => {
     }
     await Database.end();
 });
+
+TestUtils.setup();