@stamhoofd/backend 2.78.3 → 2.79.0

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

@@ -1,9 +1,9 @@
 import { OneToManyRelation } from '@simonbackx/simple-database';
-import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import { AutoEncoderPatchType, ConvertArrayToPatchableArray, Decoder, isEmptyPatch, isPatchableArray, PatchableArray, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { AuditLog, BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, mergeTwoMembers, Organization, Platform, RateLimiter, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
-import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType, GroupType, MembersBlob, MemberWithRegistrationsBlob, PermissionLevel } from '@stamhoofd/structures';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType, EmergencyContact, GroupType, MemberDetails, MemberResponsibility, MembersBlob, MemberWithRegistrationsBlob, Parent, PermissionLevel } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { Email } from '@stamhoofd/email';
@@ -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
@@ -211,6 +207,11 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
             await member.save();
 
+            // If parents changed or emergeny contacts: fetch family and merge data
+            if (patch.details && (!isEmptyPatch(patch.details?.parents) || !isEmptyPatch(patch.details?.emergencyContacts))) {
+                await PatchOrganizationMembersEndpoint.mergeDuplicateRelations(member, patch.details);
+            }
+
             // Update documents
             await Document.updateForMember(member.id);
 
@@ -261,6 +262,11 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     responsibilityRecord.startDate = patchResponsibility.startDate;
                 }
 
+                // Check maximum
+                if (responsibility) {
+                    await this.checkResponsbilityLimits(responsibilityRecord, responsibility);
+                }
+
                 await responsibilityRecord.save();
                 shouldUpdateSetupSteps = true;
             }
@@ -393,6 +399,9 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
                 model.startDate = put.startDate;
 
+                // Check maximum
+                await this.checkResponsbilityLimits(model, responsibility);
+
                 await model.save();
                 shouldUpdateSetupSteps = true;
             }
@@ -735,6 +744,129 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
         }
     }
 
+    static async mergeDuplicateRelations(member: MemberWithRegistrations, patch: AutoEncoderPatchType<MemberDetails> | MemberDetails) {
+        const _familyMembers = await Member.getFamilyWithRegistrations(member.id);
+        const familyMembers: typeof _familyMembers = [];
+        // Only modify members if we have write access to them (this avoids issues with overriding data)
+        for (const member of _familyMembers) {
+            if (await Context.auth.canAccessMember(member, PermissionLevel.Write)) {
+                familyMembers.push(member);
+            }
+        }
+
+        // Replace member with member
+        const memberIndex = familyMembers.findIndex(m => m.id === member.id);
+        if (memberIndex !== -1 && familyMembers.length >= 2) {
+            familyMembers[memberIndex] = member;
+            const parentMergeMap = MemberDetails.mergeParents(
+                familyMembers.map(m => m.details),
+                true, // Allow deletes
+            );
+            const contactsMergeMap = MemberDetails.mergeEmergencyContacts(
+                familyMembers.map(m => m.details),
+                true, // Allow deletes
+            );
+
+            // If there were patches or puts of parents or emergency contacts
+            // Make sure that those patches have been applied even after a potential merge
+            // E.g. you only changed the email, but there was a more recent parent object in a different member
+            // -> avoid losing the email change
+            const parentPatches = isPatchableArray(patch.parents) ? patch.parents.getPatches() : [];
+
+            // Add puts
+            const parentPuts = isPatchableArray(patch.parents) ? patch.parents.getPuts().map(p => p.put) : patch.parents;
+            for (const put of parentPuts) {
+                if (!parentMergeMap.get(put.id)) {
+                    // This one has not been merged
+                    continue;
+                }
+
+                const alternativeEmailsArr = new PatchableArray() as PatchableArray<string, string, string>;
+                for (const alternativeEmail of put.alternativeEmails) {
+                    alternativeEmailsArr.addPut(alternativeEmail);
+                }
+
+                const p = Parent.patch({
+                    ...put,
+                    alternativeEmails: alternativeEmailsArr,
+                    createdAt: undefined, // Not allowed to change (should have already happened + the merge method will already chose the right value)
+                    updatedAt: undefined, // Not allowed to change (should have already happened + the merge method will already chose the right value)
+                });
+
+                // Delete null values or empty strings
+                for (const key in p) {
+                    if (p[key] === null || p[key] === '') {
+                        delete p[key];
+                    }
+                }
+
+                parentPatches.push(p);
+            }
+
+            // Same for emergency contacts
+            const contactsPatches = isPatchableArray(patch.emergencyContacts) ? patch.emergencyContacts.getPatches() : [];
+
+            // Add puts
+            const contactsPuts = isPatchableArray(patch.emergencyContacts) ? patch.emergencyContacts.getPuts().map(p => p.put) : patch.emergencyContacts;
+            for (const put of contactsPuts) {
+                if (!contactsMergeMap.get(put.id)) {
+                    // This one has not been merged
+                    continue;
+                }
+                const p = EmergencyContact.patch({
+                    ...put,
+                    createdAt: undefined, // Not allowed to change (should have already happened + the merge method will already chose the right value)
+                    updatedAt: undefined, // Not allowed to change (should have already happened + the merge method will already chose the right value)
+                });
+
+                // Delete null values or empty strings
+                for (const key in p) {
+                    if (p[key] === null || p[key] === '') {
+                        delete p[key];
+                    }
+                }
+
+                contactsPatches.push(p);
+            }
+
+            // Apply patches
+            for (const parentPatch of parentPatches) {
+                for (const m of familyMembers) {
+                    const arr = new PatchableArray() as PatchableArrayAutoEncoder<Parent>;
+                    parentPatch.id = parentMergeMap.get(parentPatch.id) ?? parentPatch.id;
+                    arr.addPatch(parentPatch);
+                    m.details = m.details.patch({
+                        parents: arr,
+                    });
+                }
+            }
+
+            // Apply patches
+            for (const contactPatch of contactsPatches) {
+                for (const m of familyMembers) {
+                    const arr = new PatchableArray() as PatchableArrayAutoEncoder<EmergencyContact>;
+                    contactPatch.id = contactsMergeMap.get(contactPatch.id) ?? contactPatch.id;
+                    arr.addPatch(contactPatch);
+                    m.details = m.details.patch({
+                        emergencyContacts: arr,
+                    });
+                }
+            }
+
+            for (const m of familyMembers) {
+                m.details.cleanData();
+
+                if (await m.save() && m.id !== member.id) {
+                    // Auto link users based on data
+                    await MemberUserSyncer.onChangeMember(m);
+
+                    // Update documents
+                    await Document.updateForMember(m.id);
+                }
+            }
+        }
+    }
+
     static async findExistingMember(member: Member) {
         if (!member.details.birthDay) {
             return;
@@ -759,8 +891,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 +934,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 +955,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 +967,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
@@ -850,4 +999,41 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             organization,
         }).createMultiple(count);
     }
+
+    async checkResponsbilityLimits(model: MemberResponsibilityRecord, responsibility: MemberResponsibility) {
+        if (responsibility.maximumMembers !== null) {
+            if (!model.getBaseStructure().isActive) {
+                return;
+            }
+
+            const query = MemberResponsibilityRecord.select()
+                .where('responsibilityId', responsibility.id)
+                .andWhere('organizationId', model.organizationId)
+                .andWhere('groupId', model.groupId)
+                .andWhere(MemberResponsibilityRecord.whereActive);
+
+            if (model.existsInDatabase) {
+                query.andWhere('id', '!=', model.id);
+            }
+
+            const count = (await query.count()) + 1;
+
+            // Because it should be possible to move around responsibilities, we allow 1 extra
+            const actualLimit = responsibility.maximumMembers <= 1 ? 2 : responsibility.maximumMembers;
+
+            if (count > actualLimit) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Maximum members reached',
+                    human: responsibility.maximumMembers === 1
+                        ? (model.groupId
+                                ? $t('Je kan maar één lid hebben met de functie {responsibility} in deze leeftijdsgroep', { responsibility: responsibility.name })
+                                : $t('Je kan maar één lid hebben met de functie {responsibility}', { responsibility: responsibility.name }))
+                        : (model.groupId
+                                ? $t('Je kan maximum {count} leden hebben met de functie {responsibility} in deze leeftijdsgroep', { count: responsibility.maximumMembers.toFixed(), responsibility: responsibility.name })
+                                : $t('Je kan maximum {count} leden hebben met de functie {responsibility}', { count: responsibility.maximumMembers.toFixed(), responsibility: responsibility.name })),
+                });
+            }
+        }
+    }
 }

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/platform/PatchPlatformEnpoint.ts

@@ -49,7 +49,7 @@ export class PatchPlatformEndpoint extends Endpoint<
             throw Context.auth.error();
         }
 
-        const platform = await Platform.getShared();
+        const platform = await Platform.getForEditing();
         let shouldUpdateUserPermissions = false;
 
         if (request.body.privateConfig) {

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

@@ -295,7 +295,7 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
                 ],
             });
 
-            const platform = await Platform.getShared();
+            const platform = await Platform.getForEditing();
             platform.config.recordsConfiguration.recordCategories.push(recordCategory);
             await platform.save();
 
@@ -355,7 +355,7 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
                 ],
             });
 
-            const platform = await Platform.getShared();
+            const platform = await Platform.getForEditing();
             platform.config.recordsConfiguration.recordCategories.push(recordCategory);
             await platform.save();
 

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

@@ -1,4 +1,4 @@
-import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import { AutoEncoderPatchType, Decoder, isEmptyPatch, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Document, Member, RateLimiter } from '@stamhoofd/models';
@@ -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);
@@ -129,6 +124,12 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             }
 
             await member.save();
+
+            // If parents changed or emergeny contacts: fetch family and merge data
+            if (struct.details && (!isEmptyPatch(struct.details?.parents) || !isEmptyPatch(struct.details?.emergencyContacts))) {
+                await PatchOrganizationMembersEndpoint.mergeDuplicateRelations(member, struct.details);
+            }
+
             await MemberUserSyncer.onChangeMember(member);
 
             // Update documents

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

@@ -33,10 +33,8 @@ describe('Endpoint.RegisterMembers', () => {
         period = await new RegistrationPeriodFactory({
             startDate: new Date(2023, 0, 1),
             endDate: new Date(2023, 11, 31),
+            previousPeriodId: previousPeriod.id,
         }).create();
-
-        period.previousPeriodId = previousPeriod.id;
-        await period.save();
     });
 
     afterEach(() => {
@@ -2199,34 +2197,16 @@ describe('Endpoint.RegisterMembers', () => {
                 groupPrice: groupPrice1,
             }).create();
 
-            const group2 = await new GroupFactory({
-                organization,
-                price: 30,
-                stock: 5,
-            }).create();
-
-            const groupPrice = group2.settings.prices[0];
-
             const body = IDRegisterCheckout.create({
                 cart: IDRegisterCart.create({
-                    items: [
-                        IDRegisterItem.create({
-                            id: uuidv4(),
-                            replaceRegistrationIds: [],
-                            options: [],
-                            groupPrice,
-                            organizationId: organization.id,
-                            groupId: group2.id,
-                            memberId: member.id,
-                        }),
-                    ],
+                    items: [],
                     balanceItems: [],
                     deleteRegistrationIds: [registration.id],
                 }),
                 administrationFee: 0,
                 freeContribution: 0,
                 paymentMethod: PaymentMethod.PointOfSale,
-                totalPrice: 30,
+                totalPrice: 0,
                 customer: null,
                 asOrganizationId: organization.id,
             });

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

@@ -241,6 +241,18 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                 });
             }
 
+            if (request.body.asOrganizationId) {
+                // Do you have write access to this group?
+                if (!await Context.auth.canRegisterMembersInGroup(group, request.body.asOrganizationId)) {
+                    throw new SimpleError({
+                        code: 'forbidden',
+                        message: 'No permission to register in this group',
+                        human: $t('Je hebt geen toegangsrechten om een lid in te schrijven voor {group}', { group: group.settings.name }),
+                        statusCode: 403,
+                    });
+                }
+            }
+
             // Check if this member is already registered in this group?
             const existingRegistrations = await Registration.where({ memberId: member.id, groupId: item.groupId, cycle: group.cycle, periodId: group.periodId, registeredAt: { sign: '!=', value: null } });
 

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -285,7 +285,7 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                         tags: request.body.meta.tags as any,
                     });
 
-                    const platform: Platform = await Platform.getShared();
+                    const platform = await Platform.getShared();
                     const patchedMeta: OrganizationMetaData = organization.meta.patch(cleanedPatch);
                     for (const tag of patchedMeta.tags) {
                         if (!platform.config.tags.find(t => t.id === tag)) {
@@ -293,8 +293,7 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                         }
                     }
 
-                    const platformConfig: PlatformConfig = platform.config;
-                    organization.meta.tags = TagHelper.getAllTagsFromHierarchy(patchedMeta.tags, platformConfig.tags);
+                    organization.meta.tags = TagHelper.getAllTagsFromHierarchy(patchedMeta.tags, platform.config.tags);
 
                     updateTags = true;
                 }

package/src/endpoints/organization/dashboard/payments/PatchBalanceItemsEndpoint.ts

@@ -250,7 +250,7 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
         if (!member || !(await Context.auth.canLinkBalanceItemToMember(member))) {
             throw new SimpleError({
                 code: 'permission_denied',
-                message: 'No permission to link balanace items to this member',
+                message: 'No permission to link balance items to this member',
                 human: 'Je hebt geen toegang om aanrekeningen te maken verbonden met dit lid',
                 field: 'memberId',
             });
@@ -264,7 +264,7 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
         if (!user || !await Context.auth.canLinkBalanceItemToUser(balanceItem, user)) {
             throw new SimpleError({
                 code: 'permission_denied',
-                message: 'No permission to link balanace items to this user',
+                message: 'No permission to link balance items to this user',
                 human: 'Je hebt geen toegang om aanrekeningen te maken verbonden met deze gebruiker',
                 field: 'userId',
             });