@stamhoofd/backend 2.90.3 → 2.92.0

package/src/seeds/1755181288-remove-duplicate-members.ts

@@ -0,0 +1,145 @@
+import { Migration, SQLResultNamespacedRow } from '@simonbackx/simple-database';
+import { Member, mergeTwoMembers } from '@stamhoofd/models';
+import { SQL, SQLSelect } from '@stamhoofd/sql';
+import { PatchOrganizationMembersEndpoint } from '../endpoints/global/members/PatchOrganizationMembersEndpoint';
+
+type MergeType = {
+    a: {
+        id: string;
+        firstName: string;
+        lastName: string;
+        createdAt: Date;
+    };
+    b: {
+        id: string;
+        createdAt: Date;
+    };
+};
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    const q = new SQLSelect(
+        (row: SQLResultNamespacedRow): MergeType => {
+            return {
+                a: {
+                    id: row['a'].id as string,
+                    firstName: row['a'].firstName as string,
+                    lastName: row['a'].lastName as string,
+                    createdAt: row['a'].createdAt as Date,
+                },
+                b: {
+                    id: row['b'].id as string,
+                    createdAt: row['b'].createdAt as Date,
+                },
+            };
+        },
+        SQL.wildcard('a'),
+        SQL.wildcard('b'),
+    )
+        .from(Member.table, 'a')
+        .join(
+            SQL.join(Member.table, 'b')
+                .where(
+                    SQL.column('b', 'id'),
+                    '!=',
+                    SQL.column('a', 'id'),
+                )
+                .andWhere(
+                    SQL.column('b', 'firstName'),
+                    SQL.column('a', 'firstName'),
+                )
+                .andWhere(
+                    SQL.column('b', 'lastName'),
+                    SQL.column('a', 'lastName'),
+                )
+                .andWhere(
+                    SQL.column('b', 'birthDay'),
+                    SQL.column('a', 'birthDay'),
+                ),
+        )
+        .where(
+            SQL.where(
+                SQL.column('a', 'createdAt'),
+                '<',
+                SQL.column('b', 'createdAt'),
+            ).or(
+                SQL.where(
+                    SQL.column('b', 'createdAt'),
+                    SQL.column('a', 'createdAt'),
+                ).and(
+                    SQL.column('a', 'id'),
+                    '<',
+                    SQL.column('b', 'id'),
+                ),
+            ),
+        )
+        .orderBy(
+            SQL.column('a', 'createdAt'),
+            'ASC',
+        );
+
+    if (STAMHOOFD.userMode === 'organization') {
+        q.where(
+            SQL.column('b', 'organizationId'),
+            SQL.column('organizationId'),
+        );
+    }
+
+    const duplicates = await q.fetch();
+
+    const deletedSet = new Set<string>();
+    const mergedIntoSet = new Set<string>();
+
+    for (const duplicate of duplicates) {
+        if (mergedIntoSet.has(duplicate.b.id)) {
+            console.log('Found chained duplicate in wrong order', duplicate.a.id, 'and', duplicate.b.id);
+            continue; // Already merged this one
+        }
+
+        if (deletedSet.has(duplicate.b.id)) {
+            continue; // Already deleted this one
+        }
+
+        if (deletedSet.has(duplicate.a.id)) {
+            console.log('Skipping duplicate', duplicate.a.id, 'because it was already deleted');
+            continue; // Already deleted this one
+        }
+
+        console.log(
+            'Found duplicate member',
+            duplicate.a.id,
+            duplicate.a.createdAt,
+            'and',
+            duplicate.b.id,
+            duplicate.b.createdAt,
+            'with name',
+            duplicate.a.firstName, duplicate.a.lastName);
+        deletedSet.add(duplicate.b.id);
+        mergedIntoSet.add(duplicate.a.id);
+
+        // Run the merge
+        const [memberA] = await Member.getBlobByIds(duplicate.a.id);
+        const [memberB] = await Member.getBlobByIds(duplicate.b.id);
+
+        if (memberA.details.name !== memberB.details.name) {
+            console.warn('Member names do not match', memberA.details.name, 'and', memberB.details.name);
+            continue; // Names do not match, cannot merge
+        }
+
+        if (memberA.details.birthDayFormatted === null || memberA.details.birthDayFormatted !== memberB.details.birthDayFormatted) {
+            console.warn('Member birthday do not match', memberA.details.birthDayFormatted, 'and', memberB.details.birthDayFormatted);
+            continue; // Names do not match, cannot merge
+        }
+
+        if (!PatchOrganizationMembersEndpoint.shouldCheckIfMemberIsDuplicate(memberA)) {
+            console.log('Skipping merge because not eligible for duplicate check');
+            continue;
+        }
+
+        await mergeTwoMembers(memberA, memberB);
+    }
+});

package/src/seeds/1755532883-update-email-sender-ids.ts

@@ -0,0 +1,47 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Email, Organization, Platform } from '@stamhoofd/models';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    console.log('Start setting senderId of emails.');
+
+    const batchSize = 100;
+    let count = 0;
+    const platform = await Platform.getShared();
+
+    for await (const email of Email.select()
+        .where('senderId', null).limit(batchSize).all()) {
+        if (!email.fromAddress) {
+            continue;
+        }
+        const organization = email.organizationId ? await Organization.getByID(email.organizationId) : null;
+        if (!organization) {
+            const sender = platform.privateConfig.emails.find(s => s.email === email.fromAddress);
+            if (sender) {
+                email.senderId = sender.id;
+                await email.save();
+                count += 1;
+            }
+            else {
+                console.warn(`No sender found for email ${email.fromAddress} in platform config`);
+            }
+        }
+        else {
+            const sender = organization.privateMeta.emails.find(s => s.email === email.fromAddress);
+            if (sender) {
+                email.senderId = sender.id;
+                await email.save();
+                count += 1;
+            }
+            else {
+                console.warn(`No sender found for email ${email.fromAddress} in organization ${organization.id}`);
+            }
+        }
+    }
+
+    console.log('Finished saving ' + count + ' emails.');
+});

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

@@ -1,6 +1,6 @@
 import { Model } from '@simonbackx/simple-database';
 import { Order, WebshopUitpasNumber } from '@stamhoofd/models';
-import { OrderStatus, Product, ProductPrice, UitpasClientCredentialsStatus, UitpasOrganizersResponse } from '@stamhoofd/structures';
+import { Cart, OrderStatus, Product, ProductPrice, UitpasClientCredentialsStatus, UitpasOrganizersResponse } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 import { UitpasTokenRepository } from '../../helpers/UitpasTokenRepository';
 import { searchUitpasOrganizers } from './searchUitpasOrganizers';
@@ -13,6 +13,7 @@ import { RegisterTicketSaleRequest, RegisterTicketSaleResponse, registerTicketSa
 import { cancelTicketSales } from './cancelTicketSales';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
+import { Formatter } from '@stamhoofd/utility';
 
 type UitpasTicketSale = {
     basePrice: number;
@@ -39,7 +40,7 @@ type InsertUitpasNumber = {
     uitpasEventUrl: string | null; // null for non-official flow
 };
 
-function shouldReserveUitpasNumbers(status: OrderStatus): boolean {
+export function shouldReserveUitpasNumbers(status: OrderStatus): boolean {
     return status !== OrderStatus.Canceled && status !== OrderStatus.Deleted;
 }
 
@@ -77,7 +78,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);
@@ -356,4 +357,72 @@ export class UitpasService {
         // Clear the uitpas client credentials for the organization
         await UitpasTokenRepository.clearClientCredentialsFor(organizationId);
     }
+
+    static async areThereRegisteredTicketSales(webshopId: string): Promise<boolean> {
+        return await WebshopUitpasNumber.areThereRegisteredTicketSales(webshopId);
+    }
+
+    static async validateCart(organizationId: string, webshopId: string, cart: Cart, exisitingOrderId?: string): Promise<Cart> {
+        let access_token_org: string | null = null;
+        let access_token_platform: string | null = null;
+        for (const item of cart.items) {
+            if (item.uitpasNumbers.length === 0) {
+                continue;
+            }
+
+            // verify the UiTPAS numbers are not already used for this product
+            const hasBeenUsed = await WebshopUitpasNumber.areUitpasNumbersUsed(webshopId, item.product.id, item.uitpasNumbers.map(p => p.uitpasNumber), item.product.uitpasEvent?.url, exisitingOrderId);
+            if (hasBeenUsed) {
+                throw new SimpleError({
+                    code: 'uitpas_number_already_used',
+                    message: 'One or more uitpas numbers are already used',
+                    human: $t('f3daff19-a227-4e45-b19a-c770bd7a6687'),
+                    field: 'uitpasNumbers',
+                });
+            }
+
+            if (item.product.uitpasEvent) {
+                // official flow
+                const basePrice = item.product.prices.filter(price => price.id === item.productPrice.uitpasBaseProductPriceId)[0]?.price;
+                if (!basePrice) {
+                    throw new SimpleError({
+                        code: 'missing_uitpas_base_product_price',
+                        message: `Missing UiTPAS base product price`,
+                        human: $t(`3d08a166-11a7-4429-8ff7-84458bbe3e9a`),
+                    });
+                }
+
+                access_token_org = access_token_org ?? await UitpasTokenRepository.getAccessTokenFor(organizationId);
+                const verified = await getSocialTariffForUitpasNumbers(access_token_org, item.uitpasNumbers.map(p => p.uitpasNumber), basePrice, item.product.uitpasEvent.url);
+                if (verified.length < item.uitpasNumbers.length) {
+                    throw new SimpleError({
+                        code: 'uitpas_social_tariff_price_mismatch',
+                        message: 'UiTPAS wrong number of prices returned',
+                        human: $t('83c472b8-4bc5-4282-bbc9-1c6a2d382171'),
+                        field: 'uitpasNumbers',
+                    });
+                }
+                for (let i = 0; i < verified.length; i++) {
+                    if (item.uitpasNumbers[i].uitpasTariffId !== verified[i].uitpasTariffId) {
+                        // silently update
+                        item.uitpasNumbers[i].uitpasTariffId = verified[i].uitpasTariffId;
+                    }
+                    if (item.uitpasNumbers[i].price !== verified[i].price) {
+                        throw new SimpleError({
+                            code: 'uitpas_social_tariff_price_mismatch',
+                            message: 'UiTPAS social tariff have a different price',
+                            human: $t('9a0ad099-99e3-4341-beac-f14feb3fb9d1', { correctPrice: Formatter.price(verified[i].price), orderPrice: Formatter.price(item.uitpasNumbers[i].price) }),
+                            field: 'uitpasNumbers.' + i.toString(),
+                        });
+                    }
+                }
+            }
+            else {
+                // non-official flow
+                access_token_platform = access_token_platform ?? await UitpasTokenRepository.getAccessTokenFor();
+                await checkUitpasNumbers(access_token_platform, item.uitpasNumbers.map(p => p.uitpasNumber));
+            }
+        }
+        return cart;
+    }
 };

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`),
         });
     }
 }
@@ -64,6 +64,7 @@ async function checkUitpasNumber(access_token: string, uitpasNumber: string) {
             ),
         });
     }
+
     const baseUrl = 'https://api-test.uitpas.be'; // TO DO: Use the URL from environment variables
 
     const url = `${baseUrl}/passes/${uitpasNumber}`;
@@ -110,7 +111,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) {

package/src/services/uitpas/getSocialTariffForUitpasNumbers.ts

@@ -34,7 +34,7 @@ function assertsIsSocialTariffResponse(json: unknown): asserts json is SocialTar
         throw new SimpleError({
             code: 'invalid_response_getting_uitpas_social_tariff',
             message: `Invalid response when getting UiTPAS social tariff`,
-            human: $t(`Er is een fout opgetreden bij het ophalen van het kansentarief voor jouw UiTPAS-nummer. Probeer het later opnieuw.`),
+            human: $t(`466844b9-c042-4bc7-b77d-3f87376086b5`),
         });
     }
 }
@@ -60,7 +60,7 @@ async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber
         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);
@@ -110,7 +110,7 @@ async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber
         throw new SimpleError({
             code: 'unsuccessful_and_unexpected_response_retrieving_social_tariff_by_uitpas_number',
             message: `Unsuccesful response without message when retrieving social tariff by UiTPAS number`,
-            human: $t(`Er is een fout opgetreden bij het ophalen van je UiTPAS kansentarief. Kijk je het nummer even na?`),
+            human: $t(`1572d069-abda-4b31-a373-f0c3760c79b1`),
         });
     }
     const json = await response.json().catch(() => {
@@ -136,7 +136,7 @@ async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber
         throw new SimpleError({
             code: 'no_social_tariff_available',
             message: `No social tariff available for event ${uitpasEventUrl}`,
-            human: $t(`Er is geen kansentarief beschikbaar voor dit evenement.`),
+            human: $t(`ccd8e8b4-01a7-4e7c-8ae0-92d2a4c659eb`),
         });
     }
     if (json.available.length > 1) {
@@ -150,7 +150,7 @@ async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber
         throw new SimpleError({
             code: 'no_remaining_social_tariff',
             message: `No remaining social tariff for event ${uitpasEventUrl} and UiTPAS number ${uitpasNumber}`,
-            human: $t(`Je hebt recht op UiTPAS-kansentarief maar het overblijvend aantal is niet voldoende.`),
+            human: $t(`f9d6bc51-e7c9-4d3f-a13f-27871a018d83`),
         });
     }
     console.log('Social tariff for UiTPAS number', uitpasNumber, 'with event id', uitpasEventUrl, 'is', json.available[0].price, 'euros');

package/src/services/uitpas/registerTicketSales.ts

@@ -46,7 +46,7 @@ function assertisSuccessResponse(json: unknown): asserts json is SuccessResponse
         throw new SimpleError({
             code: 'invalid_register_ticket_sale_response',
             message: `Invalid register ticket sale response`,
-            human: $t(`Er is een fout opgetreden bij het registreren van de UiTPAS-ticketverkoop.`),
+            human: $t(`f5cac12d-ced6-43e6-bbd9-81b381807154`),
         });
     }
 }
@@ -69,7 +69,7 @@ export async function registerTicketSales(access_token: string, registerTicketSa
             throw new SimpleError({
                 code: 'invalid_uitpas_event_url',
                 message: `Invalid UiTPAS event URL: ${ticketSale.uitpasEventUrl}`,
-                human: $t(`De opgegeven UiTPAS-evenement URL is ongeldig.`),
+                human: $t(`85fb6e02-9b69-43cc-acf7-96a576461560`),
             });
         }
 
@@ -108,7 +108,7 @@ export async function registerTicketSales(access_token: string, registerTicketSa
         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`),
         });
     }
     const json = await response.json().catch(() => {});
@@ -117,7 +117,7 @@ export async function registerTicketSales(access_token: string, registerTicketSa
         throw new SimpleError({
             code: 'invalid_response_registering_ticket_sales',
             message: `Invalid response when registering ticket sales`,
-            human: $t(`Er is een fout opgetreden bij het registreren van de UiTPAS-ticketverkoop.`),
+            human: $t(`f5cac12d-ced6-43e6-bbd9-81b381807154`),
         });
     }
     const now = new Date();

package/src/services/uitpas/searchUitpasEvents.ts

@@ -49,7 +49,7 @@ function assertIsEventsResponse(json: unknown): asserts json is EventsResponse {
         throw new SimpleError({
             code: 'invalid_events_response',
             message: `Invalid events response`,
-            human: $t(`Er is een fout opgetreden bij het ophalen van de UiTPAS-evenementen.`),
+            human: $t(`0b610eb8-551f-4ef6-acdc-fb3267dfc2a8`),
         });
     }
 }
@@ -61,7 +61,7 @@ export async function searchUitpasEvents(clientId: string, uitpasOrganizerId: st
         throw new SimpleError({
             code: 'no_client_id_for_uitpas_events',
             message: `No client ID configured for Uitpas events`,
-            human: $t(`Er is geen UiTPAS client ID geconfigureerd voor deze organisatie.`),
+            human: $t(`0009cce2-9d13-4f03-9258-345d8f8e396e`),
         });
     }
     const baseUrl = 'https://search-test.uitdatabank.be/events';
@@ -97,7 +97,7 @@ export async function searchUitpasEvents(clientId: string, uitpasOrganizerId: st
         throw new SimpleError({
             code: 'unsuccessful_response_searching_uitpas_events',
             message: `Unsuccessful response when searching for UiTPAS events`,
-            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(() => {