@stamhoofd/backend 2.90.1 → 2.90.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.90.1",
+    "version": "2.90.3",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -45,14 +45,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.90.1",
-        "@stamhoofd/backend-middleware": "2.90.1",
-        "@stamhoofd/email": "2.90.1",
-        "@stamhoofd/models": "2.90.1",
-        "@stamhoofd/queues": "2.90.1",
-        "@stamhoofd/sql": "2.90.1",
-        "@stamhoofd/structures": "2.90.1",
-        "@stamhoofd/utility": "2.90.1",
+        "@stamhoofd/backend-i18n": "2.90.3",
+        "@stamhoofd/backend-middleware": "2.90.3",
+        "@stamhoofd/email": "2.90.3",
+        "@stamhoofd/models": "2.90.3",
+        "@stamhoofd/queues": "2.90.3",
+        "@stamhoofd/sql": "2.90.3",
+        "@stamhoofd/structures": "2.90.3",
+        "@stamhoofd/utility": "2.90.3",
         "archiver": "^7.0.1",
         "axios": "^1.8.2",
         "cookie": "^0.7.0",
@@ -70,5 +70,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "9a720678a4d4699e555f38c9d97779da5818d712"
+    "gitHead": "81248f4f4d578fb67e29c48c55ddb1a1beb12313"
 }

package/src/endpoints/{admin/organizations → organization/dashboard/organization}/SearchUitpasOrganizersEndpoint.ts

@@ -1,8 +1,8 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { UitpasService } from '../../../services/uitpas/UitpasService';
+import { UitpasService } from '../../../../services/uitpas/UitpasService';
 import { UitpasOrganizersResponse } from '@stamhoofd/structures';
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import { Context } from '../../../helpers/Context';
+import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
 class Query extends AutoEncoder {

package/src/endpoints/organization/dashboard/webshops/SearchUitpasEventsEndpoint.ts

@@ -0,0 +1,51 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { UitpasService } from '../../../../services/uitpas/UitpasService';
+import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import { Context } from '../../../../helpers/Context';
+import { UitpasEventsResponse } from '@stamhoofd/structures';
+import { SimpleError } from '@simonbackx/simple-errors';
+
+type Params = Record<string, never>;
+class Query extends AutoEncoder {
+    @field({ decoder: StringDecoder })
+    text: string;
+}
+type Body = undefined;
+type ResponseBody = UitpasEventsResponse;
+
+export class SearchUitpasEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/organization/search-uitpas-events', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        if (!await Context.auth.hasFullAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        if (!organization.meta.uitpasOrganizerId) {
+            throw new SimpleError({
+                code: 'no_uitpas_organizer_id',
+                message: `No UiTPAS organizer ID set for organization`,
+                human: $t(`Deze organisatie heeft nog geen UiTPAS-organisatie ingesteld. Stel dit in via de algemene instellingen.`),
+            });
+        }
+        const uitpasOrganizersResponse = await UitpasService.searchUitpasEvents(organization.id, organization.meta.uitpasOrganizerId, request.query.text);
+
+        return new Response(uitpasOrganizersResponse);
+    }
+}

package/src/endpoints/organization/webshops/PlaceOrderEndpoint.ts

@@ -173,7 +173,7 @@ export class PlaceOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                 if (item.product.uitpasEvent) {
                     const basePrice = item.product.prices.find(p => p.id === item.productPrice.uitpasBaseProductPriceId)?.price ?? 0;
                     const reducedPrices = await UitpasService.getSocialTariffForUitpasNumbers(organization.id, uitpasNumbersOnly, basePrice, item.product.uitpasEvent.url);
-                    const expectedReducedPrices = item.uitpasNumbers.map(p => p.price);
+                    const expectedReducedPrices = item.uitpasNumbers;
                     if (reducedPrices.length < expectedReducedPrices.length) {
                         // should not happen
                         throw new SimpleError({
@@ -184,14 +184,15 @@ export class PlaceOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                         });
                     }
                     for (let i = 0; i < expectedReducedPrices.length; i++) {
-                        if (reducedPrices[i] !== expectedReducedPrices[i]) {
+                        if (reducedPrices[i].price !== expectedReducedPrices[i].price) {
                             throw new SimpleError({
                                 code: 'uitpas_social_tariff_price_mismatch',
                                 message: 'UiTPAS social tariff have a different price',
-                                human: $t('Het kansentarief voor deze UiTPAS is {correctPrice} in plaats van {orderPrice}.', { correctPrice: Formatter.price(reducedPrices[i]), orderPrice: Formatter.price(expectedReducedPrices[i]) }),
+                                human: $t('Het kansentarief voor deze UiTPAS is {correctPrice} in plaats van {orderPrice}.', { correctPrice: Formatter.price(reducedPrices[i].price), orderPrice: Formatter.price(expectedReducedPrices[i].price) }),
                                 field: 'uitpasNumbers.' + i.toString(),
                             });
                         }
+                        item.uitpasNumbers[i].uitpasTariffId = reducedPrices[i].uitpasTariffId;
                     }
                 }
                 else {

package/src/endpoints/organization/webshops/RetrieveUitpasSocialTariffPriceEndpoint.ts

@@ -52,7 +52,7 @@ export class RetrieveUitpasSocialTariffPricesEndpoint extends Endpoint<Params, Q
                 const organization = await Context.setOrganizationScope({ willAuthenticate: false });
                 const reducedPrices = await UitpasService.getSocialTariffForUitpasNumbers(organization.id, request.body.uitpasNumbers, request.body.basePrice, request.body.uitpasEventUrl); // Throws if invalid
                 const uitpasPriceCheckResponse = UitpasPriceCheckResponse.create({
-                    prices: reducedPrices,
+                    prices: reducedPrices.map(price => price.price), // ignore tariff id's here
                 });
                 return new Response(uitpasPriceCheckResponse);
             }

package/src/helpers/UitpasTokenRepository.ts

@@ -203,10 +203,10 @@ export class UitpasTokenRepository {
         });
     }
 
-    static async getClientIdFor(organisationId: string | null): Promise<string> {
-        const repo = UitpasTokenRepository.getRepoFromMemory(organisationId);
+    static async getClientIdFor(organizationId: string | null): Promise<string> {
+        const repo = UitpasTokenRepository.getRepoFromMemory(organizationId);
         if (!repo) {
-            const model = await UitpasClientCredential.select().where('organizationId', organisationId).first(false);
+            const model = await UitpasClientCredential.select().where('organizationId', organizationId).first(false);
             if (!model) {
                 return ''; // no client ID and secret configured
             }

package/src/services/uitpas/UitpasService.ts

@@ -1,6 +1,6 @@
 import { Model } from '@simonbackx/simple-database';
 import { Order, WebshopUitpasNumber } from '@stamhoofd/models';
-import { OrderStatus, UitpasClientCredentialsStatus, UitpasOrganizersResponse } from '@stamhoofd/structures';
+import { OrderStatus, Product, ProductPrice, UitpasClientCredentialsStatus, UitpasOrganizersResponse } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 import { UitpasTokenRepository } from '../../helpers/UitpasTokenRepository';
 import { searchUitpasOrganizers } from './searchUitpasOrganizers';
@@ -8,88 +8,225 @@ import { checkPermissionsFor } from './checkPermissionsFor';
 import { checkUitpasNumbers } from './checkUitpasNumbers';
 import { getSocialTariffForEvent } from './getSocialTariffForEvent';
 import { getSocialTariffForUitpasNumbers } from './getSocialTariffForUitpasNumbers';
+import { searchUitpasEvents } from './searchUitpasEvents';
+import { RegisterTicketSaleRequest, RegisterTicketSaleResponse, registerTicketSales } from './registerTicketSales';
+import { cancelTicketSales } from './cancelTicketSales';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { QueueHandler } from '@stamhoofd/queues';
+
+type UitpasTicketSale = {
+    basePrice: number;
+    uitpasNumber: string;
+    basePriceLabel: string;
+    reducedPrice: number;
+    uitpasEventUrl: string | null;
+    uitpasTariffId: string | null;
+    productId: string;
+};
+
+type InsertUitpasNumber = {
+    ticketSaleId: string | null;
+    reducedPriceUitpas: number | null;
+    registeredAt: Date | null;
+    webshopId: string;
+    orderId: string;
+    productId: string;
+    uitpasNumber: string;
+    basePrice: number;
+    reducedPrice: number;
+    basePriceLabel: string;
+    uitpasTariffId: string | null; // null for non-official flow
+    uitpasEventUrl: string | null; // null for non-official flow
+};
 
 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
+function areThereUitpasChanges(oldTicketSales: UitpasTicketSale[], newTicketSales: UitpasTicketSale[]): boolean {
+    if (oldTicketSales.length !== newTicketSales.length) {
+        return true;
+    }
+    for (const oldTicketSale of oldTicketSales) {
+        const newTicketSale = newTicketSales.find(
+            ts =>
+                ts.uitpasNumber === oldTicketSale.uitpasNumber
+                && ts.basePrice === oldTicketSale.basePrice
+                && ts.basePriceLabel === oldTicketSale.basePriceLabel
+                && ts.reducedPrice === oldTicketSale.reducedPrice
+                && ts.uitpasTariffId === oldTicketSale.uitpasTariffId
+                && ts.uitpasEventUrl === oldTicketSale.uitpasEventUrl
+                && ts.productId === oldTicketSale.productId,
+        );
+        if (!newTicketSale) {
+            return true;
         }
     }
-    return productIdToUitpasNumbers;
+    return false;
 }
 
-function areUitpasNumbersChanged(oldOrder: Order, newOrder: Order): boolean {
-    const oldMap = mapUitpasNumbersToProducts(oldOrder);
-    const newMap = mapUitpasNumbersToProducts(newOrder);
-    if (oldMap.size !== newMap.size) {
-        return true;
+function getUitpasTicketSales(order: Order): UitpasTicketSale[] {
+    const ticketSales: UitpasTicketSale[] = [];
+    if (!shouldReserveUitpasNumbers(order.status)) {
+        return ticketSales;
     }
-    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;
+    for (const item of order.data.cart.items) {
+        if (item.uitpasNumbers.length > 0) {
+            const baseProductPrice = item.product.prices.filter(price => price.id === item.productPrice.uitpasBaseProductPriceId)[0];
+            if (!baseProductPrice) {
+                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.`),
+                });
+            }
+            const label = makeBaseProductPriceLabel(item.product, baseProductPrice);
+            for (const uitpasNumber of item.uitpasNumbers) {
+                ticketSales.push({
+                    productId: item.product.id,
+                    uitpasNumber: uitpasNumber.uitpasNumber,
+                    basePrice: baseProductPrice.price,
+                    reducedPrice: uitpasNumber.price,
+                    basePriceLabel: label,
+                    uitpasEventUrl: item.product.uitpasEvent?.url || null,
+                    uitpasTariffId: uitpasNumber.uitpasTariffId || null,
+                });
             }
         }
     }
-    return false;
+    return ticketSales;
+}
+
+function makeBaseProductPriceLabel(product: Product, productPrice: ProductPrice): string {
+    if (product.name && productPrice.name) {
+        return product.name + ' - ' + productPrice.name;
+    }
+    if (productPrice.name) {
+        return productPrice.name;
+    }
+    return product.name;
 }
 
 export class UitpasService {
     static listening = false;
 
-    static async updateUitpasNumbers(order: Order) {
-        await this.deleteUitpasNumbers(order);
-        await this.createUitpasNumbers(order);
+    static async getWebshopUitpasNumberFromDb(order: Order): Promise<WebshopUitpasNumber[]> {
+        return await WebshopUitpasNumber.select().where('webshopId', order.webshopId).andWhere('orderId', order.id).fetch();
     }
 
-    static async createUitpasNumbers(order: Order) {
-        const mappedUitpasNumbers = mapUitpasNumbersToProducts(order); // productId -> Set of uitpas numbers
+    static async createUitpasNumbers(toBeInserted: InsertUitpasNumber[]) {
+        if (toBeInserted.length === 0) {
+            return;
+        }
         // add to DB
         const insert = WebshopUitpasNumber.insert();
         insert.columns(
             'id',
+            'ticketSaleId',
+            'reducedPriceUitpas',
+            'registeredAt',
             'webshopId',
             'orderId',
             'productId',
             'uitpasNumber',
+            'basePrice',
+            'reducedPrice',
+            'basePriceLabel',
+            'uitpasTariffId',
+            'uitpasEventUrl',
         );
-        const rows = [...mappedUitpasNumbers].flatMap(([productId, uitpasNumbers]) => {
-            return uitpasNumbers.map(uitpasNumber => [
+        const rows = toBeInserted.map((insert) => {
+            return [
                 uuidv4(),
-                order.webshopId,
-                order.id,
-                productId,
-                uitpasNumber,
-            ]);
+                insert.ticketSaleId,
+                insert.reducedPriceUitpas,
+                insert.registeredAt,
+                insert.webshopId,
+                insert.orderId,
+                insert.productId,
+                insert.uitpasNumber,
+                insert.basePrice,
+                insert.reducedPrice,
+                insert.basePriceLabel,
+                insert.uitpasTariffId,
+                insert.uitpasEventUrl,
+            ];
         });
-        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 async updateTicketSales(order: Order, isNewOrder: boolean, ticketSalesHint?: UitpasTicketSale[]): Promise<void> {
+        const ticketSales = ticketSalesHint ?? getUitpasTicketSales(order);
+
+        // queue on order, so no race conditions if the same order is updated multiple times in short time period
+        return await QueueHandler.schedule('uitpas-order-' + order.id, async () => {
+            const registered = isNewOrder ? [] : await this.getWebshopUitpasNumberFromDb(order);
+
+            const unchangedRegistered: WebshopUitpasNumber[] = [];
+            const toBeRegistered: UitpasTicketSale[] = [];
+
+            for (const ticketSale of ticketSales) {
+                const i = registered.findIndex(request => request.uitpasNumber === ticketSale.uitpasNumber && request.basePrice === ticketSale.basePrice && request.basePriceLabel === ticketSale.basePriceLabel);
+                if (i !== -1) {
+                    unchangedRegistered.push(registered[i]);
+                    registered.splice(i, 1);
+                    continue; // already registered, so skip
+                }
+                toBeRegistered.push(ticketSale);
+            }
+
+            const toBeCanceled = registered;
+
+            // Only register/cancel tickets if official flow is/was used
+            const toBeCanceledUitpasIds = toBeCanceled.filter(c => c.uitpasEventUrl && c.uitpasTariffId && c.ticketSaleId).map(c => c.ticketSaleId!);
+            const toBeRegisteredUitpasRequests: RegisterTicketSaleRequest[] = toBeRegistered.filter(c => c.uitpasEventUrl && c.uitpasTariffId) as RegisterTicketSaleRequest[];
+            const noUitpasTariffId = toBeRegistered.filter(c => c.uitpasEventUrl && !c.uitpasTariffId);
+            if (noUitpasTariffId.length > 0) {
+                console.warn('Some UiTPAS do not have an uitpasTariffId, although an UiTPAS event is linked (official flow)', noUitpasTariffId);
+            }
+
+            let canceledUitpasId: string[] = [];
+            let newlyRegistered: Map<RegisterTicketSaleRequest, RegisterTicketSaleResponse> = new Map();
+            if (toBeRegisteredUitpasRequests.length !== 0 || toBeCanceledUitpasIds.length !== 0) {
+                const access_token = await UitpasTokenRepository.getAccessTokenFor(order.organizationId);
+                canceledUitpasId = await cancelTicketSales(access_token, toBeCanceledUitpasIds);
+                if (canceledUitpasId.length !== toBeCanceledUitpasIds.length) {
+                    console.error('Failed to cancel some UiTPAS ticket sales, successfully canceled:', canceledUitpasId, 'but tried to cancel:', toBeCanceledUitpasIds);
+                }
+                try {
+                    newlyRegistered = await registerTicketSales(access_token, toBeRegisteredUitpasRequests);
+                }
+                catch (e) {
+                    console.error('Failed to register UiTPAS ticket sales', e);
+                }
+            }
+
+            const effectiveDeletes = toBeCanceled.filter(c => c.ticketSaleId === null || canceledUitpasId.find(id => id === c.ticketSaleId));
+            if (effectiveDeletes.length !== 0) {
+                await WebshopUitpasNumber.delete().where('id', effectiveDeletes.map(c => c.id));
+            }
+
+            const inserts = toBeRegistered.map((c) => {
+                const response = newlyRegistered.get(c as RegisterTicketSaleRequest);
+                return {
+                    ticketSaleId: response?.ticketSaleId ?? null,
+                    reducedPriceUitpas: response?.reducedPriceUitpas ?? null,
+                    registeredAt: response?.registeredAt ?? null,
+                    webshopId: order.webshopId,
+                    orderId: order.id,
+                    productId: c.productId,
+                    uitpasNumber: c.uitpasNumber,
+                    basePrice: c.basePrice,
+                    reducedPrice: c.reducedPrice,
+                    basePriceLabel: c.basePriceLabel,
+                    uitpasTariffId: c.uitpasTariffId, // null for non-official flow
+                    uitpasEventUrl: c.uitpasEventUrl, // null for non-official flow
+                };
+            });
+            await this.createUitpasNumbers(inserts);
+        });
     }
 
     static listen() {
@@ -100,9 +237,11 @@ export class UitpasService {
         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 === 'deleted') {
+                    // delete from db is not not needed as foreign key will delete the order
+                    // we do not cancel the ticket sales
                     if (event.type === 'created' && shouldReserveUitpasNumbers(event.model.status)) {
-                        await this.createUitpasNumbers(event.model);
+                        await this.updateTicketSales(event.model, true);
                         return;
                     }
                     if (event.type === 'updated') {
@@ -111,18 +250,16 @@ export class UitpasService {
                             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);
+                                await this.updateTicketSales(event.model, shouldReserveAfter);
                                 return;
                             }
                         }
                         if (event.changedFields.data) {
-                            const oldOrder = event.getOldModel() as Order;
-                            if (areUitpasNumbersChanged(oldOrder, event.model)) {
-                                await this.updateUitpasNumbers(event.model);
+                            const oldTicketSales = getUitpasTicketSales(event.getOldModel() as Order);
+                            const newTicketSales = getUitpasTicketSales(event.model);
+                            if (areThereUitpasChanges(oldTicketSales, newTicketSales)) {
+                                await this.updateTicketSales(event.model, false, newTicketSales);
+                                return;
                             }
                         }
                     }
@@ -134,24 +271,22 @@ export class UitpasService {
         });
     }
 
-    static async getSocialTariffForUitpasNumbers(organisationId: string, uitpasNumbers: string[], basePrice: number, uitpasEventUrl: string) {
+    static async getSocialTariffForUitpasNumbers(organizationId: 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);
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(organizationId);
         return await getSocialTariffForUitpasNumbers(access_token, uitpasNumbers, basePrice, uitpasEventUrl);
     }
 
-    static async getSocialTariffForEvent(organisationId: string, basePrice: number, uitpasEventUrl: string) {
+    static async getSocialTariffForEvent(organizationId: 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);
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(organizationId);
         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() {
+    static async cancelTicketSales(organisationId: string, ticketSaleIds: string[]) {
         // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/delete-a-ticket-sale
+        const access_token = await UitpasTokenRepository.getAccessTokenFor(organisationId);
+        return await cancelTicketSales(access_token, ticketSaleIds);
     }
 
     static async getTicketSales() {
@@ -162,9 +297,11 @@ export class UitpasService {
         // https://api-test.uitpas.be/checkins
     }
 
-    static searchUitpasEvents(organizationId: string, uitpasOrganizerId: string, textQuery?: string) {
+    static async 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
+        const clientId = await UitpasTokenRepository.getClientIdFor(organizationId);
+        return searchUitpasEvents(clientId, uitpasOrganizerId, textQuery);
     }
 
     static async searchUitpasOrganizers(name: string): Promise<UitpasOrganizersResponse> {
@@ -184,7 +321,7 @@ export class UitpasService {
 
     /**
      * 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
+     * @param organizationId
      * @returns clientId or empty string if not configured
      */
     static async getClientIdFor(organizationId: string | null): Promise<string> {

package/src/services/uitpas/cancelTicketSales.ts

@@ -0,0 +1,41 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+
+async function cancelTicketSale(access_token: string, ticketSaleId: string) {
+    // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/delete-a-ticket-sale
+    const url = 'https://api-test.uitpas.be/ticket-sales/' + ticketSaleId;
+    const myHeaders = new Headers();
+    myHeaders.append('Authorization', 'Bearer ' + access_token);
+    myHeaders.append('Accept', 'application/json');
+    const requestOptions = {
+        method: 'DELETE',
+        headers: myHeaders,
+    };
+    const response = await fetch(url, requestOptions).catch(() => {
+        // Handle network errors
+        throw new SimpleError({
+            code: 'uitpas_unreachable_registering_ticket_sales',
+            message: `Network issue when registering UiTPAS ticket sales`,
+            human: $t(
+                `We konden UiTPAS niet bereiken om de ticket verkoop te registreren bij UiTPAS. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+    if (!response.ok) {
+        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.`),
+        });
+    }
+    return ticketSaleId;
+}
+
+/**
+ * Will never throw an error, but will return array of successfully canceled ticket sale ids
+ */
+export async function cancelTicketSales(access_token: string, ticketSaleIds: string[]) {
+    // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/delete-a-ticket-sale
+    const promises = ticketSaleIds.map(ticketSaleId => cancelTicketSale(access_token, ticketSaleId));
+    const results = await Promise.allSettled(promises);
+    return results.filter(result => result.status === 'fulfilled').map(result => result.value);
+}

package/src/services/uitpas/getSocialTariffForUitpasNumbers.ts

@@ -1,7 +1,9 @@
 import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
+import { UitpasNumberAndPrice } from '@stamhoofd/structures';
 
 type SocialTariffReponse = {
     available: Array<{
+        id: string;
         price: number;
         remaining: number;
         // other properties ignored
@@ -25,7 +27,7 @@ function assertsIsSocialTariffResponse(json: unknown): asserts json is SocialTar
         || !('available' in json)
         || !Array.isArray(json.available)
         || !json.available.every(
-            (item: unknown) => typeof item === 'object' && item !== null && 'price' in item && typeof item.price === 'number' && 'remaining' in item && typeof item.remaining === 'number',
+            (item: unknown) => typeof item === 'object' && item !== null && 'id' in item && typeof item.id === 'string' && 'price' in item && typeof item.price === 'number' && 'remaining' in item && typeof item.remaining === 'number',
         )
     ) {
         console.error('Invalid response when getting UiTPAS social tariff:', json);
@@ -152,16 +154,20 @@ async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber
         });
     }
     console.log('Social tariff for UiTPAS number', uitpasNumber, 'with event id', uitpasEventUrl, 'is', json.available[0].price, 'euros');
-    return Math.round((json.available[0].price) * 100);
+    return UitpasNumberAndPrice.create({
+        uitpasNumber,
+        price: Math.round((json.available[0].price) * 100),
+        uitpasTariffId: json.available[0].id,
+    });
 }
 
 export async function getSocialTariffForUitpasNumbers(access_token: string, uitpasNumbers: string[], basePrice: number, uitpasEventUrl: string) {
     const simpleErrors = new SimpleErrors();
-    const reducedPrices = new Array<number>(uitpasNumbers.length);
+    const reducedPrices = new Array<UitpasNumberAndPrice>(uitpasNumbers.length);
     for (let i = 0; i < uitpasNumbers.length; i++) {
         const uitpasNumber = uitpasNumbers[i];
         try {
-            reducedPrices[i] = await getSocialTariffForUitpasNumber(access_token, uitpasNumber, basePrice, uitpasEventUrl); // Throws if invalid
+            reducedPrices[i] = await getSocialTariffForUitpasNumber(access_token, uitpasNumber, basePrice, uitpasEventUrl);
         }
         catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {

package/src/services/uitpas/registerTicketSales.ts

@@ -0,0 +1,139 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+
+export type RegisterTicketSaleRequest = {
+    basePrice: number;
+    uitpasEventUrl: string;
+    basePriceLabel: string;
+    uitpasNumber: string;
+    uitpasTariffId: string;
+};
+
+export type RegisterTicketSaleResponse = {
+    ticketSaleId: string;
+    reducedPriceUitpas: number;
+    registeredAt: Date;
+};
+
+type SuccessResponse = {
+    id: string;
+    tariff: {
+        price: number;
+        id: string;
+    };
+    uitpasNumber: string;
+    eventId: string;
+};
+
+function assertisSuccessResponse(json: unknown): asserts json is SuccessResponse {
+    if (
+        typeof json !== 'object'
+        || json === null
+        || !('tariff' in json)
+        || typeof json.tariff !== 'object'
+        || json.tariff === null
+        || !('price' in json.tariff)
+        || typeof json.tariff.price !== 'number'
+        || !('id' in json.tariff)
+        || typeof json.tariff.id !== 'string'
+        || !('id' in json)
+        || typeof json.id !== 'string'
+        || !('uitpasNumber' in json)
+        || typeof json.uitpasNumber !== 'string'
+        || !('eventId' in json)
+        || typeof json.eventId !== 'string'
+    ) {
+        console.error('Invalid register ticket sale response', json);
+        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.`),
+        });
+    }
+}
+
+/**
+ * @returns Map of request (from parameters) -> response
+ */
+
+export async function registerTicketSales(access_token: string, registerTicketSaleRequests: RegisterTicketSaleRequest[]): Promise<Map<RegisterTicketSaleRequest, RegisterTicketSaleResponse>> {
+    // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/create-a-ticket-sale
+
+    console.error('Registering ticket sales', registerTicketSaleRequests);
+    if (registerTicketSaleRequests.length === 0) {
+        return new Map();
+    };
+    const url = 'https://api-test.uitpas.be/ticket-sales';
+    const body = registerTicketSaleRequests.map((ticketSale) => {
+        const eventId = ticketSale.uitpasEventUrl.split('/').pop();
+        if (!eventId) {
+            throw new SimpleError({
+                code: 'invalid_uitpas_event_url',
+                message: `Invalid UiTPAS event URL: ${ticketSale.uitpasEventUrl}`,
+                human: $t(`De opgegeven UiTPAS-evenement URL is ongeldig.`),
+            });
+        }
+
+        return {
+            uitpasNumber: ticketSale.uitpasNumber,
+            eventId,
+            regularPrice: (ticketSale.basePrice / 100).toFixed(2), // Convert from cents to euros
+            regularPriceLabel: ticketSale.basePriceLabel,
+            tariff: {
+                id: ticketSale.uitpasTariffId,
+            },
+        };
+    });
+    const myHeaders = new Headers();
+    myHeaders.append('Authorization', 'Bearer ' + access_token);
+    myHeaders.append('Accept', 'application/json');
+    myHeaders.append('Content-Type', 'application/json');
+    const requestOptions = {
+        method: 'POST',
+        headers: myHeaders,
+        body: JSON.stringify(body),
+    };
+    const response = await fetch(url, requestOptions).catch(() => {
+        // Handle network errors
+        throw new SimpleError({
+            code: 'uitpas_unreachable_registering_ticket_sales',
+            message: `Network issue when registering UiTPAS ticket sales`,
+            human: $t(
+                `We konden UiTPAS niet bereiken om de ticket verkoop te registreren bij UiTPAS. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+    if (!response.ok) {
+        const json: unknown = await response.json().catch(() => { /* ignore */ });
+        console.error('Unsuccessful response when registering ticket sales', json);
+        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.`),
+        });
+    }
+    const json = await response.json().catch(() => {});
+    if (!json || !Array.isArray(json)) {
+        console.error('Invalid response when registering ticket sales', json);
+        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.`),
+        });
+    }
+    const now = new Date();
+    const results: Map<RegisterTicketSaleRequest, RegisterTicketSaleResponse> = new Map();
+    for (const ticketSale of json) {
+        assertisSuccessResponse(ticketSale);
+        const request = registerTicketSaleRequests.find(r => r.uitpasNumber === ticketSale.uitpasNumber && r.uitpasEventUrl.endsWith(`/${ticketSale.eventId}`) && r.uitpasTariffId === ticketSale.tariff.id);
+        if (!request) {
+            console.error('Could not find request for ticket sale', ticketSale);
+            continue;
+        }
+        results.set(request, {
+            ticketSaleId: ticketSale.id,
+            reducedPriceUitpas: Math.round(ticketSale.tariff.price * 100),
+            registeredAt: now,
+        });
+    }
+    return results;
+}

package/src/services/uitpas/searchUitpasEvents.ts

@@ -0,0 +1,141 @@
+import { UitpasEventResponse, UitpasEventsResponse } from '@stamhoofd/structures';
+import { SimpleError } from '@simonbackx/simple-errors';
+
+type EventsResponse = {
+    totalItems: number;
+    itemsPerPage: number;
+    member: Array<{
+        '@id': string;
+        'name': {
+            nl: string;
+        };
+        'location': {
+            name: object;
+        };
+        'startDate'?: string;
+        'endDate'?: string;
+    }>;
+};
+
+function assertIsEventsResponse(json: unknown): asserts json is EventsResponse {
+    if (
+        typeof json !== 'object'
+        || json === null
+        || !('totalItems' in json)
+        || typeof json.totalItems !== 'number'
+        || !('itemsPerPage' in json)
+        || typeof json.itemsPerPage !== 'number'
+        || !('member' in json)
+        || !Array.isArray(json.member)
+        || json.member.some(member => (
+            typeof member !== 'object'
+            || member === null
+            || !('@id' in member)
+            || typeof member['@id'] !== 'string'
+            || !('name' in member)
+            || typeof member.name !== 'object'
+            || member.name === null
+            || !('nl' in member.name)
+            || typeof member.name.nl !== 'string'
+            || !('location' in member)
+            || typeof member.location !== 'object'
+            || member.location === null
+            || !('name' in member.location)
+            || typeof member.location.name !== 'object'
+            || member.location.name === null
+        ))
+    ) {
+        console.error('Invalid events response', json);
+        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.`),
+        });
+    }
+}
+
+export async function searchUitpasEvents(clientId: string, uitpasOrganizerId: string, textQuery?: string): Promise<UitpasEventsResponse> {
+    // uses no credentials (only client id of the organization)
+    // https://docs.publiq.be/docs/uitpas/events/searching
+    if (!clientId) {
+        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.`),
+        });
+    }
+    const baseUrl = 'https://search-test.uitdatabank.be/events';
+    const params = new URLSearchParams();
+    params.append('clientId', clientId);
+    params.append('organizerId', uitpasOrganizerId);
+    params.append('embed', 'true');
+    params.append('uitpas', 'true');
+    params.append('start', '0');
+    params.append('limit', '200');
+    if (textQuery) {
+        params.append('text', textQuery);
+    }
+    const url = `${baseUrl}?${params.toString()}`;
+    const myHeaders = new Headers();
+    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_searching_events',
+            message: `Network issue when searching for UiTPAS events`,
+            human: $t(
+                `We konden UiTPAS niet bereiken om UiTPAS-evenementen op te zoeken. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+    if (!response.ok) {
+        console.error('Unsuccessful response when searching for UiTPAS events', response);
+        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.`),
+        });
+    }
+    const json = await response.json().catch(() => {
+        // Handle JSON parsing errors
+        throw new SimpleError({
+            code: 'invalid_json_searching_uitpas_events',
+            message: `Invalid json when searching for UiTPAS events`,
+            human: $t(
+                `Er is een fout opgetreden bij het communiceren met UiTPAS. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+
+    assertIsEventsResponse(json);
+    const eventsResponse = new UitpasEventsResponse();
+    eventsResponse.totalItems = json.totalItems;
+    eventsResponse.itemsPerPage = json.itemsPerPage;
+    eventsResponse.member = json.member.map((member) => {
+        const event = new UitpasEventResponse();
+        event.url = member['@id'];
+        event.name = member.name.nl;
+        const locationName = member.location.name as Record<string, string>;
+        const entrs = Object.entries(locationName);
+        const hasNl = entrs.find(([key]) => key === 'nl');
+        if (hasNl) {
+            event.location = locationName.nl;
+        }
+        else {
+            const lang = entrs[0];
+            event.location = lang ? lang[1] : '';
+        }
+        if (member.startDate) {
+            event.startDate = new Date(member.startDate);
+        }
+        if (member.endDate) {
+            event.endDate = new Date(member.endDate);
+        }
+        return event;
+    });
+    return eventsResponse;
+}