@stamhoofd/backend 2.78.2 → 2.78.4

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

@@ -16,8 +16,7 @@ import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
 import { RegistrationService } from '../../../services/RegistrationService';
-import { shouldCheckIfMemberIsDuplicateForPatch, shouldCheckIfMemberIsDuplicateForPut } from './shouldCheckIfMemberIsDuplicate';
-import { AuditLogService } from '../../../services/AuditLogService';
+import { shouldCheckIfMemberIsDuplicateForPatch } from './shouldCheckIfMemberIsDuplicate';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -109,12 +108,10 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             struct.details.cleanData();
             member.details = struct.details;
 
-            if (shouldCheckIfMemberIsDuplicateForPut(struct)) {
-                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode);
-                if (duplicate) {
+            const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode, 'put');
+            if (duplicate) {
                 // Merge data
-                    member = duplicate;
-                }
+                member = duplicate;
             }
 
             // We risk creating a new member without being able to access it manually afterwards
@@ -159,12 +156,11 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             const securityCode = patch.details?.securityCode; // will get cleared after the filter
 
             if (!member) {
-                throw Context.auth.notFoundOrNoAccess('Je hebt geen toegang tot dit lid of het bestaat niet');
+                throw Context.auth.memberNotFoundOrNoAccess();
             }
 
-            if (!await Context.auth.canAccessMember(member, PermissionLevel.Write)) {
-                // Still allowed if you provide a security code
-                await PatchOrganizationMembersEndpoint.checkSecurityCode(member, securityCode);
+            if (!(await Context.auth.canAccessMember(member, PermissionLevel.Write))) {
+                await PatchOrganizationMembersEndpoint.checkSecurityCode(member, securityCode, 'patch');
             }
 
             patch = await Context.auth.filterMemberPatch(member, patch);
@@ -194,7 +190,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             }
 
             if (shouldCheckDuplicate) {
-                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode);
+                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode, 'patch');
 
                 if (duplicate) {
                     // Remove the member from the list
@@ -759,8 +755,8 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
         }
     }
 
-    static async checkSecurityCode(member: MemberWithRegistrations, securityCode: string | null | undefined) {
-        if (await member.isSafeToMergeDuplicateWithoutSecurityCode() || await Context.auth.canAccessMember(member, PermissionLevel.Write)) {
+    static async checkSecurityCode(member: MemberWithRegistrations, securityCode: string | null | undefined, type: 'put' | 'patch') {
+        if ((type === 'put' && await member.isSafeToMergeDuplicateWithoutSecurityCode()) || await Context.auth.canAccessMember(member, PermissionLevel.Write)) {
             console.log('checkSecurityCode: without security code: allowed for ' + member.id);
         }
         else if (securityCode) {
@@ -802,8 +798,8 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             const log = new AuditLog();
 
             // a member has multiple organizations, so this is difficult to determine - for now it is only visible in the admin panel
-            log.organizationId = member.organizationId; 
-            
+            log.organizationId = member.organizationId;
+
             log.type = AuditLogType.MemberSecurityCodeUsed;
             log.source = AuditLogSource.Anonymous;
 
@@ -823,6 +819,9 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             await log.save();
         }
         else {
+            if (type === 'patch') {
+                throw Context.auth.memberNotFoundOrNoAccess();
+            }
             throw new SimpleError({
                 code: 'known_member_missing_rights',
                 message: 'Creating known member without sufficient access rights',
@@ -832,11 +831,25 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
         }
     }
 
-    static async checkDuplicate(member: Member, securityCode: string | null | undefined) {
+    static shouldCheckIfMemberIsDuplicate(put: Member): boolean {
+        if (put.details.firstName.length <= 3 && put.details.lastName.length <= 3) {
+            return false;
+        }
+
+        const age = put.details.age;
+        // do not check if member is duplicate for historical members
+        return age !== null && age < 81;
+    }
+
+    static async checkDuplicate(member: Member, securityCode: string | null | undefined, type: 'put' | 'patch') {
+        if (!this.shouldCheckIfMemberIsDuplicate(member)) {
+            return;
+        }
+
         // Check for duplicates and prevent creating a duplicate member by a user
         const duplicate = await this.findExistingMember(member);
         if (duplicate) {
-            await this.checkSecurityCode(duplicate, securityCode);
+            await this.checkSecurityCode(duplicate, securityCode, type);
 
             // Merge data
             // NOTE: We use mergeTwoMembers instead of mergeMultipleMembers, because we should never safe 'member' , because that one does not exist in the database

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

@@ -1,34 +1,22 @@
 import { AutoEncoderPatchType } from '@simonbackx/simple-encoding';
 import { MemberDetails, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
 
+/**
+ * Returns true when either the firstname, lastname or birthday has changed
+ */
 export function shouldCheckIfMemberIsDuplicateForPatch(patch: { details: MemberDetails | AutoEncoderPatchType<MemberDetails> | undefined }, originalDetails: MemberDetails): boolean {
     if (patch.details === undefined) {
         return false;
     }
 
-    return (
-    // has long first name
-        ((patch.details.firstName !== undefined && patch.details.firstName.length > 3) || (patch.details.firstName === undefined && originalDetails.firstName.length > 3))
-        // or has long last name
-        || ((patch.details.lastName !== undefined && patch.details.lastName.length > 3) || (patch.details.lastName === undefined && originalDetails.lastName.length > 3))
-    )
-    // has name change or birthday change
-    && (
-    // has first name change
+    // name or birthday has changed
+    if (
         (patch.details.firstName !== undefined && patch.details.firstName !== originalDetails.firstName)
-        // has last name change
         || (patch.details.lastName !== undefined && patch.details.lastName !== originalDetails.lastName)
-        // has birth day change
-        || (patch.details.birthDay !== undefined && patch.details.birthDay?.getTime() !== originalDetails.birthDay?.getTime())
-    );
-}
-
-export function shouldCheckIfMemberIsDuplicateForPut(put: MemberWithRegistrationsBlob): boolean {
-    if (put.details.firstName.length <= 3 && put.details.lastName.length <= 3) {
-        return false;
+        || (patch.details.birthDay !== undefined && patch.details.birthDay !== originalDetails.birthDay)
+    ) {
+        return true;
     }
 
-    const age = put.details.age;
-    // do not check if member is duplicate for historical members
-    return age !== null && age < 81;
+    return false;
 }

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/PatchUserMembersEndpoint.ts

@@ -8,7 +8,7 @@ import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructure
 import { Context } from '../../../helpers/Context';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { PatchOrganizationMembersEndpoint } from '../../global/members/PatchOrganizationMembersEndpoint';
-import { shouldCheckIfMemberIsDuplicateForPatch, shouldCheckIfMemberIsDuplicateForPut } from '../members/shouldCheckIfMemberIsDuplicate';
+import { shouldCheckIfMemberIsDuplicateForPatch } from '../members/shouldCheckIfMemberIsDuplicate';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = PatchableArrayAutoEncoder<MemberWithRegistrationsBlob>;
@@ -61,12 +61,10 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
 
             this.throwIfInvalidDetails(member.details);
 
-            if (shouldCheckIfMemberIsDuplicateForPut(struct)) {
-                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode);
-                if (duplicate) {
-                    addedMembers.push(duplicate);
-                    continue;
-                }
+            const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, struct.details.securityCode, 'put');
+            if (duplicate) {
+                addedMembers.push(duplicate);
+                continue;
             }
 
             await member.save();
@@ -79,12 +77,9 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
         for (let struct of request.body.getPatches()) {
             const member = members.find(m => m.id === struct.id);
             if (!member) {
-                throw new SimpleError({
-                    code: 'invalid_member',
-                    message: "This member does not exist or you don't have permissions to modify this member",
-                    human: 'Je probeert een lid aan te passen die niet (meer) bestaat. Er ging ergens iets mis.',
-                });
+                throw Context.auth.memberNotFoundOrNoAccess();
             }
+
             const securityCode = struct.details?.securityCode; // will get cleared after the filter
             struct = await Context.auth.filterMemberPatch(member, struct);
 
@@ -117,7 +112,7 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             }
 
             if (shouldCheckDuplicate) {
-                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode);
+                const duplicate = await PatchOrganizationMembersEndpoint.checkDuplicate(member, securityCode, 'patch');
                 if (duplicate) {
                 // Remove the member from the list
                     members.splice(members.findIndex(m => m.id === member.id), 1);

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,
             });