@stamhoofd/backend 2.89.2 → 2.90.1

package/src/services/RegistrationService.ts

@@ -6,7 +6,7 @@ import { GroupService } from './GroupService';
 import { PlatformMembershipService } from './PlatformMembershipService';
 import { QueueHandler } from '@stamhoofd/queues';
 import { Formatter } from '@stamhoofd/utility';
-import { encodeObject, patchContainsChanges } from '@simonbackx/simple-encoding';
+import { encodeObject } from '@simonbackx/simple-encoding';
 
 export const RegistrationService = {
     async markValid(registrationId: string) {
@@ -28,9 +28,11 @@ export const RegistrationService = {
 
         await PlatformMembershipService.updateMembershipsForId(registration.memberId);
 
-        await registration.sendEmailTemplate({
-            type: EmailTemplateType.RegistrationConfirmation,
-        });
+        if (registration.sendConfirmationEmail) {
+            await registration.sendEmailTemplate({
+                type: EmailTemplateType.RegistrationConfirmation,
+            });
+        }
 
         const member = await Member.getByID(registration.memberId);
         if (member) {

package/src/services/uitpas/UitpasService.test.ts

@@ -0,0 +1,23 @@
+import { STExpect } from '@stamhoofd/test-utils';
+import { UitpasService } from './UitpasService';
+
+describe.skip('UitpasService', () => {
+    it('should validate a correct Uitpas number with kansentarief', async () => {
+        const validNumbers = ['0900000067513'];
+        await expect(UitpasService.checkUitpasNumbers(validNumbers)).resolves.toBeUndefined();
+    });
+
+    it('should throw an error for an invalid Uitpas number', async () => {
+        const invalidNumbers = ['1234567890123'];
+        await expect(UitpasService.checkUitpasNumbers(invalidNumbers)).rejects.toThrow(
+            STExpect.simpleError({ code: 'unsuccessful_but_expected_response_retrieving_pass_by_uitpas_number' }),
+        );
+    });
+
+    it('should throw an error for a Uitpas number with kansentarief expired', async () => {
+        const expiredNumbers = ['0900000058918'];
+        await expect(UitpasService.checkUitpasNumbers(expiredNumbers)).rejects.toThrow(
+            STExpect.simpleError({ code: 'uitpas_number_issue' }),
+        );
+    });
+});

package/src/services/uitpas/UitpasService.ts

@@ -0,0 +1,222 @@
+import { Model } from '@simonbackx/simple-database';
+import { Order, WebshopUitpasNumber } from '@stamhoofd/models';
+import { OrderStatus, UitpasClientCredentialsStatus, UitpasOrganizersResponse } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from 'uuid';
+import { UitpasTokenRepository } from '../../helpers/UitpasTokenRepository';
+import { searchUitpasOrganizers } from './searchUitpasOrganizers';
+import { checkPermissionsFor } from './checkPermissionsFor';
+import { checkUitpasNumbers } from './checkUitpasNumbers';
+import { getSocialTariffForEvent } from './getSocialTariffForEvent';
+import { getSocialTariffForUitpasNumbers } from './getSocialTariffForUitpasNumbers';
+
+function shouldReserveUitpasNumbers(status: OrderStatus): boolean {
+    return status !== OrderStatus.Canceled && status !== OrderStatus.Deleted;
+}
+
+function mapUitpasNumbersToProducts(order: Order): Map<string, string[]> {
+    const items = order.data.cart.items;
+    const productIdToUitpasNumbers: Map<string, string[]> = new Map();
+    for (const item of items) {
+        const a = productIdToUitpasNumbers.get(item.product.id);
+        if (a) {
+            a.push(...item.uitpasNumbers.map(p => p.uitpasNumber));
+        }
+        else {
+            productIdToUitpasNumbers.set(item.product.id, [...item.uitpasNumbers.map(p => p.uitpasNumber)]); // make a copy
+        }
+    }
+    return productIdToUitpasNumbers;
+}
+
+function areUitpasNumbersChanged(oldOrder: Order, newOrder: Order): boolean {
+    const oldMap = mapUitpasNumbersToProducts(oldOrder);
+    const newMap = mapUitpasNumbersToProducts(newOrder);
+    if (oldMap.size !== newMap.size) {
+        return true;
+    }
+    for (const [productId, uitpasNumbers] of oldMap.entries()) {
+        const newUitpasNumbers = newMap.get(productId);
+        if (!newUitpasNumbers) {
+            return true;
+        }
+        if (newUitpasNumbers.length !== uitpasNumbers.length) {
+            return true;
+        }
+        for (const uitpasNumber of uitpasNumbers) {
+            if (!newUitpasNumbers.includes(uitpasNumber)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+export class UitpasService {
+    static listening = false;
+
+    static async updateUitpasNumbers(order: Order) {
+        await this.deleteUitpasNumbers(order);
+        await this.createUitpasNumbers(order);
+    }
+
+    static async createUitpasNumbers(order: Order) {
+        const mappedUitpasNumbers = mapUitpasNumbersToProducts(order); // productId -> Set of uitpas numbers
+        // add to DB
+        const insert = WebshopUitpasNumber.insert();
+        insert.columns(
+            'id',
+            'webshopId',
+            'orderId',
+            'productId',
+            'uitpasNumber',
+        );
+        const rows = [...mappedUitpasNumbers].flatMap(([productId, uitpasNumbers]) => {
+            return uitpasNumbers.map(uitpasNumber => [
+                uuidv4(),
+                order.webshopId,
+                order.id,
+                productId,
+                uitpasNumber,
+            ]);
+        });
+        if (rows.length === 0) {
+            // No uitpas numbers to insert, skipping
+            return;
+        }
+        insert.values(...rows);
+        await insert.insert();
+    }
+
+    static async deleteUitpasNumbers(order: Order) {
+        await WebshopUitpasNumber.delete().where('webshopId', order.webshopId)
+            .andWhere('orderId', order.id);
+    }
+
+    static listen() {
+        if (this.listening) {
+            return;
+        }
+        this.listening = true;
+        Model.modelEventBus.addListener(this, async (event) => {
+            try {
+                if (event.model instanceof Order) {
+                    // event.type ==='deteled' -> not needed as foreign key will delete the order
+                    if (event.type === 'created' && shouldReserveUitpasNumbers(event.model.status)) {
+                        await this.createUitpasNumbers(event.model);
+                        return;
+                    }
+                    if (event.type === 'updated') {
+                        if (event.changedFields.status) {
+                            const statusBefore = event.originalFields.status as OrderStatus;
+                            const statusAfter = event.changedFields.status as OrderStatus;
+                            const shouldReserveAfter = shouldReserveUitpasNumbers(statusAfter);
+                            if (shouldReserveUitpasNumbers(statusBefore) !== shouldReserveAfter) {
+                                if (shouldReserveAfter) {
+                                    await this.createUitpasNumbers(event.model);
+                                    return;
+                                }
+                                await this.deleteUitpasNumbers(event.model);
+                                return;
+                            }
+                        }
+                        if (event.changedFields.data) {
+                            const oldOrder = event.getOldModel() as Order;
+                            if (areUitpasNumbersChanged(oldOrder, event.model)) {
+                                await this.updateUitpasNumbers(event.model);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                console.error('Failed to update UiTPAS-numbers after order update', e);
+            }
+        });
+    }
+
+    static async getSocialTariffForUitpasNumbers(organisationId: string, uitpasNumbers: string[], basePrice: number, uitpasEventUrl: string) {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/list-tariffs
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(organisationId);
+        return await getSocialTariffForUitpasNumbers(access_token, uitpasNumbers, basePrice, uitpasEventUrl);
+    }
+
+    static async getSocialTariffForEvent(organisationId: string, basePrice: number, uitpasEventUrl: string) {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/get-a-tariff-static
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(organisationId);
+        return await getSocialTariffForEvent(access_token, basePrice, uitpasEventUrl);
+    }
+
+    static async registerTicketSales() {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/create-a-ticket-sale
+    }
+
+    static async cancelTicketSale() {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/delete-a-ticket-sale
+    }
+
+    static async getTicketSales() {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/list-ticket-sales
+    }
+
+    static async registerAttendance() {
+        // https://api-test.uitpas.be/checkins
+    }
+
+    static searchUitpasEvents(organizationId: string, uitpasOrganizerId: string, textQuery?: string) {
+        // input = client id of organization (never platform0 & uitpasOrganizerId
+        // https://docs.publiq.be/docs/uitpas/events/searching#searching-for-uitpas-events-of-one-specific-organizer
+    }
+
+    static async searchUitpasOrganizers(name: string): Promise<UitpasOrganizersResponse> {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/list-organizers
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(); // uses platform credentials
+        return await searchUitpasOrganizers(access_token, name);
+    }
+
+    static async checkPermissionsFor(organizationId: string | null, uitpasOrganizerId: string): Promise<{
+        status: UitpasClientCredentialsStatus;
+        human?: string;
+    }> {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/list-permissions
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(organizationId);
+        return await checkPermissionsFor(access_token, organizationId, uitpasOrganizerId);
+    }
+
+    /**
+     * Returns the client ID if it is configured for the organization, otherwise an empty string. Empty strings means no client ID and secret configured.
+     * @param organisationId
+     * @returns clientId or empty string if not configured
+     */
+    static async getClientIdFor(organizationId: string | null): Promise<string> {
+        // Get the uitpas client credentials for the organization
+        return await UitpasTokenRepository.getClientIdFor(organizationId);
+    }
+
+    /**
+     * Checks multiple uitpas numbers
+     * If any of the uitpas numbers is invalid, it will throw a SimpleErrors instance with all errors.
+     * The field of the error will be the index of the uitpas number in the array.
+     * @param uitpasNumbers The uitpas numbers to check
+     */
+    static async checkUitpasNumbers(uitpasNumbers: string[]) {
+        // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/get-a-pass
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(); // use platform credentials
+        return await checkUitpasNumbers(access_token, uitpasNumbers);
+    }
+
+    /**
+     * Store the uitpas client credentials if they are valid
+     * @param organizationId null for platform
+     * @param clientId
+     * @param clientSecret
+     * @returns wether the credentials were valid and thus stored successfully
+     */
+    static async storeIfValid(organizationId: string | null, clientId: string, clientSecret: string): Promise<boolean> {
+        return await UitpasTokenRepository.storeIfValid(organizationId, clientId, clientSecret);
+    }
+
+    static async clearClientCredentialsFor(organizationId: string | null) {
+        // Clear the uitpas client credentials for the organization
+        await UitpasTokenRepository.clearClientCredentialsFor(organizationId);
+    }
+};

package/src/services/uitpas/checkPermissionsFor.ts

@@ -0,0 +1,111 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { UitpasClientCredentialsStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+
+type PermissionsResponse = Array<{
+    organizer: {
+        id: string;
+        name: string;
+    };
+    permissions: Array<string>;
+}>;
+
+function assertIsPermissionsResponse(json: unknown): asserts json is PermissionsResponse {
+    if (!Array.isArray(json)) {
+        console.error('Invalid PermissionsResponse:', json);
+        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.'),
+        });
+    }
+
+    for (const item of json) {
+        if (
+            typeof item !== 'object' || item === null
+            || !('organizer' in item)
+            || typeof (item as any).organizer !== 'object' || (item as any).organizer === null
+            || typeof (item as any).organizer.id !== 'string'
+            || typeof (item as any).organizer.name !== 'string'
+            || !('permissions' in item)
+            || !Array.isArray((item as any).permissions)
+            || !(item as any).permissions.every((perm: unknown) => typeof perm === 'string')
+        ) {
+            console.error('Invalid PermissionsResponse:', json);
+            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.'),
+            });
+        }
+    }
+}
+
+export async function checkPermissionsFor(access_token: string, organizationId: string | null, uitpasOrganizerId: string) {
+    const url = 'https://api-test.uitpas.be/permissions';
+    const myHeaders = new Headers();
+    myHeaders.append('Authorization', 'Bearer ' + access_token);
+    myHeaders.append('Accept', 'application/json');
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: myHeaders,
+    }).catch(() => {
+        // Handle network errors
+        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.`),
+        });
+    });
+    if (!response.ok) {
+        console.error(`Unsuccessful response whe n checking UiTPAS permissions for organization with id ${organizationId}:`, response.statusText);
+        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.`),
+        });
+    }
+    const json = await response.json().catch(() => {
+        // Handle JSON parsing errors
+        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.`),
+        });
+    });
+    assertIsPermissionsResponse(json);
+    const neededPermissions = organizationId
+        ? [{
+                permission: 'PASSES_READ',
+                human: 'Basis UiTPAS informatie ophalen met UiTPAS nummer',
+            }]
+        : [{
+                permission: 'TARIFFS_READ',
+                human: 'Tarieven opvragen',
+            }, {
+                permission: 'TICKETSALES_REGISTER',
+                human: 'Ticketsales registreren',
+            }, {
+                permission: 'TICKETSALES_SEARCH',
+                human: 'Ticketsales zoeken',
+            }];
+    const item = json.find(item => item.organizer.id === uitpasOrganizerId);
+    if (!item) {
+        const organizers = Formatter.joinLast(json.map(i => i.organizer.name), ', ', ' ' + $t(' en ') + ' ');
+        return {
+            status: UitpasClientCredentialsStatus.NoPermissions,
+            human: $t('Jouw UiTPAS-integratie heeft geen toegansrechten tot de geselecteerde UiTPAS-organisator, maar wel tot ') + 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 ') + ' ');
+        return {
+            status: UitpasClientCredentialsStatus.MissingPermissions,
+            human: $t('Jouw UiTPAS-integratie mist de volgende toegangsrechten voor de geselecteerde UiTPAS-organisator: ') + missingPermissionsHuman,
+        };
+    }
+    return {
+        status: UitpasClientCredentialsStatus.Ok,
+    };
+}

package/src/services/uitpas/checkUitpasNumbers.ts

@@ -0,0 +1,180 @@
+import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
+import { DataValidator } from '@stamhoofd/utility';
+
+type UitpasNumberSuccessfulResponse = {
+    socialTariff: {
+        status: 'ACTIVE' | 'EXPIRED' | 'NONE';
+    };
+    messages?: Array<{
+        text: string;
+    }>;
+};
+
+type UitpasNumberErrorResponse = {
+    title: string; // e.g., "Invalid uitpas number"
+    endUserMessage?: {
+        nl: string;
+    };
+};
+
+function assertIsUitpasNumberSuccessfulResponse(
+    json: unknown,
+): asserts json is UitpasNumberSuccessfulResponse {
+    if (
+        typeof json !== 'object'
+        || json === null
+        || !('socialTariff' in json)
+        || typeof json.socialTariff !== 'object'
+        || json.socialTariff === null
+        || !('status' in json.socialTariff)
+        || typeof json.socialTariff.status !== 'string'
+        || (json.socialTariff.status !== 'ACTIVE' && json.socialTariff.status !== 'EXPIRED' && json.socialTariff.status !== 'NONE')
+        || ('messages' in json && (!Array.isArray(json.messages) || !json.messages.every(
+            (message: unknown) => typeof message === 'object' && message !== null && 'text' in message && typeof message.text === 'string')))
+    ) {
+        console.error('Invalid response when retrieving pass by UiTPAS number:', json);
+        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?`),
+        });
+    }
+}
+
+function isUitpasNumberErrorResponse(
+    json: unknown,
+): json is UitpasNumberErrorResponse {
+    return typeof json === 'object'
+        && json !== null
+        && 'title' in json
+        && typeof json.title === 'string'
+        && (!('endUserMessage' in json)
+            || (typeof json.endUserMessage === 'object' && json.endUserMessage !== null && 'nl' in json.endUserMessage && typeof json.endUserMessage.nl === 'string')
+        );
+}
+
+async function checkUitpasNumber(access_token: string, uitpasNumber: string) {
+    // static check (using regex)
+    if (!DataValidator.isUitpasNumberValid(uitpasNumber)) {
+        throw new SimpleError({
+            code: 'invalid_uitpas_number',
+            message: `Invalid UiTPAS number: ${uitpasNumber}`,
+            human: $t(
+                `Het opgegeven UiTPAS-nummer is ongeldig. Controleer het nummer en probeer het opnieuw.`,
+            ),
+        });
+    }
+    const baseUrl = 'https://api-test.uitpas.be'; // TO DO: Use the URL from environment variables
+
+    const url = `${baseUrl}/passes/${uitpasNumber}`;
+    const myHeaders = new Headers();
+    myHeaders.append('Authorization', 'Bearer ' + access_token);
+    const requestOptions = {
+        method: 'GET',
+        headers: myHeaders,
+    };
+
+    const response = await fetch(url, requestOptions).catch(() => {
+        // Handle network errors
+        throw new SimpleError({
+            code: 'uitpas_unreachable_retrieving_pass_by_uitpas_number',
+            message: `Network issue when retrieving pass by UiTPAS number`,
+            human: $t(
+                `We konden UiTPAS niet bereiken om jouw UiTPAS-nummer te valideren. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+    if (!response.ok) {
+        const json: unknown = await response.json().catch(() => { /* ignore */ });
+        let endUserMessage = '';
+
+        if (json) {
+            console.error(`UiTPAS API returned an error for UiTPAS number ${uitpasNumber}:`, json);
+        }
+        else {
+            console.error(`UiTPAS API returned an error for UiTPAS number ${uitpasNumber}:`, response.statusText);
+        }
+
+        if (isUitpasNumberErrorResponse(json)) {
+            endUserMessage = json.endUserMessage ? json.endUserMessage.nl : '';
+        }
+
+        if (endUserMessage) {
+            throw new SimpleError({
+                code: 'unsuccessful_but_expected_response_retrieving_pass_by_uitpas_number',
+                message: `Unsuccesful response with message when retrieving pass by UiTPAS number, message: ${endUserMessage}`,
+                human: endUserMessage,
+            });
+        }
+
+        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?`),
+        });
+    }
+
+    const json = await response.json().catch(() => {
+        // Handle JSON parsing errors
+        throw new SimpleError({
+            code: 'invalid_json_retrieving_pass_by_uitpas_number',
+            message: `Invalid json when retrieving pass by UiTPAS  number`,
+            human: $t(
+                `Er is een fout opgetreden bij het communiceren met UiTPAS. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+    assertIsUitpasNumberSuccessfulResponse(json);
+    if (json.messages) {
+        const humanMessage = json.messages[0].text; // only display the first message
+
+        // alternatively, join all messages
+        // const text = json.messages.map((message: any) => message.text).join(', ');
+
+        throw new SimpleError({
+            code: 'uitpas_number_issue',
+            message: `UiTPAS API returned an error: ${humanMessage}`,
+            human: humanMessage,
+        });
+    }
+    if (json.socialTariff.status !== 'ACTIVE') {
+        // THIS SHOULD NOT HAPPEN, as in that case json.messages should be present
+        throw new SimpleError({
+            code: 'non_active_social_tariff',
+            message: `UiTPAS social tariff is not ACTIVE but ${json.socialTariff.status}`,
+            human: $t(
+                `Het opgegeven UiTPAS-nummer heeft geen actief kansentarief. Neem contact op met de UiTPAS-organisatie voor meer informatie.`,
+            ),
+        });
+    }
+    // no errors -> the uitpas number is valid and social tariff is applicable
+}
+
+/**
+ * Checks multiple uitpas numbers
+ * If any of the uitpas numbers is invalid, it will throw a SimpleErrors instance with all errors.
+ * The field of the error will be the index of the uitpas number in the array.
+ * @param uitpasNumbers The uitpas numbers to check
+ */
+export async function checkUitpasNumbers(access_token: string, uitpasNumbers: string[]) {
+    const simpleErrors = new SimpleErrors();
+    for (let i = 0; i < uitpasNumbers.length; i++) {
+        const uitpasNumber = uitpasNumbers[i];
+        try {
+            await checkUitpasNumber(access_token, uitpasNumber); // Throws if invalid
+        }
+        catch (e) {
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                e.addNamespace(i.toString());
+                e.addNamespace('uitpasNumbers');
+                simpleErrors.addError(e);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    if (simpleErrors.errors.length > 0) {
+        throw simpleErrors;
+    }
+}

package/src/services/uitpas/getSocialTariffForEvent.ts

@@ -0,0 +1,90 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+
+type StaticSocialTariffReponse = {
+    available: Array<{
+        price: number;
+        // other properties ignored
+    }>;
+};
+
+function assertsIsStaticSocialTariffResponse(json: unknown): asserts json is StaticSocialTariffReponse {
+    if (
+        typeof json !== 'object'
+        || json === null
+        || !('available' in json)
+        || !Array.isArray(json.available)
+        || !json.available.every(
+            (item: unknown) => typeof item === 'object' && item !== null && 'price' in item && typeof item.price === 'number',
+        )
+    ) {
+        console.error('Invalid response when getting static UiTPAS social tariff:', json);
+        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.`),
+        });
+    }
+}
+
+export async function getSocialTariffForEvent(access_token: string, basePrice: number, uitpasEventUrl: string) {
+    const baseUrl = 'https://api-test.uitpas.be/tariffs/static';
+    const params = new URLSearchParams();
+    params.append('regularPrice', (basePrice / 100).toFixed(2));
+    const eventId = uitpasEventUrl.split('/').pop(); // Extract the event ID from the URL
+    if (!eventId) {
+        throw new SimpleError({
+            code: 'invalid_uitpas_event_url',
+            message: `Invalid UiTPAS event URL: ${uitpasEventUrl}`,
+            human: $t(`De opgegeven UiTPAS-evenement URL is ongeldig.`),
+        });
+    }
+    params.append('eventId', eventId);
+    const url = `${baseUrl}?${params.toString()}`;
+    const myHeaders = new Headers();
+    myHeaders.append('Authorization', 'Bearer ' + access_token);
+    myHeaders.append('Accept', 'application/json');
+    const requestOptions = {
+        method: 'GET',
+        headers: myHeaders,
+    };
+    const response = await fetch(url, requestOptions).catch(() => {
+        // Handle network errors
+        throw new SimpleError({
+            code: 'uitpas_unreachable_getting_static_uitpas_social_tariff',
+            message: `Network issue when getting static UiTPAS social tariff`,
+            human: $t(
+                `We konden UiTPAS niet bereiken om het kansentarief op te zoeken. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+    if (!response.ok) {
+        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.`),
+        });
+    }
+    const json = await response.json().catch(() => {
+        // Handle JSON parsing errors
+        throw new SimpleError({
+            code: 'invalid_json_getting_static_uitpas_social_tariff',
+            message: `Invalid json when getting static UiTPAS social tariff`,
+            human: $t(
+                `Er is een fout opgetreden bij het communiceren met UiTPAS. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+
+    assertsIsStaticSocialTariffResponse(json);
+    if (json.available.length === 0) {
+        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.`),
+        });
+    }
+    if (json.available.length > 1) {
+        console.warn('Multiple social tariffs available for event', eventId, '(used ', json.available[0].price, ' as base price. All options:', json.available);
+    }
+    return Math.round(json.available[0].price * 100);
+}