@stamhoofd/backend 2.78.1 → 2.78.3

package/.env.ci.json

@@ -8,16 +8,19 @@
             "NL": "dev.stamhoofd.nl"
         },
         "webshop": "shop.stamhoofd.dev",
-        "api": "api.stamhoofd.dev"
+        "api": "api.stamhoofd.dev",
+        "defaultBroadcastEmail": {
+            "": "stamhoofd.email"
+        }
     },
     
     "PORT": 9091,
     "DB_HOST": "127.0.0.1",
     "DB_USER": "root",
     "DB_PASS": "root",
-    "DB_DATABASE": "stamhoofd",
+    "DB_DATABASE": "stamhoofd-tests",
 
-    "SMTP_HOST": "email-smtp.eu-west-1.amazonaws.com",
+    "SMTP_HOST": "0.0.0.0",
     "SMTP_USERNAME": "test",
     "SMTP_PASSWORD": "test",
     "SMTP_PORT": 587,
@@ -26,17 +29,19 @@
     "AWS_SECRET_ACCESS_KEY": "",
     "AWS_REGION": "",
 
-    "SPACES_ENDPOINT": "ams3.digitaloceanspaces.com",
-    "SPACES_BUCKET": "stamhoofd",
-    "SPACES_KEY": "",
-    "SPACES_SECRET": "",
+    "SPACES_ENDPOINT": "anydomain.example",
+    "SPACES_BUCKET": "example",
+    "SPACES_KEY": "test",
+    "SPACES_SECRET": "test",
 
     "INTERNAL_SECRET_KEY": "test",
 
-    "STRIPE_SECRET_KEY": "test",
-    "STRIPE_ENDPOINT_SECRET": "test",
+    "STRIPE_SECRET_KEY": "sk_test_test",
+    "STRIPE_ENDPOINT_SECRET": "sk_test",
     "translationNamespace": "digit",
     "platformName": "ravot",
     "userMode": "organization",
-    "WHITELISTED_EMAIL_DESTINATIONS": []
+    "WHITELISTED_EMAIL_DESTINATIONS": [],
+    "MEMBER_NUMBER_ALGORITHM": "Incremental",
+    "MEMBER_NUMBER_ALGORITHM_LENGTH": 10
 }

package/jest.config.cjs

@@ -1,3 +1,5 @@
+const useGithubActions = !!process.env.GITHUB_ACTIONS;
+
 module.exports = {
     roots: ['<rootDir>/dist'],
     testEnvironment: 'node',
@@ -5,6 +7,21 @@ module.exports = {
         'jest-extended/all',
         './dist/tests/jest.setup.js',
     ],
+    reporters: [['jest-console-group-reporter', {
+        consoleLevels: ['error', 'warn', 'log'],
+        filters: [],
+        groups: [],
+        onlyFailingTestSuites: true,
+        afterEachTest: {
+            enable: false,
+        },
+        afterAllTests: {
+            reportType: 'detailed',
+            enable: true,
+            filePaths: true,
+        },
+        useGitHubActions: useGithubActions,
+    }]],
     globalSetup: './dist/tests/jest.global.setup.js',
     // verbose: true,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.78.1",
+    "version": "2.78.3",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -37,14 +37,14 @@
         "@simonbackx/simple-encoding": "2.20.0",
         "@simonbackx/simple-endpoints": "1.19.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.78.1",
-        "@stamhoofd/backend-middleware": "2.78.1",
-        "@stamhoofd/email": "2.78.1",
-        "@stamhoofd/models": "2.78.1",
-        "@stamhoofd/queues": "2.78.1",
-        "@stamhoofd/sql": "2.78.1",
-        "@stamhoofd/structures": "2.78.1",
-        "@stamhoofd/utility": "2.78.1",
+        "@stamhoofd/backend-i18n": "2.78.3",
+        "@stamhoofd/backend-middleware": "2.78.3",
+        "@stamhoofd/email": "2.78.3",
+        "@stamhoofd/models": "2.78.3",
+        "@stamhoofd/queues": "2.78.3",
+        "@stamhoofd/sql": "2.78.3",
+        "@stamhoofd/structures": "2.78.3",
+        "@stamhoofd/utility": "2.78.3",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "3e6f3c8bf1f8ca422b22e53ad0621f7a0cf2f01d"
+    "gitHead": "272bfbb259109530326ec2fd8c83af5f69d6268b"
 }

package/src/endpoints/auth/GetUserEndpoint.test.ts

@@ -1,6 +1,5 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory, Token, UserFactory } from '@stamhoofd/models';
-import { NewUser } from '@stamhoofd/structures';
 
 import { testServer } from '../../../tests/helpers/TestServer';
 import { GetUserEndpoint } from './GetUserEndpoint';
@@ -19,21 +18,12 @@ describe('Endpoint.GetUser', () => {
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
-
-        if (!(response.body instanceof NewUser)) {
-            throw new Error('Expected NewUser');
-        }
-
         expect(response.body.id).toEqual(user.id);
     });
 
     test('Request user details when not signed in is not working', async () => {
         const organization = await new OrganizationFactory({}).create();
-        const user = await new UserFactory({ organization }).create();
-        const token = await Token.createToken(user);
-
         const r = Request.buildJson('GET', '/v1/user', organization.getApiHost());
-
         await expect(testServer.test(endpoint, r)).rejects.toThrow(/missing/i);
     });
 

package/src/endpoints/global/organizations/CreateOrganizationEndpoint.test.ts

@@ -4,7 +4,7 @@ import { Address, Country, CreateOrganization, NewUser, Organization as Organiza
 import { testServer } from '../../../../tests/helpers/TestServer';
 import { CreateOrganizationEndpoint } from './CreateOrganizationEndpoint';
 
-describe('Endpoint.CreateOrganization', () => {
+describe.skip('Endpoint.CreateOrganization', () => {
     // Test endpoint
     const endpoint = new CreateOrganizationEndpoint();
 

package/src/endpoints/global/organizations/GetOrganizationFromDomainEndpoint.test.ts

@@ -11,7 +11,6 @@ describe('Endpoint.GetOrganizationFromDomain', () => {
 
     test('Get organization from default uri', async () => {
         const organization = await new OrganizationFactory({}).create();
-        const groups = await new GroupFactory({ organization }).createMultiple(2);
 
         const r = Request.buildJson('GET', '/v2/organization-from-domain');
         r.query = {
@@ -26,12 +25,10 @@ describe('Endpoint.GetOrganizationFromDomain', () => {
         }
 
         expect(response.body.id).toEqual(organization.id);
-        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort());
     });
 
     test('Get organization from custom domain', async () => {
         const organization = await new OrganizationFactory({ domain: 'inschrijven.mijnscouts.be' }).create();
-        const groups = await new GroupFactory({ organization }).createMultiple(2);
 
         const r = Request.buildJson('GET', '/v2/organization-from-domain');
         r.query = {
@@ -46,6 +43,5 @@ describe('Endpoint.GetOrganizationFromDomain', () => {
         }
 
         expect(response.body.id).toEqual(organization.id);
-        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort());
     });
 });

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.test.ts

@@ -1,6 +1,5 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory } from '@stamhoofd/models';
-import { OrganizationSimple } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 
 import { testServer } from '../../../../tests/helpers/TestServer';
@@ -25,7 +24,6 @@ describe('Endpoint.SearchOrganization', () => {
         expect(response.body).toHaveLength(1);
 
         // Access token should be expired
-        expect(response.body[0]).toBeInstanceOf(OrganizationSimple);
         expect(response.status).toEqual(200);
         expect(response.body[0]).toMatchObject({
             id: organization.id,
@@ -50,8 +48,6 @@ describe('Endpoint.SearchOrganization', () => {
         expect(response.body).toHaveLength(2);
 
         // Access token should be expired
-        expect(response.body[0]).toBeInstanceOf(OrganizationSimple);
-        expect(response.body[1]).toBeInstanceOf(OrganizationSimple);
         expect(response.status).toEqual(200);
         expect(response.body.map(o => o.id).sort()).toEqual(organizations.map(o => o.id).sort());
     });

package/src/endpoints/global/registration/PatchUserMembersEndpoint.test.ts

@@ -1,9 +1,11 @@
-import { PatchableArray } from '@simonbackx/simple-encoding';
+import { PatchableArray, PatchMap } from '@simonbackx/simple-encoding';
 import { Endpoint, Request } from '@simonbackx/simple-endpoints';
-import { GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, Token, UserFactory } from '@stamhoofd/models';
-import { MemberDetails, MemberWithRegistrationsBlob, Parent } from '@stamhoofd/structures';
+import { GroupFactory, MemberFactory, OrganizationFactory, Platform, RegistrationFactory, Token, UserFactory } from '@stamhoofd/models';
+import { MemberDetails, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PatchAnswers, PermissionLevel, RecordCategory, RecordSettings, RecordTextAnswer } from '@stamhoofd/structures';
 import { testServer } from '../../../../tests/helpers/TestServer';
 import { PatchUserMembersEndpoint } from './PatchUserMembersEndpoint';
+import { Database } from '@simonbackx/simple-database';
+import { TestUtils } from '@stamhoofd/test-utils';
 
 const baseUrl = `/members`;
 const endpoint = new PatchUserMembersEndpoint();
@@ -17,12 +19,20 @@ const birthDay = { year: 1993, month: 4, day: 5 };
 const errorWithCode = (code: string) => expect.objectContaining({ code }) as jest.Constructable;
 
 describe('Endpoint.PatchUserMembersEndpoint', () => {
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    afterEach(async () => {
+        // Delete all members (so the duplicate checks work as expected)
+        await Database.delete('DELETE FROM `members`');
+    });
+
     describe('Duplicate members', () => {
         test('The security code should be a requirement', async () => {
             const organization = await new OrganizationFactory({ }).create();
-            const user = await new UserFactory({ organization }).create();
+            const user = await new UserFactory({ }).create();
             const existingMember = await new MemberFactory({
-                organization,
                 firstName,
                 lastName,
                 birthDay,
@@ -50,9 +60,8 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
 
         test('The security code is not a requirement for members without additional data', async () => {
             const organization = await new OrganizationFactory({ }).create();
-            const user = await new UserFactory({ organization }).create();
+            const user = await new UserFactory({ }).create();
             const existingMember = await new MemberFactory({
-                organization,
                 firstName,
                 lastName,
                 birthDay,
@@ -108,7 +117,6 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
             });
 
             const existingMember = await new MemberFactory({
-                organization,
                 birthDay,
                 details,
             }).create();
@@ -160,4 +168,276 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
             expect(member.details.parents[0]).toEqual(existingMember.details.parents[0]);
         });
     });
+
+    describe('Record answers', () => {
+        test('A user can save answers of records of an organization it has not yet registered for', async () => {
+            const commentsRecord = RecordSettings.create({
+                name: 'Opmerkingen',
+            });
+
+            const recordCategory = RecordCategory.create({
+                name: 'Medische fiche',
+                records: [
+                    commentsRecord,
+                ],
+            });
+            const organization = await new OrganizationFactory({
+                meta: OrganizationMetaData.create({
+                    recordsConfiguration: OrganizationRecordsConfiguration.create({
+                        recordCategories: [recordCategory],
+                    }),
+                }),
+            }).create();
+
+            const user = await new UserFactory({ }).create();
+            const existingMember = await new MemberFactory({
+                firstName,
+                lastName,
+                birthDay,
+                generateData: false,
+                // Give user access to this member
+                user,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const recordAnswers = new PatchMap() as PatchAnswers;
+
+            recordAnswers.set(commentsRecord.id, RecordTextAnswer.create({
+                settings: commentsRecord,
+                value: 'Some comments',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: existingMember.id,
+                details: MemberDetails.patch({
+                    recordAnswers,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            const response = await testServer.test(endpoint, request);
+
+            // Check returned
+            expect(response.status).toBe(200);
+            expect(response.body.members.length).toBe(1);
+            const member = response.body.members[0];
+            expect(member.details.recordAnswers.get(commentsRecord.id)).toMatchObject({
+                value: 'Some comments',
+            });
+        });
+
+        test('A user cannot save answers to organization read-only records', async () => {
+            const commentsRecord = RecordSettings.create({
+                name: 'Opmerkingen',
+                externalPermissionLevel: PermissionLevel.Read,
+            });
+
+            const recordCategory = RecordCategory.create({
+                name: 'Medische fiche',
+                records: [
+                    commentsRecord,
+                ],
+            });
+            const organization = await new OrganizationFactory({
+                meta: OrganizationMetaData.create({
+                    recordsConfiguration: OrganizationRecordsConfiguration.create({
+                        recordCategories: [recordCategory],
+                    }),
+                }),
+            }).create();
+
+            const user = await new UserFactory({ }).create();
+            const existingMember = await new MemberFactory({
+                firstName,
+                lastName,
+                birthDay,
+                generateData: false,
+                // Give user access to this member
+                user,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const recordAnswers = new PatchMap() as PatchAnswers;
+
+            recordAnswers.set(commentsRecord.id, RecordTextAnswer.create({
+                settings: commentsRecord,
+                value: 'Some comments',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: existingMember.id,
+                details: MemberDetails.patch({
+                    recordAnswers,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            await expect(testServer.test(endpoint, request)).rejects.toThrow(errorWithCode('permission_denied'));
+        });
+
+        test('A user can save answers of records of the platform', async () => {
+            const commentsRecord = RecordSettings.create({
+                name: 'Opmerkingen',
+            });
+
+            const recordCategory = RecordCategory.create({
+                name: 'Medische fiche',
+                records: [
+                    commentsRecord,
+                ],
+            });
+
+            const platform = await Platform.getShared();
+            platform.config.recordsConfiguration.recordCategories.push(recordCategory);
+            await platform.save();
+
+            const organization = await new OrganizationFactory({}).create();
+
+            const user = await new UserFactory({ }).create();
+            const existingMember = await new MemberFactory({
+                firstName,
+                lastName,
+                birthDay,
+                generateData: false,
+                // Give user access to this member
+                user,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const recordAnswers = new PatchMap() as PatchAnswers;
+
+            recordAnswers.set(commentsRecord.id, RecordTextAnswer.create({
+                settings: commentsRecord,
+                value: 'Some comments',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: existingMember.id,
+                details: MemberDetails.patch({
+                    recordAnswers,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            const response = await testServer.test(endpoint, request);
+
+            // Check returned
+            expect(response.status).toBe(200);
+            expect(response.body.members.length).toBe(1);
+            const member = response.body.members[0];
+            expect(member.details.recordAnswers.get(commentsRecord.id)).toMatchObject({
+                value: 'Some comments',
+            });
+        });
+
+        test('A user cannot save answers to platform read-only records', async () => {
+            const commentsRecord = RecordSettings.create({
+                name: 'Opmerkingen',
+                externalPermissionLevel: PermissionLevel.Read,
+            });
+
+            const recordCategory = RecordCategory.create({
+                name: 'Medische fiche',
+                records: [
+                    commentsRecord,
+                ],
+            });
+
+            const platform = await Platform.getShared();
+            platform.config.recordsConfiguration.recordCategories.push(recordCategory);
+            await platform.save();
+
+            const organization = await new OrganizationFactory({}).create();
+
+            const user = await new UserFactory({ }).create();
+            const existingMember = await new MemberFactory({
+                firstName,
+                lastName,
+                birthDay,
+                generateData: false,
+                // Give user access to this member
+                user,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const recordAnswers = new PatchMap() as PatchAnswers;
+
+            recordAnswers.set(commentsRecord.id, RecordTextAnswer.create({
+                settings: commentsRecord,
+                value: 'Some comments',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: existingMember.id,
+                details: MemberDetails.patch({
+                    recordAnswers,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            await expect(testServer.test(endpoint, request)).rejects.toThrow(errorWithCode('permission_denied'));
+        });
+
+        test('A user can not save anwers to inexisting records', async () => {
+            const commentsRecord = RecordSettings.create({
+                name: 'Opmerkingen',
+            });
+
+            const organization = await new OrganizationFactory({
+                meta: OrganizationMetaData.create({
+                    recordsConfiguration: OrganizationRecordsConfiguration.create({
+                        recordCategories: [],
+                    }),
+                }),
+            }).create();
+
+            const user = await new UserFactory({ }).create();
+            const existingMember = await new MemberFactory({
+                firstName,
+                lastName,
+                birthDay,
+                generateData: false,
+                // Give user access to this member
+                user,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const recordAnswers = new PatchMap() as PatchAnswers;
+
+            recordAnswers.set(commentsRecord.id, RecordTextAnswer.create({
+                settings: commentsRecord,
+                value: 'Some comments',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: existingMember.id,
+                details: MemberDetails.patch({
+                    recordAnswers,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            await expect(testServer.test(endpoint, request)).rejects.toThrow(errorWithCode('permission_denied'));
+        });
+    });
 });

package/src/endpoints/global/registration/RegisterMembersEndpoint.test.ts

@@ -770,7 +770,7 @@ describe('Endpoint.RegisterMembers', () => {
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 0,
+                totalPrice: 25,
                 asOrganizationId: organization.id,
             });
 
@@ -1649,7 +1649,7 @@ describe('Endpoint.RegisterMembers', () => {
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 5,
+                totalPrice: 30,
                 asOrganizationId: organization.id,
                 customer: null,
             });
@@ -1927,7 +1927,7 @@ describe('Endpoint.RegisterMembers', () => {
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 5,
+                totalPrice: 30,
                 asOrganizationId: organization1.id,
                 customer: null,
             });
@@ -2049,7 +2049,7 @@ describe('Endpoint.RegisterMembers', () => {
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 5,
+                totalPrice: 30,
                 asOrganizationId: organization.id,
                 customer: null,
             });
@@ -2226,7 +2226,7 @@ describe('Endpoint.RegisterMembers', () => {
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 5,
+                totalPrice: 30,
                 customer: null,
                 asOrganizationId: organization.id,
             });
@@ -2331,7 +2331,7 @@ describe('Endpoint.RegisterMembers', () => {
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 5,
+                totalPrice: 30,
                 customer: null,
                 asOrganizationId: organization.id,
             });
@@ -2355,7 +2355,7 @@ describe('Endpoint.RegisterMembers', () => {
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 5,
+                totalPrice: 30,
                 customer: null,
                 asOrganizationId: organization.id,
             });