@stamhoofd/backend 2.90.3 → 2.91.0

package/src/helpers/PeriodHelper.ts

@@ -1,11 +1,10 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Group, Member, MemberResponsibilityRecord, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from '@stamhoofd/models';
+import { Group, Organization, OrganizationRegistrationPeriod, RegistrationPeriod } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { AuditLogSource, Group as GroupStruct, PermissionLevel } from '@stamhoofd/structures';
+import { AuditLogSource, Group as GroupStruct } from '@stamhoofd/structures';
 import { PatchOrganizationRegistrationPeriodsEndpoint } from '../endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint';
-import { AuthenticatedStructures } from './AuthenticatedStructures';
-import { MemberUserSyncer } from './MemberUserSyncer';
 import { AuditLogService } from '../services/AuditLogService';
+import { AuthenticatedStructures } from './AuthenticatedStructures';
 import { SetupStepUpdater } from './SetupStepUpdater';
 
 export class PeriodHelper {
@@ -18,88 +17,6 @@ export class PeriodHelper {
         });
     }
 
-    static async stopAllResponsibilities() {
-        console.log('Stopping all responsibilities');
-        const platform = await Platform.getSharedPrivateStruct();
-        const keepPlatformResponsibilityIds = platform.config.responsibilities.filter(r => !r.organizationBased).map(r => r.id);
-        const keepResponsibilityIds = platform.config.responsibilities.filter(r => !r.organizationBased || r.permissions?.level === PermissionLevel.Full).map(r => r.id);
-        const batchSize = 100;
-
-        let lastId = '';
-        let c = 0;
-
-        while (true) {
-            const records = await MemberResponsibilityRecord.where(
-                {
-                    id: { sign: '>', value: lastId },
-                    endDate: null,
-                },
-                {
-                    limit: batchSize,
-                    sort: ['id'],
-                },
-            );
-
-            for (const record of records) {
-                lastId = record.id;
-
-                const invalid = keepPlatformResponsibilityIds.includes(record.responsibilityId) && record.organizationId;
-
-                if (!keepResponsibilityIds.includes(record.responsibilityId) || invalid) {
-                    record.endDate = new Date();
-                    await record.save();
-                    c++;
-                }
-            }
-
-            if (records.length < batchSize) {
-                break;
-            }
-        }
-
-        console.log('Done: stopped all responsibilities: ' + c);
-    }
-
-    static async syncAllMemberUsers() {
-        console.log('Syncing all members');
-
-        let c = 0;
-        let lastId: string = '';
-
-        while (true) {
-            const rawMembers = await Member.where({
-                id: {
-                    value: lastId,
-                    sign: '>',
-                },
-            }, { limit: 500, sort: ['id'] });
-
-            if (rawMembers.length === 0) {
-                break;
-            }
-
-            const membersWithRegistrations = await Member.getBlobByIds(...rawMembers.map(m => m.id));
-
-            const promises: Promise<any>[] = [];
-
-            for (const memberWithRegistrations of membersWithRegistrations) {
-                promises.push((async () => {
-                    await MemberUserSyncer.onChangeMember(memberWithRegistrations);
-                    c++;
-
-                    if (c % 10000 === 0) {
-                        console.log('Synced ' + c + ' members');
-                    }
-                })());
-            }
-
-            await Promise.all(promises);
-            lastId = rawMembers[rawMembers.length - 1].id;
-        }
-
-        console.log('Done: synced all members: ' + c);
-    }
-
     static async createOrganizationPeriodForPeriod(organization: Organization, period: RegistrationPeriod) {
         const oPeriods = await OrganizationRegistrationPeriod.where({ periodId: period.id, organizationId: organization.id }, { limit: 1 });
 
@@ -128,38 +45,15 @@ export class PeriodHelper {
             });
         }
 
-        const batchSize = 10;
         await QueueHandler.schedule(tag, async () => {
-            let lastId = '';
-
-            while (true) {
-                const organizations = await Organization.where(
-                    {
-                        id: { sign: '>', value: lastId },
-                    },
-                    {
-                        limit: batchSize,
-                        sort: ['id'],
-                    },
-                );
-
-                for (const organization of organizations) {
-                    try {
-                        await this.moveOrganizationToPeriod(organization, period);
-                    }
-                    catch (error) {
-                        console.error('Error moving organization to period', organization.id, error);
-                    }
-                    lastId = organization.id;
+            for await (const organization of Organization.select().all()) {
+                try {
+                    await this.moveOrganizationToPeriod(organization, period);
                 }
-
-                if (organizations.length < batchSize) {
-                    break;
+                catch (error) {
+                    console.error('Error moving organization to period', organization.id, error);
                 }
             }
-
-            await this.stopAllResponsibilities();
-            await this.syncAllMemberUsers();
         });
 
         // When done: update setup steps
@@ -175,31 +69,10 @@ export class PeriodHelper {
 
         console.log(tag);
 
-        const batchSize = 100;
         await QueueHandler.schedule(tag, async () => {
             await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
-                let lastId = '';
-
-                while (true) {
-                    const groups = await Group.where(
-                        {
-                            id: { sign: '>', value: lastId },
-                            periodId: period.id,
-                        },
-                        {
-                            limit: batchSize,
-                            sort: ['id'],
-                        },
-                    );
-
-                    for (const group of groups) {
-                        await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(GroupStruct.patch({ id: group.id }), period);
-                        lastId = group.id;
-                    }
-
-                    if (groups.length < batchSize) {
-                        break;
-                    }
+                for await (const group of Group.select().where('periodId', period.id).all()) {
+                    await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(GroupStruct.patch({ id: group.id }), period);
                 }
             });
         });

package/src/helpers/SetupStepUpdater.ts

@@ -7,6 +7,7 @@ import {
     Organization,
     OrganizationRegistrationPeriod,
     Platform,
+    Registration,
 } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
@@ -15,11 +16,14 @@ import {
     GroupType,
     MemberResponsibility,
     Platform as PlatformStruct,
+    RecordCategory,
     SetupStepType,
     SetupSteps,
 } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { AuditLogService } from '../services/AuditLogService';
+import { GroupedThrottledQueue } from './GroupedThrottledQueue';
+import { AuthenticatedStructures } from './AuthenticatedStructures';
 
 type SetupStepOperation = (setupSteps: SetupSteps, organization: Organization, platform: PlatformStruct) => void | Promise<void>;
 
@@ -81,10 +85,25 @@ export class SetupStepUpdater {
             if (before !== after) {
                 console.log('Updating setups steps for organization', event.model.organizationId, 'because of change in members in group', event.model.id, 'from', before, 'to', after, '(limited)');
                 // We need to do a recalculation
-                SetupStepUpdater.updateForOrganizationId(event.model.organizationId)
+                SetupStepUpdater.updateForOrganizationId(event.model.organizationId, { types: [SetupStepType.Registrations] })
                     .catch(console.error);
             }
         });
+
+        const updateResponsibilitiesQueue = new GroupedThrottledQueue(async (organizationId: string) => {
+            console.log('(delayed) Updating setups steps for organization', organizationId, 'because of change in registrations');
+            SetupStepUpdater.updateForOrganizationId(organizationId, { types: [SetupStepType.Responsibilities] }).catch(console.error);
+        }, { maxDelay: 3_000 });
+
+        Model.modelEventBus.addListener({}, async (event) => {
+            if (!(event.model instanceof Registration)) {
+                return;
+            }
+
+            if ((event.type === 'updated' && ('registeredAt' in event.changedFields || 'deactivatedAt' in event.changedFields)) || (event.type === 'created' && event.model.registeredAt)) {
+                updateResponsibilitiesQueue.addItem(event.model.organizationId, 1);
+            }
+        });
     }
 
     private static readonly STEP_TYPE_OPERATIONS: Record<
@@ -170,7 +189,7 @@ export class SetupStepUpdater {
         });
     }
 
-    static async updateForOrganizationId(id: string) {
+    static async updateForOrganizationId(id: string, options?: { types?: SetupStepType[] }) {
         const organization = await Organization.getByID(id);
         if (!organization) {
             throw new SimpleError({
@@ -180,7 +199,7 @@ export class SetupStepUpdater {
             });
         }
 
-        await this.updateForOrganization(organization);
+        await this.updateForOrganization(organization, options);
     }
 
     static async updateForOrganization(
@@ -188,9 +207,11 @@ export class SetupStepUpdater {
         {
             platform,
             organizationRegistrationPeriod,
+            types,
         }: {
             platform?: PlatformStruct;
             organizationRegistrationPeriod?: OrganizationRegistrationPeriod;
+            types?: SetupStepType[];
         } = {},
     ) {
         if (!platform) {
@@ -222,6 +243,7 @@ export class SetupStepUpdater {
             organizationRegistrationPeriod,
             platform,
             organization,
+            types,
         );
     }
 
@@ -229,12 +251,13 @@ export class SetupStepUpdater {
         organizationRegistrationPeriod: OrganizationRegistrationPeriod,
         platform: PlatformStruct,
         organization: Organization,
+        types?: SetupStepType[],
     ) {
         console.log('Updating setup steps for organization', organization.id);
         const setupSteps = organizationRegistrationPeriod.setupSteps;
 
         await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
-            for (const stepType of Object.values(SetupStepType)) {
+            for (const stepType of types ?? Object.values(SetupStepType)) {
                 const operation = this.STEP_TYPE_OPERATIONS[stepType];
                 await operation(setupSteps, organization, platform);
             }
@@ -309,15 +332,28 @@ export class SetupStepUpdater {
     private static updateStepCompanies(
         setupSteps: SetupSteps,
         organization: Organization,
-        _platform: PlatformStruct,
+        platform: PlatformStruct,
     ) {
         const totalSteps = 1;
         let finishedSteps = 0;
 
         if (organization.meta.companies.length) {
             finishedSteps = 1;
+
+            try {
+                RecordCategory.validate(
+                    platform.config.organizationLevelRecordsConfiguration.recordCategories,
+                    organization.getBaseStructureWithPrivateMeta(), // private data needed for answers
+                );
+            }
+            catch (error) {
+                console.error('Error validating record categories for organization', organization.id, error);
+                finishedSteps = 0;
+            }
         }
 
+        console.log('Updating companies step for organization', organization.id, 'with total steps', totalSteps, 'and finished steps', finishedSteps);
+
         setupSteps.update(SetupStepType.Companies, {
             totalSteps,
             finishedSteps,
@@ -346,11 +382,14 @@ export class SetupStepUpdater {
         // Remove invalid responsibilities: members that are not registered in the current period
         const memberIds = Formatter.uniqueArray(allRecords.map(r => r.memberId));
         const members = await Member.getBlobByIds(...memberIds);
-        const validMembers = members.filter(m => m.registrations.some(r => r.organizationId === organization.id && r.periodId === organization.periodId && r.group.type === GroupType.Membership && r.deactivatedAt === null && r.registeredAt !== null));
+        const validMembers = members.filter(m => m.registrations.some(r => r.organizationId === organization.id && r.periodId === organization.periodId && r.group.defaultAgeGroupId && r.group.type === GroupType.Membership && r.deactivatedAt === null && r.registeredAt !== null));
+        const invalidMembers = members.filter(m => !m.registrations.some(r => r.organizationId === organization.id && r.periodId === organization.periodId && r.group.defaultAgeGroupId && r.group.type === GroupType.Membership && r.deactivatedAt === null && r.registeredAt !== null));
 
         const validMembersIds = validMembers.map(m => m.id);
+        const invalidMembersIds = invalidMembers.map(m => m.id);
 
         const records = allRecords.filter(r => validMembersIds.includes(r.memberId));
+        const invalidRecords = allRecords.filter(r => invalidMembersIds.includes(r.memberId));
 
         let totalSteps = 0;
         let finishedSteps = 0;
@@ -381,6 +420,13 @@ export class SetupStepUpdater {
         for (const { responsibility, group } of flatResponsibilities) {
             const { minimumMembers: min, maximumMembers: max } = responsibility;
 
+            const invalidMembersWithThisResponsibility = !!invalidRecords.find(r => r.responsibilityId === responsibility.id && (group ? r.groupId === group.id : true));
+            if (invalidMembersWithThisResponsibility) {
+                totalSteps += Math.max(min ?? 1, 1);
+                // Step not okay: we have an invalid member with this responsibility
+                continue;
+            }
+
             if (min === null) {
                 continue;
             }
@@ -406,13 +452,14 @@ export class SetupStepUpdater {
             }
 
             if (max !== null && totalRecordsWithThisResponsibility > max) {
-                // Not added
+                // Not added (not okay)
                 continue;
             }
 
             finishedSteps += Math.min(min, totalRecordsWithThisResponsibility);
         }
 
+        console.log('Updating responsibilities step for organization', organization.id, 'with total steps', totalSteps, 'and finished steps', finishedSteps);
         setupSteps.update(SetupStepType.Responsibilities, {
             totalSteps,
             finishedSteps,

package/src/helpers/UitpasTokenRepository.ts

@@ -83,7 +83,7 @@ export class UitpasTokenRepository {
                 throw new SimpleError({
                     code: 'uitpas_api_not_configured_for_platform',
                     message: 'UiTPAS api is not configured for the platform',
-                    human: $t('UiTPAS is niet volledig geconfigureerd, contacteer de platformbeheerder.'),
+                    human: $t('71a8218b-c58e-4e95-9626-551b80eb8367'),
                 });
             }
             model = new UitpasClientCredential();
@@ -123,7 +123,7 @@ export class UitpasTokenRepository {
                 throw new SimpleError({
                     code: 'invalid_uitpas_client_credentials',
                     message: `Invalid UiTPAS client credentials`,
-                    human: $t(`De opgegeven UiTPAS client credentials zijn ongeldig. Controleer ze en probeer opnieuw.`),
+                    human: $t(`1086bb24-5df4-4faf-9dc0-ab5a955b0d8f`),
                 });
             }
             console.error(`Unsuccessful response when fetching UiTPAS token for organization with id ${this.uitpasClientCredential.organizationId}:`, response.statusText);
@@ -193,7 +193,7 @@ export class UitpasTokenRepository {
                     throw new SimpleError({
                         code: 'uitpas_api_not_configured_for_this_organization',
                         message: `UiTPAS api not configured for organization with id ${organizationId}`,
-                        human: $t('UiTPAS is nog niet volledig geconfigureerd voor deze organisatie.'),
+                        human: $t('6b333cb4-21fd-42be-b0c9-6d899f2fd348'),
                     });
                 }
                 repo = UitpasTokenRepository.setRepoInMemory(organizationId, new UitpasTokenRepository(model)); // store in memory

package/src/seeds/1750090030-records-configuration.ts

@@ -1,10 +1,14 @@
 import { Migration } from '@simonbackx/simple-database';
-import { Organization } from '@stamhoofd/models';
+import { Organization, Webshop } from '@stamhoofd/models';
 
 export async function startRecordsConfigurationMigration() {
     for await (const organization of Organization.select().all()) {
         await organization.save();
     }
+
+    for await (const webshop of Webshop.select().all()) {
+        await webshop.save();
+    }
 }
 
 export default new Migration(async () => {

package/src/services/BalanceItemService.ts

@@ -1,12 +1,11 @@
+import { Model } from '@simonbackx/simple-database';
 import { BalanceItem, CachedBalance, Document, MemberUser, Order, Organization, Payment, Webshop } from '@stamhoofd/models';
-import { AuditLogSource, BalanceItemStatus, BalanceItemType, OrderStatus, ReceivableBalanceType } from '@stamhoofd/structures';
-import { Formatter } from '@stamhoofd/utility';
+import { AuditLogSource, BalanceItemStatus, BalanceItemType, OrderStatus, PaymentStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import { GroupedThrottledQueue } from '../helpers/GroupedThrottledQueue';
+import { ThrottledQueue } from '../helpers/ThrottledQueue';
 import { AuditLogService } from './AuditLogService';
 import { PaymentReallocationService } from './PaymentReallocationService';
 import { RegistrationService } from './RegistrationService';
-import { Model } from '@simonbackx/simple-database';
-import { GroupedThrottledQueue } from '../helpers/GroupedThrottledQueue';
-import { ThrottledQueue } from '../helpers/ThrottledQueue';
 
 const memberUpdateQueue = new GroupedThrottledQueue(async (organizationId: string, memberIds: string[]) => {
     await CachedBalance.updateForMembers(organizationId, memberIds);
@@ -210,6 +209,12 @@ export const BalanceItemService = {
             if (shouldMarkUpdated) {
                 await this.markUpdated(balanceItem, payment, organization);
             }
+
+            if (balanceItem.registrationId) {
+                if (balanceItem.type === BalanceItemType.Registration && !!payment && payment.status === PaymentStatus.Succeeded) {
+                    await RegistrationService.markRepeatedPaid(balanceItem.registrationId);
+                }
+            }
             return;
         }
 
@@ -220,7 +225,7 @@ export const BalanceItemService = {
         // If registration
         if (balanceItem.registrationId) {
             if (balanceItem.type === BalanceItemType.Registration) {
-                await RegistrationService.markValid(balanceItem.registrationId);
+                await RegistrationService.markValid(balanceItem.registrationId, { paid: !!payment && payment.status === PaymentStatus.Succeeded });
             }
         }
 
@@ -228,7 +233,7 @@ export const BalanceItemService = {
         await balanceItem.save();
     },
 
-    async markUpdated(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+    async markUpdated(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
         // For orders: mark order as changed (so they are refetched in front ends)
         if (balanceItem.orderId) {
             await AuditLogService.setContext({ source: AuditLogSource.Payment }, async () => {

package/src/services/DocumentService.ts

@@ -27,7 +27,6 @@ export class DocumentService {
                     const newFields = getGroupFieldsAffectingDocuments(event.model);
 
                     if (JSON.stringify(oldFields) === JSON.stringify(newFields)) {
-                        console.log('Group changes cannot affect documents');
                         return;
                     }
 

package/src/services/RegistrationService.ts

@@ -9,16 +9,45 @@ import { Formatter } from '@stamhoofd/utility';
 import { encodeObject } from '@simonbackx/simple-encoding';
 
 export const RegistrationService = {
-    async markValid(registrationId: string) {
+    /**
+     * If the registration was marked valid, and later paid, we'll still shorten the trail until period
+     */
+    async markRepeatedPaid(registrationId: string) {
+        const registration = await Registration.getByID(registrationId);
+        if (!registration) {
+            throw new Error('Registration not found');
+        }
+
+        if (registration.registeredAt !== null && registration.deactivatedAt === null) {
+            // Already valid
+            if (registration.trialUntil && registration.trialUntil > new Date()) {
+                registration.trialUntil = new Date();
+                await registration.save();
+                await PlatformMembershipService.updateMembershipsForId(registration.memberId);
+            }
+        }
+        // do nothing: possible that we canceled the registration and don't want to reactivate it when we mark something paid
+    },
+
+    async markValid(registrationId: string, options?: { paid?: boolean }) {
         const registration = await Registration.getByID(registrationId);
         if (!registration) {
             throw new Error('Registration not found');
         }
 
         if (registration.registeredAt !== null && registration.deactivatedAt === null) {
+            // Already valid
+            if (options?.paid && registration.trialUntil && registration.trialUntil > new Date()) {
+                registration.trialUntil = new Date();
+                await registration.save();
+                await PlatformMembershipService.updateMembershipsForId(registration.memberId);
+            }
             return false;
         }
 
+        if (options?.paid && registration.trialUntil && registration.trialUntil > new Date()) {
+            registration.trialUntil = new Date();
+        }
         registration.reservedUntil = null;
         registration.registeredAt = registration.registeredAt ?? new Date();
         registration.deactivatedAt = null;

package/src/services/uitpas/UitpasService.ts

@@ -77,7 +77,7 @@ function getUitpasTicketSales(order: Order): UitpasTicketSale[] {
                 throw new SimpleError({
                     code: 'missing_uitpas_base_product_price',
                     message: `Missing UiTPAS base product price`,
-                    human: $t(`Er is een fout opgetreden bij het registreren van de UiTPAS ticket verkoop. Probeer het later opnieuw.`),
+                    human: $t(`f7eea411-fb92-458f-bf3e-e36ed870591b`),
                 });
             }
             const label = makeBaseProductPriceLabel(item.product, baseProductPrice);

package/src/services/uitpas/cancelTicketSales.ts

@@ -24,7 +24,7 @@ async function cancelTicketSale(access_token: string, ticketSaleId: string) {
         throw new SimpleError({
             code: 'unsuccessful_response_registering_ticket_sales',
             message: `Unsuccessful response when registering UiTPAS ticket sales`,
-            human: $t(`Er is een fout opgetreden bij het verbinden met UiTPAS. Probeer het later opnieuw.`),
+            human: $t(`ed4e876c-6a40-49a7-ab65-2a4d5f31c13f`),
         });
     }
     return ticketSaleId;

package/src/services/uitpas/checkPermissionsFor.ts

@@ -16,7 +16,7 @@ function assertIsPermissionsResponse(json: unknown): asserts json is Permissions
         throw new SimpleError({
             code: 'invalid_permissions_response',
             message: 'Invalid response format for permissions',
-            human: $t('Er is iets misgelopen bij het ophalen van je rechten. Probeer het later opnieuw.'),
+            human: $t('7d3a6b57-f81a-4d58-bc2b-babb2261c40b'),
         });
     }
 
@@ -35,7 +35,7 @@ function assertIsPermissionsResponse(json: unknown): asserts json is Permissions
             throw new SimpleError({
                 code: 'invalid_permissions_response',
                 message: 'Invalid response format for permissions',
-                human: $t('Er is iets misgelopen bij het ophalen van je rechten. Probeer het later opnieuw.'),
+                human: $t('7d3a6b57-f81a-4d58-bc2b-babb2261c40b'),
             });
         }
     }
@@ -54,7 +54,7 @@ export async function checkPermissionsFor(access_token: string, organizationId:
         throw new SimpleError({
             code: 'uitpas_unreachable_checking_permissions',
             message: `Network issue when checking UiTPAS permissions`,
-            human: $t(`We konden UiTPAS niet bereiken om de rechten te controleren. Probeer het later opnieuw.`),
+            human: $t(`542b793c-3edf-4505-b33d-199ea409bbda`),
         });
     });
     if (!response.ok) {
@@ -62,7 +62,7 @@ export async function checkPermissionsFor(access_token: string, organizationId:
         throw new SimpleError({
             code: 'unsuccessful_response_checking_permissions',
             message: `Unsuccesful response when checking UiTPAS permissions`,
-            human: $t(`Er is een fout opgetreden bij het verbinden met UiTPAS. Probeer het later opnieuw.`),
+            human: $t(`ed4e876c-6a40-49a7-ab65-2a4d5f31c13f`),
         });
     }
     const json = await response.json().catch(() => {
@@ -70,7 +70,7 @@ export async function checkPermissionsFor(access_token: string, organizationId:
         throw new SimpleError({
             code: 'invalid_json_checking_permissions',
             message: `Invalid json when checking UiTPAS permissions`,
-            human: $t(`Er is een fout opgetreden bij het communiceren met UiTPAS. Probeer het later opnieuw.`),
+            human: $t(`93004d03-955a-4a9a-937d-2f30841dc5cc`),
         });
     });
     assertIsPermissionsResponse(json);
@@ -91,18 +91,18 @@ export async function checkPermissionsFor(access_token: string, organizationId:
             }];
     const item = json.find(item => item.organizer.id === uitpasOrganizerId);
     if (!item) {
-        const organizers = Formatter.joinLast(json.map(i => i.organizer.name), ', ', ' ' + $t(' en ') + ' ');
+        const organizers = Formatter.joinLast(json.map(i => i.organizer.name), ', ', ' ' + $t('6d35156d-e452-4b0f-80f4-b1e9024d08ee') + ' ');
         return {
             status: UitpasClientCredentialsStatus.NoPermissions,
-            human: $t('Jouw UiTPAS-integratie heeft geen toegansrechten tot de geselecteerde UiTPAS-organisator, maar wel tot ') + organizers,
+            human: $t('96c8a719-dba5-47ce-bb61-ee0754a5f776') + organizers,
         };
     }
     const missingPermissions = neededPermissions.filter(needed => !item.permissions.includes(needed.permission));
     if (missingPermissions.length > 0) {
-        const missingPermissionsHuman = Formatter.joinLast(missingPermissions.map(p => p.human), ', ', ' ' + $t(' en ') + ' ');
+        const missingPermissionsHuman = Formatter.joinLast(missingPermissions.map(p => p.human), ', ', ' ' + $t('6d35156d-e452-4b0f-80f4-b1e9024d08ee') + ' ');
         return {
             status: UitpasClientCredentialsStatus.MissingPermissions,
-            human: $t('Jouw UiTPAS-integratie mist de volgende toegangsrechten voor de geselecteerde UiTPAS-organisator: ') + missingPermissionsHuman,
+            human: $t('040fa935-5cbc-4a85-b578-354bf9d7fc04') + missingPermissionsHuman,
         };
     }
     return {

package/src/services/uitpas/checkUitpasNumbers.ts

@@ -36,7 +36,7 @@ function assertIsUitpasNumberSuccessfulResponse(
         throw new SimpleError({
             code: 'invalid_response_retrieving_pass_by_uitpas_number',
             message: `Invalid response when retrieving pass by UiTPAS  number`,
-            human: $t(`Er is een fout opgetreden bij het ophalen van je UiTPAS. Kijk je het nummer even na?`),
+            human: $t(`4c6482ff-e6d9-4ea1-b11d-e12d697b4b7b`),
         });
     }
 }
@@ -110,7 +110,7 @@ async function checkUitpasNumber(access_token: string, uitpasNumber: string) {
         throw new SimpleError({
             code: 'unsuccessful_and_unexpected_response_retrieving_pass_by_uitpas_number',
             message: `Unsuccesful response without message when retrieving pass by UiTPAS number`,
-            human: $t(`Er is een fout opgetreden bij het ophalen van je UiTPAS. Kijk je het nummer even na?`),
+            human: $t(`4c6482ff-e6d9-4ea1-b11d-e12d697b4b7b`),
         });
     }
 

package/src/services/uitpas/getSocialTariffForEvent.ts

@@ -21,7 +21,7 @@ function assertsIsStaticSocialTariffResponse(json: unknown): asserts json is Sta
         throw new SimpleError({
             code: 'invalid_response_getting_static_uitpas_social_tariff',
             message: `Invalid response when getting static UiTPAS social tariff`,
-            human: $t(`Er is een fout opgetreden bij het ophalen van het kansentarief voor dit evenement. Probeer het later opnieuw.`),
+            human: $t(`a56854af-464a-45a4-8c39-10a9264b6ce4`),
         });
     }
 }
@@ -35,7 +35,7 @@ export async function getSocialTariffForEvent(access_token: string, basePrice: n
         throw new SimpleError({
             code: 'invalid_uitpas_event_url',
             message: `Invalid UiTPAS event URL: ${uitpasEventUrl}`,
-            human: $t(`De opgegeven UiTPAS-evenement URL is ongeldig.`),
+            human: $t(`85fb6e02-9b69-43cc-acf7-96a576461560`),
         });
     }
     params.append('eventId', eventId);
@@ -61,7 +61,7 @@ export async function getSocialTariffForEvent(access_token: string, basePrice: n
         throw new SimpleError({
             code: 'unsuccessful_response_getting_static_uitpas_social_tariff',
             message: `Unsuccessful response when getting static UiTPAS social tariff`,
-            human: $t(`Er is een fout opgetreden bij het verbinden met UiTPAS. Probeer het later opnieuw.`),
+            human: $t(`ed4e876c-6a40-49a7-ab65-2a4d5f31c13f`),
         });
     }
     const json = await response.json().catch(() => {
@@ -80,7 +80,7 @@ export async function getSocialTariffForEvent(access_token: string, basePrice: n
         throw new SimpleError({
             code: 'no_social_tariff_available',
             message: `No social tariff available for event ${eventId}`,
-            human: $t(`Er is geen kansentarief beschikbaar voor dit evenement.`),
+            human: $t(`ccd8e8b4-01a7-4e7c-8ae0-92d2a4c659eb`),
         });
     }
     if (json.available.length > 1) {