@stamhoofd/backend 2.78.4 → 2.79.0

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

@@ -1,8 +1,8 @@
 import { Database } from '@simonbackx/simple-database';
-import { PatchableArray, PatchMap } from '@simonbackx/simple-encoding';
+import { PatchableArray, PatchableArrayAutoEncoder, PatchMap } from '@simonbackx/simple-encoding';
 import { Endpoint, Request } from '@simonbackx/simple-endpoints';
 import { GroupFactory, MemberFactory, OrganizationFactory, OrganizationTagFactory, Platform, RegistrationFactory, Token, UserFactory } from '@stamhoofd/models';
-import { MemberDetails, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PatchAnswers, PermissionLevel, Permissions, PermissionsResourceType, RecordCategory, RecordSettings, RecordTextAnswer, ResourcePermissions, UserPermissions } from '@stamhoofd/structures';
+import { Address, Country, EmergencyContact, MemberDetails, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PatchAnswers, PermissionLevel, Permissions, PermissionsResourceType, RecordCategory, RecordSettings, RecordTextAnswer, ResourcePermissions, ReviewTime, ReviewTimes } from '@stamhoofd/structures';
 import { TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer';
 import { PatchOrganizationMembersEndpoint } from './PatchOrganizationMembersEndpoint';
@@ -579,7 +579,7 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
                 ],
             });
 
-            const platform = await Platform.getShared();
+            const platform = await Platform.getForEditing();
             platform.config.recordsConfiguration.recordCategories.push(recordCategory);
             await platform.save();
 
@@ -657,7 +657,7 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
                 ],
             });
 
-            const platform = await Platform.getShared();
+            const platform = await Platform.getForEditing();
             platform.config.recordsConfiguration.recordCategories.push(recordCategory);
             await platform.save();
 
@@ -723,4 +723,1964 @@ describe('Endpoint.PatchOrganizationMembersEndpoint', () => {
             });
         });
     });
+
+    describe('Parents', () => {
+        test('Setting updatedAt for one parent, changes it for the whole family', async () => {
+            const user = await new UserFactory({}).create();
+
+            const parent1 = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+                updatedAt: new Date(0),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [parent1],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [parent1],
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    parents: [parent1],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's parents, and check if all parents are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+
+            const arr: Body = new PatchableArray();
+            const d = new Date();
+            const parentsPatch = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            parentsPatch.addPatch(
+                Parent.patch({
+                    id: parent1.id,
+                    updatedAt: d,
+                }),
+            );
+
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    parents: parentsPatch,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load parents again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all parents equal
+            const expectedParent = Parent.create({
+                ...parent1,
+                updatedAt: d,
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+            expect(member3.details.parents).toEqual([expectedParent]);
+        });
+
+        test('Patches without updatedAt are handled correctly and applied to the most recent parent', async () => {
+            const user = await new UserFactory({}).create();
+
+            const mostRecentParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012347',
+                updatedAt: new Date(10_000),
+                createdAt: new Date(0),
+            });
+
+            const outOfDateParent = Parent.create({
+                id: mostRecentParent.id,
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+                updatedAt: new Date(0),
+                createdAt: new Date(200),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [outOfDateParent],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [outOfDateParent],
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    parents: [mostRecentParent],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's parents, and check if all parents are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+
+            const arr: Body = new PatchableArray();
+            const parentsPatch = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            parentsPatch.addPatch(
+                Parent.patch({
+                    id: outOfDateParent.id,
+                    email: 'changed@example.com',
+                }),
+            );
+
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    parents: parentsPatch,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load parents again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all parents equal
+            const expectedParent = Parent.create({
+                ...mostRecentParent,
+                email: 'changed@example.com',
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+            expect(member3.details.parents).toEqual([expectedParent]);
+        });
+
+        test('Patches without updatedAt are handled correctly and applied to the most recent parent when merging', async () => {
+            const user = await new UserFactory({}).create();
+
+            const mostRecentParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012347',
+                updatedAt: new Date(10_000),
+            });
+
+            const outOfDateParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda+oldest@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+                updatedAt: new Date(0),
+                createdAt: new Date(0),
+            });
+
+            const outOfDateParent2 = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+                updatedAt: new Date(1000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [outOfDateParent],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [outOfDateParent2],
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    parents: [mostRecentParent],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's parents, and check if all parents are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+
+            const arr: Body = new PatchableArray();
+            const parentsPatch = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            parentsPatch.addPatch(
+                Parent.patch({
+                    id: outOfDateParent.id,
+                    email: 'changed@example.com',
+                }),
+            );
+
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    parents: parentsPatch,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load parents again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all parents equal
+            const expectedParent = Parent.create({
+                ...mostRecentParent,
+                id: outOfDateParent.id, // the oldest parent id is use
+                createdAt: outOfDateParent.createdAt,
+                email: 'changed@example.com',
+                alternativeEmails: [
+                    'linda@work.com',
+                    'linda+oldest@work.com',
+                ],
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+            expect(member3.details.parents).toEqual([expectedParent]);
+        });
+
+        test('Puts without updatedAt are handled correctly and applied to the most recent parent when merging', async () => {
+            const user = await new UserFactory({}).create();
+
+            const mostRecentParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012347',
+                updatedAt: new Date(10_000),
+            });
+
+            const outOfDateParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda+oldest@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+                updatedAt: new Date(1000),
+                createdAt: new Date(0),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [outOfDateParent],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [],
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    parents: [mostRecentParent],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's parents, and check if all parents are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+
+            const arr: Body = new PatchableArray();
+            const parentsPatch = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            const createdParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                updatedAt: new Date(0),
+                email: 'changed@example.com',
+                phone: '+3241111111',
+                alternativeEmails: ['another-alternative-email@example.com'],
+            });
+            parentsPatch.addPut(createdParent);
+
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    parents: parentsPatch,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load parents again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all parents equal
+            const expectedParent = Parent.create({
+                ...mostRecentParent,
+                id: outOfDateParent.id, // the oldest parent id is use
+                createdAt: outOfDateParent.createdAt,
+                email: 'changed@example.com',
+                phone: '+3241111111',
+                alternativeEmails: [
+                    'linda@work.com',
+                    'linda+oldest@work.com',
+                    'another-alternative-email@example.com',
+                ],
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+            expect(member3.details.parents).toEqual([expectedParent]);
+        });
+
+        test('Duplicate parents are merged in a family', async () => {
+            const user = await new UserFactory({}).create();
+
+            const parent1 = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+                createdAt: new Date(0),
+            });
+
+            // Create two clones of this parent with a different ID
+            const parent2 = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                createdAt: new Date(1000),
+            });
+
+            const parent3 = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work2.com'],
+                phone: '+32412345679',
+                address: Address.create({
+                    street: 'Main street 2',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012348',
+                createdAt: new Date(2000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [parent1],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(0),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [parent2],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(1000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    parents: [parent3],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(2000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Now simulate a change to member1's parents, and check if all parents are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            nonEmtpyArray.addPatch(Parent.patch({
+                id: parent1.id,
+                // no changes
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    parents: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load parents again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all parents equal
+            const expectedParent = Parent.create({
+                ...parent3,
+                id: parent1.id, // the oldest parent id is use
+                createdAt: parent1.createdAt,
+                alternativeEmails: [
+                    'linda@work2.com',
+                    'linda@work.com',
+                ],
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+            expect(member3.details.parents).toEqual([expectedParent]);
+        });
+
+        test('Deleting a parent alternative email address is possible in a family if all parents have the same ID', async () => {
+            const user = await new UserFactory({}).create();
+
+            const parent1 = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+            });
+
+            // Create two clones of this parent with a different ID
+            const parent2 = Parent.create({
+                id: parent1.id,
+                firstName: 'Linda',
+                lastName: 'Doe',
+            });
+
+            const parent3 = Parent.create({
+                id: parent1.id,
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work2.com'],
+                phone: '+32412345679',
+                address: Address.create({
+                    street: 'Main street 2',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012348',
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [parent1],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(0),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [parent2],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(1000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    parents: [parent3],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(2000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Now simulate a change to member1's parents, and check if all parents are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            nonEmtpyArray.addPatch(Parent.patch({
+                id: parent1.id,
+                // no changes
+            }));
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    parents: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load parents again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all parents equal
+            const expectedParent = parent3;
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+            expect(member3.details.parents).toEqual([expectedParent]);
+        });
+
+        test('Deleting a parent address, NRN, phone or email is possible in a family if all parents have the same ID', async () => {
+            const user = await new UserFactory({}).create();
+
+            const parent1 = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work.com'],
+                phone: '+32412345678',
+                address: Address.create({
+                    street: 'Main street 1',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012345',
+                createdAt: new Date(0),
+            });
+
+            // Create two clones of this parent with a different ID
+            const parent2 = Parent.create({
+                id: parent1.id,
+                firstName: 'Linda',
+                lastName: 'Doe',
+                createdAt: new Date(1000),
+            });
+
+            const parent3 = Parent.create({
+                id: parent1.id,
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work2.com'],
+                phone: '+32412345679',
+                address: Address.create({
+                    street: 'Main street 2',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012348',
+                createdAt: new Date(3000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [parent1],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(0),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [parent2],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(1000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    parents: [parent3],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(2000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Now simulate a change to member1's parents, and check if all parents are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            nonEmtpyArray.addPatch(Parent.patch({
+                id: parent1.id,
+                // no changes
+            }));
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    parents: nonEmtpyArray,
+                    // Mark these parents as reviewed last, so it overrides all the same parents
+                    reviewTimes: ReviewTimes.patch({
+                        times: [
+                            ReviewTime.create({
+                                name: 'parents',
+                                reviewedAt: new Date(),
+                            }),
+                        ],
+                    }),
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load parents again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all parents equal
+            const expectedParent = Parent.create({
+                ...parent2,
+                createdAt: parent1.createdAt, // the oldest one is used
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+            expect(member3.details.parents).toEqual([expectedParent]);
+        });
+
+        test('When adding a new parent that is and old copy, the most recent copy is added instead', async () => {
+            const user = await new UserFactory({}).create();
+
+            /**
+             * This one is the oldest and has been reviewed the most recent
+             */
+            const latestParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work2.com'],
+                phone: '+32412345679',
+                address: Address.create({
+                    street: 'Main street 2',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012348',
+                createdAt: new Date(3000),
+                updatedAt: new Date(),
+            });
+
+            const oldestParent = Parent.create({
+                id: latestParent.id,
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'ignored@example.com',
+                createdAt: new Date(3000),
+                updatedAt: new Date(10_000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [latestParent],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            nonEmtpyArray.addPut(oldestParent);
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    parents: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // The contact should be equal to contact1, and ignore other changes
+            const expectedParent = Parent.create({
+                ...latestParent,
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+        });
+
+        test('It is possible to change the name of a parent without setting updatedAt', async () => {
+            const user = await new UserFactory({}).create();
+
+            /**
+             * This one is the oldest and has been reviewed the most recent
+             */
+            const latestParent = Parent.create({
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'linda@example.com',
+                alternativeEmails: ['linda@work2.com'],
+                phone: '+32412345679',
+                address: Address.create({
+                    street: 'Main street 2',
+                    postalCode: '1000',
+                    city: 'Brussels',
+                    country: Country.Belgium,
+                }),
+                nationalRegisterNumber: '93042012348',
+                createdAt: new Date(3000),
+                updatedAt: new Date(),
+            });
+
+            const oldestParent = Parent.create({
+                id: latestParent.id,
+                firstName: 'Linda',
+                lastName: 'Doe',
+                email: 'ignored@example.com',
+                createdAt: new Date(3000),
+                updatedAt: new Date(10_000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    parents: [latestParent],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    parents: [oldestParent],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+            nonEmtpyArray.addPatch(Parent.patch({
+                id: latestParent.id,
+                firstName: 'Linda2',
+                lastName: 'Doe2',
+                // Note that 'by accident' the frontend did not pass the updatedAt value correctly - this should still work as expected
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    parents: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // The contact should be equal to contact1, and ignore other changes
+            const expectedParent = Parent.create({
+                ...latestParent,
+                firstName: 'Linda2',
+                lastName: 'Doe2',
+            });
+
+            expect(member1.details.parents).toEqual([expectedParent]);
+            expect(member2.details.parents).toEqual([expectedParent]);
+        });
+    });
+
+    describe('Emergency contacts', () => {
+        test('Duplicate emergency contacts are merged in a family', async () => {
+            const user = await new UserFactory({}).create();
+
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+            });
+
+            // Create two clones of this contact with a different ID
+            const contact2 = EmergencyContact.create({
+                name: 'Linda Doe',
+                createdAt: new Date(2000),
+            });
+
+            const contact3 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Oma',
+                phone: '+32412345679',
+                createdAt: new Date(4000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'emergencyContacts',
+                                reviewedAt: new Date(0),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact2],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'emergencyContacts',
+                                reviewedAt: new Date(1000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact3],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'emergencyContacts',
+                                reviewedAt: new Date(2000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPatch(EmergencyContact.patch({
+                id: contact1.id,
+                // no changes
+            }));
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all contacts equal
+            const expectedParent = EmergencyContact.create({
+                ...contact3,
+                id: contact1.id, // the oldest contact id is used
+                createdAt: contact1.createdAt,
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedParent]);
+            expect(member2.details.emergencyContacts).toEqual([expectedParent]);
+            expect(member3.details.emergencyContacts).toEqual([expectedParent]);
+        });
+
+        test('Deleting a contact title and phone is possible in a family if all contacts have the same ID', async () => {
+            const user = await new UserFactory({}).create();
+
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+            });
+
+            // Create two clones of this contact with a different ID
+            const contact2 = EmergencyContact.create({
+                id: contact1.id,
+                name: 'Linda Doe',
+            });
+
+            const contact3 = EmergencyContact.create({
+                id: contact1.id,
+                name: 'Linda Doe',
+                title: 'Oma',
+                phone: '+32412345679',
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'emergencyContacts',
+                                reviewedAt: new Date(0),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact2],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'emergencyContacts',
+                                reviewedAt: new Date(1000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Parent3 was reviewed last, so has priority
+            const member3 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Bob',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact3],
+                    reviewTimes: ReviewTimes.create({
+                        times: [
+                            ReviewTime.create({
+                                name: 'emergencyContacts',
+                                reviewedAt: new Date(2000),
+                            }),
+                        ],
+                    }),
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPatch(EmergencyContact.patch({
+                id: contact1.id,
+                // no changes
+            }));
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                    // Mark these contacts as reviewed last, so it overrides all the same contacts
+                    reviewTimes: ReviewTimes.patch({
+                        times: [
+                            ReviewTime.create({
+                                name: 'emergencyContacts',
+                                reviewedAt: new Date(),
+                            }),
+                        ],
+                    }),
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+            await member3.refresh();
+
+            // Check all contacts equal
+            const expectedParent = contact2;
+
+            expect(member1.details.emergencyContacts).toEqual([expectedParent]);
+            expect(member2.details.emergencyContacts).toEqual([expectedParent]);
+            expect(member3.details.emergencyContacts).toEqual([expectedParent]);
+        });
+
+        test('When adding a new emergency contact it is automatically merged with existing contacts', async () => {
+            const user = await new UserFactory({}).create();
+
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPut(EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Oma',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // Check all contacts equal
+            const expectedParent = EmergencyContact.create({
+                ...contact1,
+                title: 'Oma',
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedParent]);
+            expect(member2.details.emergencyContacts).toEqual([expectedParent]);
+        });
+
+        test('When adding a new emergency contact that is an old copy, the most recent copy is added instead', async () => {
+            const user = await new UserFactory({}).create();
+
+            /**
+             * This one is the oldest and has been reviewed the most recent
+             */
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+                updatedAt: new Date(),
+            });
+
+            // The frontend for some reason got and old version of this contact
+            const oldVersionContact = EmergencyContact.create({
+                id: contact1.id,
+                name: 'Linda Doe',
+                title: 'Oma',
+                phone: '+32412345676',
+                createdAt: new Date(0),
+                updatedAt: new Date(10_000), // This one is older
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPut(oldVersionContact);
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // The contact should be equal to contact1, and ignore other changes
+            const expectedParent = EmergencyContact.create({
+                ...contact1,
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedParent]);
+            expect(member2.details.emergencyContacts).toEqual([expectedParent]);
+        });
+
+        test('It is possible to change the name of an emergency contact without setting updatedAt', async () => {
+            const user = await new UserFactory({}).create();
+
+            /**
+             * This one is the oldest and has been reviewed the most recent
+             */
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+                updatedAt: new Date(),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPatch(EmergencyContact.patch({
+                id: contact1.id,
+                name: 'Linda2 Doe2',
+                // Note that 'by accident' the frontend did not pass the updatedAt value correctly - this should still work as expected
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // The contact should be equal to contact1, and ignore other changes
+            const expectedContact = EmergencyContact.create({
+                ...contact1,
+                name: 'Linda2 Doe2',
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedContact]);
+            expect(member2.details.emergencyContacts).toEqual([expectedContact]);
+        });
+
+        test('It is possible to change the name of an emergency contact with setting updatedAt', async () => {
+            const user = await new UserFactory({}).create();
+
+            /**
+             * This one is the oldest and has been reviewed the most recent
+             */
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+                updatedAt: new Date(Date.now() - 5_000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            // Now simulate a change to member1's contacts, and check if all contacts are updated to the same id and details
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            const d = new Date();
+            nonEmtpyArray.addPatch(EmergencyContact.patch({
+                id: contact1.id,
+                name: 'Linda2 Doe2',
+                title: 'Changed',
+                updatedAt: d,
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // The contact should be equal to contact1, and ignore other changes
+            const expectedContact = EmergencyContact.create({
+                ...contact1,
+                name: 'Linda2 Doe2',
+                title: 'Changed',
+                updatedAt: d,
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedContact]);
+            expect(member2.details.emergencyContacts).toEqual([expectedContact]);
+        });
+
+        test('Adding a completely new emergency contact works correctly', async () => {
+            const user = await new UserFactory({}).create();
+
+            const existing = EmergencyContact.create({
+                name: 'Existing friend',
+                title: 'Friend',
+                phone: '+32412345111',
+            });
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [
+                        existing,
+                    ],
+                }),
+            }).create();
+
+            const newContact = EmergencyContact.create({
+                name: 'New Contact',
+                title: 'Friend',
+                phone: '+32412345670',
+            });
+
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPut(newContact);
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+
+            // Check the new contact is added
+            expect(member1.details.emergencyContacts).toEqual([
+                existing,
+                newContact,
+            ]);
+        });
+
+        test('Updating an existing emergency contact\'s details works correctly', async () => {
+            const user = await new UserFactory({}).create();
+
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const updatedContact = EmergencyContact.patch({
+                id: contact1.id,
+                phone: '+32412345679',
+            });
+
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPatch(updatedContact);
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+
+            // Check the contact is updated
+            const expectedContact = EmergencyContact.create({
+                ...contact1,
+                phone: '+32412345679',
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedContact]);
+        });
+
+        test('Removing an emergency contact works correctly', async () => {
+            const user = await new UserFactory({}).create();
+
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addDelete(contact1.id);
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+
+            // Check the contact is removed
+            expect(member1.details.emergencyContacts).toEqual([]);
+        });
+
+        test('Handling multiple members with different emergency contacts works correctly', async () => {
+            const user = await new UserFactory({}).create();
+
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+            });
+
+            const contact2 = EmergencyContact.create({
+                name: 'John Doe',
+                title: 'Uncle',
+                phone: '+32412345679',
+                createdAt: new Date(1000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact2],
+                }),
+            }).create();
+
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray1 = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray1.addPatch(EmergencyContact.patch({
+                id: contact1.id,
+                phone: '+32412345680',
+            }));
+
+            const nonEmtpyArray2 = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray2.addPatch(EmergencyContact.patch({
+                id: contact2.id,
+                phone: '+32412345681',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch1 = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray1,
+                }),
+            });
+            const patch2 = MemberWithRegistrationsBlob.patch({
+                id: member2.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray2,
+                }),
+            });
+            arr.addPatch(patch1);
+            arr.addPatch(patch2);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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(2);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // Check the contacts are updated independently
+            const expectedContact1 = EmergencyContact.create({
+                ...contact1,
+                phone: '+32412345680',
+            });
+
+            const expectedContact2 = EmergencyContact.create({
+                ...contact2,
+                phone: '+32412345681',
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedContact1]);
+            expect(member2.details.emergencyContacts).toEqual([expectedContact2]);
+        });
+
+        test('Handling emergency contacts with different IDs but same details works correctly', async () => {
+            const user = await new UserFactory({}).create();
+
+            const contact1 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(0),
+            });
+
+            const contact2 = EmergencyContact.create({
+                name: 'Linda Doe',
+                title: 'Grandmother',
+                phone: '+32412345678',
+                createdAt: new Date(1000),
+            });
+
+            const member1 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'John',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact1],
+                }),
+            }).create();
+
+            const member2 = await new MemberFactory({
+                user,
+                details: MemberDetails.create({
+                    firstName: 'Jane',
+                    lastName: 'Doe',
+                    emergencyContacts: [contact2],
+                }),
+            }).create();
+
+            const admin = await new UserFactory({
+                globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            }).create();
+            const token = await Token.createToken(admin);
+            const nonEmtpyArray = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+            nonEmtpyArray.addPatch(EmergencyContact.patch({
+                id: contact1.id,
+                phone: '+32412345679',
+            }));
+
+            const arr: Body = new PatchableArray();
+            const patch = MemberWithRegistrationsBlob.patch({
+                id: member1.id,
+                details: MemberDetails.patch({
+                    emergencyContacts: nonEmtpyArray,
+                }),
+            });
+            arr.addPatch(patch);
+
+            const request = Request.buildJson('PATCH', baseUrl, undefined, 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);
+
+            // Load contacts again
+            await member1.refresh();
+            await member2.refresh();
+
+            // Check the contacts are updated correctly
+            const expectedContact = EmergencyContact.create({
+                ...contact1,
+                phone: '+32412345679',
+            });
+
+            expect(member1.details.emergencyContacts).toEqual([expectedContact]);
+            expect(member2.details.emergencyContacts).toEqual([expectedContact]);
+        });
+    });
 });