@stamhoofd/backend 2.115.1 → 2.117.0

package/src/email-replacements/getEmailReplacementsForPayment.ts

@@ -0,0 +1,321 @@
+import { Order, Organization, Webshop } from '@stamhoofd/models';
+import { BalanceItemPaymentsHtmlTableItem, BalanceItemRelationType, BalanceItemType, getBalanceItemPaymentsHtmlTable, PaymentGeneral, PaymentMethod, PaymentMethodHelper, Replacement, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { createOrderDataHTMLTable } from '../helpers/email-html-helpers.js';
+
+export type ReplacementsOptions = {
+    /**
+     * If not set, defaults to true
+     */
+    shouldAddReplacementsForOrder?: boolean;
+
+    /**
+     * If not set, defaults to true
+     */
+    shouldAddReplacementsForTransfers?: boolean;
+    orderMap: Map<string, Order>;
+    webshopMap: Map<string, Webshop>;
+    organizationMap: Map<string, Organization>;
+};
+
+/**
+ * To reduce the amount of queries, payment options should be generated for the whole aray of payments you want to send emails to.
+ */
+export async function buildReplacementOptions(payments: PaymentGeneral[], options?: { doesIncludePaymentWithoutOrders: boolean; areAllPaymentsTransfers: boolean }): Promise<ReplacementsOptions> {
+    // get all orders linked to the payments
+    const allOrderIdsSet = new Set<string>();
+    const allWebshopIdsSet = new Set<string>();
+    const organizationIdsForOrdersSet = new Set<string>();
+
+    for (const payment of payments) {
+        payment.webshopIds.forEach(id => allWebshopIdsSet.add(id));
+
+        for (const balanceItemPayment of payment.balanceItemPayments) {
+            const balanceItem = balanceItemPayment.balanceItem;
+            if (balanceItem.orderId) {
+                allOrderIdsSet.add(balanceItem.orderId);
+
+                // only important if balance item has order
+                organizationIdsForOrdersSet.add(balanceItem.organizationId);
+            }
+        }
+    }
+
+    // get all orders (for replacements later)
+    const orders = await Order.getByIDs(...allOrderIdsSet);
+    const orderMap = new Map<string, Order>(orders.map(o => [o.id, o] as [string, Order]));
+
+    // get all webshops (for replacements later)
+    const webshops = await Webshop.getByIDs(...allWebshopIdsSet);
+    const webshopMap = new Map<string, Webshop>(webshops.map(w => [w.id, w] as [string, Webshop]));
+
+    // get all organizations (for replacements later)
+    const organizations = await Organization.getByIDs(...organizationIdsForOrdersSet);
+    const organizationMap = new Map<string, Organization>(organizations.map(o => [o.id, o] as [string, Organization]));
+
+    return {
+        shouldAddReplacementsForOrder: options ? !options.doesIncludePaymentWithoutOrders : true,
+        shouldAddReplacementsForTransfers: options ? options.areAllPaymentsTransfers : true,
+        orderMap,
+        webshopMap,
+        organizationMap,
+    };
+}
+
+export function getEmailReplacementsForPayment(payment: PaymentGeneral, options: ReplacementsOptions): Replacement[] {
+    const { orderMap, webshopMap, organizationMap, shouldAddReplacementsForOrder, shouldAddReplacementsForTransfers } = options;
+    const orderIds = new Set<string>();
+
+    for (const balanceItemPayment of payment.balanceItemPayments) {
+        const orderId = balanceItemPayment.balanceItem.orderId;
+        if (orderId) {
+            orderIds.add(orderId);
+        }
+    }
+
+    // will be set if only 1 order is linked
+    let singleOrder: Order | null = null;
+
+    if (orderIds.size === 1) {
+        const singleOrderId = [...orderIds][0];
+        if (singleOrderId) {
+            const order = orderMap.get(singleOrderId);
+
+            if (order) {
+                singleOrder = order;
+            }
+        }
+    }
+
+    let orderUrlReplacement: Replacement | null = null;
+    let paymentUrl: string = '{{signInUrl}}';
+
+    // add replacement for order url if only 1 order is linked
+    if (shouldAddReplacementsForOrder ?? true) {
+        if (singleOrder) {
+            const webshop = webshopMap.get(singleOrder.webshopId);
+            const organization = organizationMap.get(singleOrder.organizationId);
+
+            if (webshop && organization) {
+                const webshopStruct = WebshopStruct.create(webshop);
+
+                orderUrlReplacement = Replacement.create({
+                    token: 'orderUrl',
+                    value: 'https://' + webshopStruct.getUrl(organization) + '/order/' + (singleOrder.id),
+                });
+                paymentUrl = 'https://' + webshopStruct.getUrl(organization) + '/order/' + (singleOrder.id);
+            }
+        }
+        else {
+            // Fallback (should not happen, but better than leaving {{orderUrl}} in place)
+            orderUrlReplacement = Replacement.create({
+                token: 'orderUrl',
+                value: paymentUrl,
+            });
+        }
+    }
+
+    const createPaymentDataHtml = () => {
+        if (singleOrder) {
+            const webshop = webshopMap.get(singleOrder.webshopId);
+            if (webshop) {
+                return createOrderDataHTMLTable(singleOrder, webshop);
+            }
+        }
+
+        return payment.getPaymentDataHTMLTable();
+    };
+
+    const paymentDataHtml = createPaymentDataHtml();
+
+    return ([
+        Replacement.create({
+            token: 'paymentUrl',
+            value: paymentUrl,
+        }),
+        Replacement.create({
+            token: 'priceToPay',
+            value: Formatter.price(payment.price),
+        }),
+        Replacement.create({
+            token: 'paymentMethod',
+            value: PaymentMethodHelper.getName(payment.method ?? PaymentMethod.Unknown),
+        }),
+        ...((shouldAddReplacementsForTransfers ?? true)
+            ? [
+                    Replacement.create({
+                        token: 'transferDescription',
+                        value: (payment.transferDescription ?? ''),
+                    }),
+                    Replacement.create({
+                        token: 'transferBankAccount',
+                        value: payment.transferSettings?.iban ?? '',
+                    }),
+                    Replacement.create({
+                        token: 'transferBankCreditor',
+                        value: payment.transferSettings?.creditor ?? (payment.organizationId ? organizationMap.get(payment.organizationId)?.name : '') ?? '',
+                    }),
+                ]
+            : [
+                    Replacement.create({
+                        token: 'transferDescription',
+                        value: '',
+                    }),
+                    Replacement.create({
+                        token: 'transferBankAccount',
+                        value: '',
+                    }),
+                    Replacement.create({
+                        token: 'transferBankCreditor',
+                        value: '',
+                    }),
+                ]),
+
+        Replacement.create({
+            token: 'overviewTable',
+            value: '',
+            html: getBalanceItemPaymentsHtmlTable(unboxBalanceItemPayments(payment, orderMap)),
+        }),
+        Replacement.create({
+            token: 'paymentTable',
+            value: '',
+            html: payment.getHTMLTable(),
+        }),
+        Replacement.create({
+            token: 'paymentData',
+            value: '',
+            html: paymentDataHtml,
+        }),
+        Replacement.create({
+            token: 'overviewContext',
+            value: getPaymentContext(payment, options),
+        }),
+        Replacement.create({
+            token: 'memberNames',
+            value: payment.memberNames,
+        }),
+        orderUrlReplacement,
+    ]).filter(replacementOrNull => replacementOrNull !== null);
+}
+
+function getPaymentContext(payment: PaymentGeneral, { orderMap, webshopMap }: ReplacementsOptions) {
+    const overviewContext = new Set<string>();
+    const registrationMemberNames = new Set<string>();
+
+    // only add to context if type is order or registration
+    for (const balanceItemPayment of payment.balanceItemPayments) {
+        const balanceItem = balanceItemPayment.balanceItem;
+        const type = balanceItem.type;
+
+        switch (type) {
+            case BalanceItemType.Order: {
+                if (balanceItem.orderId) {
+                    const order = orderMap.get(balanceItem.orderId);
+
+                    if (order) {
+                        const webshop = webshopMap.get(order.webshopId);
+                        if (webshop) {
+                            if (order.number) {
+                                overviewContext.add($t('80c86ad4-5ca1-481a-a408-db018a81f25e', {
+                                    webshop: webshop.meta.name,
+                                    orderNumber: order.number ?? '',
+                                }));
+                            }
+                            else {
+                                overviewContext.add(webshop.meta.name);
+                            }
+                        }
+                        else {
+                            overviewContext.add($t('8bb27033-cf3c-4af1-a3f4-3373734ab189', {
+                                orderNumber: order.number ?? '',
+                            }));
+                        }
+                    }
+                }
+                break;
+            }
+            case BalanceItemType.Registration: {
+                const memberName = balanceItem.relations.get(BalanceItemRelationType.Member)?.name.toString();
+                if (memberName) {
+                    registrationMemberNames.add(memberName);
+                }
+                else {
+                    overviewContext.add(balanceItem.itemTitle);
+                }
+
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+    }
+
+    if (registrationMemberNames.size > 0) {
+        const memberNames = Formatter.joinLast([...registrationMemberNames], ', ', ' ' + $t(`6a156458-b396-4d0f-b562-adb3e38fc51b`) + ' ');
+        overviewContext.add($t(`01d5fd7e-2960-4eb4-ab3a-2ac6dcb2e39c`) + ' ' + memberNames);
+    }
+
+    if (overviewContext.size === 0) {
+        // add item title if no balance items with type order or registration
+        if (payment.balanceItemPayments.length === 1) {
+            const balanceItem = payment.balanceItemPayments[0].balanceItem;
+            return balanceItem.itemTitle;
+        }
+
+        if (payment.balanceItemPayments.length > 1) {
+            // return title if all balance items have the same title
+            const firstTitle = payment.balanceItemPayments[0].balanceItem.itemTitle;
+            const haveAllSameTitle = payment.balanceItemPayments.every(p => p.balanceItem.itemTitle === firstTitle);
+
+            if (haveAllSameTitle) {
+                return `${firstTitle} (${payment.balanceItemPayments.length}x)`;
+            }
+
+            // else return default text for multiple items
+            return $t('7462f89e-db05-452f-804f-b9f2d51bff0d', { count: payment.balanceItemPayments.length });
+        }
+
+        // else return default text for single item
+        return $t('fe349d88-fecf-4cd8-8ea4-9e3b13cfa0dc');
+    }
+
+    // join texts for balance items with type order or registration
+    return [...overviewContext].join(', ');
+}
+
+function unboxBalanceItemPayments({ balanceItemPayments }: PaymentGeneral, orderMap: Map<string, Order>): BalanceItemPaymentsHtmlTableItem[] {
+    const results: BalanceItemPaymentsHtmlTableItem[] = [];
+    for (const item of balanceItemPayments) {
+        const orderId = item.balanceItem.orderId;
+        if (orderId === null) {
+            results.push(item);
+            continue;
+        }
+
+        const order = orderMap.get(orderId);
+        if (!order) {
+            // if 1 order is not found -> do not unbox the payment
+            return balanceItemPayments;
+        }
+
+        for (const cartItem of order.data.cart.items) {
+            const price = cartItem.getPriceWithDiscounts();
+            const quantity = cartItem.amount;
+            const unitPrice = Math.abs(quantity) > 1 ? price / quantity : price;
+
+            results.push({
+                itemTitle: cartItem.product.name,
+                itemDescription: cartItem.description,
+                balanceItem: {
+                    description: cartItem.description,
+                },
+                quantity,
+                unitPrice,
+                price,
+            });
+        }
+    }
+
+    return results;
+}

package/src/endpoints/admin/members/ChargeMembersEndpoint.ts

@@ -1,7 +1,7 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { ChargeMembersRequest, LimitedFilteredRequest, PermissionLevel } from '@stamhoofd/structures';
+import { ChargeRequest, LimitedFilteredRequest, PermissionLevel } from '@stamhoofd/structures';
 
 import { QueueHandler } from '@stamhoofd/queues';
 import { Context } from '../../../helpers/Context.js';
@@ -10,13 +10,12 @@ import { MemberCharger } from '../../../helpers/MemberCharger.js';
 import { GetMembersEndpoint } from '../../global/members/GetMembersEndpoint.js';
 
 type Params = Record<string, never>;
-type Query = LimitedFilteredRequest;
-type Body = ChargeMembersRequest;
+type Query = undefined;
+type Body = ChargeRequest;
 type ResponseBody = undefined;
 
 export class ChargeMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
-    bodyDecoder = ChargeMembersRequest as Decoder<ChargeMembersRequest>;
+    bodyDecoder = ChargeRequest as Decoder<ChargeRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'POST') {
@@ -72,7 +71,7 @@ export class ChargeMembersEndpoint extends Endpoint<Params, Query, Body, Respons
 
         ChargeMembersEndpoint.throwIfInvalidBody(body);
 
-        const queueId = 'charge-members';
+        const queueId = 'charge-members-' + organization.id;
 
         if (QueueHandler.isRunning(queueId)) {
             throw new SimpleError({
@@ -83,7 +82,10 @@ export class ChargeMembersEndpoint extends Endpoint<Params, Query, Body, Respons
         }
 
         await QueueHandler.schedule(queueId, async () => {
-            const dataGenerator = fetchToAsyncIterator(request.query, {
+            const dataGenerator = fetchToAsyncIterator(new LimitedFilteredRequest({
+                filter: body.filter,
+                limit: 100,
+            }), {
                 fetch: request => GetMembersEndpoint.buildData(request, PermissionLevel.Write),
             });
 

package/src/endpoints/admin/memberships/ChargeMembershipsEndpoint.ts

@@ -1,8 +1,8 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
-import { Context } from '../../../helpers/Context';
-import { MembershipCharger } from '../../../helpers/MembershipCharger';
+import { Context } from '../../../helpers/Context.js';
+import { MembershipCharger } from '../../../helpers/MembershipCharger.js';
 
 type Params = Record<string, never>;
 type Query = Record<string, never>;

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -3,7 +3,7 @@ import { Platform } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLAlias, SQLCount, SQLDistinct, SQLSelectAs, SQLSum, SQLWhereSign } from '@stamhoofd/sql';
 import { ChargeMembershipsSummary, ChargeMembershipsTypeSummary } from '@stamhoofd/structures';
-import { Context } from '../../../helpers/Context';
+import { Context } from '../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = Record<string, never>;

package/src/endpoints/admin/organizations/ChargeOrganizationsEndpoint.ts

@@ -1,22 +1,22 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { ChargeOrganizationsRequest, LimitedFilteredRequest } from '@stamhoofd/structures';
+import { ChargeRequest, LimitedFilteredRequest } from '@stamhoofd/structures';
 
 import { QueueHandler } from '@stamhoofd/queues';
-import { Context } from '../../../helpers/Context';
-import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator';
-import { OrganizationCharger } from '../../../helpers/OrganizationCharger';
-import { GetOrganizationsEndpoint } from './GetOrganizationsEndpoint';
+import { Context } from '../../../helpers/Context.js';
+import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator.js';
+import { OrganizationCharger } from '../../../helpers/OrganizationCharger.js';
+import { GetOrganizationsEndpoint } from './GetOrganizationsEndpoint.js';
+import { ChargeMembersEndpoint } from '../members/ChargeMembersEndpoint.js';
 
 type Params = Record<string, never>;
-type Query = LimitedFilteredRequest;
-type Body = ChargeOrganizationsRequest;
+type Query = undefined;
+type Body = ChargeRequest;
 type ResponseBody = undefined;
 
 export class ChargeOrganizationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
-    bodyDecoder = ChargeOrganizationsRequest as Decoder<ChargeOrganizationsRequest>;
+    bodyDecoder = ChargeRequest as Decoder<ChargeRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'POST') {
@@ -31,45 +31,8 @@ export class ChargeOrganizationsEndpoint extends Endpoint<Params, Query, Body, R
         return [false];
     }
 
-    private static throwIfInvalidBody(body: Body) {
-        if (!body.description?.trim()?.length) {
-            throw new SimpleError({
-                code: 'invalid_field',
-                message: 'Invalid description',
-                human: $t(`2449fba5-99dc-496f-a9d6-a67263d56616`),
-                field: 'description',
-            });
-        }
-
-        if (!body.price) {
-            throw new SimpleError({
-                code: 'invalid_field',
-                message: 'Invalid price',
-                human: $t(`1e165aac-8a58-45c5-bdd8-c58131a7b7f5`),
-                field: 'price',
-            });
-        }
-
-        if (body.amount === 0) {
-            throw new SimpleError({
-                code: 'invalid_field',
-                message: 'Invalid amount',
-                human: $t(`0bdf4953-1eae-41fd-b142-5ad3287f17a7`),
-                field: 'amount',
-            });
-        }
-
-        if (!body.organizationId) {
-            throw new SimpleError({
-                code: 'invalid_field',
-                message: 'Invalid organization id',
-                human: $t(`ae7ac6ab-bb02-4cd6-823f-7076e4ce6f6c`),
-                field: 'organizationId',
-            });
-        }
-    }
-
     async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 
         if (!Context.auth.hasPlatformFullAccess()) {
@@ -77,7 +40,7 @@ export class ChargeOrganizationsEndpoint extends Endpoint<Params, Query, Body, R
         }
 
         const body = request.body;
-        ChargeOrganizationsEndpoint.throwIfInvalidBody(body);
+        ChargeMembersEndpoint.throwIfInvalidBody(body);
 
         const queueId = 'charge-organizations';
 
@@ -90,13 +53,16 @@ export class ChargeOrganizationsEndpoint extends Endpoint<Params, Query, Body, R
         }
 
         await QueueHandler.schedule(queueId, async () => {
-            const dataGenerator = fetchToAsyncIterator(request.query, {
+            const dataGenerator = fetchToAsyncIterator(new LimitedFilteredRequest({
+                filter: body.filter,
+                limit: 100,
+            }), {
                 fetch: GetOrganizationsEndpoint.buildData,
             });
 
             for await (const data of dataGenerator) {
                 await OrganizationCharger.chargeMany({
-                    chargingOrganizationId: body.organizationId,
+                    chargingOrganizationId: organization.id,
                     organizationsToCharge: data,
                     price: body.price,
                     amount: body.amount ?? 1,

package/src/endpoints/admin/organizations/GetOrganizationsCountEndpoint.ts

@@ -2,8 +2,8 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
 
-import { Context } from '../../../helpers/Context';
-import { GetOrganizationsEndpoint } from './GetOrganizationsEndpoint';
+import { Context } from '../../../helpers/Context.js';
+import { GetOrganizationsEndpoint } from './GetOrganizationsEndpoint.js';
 
 type Params = Record<string, never>;
 type Query = CountFilteredRequest;

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.ts

@@ -6,10 +6,10 @@ import { SQL, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, LimitedFilteredRequest, Organization as OrganizationStruct, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
-import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../helpers/Context';
-import { organizationFilterCompilers } from '../../../sql-filters/organizations';
-import { organizationSorters } from '../../../sql-sorters/organizations';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../helpers/Context.js';
+import { organizationFilterCompilers } from '../../../sql-filters/organizations.js';
+import { organizationSorters } from '../../../sql-sorters/organizations.js';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;

package/src/endpoints/admin/organizations/PatchOrganizationsEndpoint.ts

@@ -1,12 +1,12 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Organization, OrganizationRegistrationPeriod, Platform } from '@stamhoofd/models';
+import { Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';
-import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
-import { Context } from '../../../helpers/Context';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -126,8 +126,18 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
             organization.meta = put.meta;
             organization.address = put.address;
 
-            const periodId = (await Platform.getShared()).periodIdIfPlatform;
-            organization.periodId = periodId;
+            let period: RegistrationPeriod | null = null;
+
+            if (STAMHOOFD.userMode === 'platform') {
+                const periodId = (await Platform.getShared()).periodIdIfPlatform;
+                organization.periodId = periodId;
+            }
+            else {
+                period = new RegistrationPeriod();
+                period.configureForNewOrganization();
+                await period.save();
+                organization.periodId = period.id;
+            }
 
             if (put.privateMeta) {
                 organization.privateMeta = put.privateMeta;
@@ -145,9 +155,14 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
                 });
             }
 
+            if (STAMHOOFD.userMode !== 'platform' && period) {
+                period.organizationId = organization.id;
+                await period.save();
+            }
+
             const organizationPeriod = new OrganizationRegistrationPeriod();
             organizationPeriod.organizationId = organization.id;
-            organizationPeriod.periodId = periodId;
+            organizationPeriod.periodId = organization.periodId;
             await organizationPeriod.save();
 
             result.push(organization);

package/src/endpoints/admin/registrations/ChargeRegistrationsEndpoint.ts

@@ -1,7 +1,7 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { ChargeMembersRequest, LimitedFilteredRequest, PermissionLevel } from '@stamhoofd/structures';
+import { ChargeRequest, LimitedFilteredRequest, PermissionLevel } from '@stamhoofd/structures';
 
 import { QueueHandler } from '@stamhoofd/queues';
 import { Context } from '../../../helpers/Context.js';
@@ -11,13 +11,12 @@ import { GetRegistrationsEndpoint } from '../../global/registration/GetRegistrat
 import { ChargeMembersEndpoint } from '../members/ChargeMembersEndpoint.js';
 
 type Params = Record<string, never>;
-type Query = LimitedFilteredRequest;
-type Body = ChargeMembersRequest;
+type Query = undefined;
+type Body = ChargeRequest;
 type ResponseBody = undefined;
 
 export class ChargeRegistrationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
-    bodyDecoder = ChargeMembersRequest as Decoder<ChargeMembersRequest>;
+    bodyDecoder = ChargeRequest as Decoder<ChargeRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'POST') {
@@ -44,7 +43,7 @@ export class ChargeRegistrationsEndpoint extends Endpoint<Params, Query, Body, R
 
         ChargeMembersEndpoint.throwIfInvalidBody(body);
 
-        const queueId = 'charge-registrations';
+        const queueId = 'charge-registrations-' + organization.id;
 
         if (QueueHandler.isRunning(queueId)) {
             throw new SimpleError({
@@ -55,7 +54,10 @@ export class ChargeRegistrationsEndpoint extends Endpoint<Params, Query, Body, R
         }
 
         await QueueHandler.schedule(queueId, async () => {
-            const dataGenerator = fetchToAsyncIterator(request.query, {
+            const dataGenerator = fetchToAsyncIterator(new LimitedFilteredRequest({
+                filter: body.filter,
+                limit: 100,
+            }), {
                 fetch: request => GetRegistrationsEndpoint.buildData(request, PermissionLevel.Write),
             });
 

package/src/endpoints/auth/CreateAdminEndpoint.ts

@@ -5,8 +5,8 @@ import { PasswordToken, Platform, sendEmailTemplate, User } from '@stamhoofd/mod
 import { EmailTemplateType, Recipient, Replacement, UserPermissions, User as UserStruct, UserWithMembers } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
-import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures';
-import { Context } from '../../helpers/Context';
+import { AuthenticatedStructures } from '../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../helpers/Context.js';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = UserStruct;

package/src/endpoints/auth/CreateTokenEndpoint.test.ts

@@ -2,8 +2,8 @@ import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory, Token, UserFactory } from '@stamhoofd/models';
 import { Token as TokenStruct } from '@stamhoofd/structures';
 
-import { testServer } from '../../../tests/helpers/TestServer';
-import { CreateTokenEndpoint } from './CreateTokenEndpoint';
+import { testServer } from '../../../tests/helpers/TestServer.js';
+import { CreateTokenEndpoint } from './CreateTokenEndpoint.js';
 
 describe('Endpoint.CreateToken', () => {
     // Test endpoint

package/src/endpoints/auth/CreateTokenEndpoint.ts

@@ -3,7 +3,7 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { EmailVerificationCode, PasswordToken, Platform, Token, User } from '@stamhoofd/models';
 import { ChallengeGrantStruct, CreateTokenStruct, LoginMethod, PasswordGrantStruct, PasswordTokenGrantStruct, RefreshTokenGrantStruct, RequestChallengeGrantStruct, SignupResponse, Token as TokenStruct } from '@stamhoofd/structures';
 
-import { Context } from '../../helpers/Context';
+import { Context } from '../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = undefined;

package/src/endpoints/auth/DeleteTokenEndpoint.ts

@@ -1,6 +1,6 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 
-import { Context } from '../../helpers/Context';
+import { Context } from '../../helpers/Context.js';
 
 type Params = Record<string, never>;
 type Query = undefined;