@stamhoofd/backend 2.89.1 → 2.90.0

package/src/endpoints/organization/dashboard/organization/SetUitpasClientCredentialsEndpoint.ts

@@ -0,0 +1,108 @@
+import { AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { UitpasClientCredentialsStatus, UitpasClientIdAndSecret, UitpasSetClientCredentialsResponse } from '@stamhoofd/structures';
+import { Context } from '../../../../helpers/Context';
+import { UitpasService } from '../../../../services/uitpas/UitpasService';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = AutoEncoderPatchType<UitpasClientIdAndSecret>;
+type ResponseBody = UitpasSetClientCredentialsResponse;
+
+/**
+ * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
+ */
+
+export class SetUitpasClientCredentialsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    bodyDecoder = UitpasClientIdAndSecret.patchType() as Decoder<AutoEncoderPatchType<UitpasClientIdAndSecret>>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'POST') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/organization/uitpas-client-credentials', {});
+
+        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 (request.body.clientId === '' && request.body.clientSecret === '') {
+            // clear
+            await UitpasService.clearClientCredentialsFor(organization.id);
+            organization.meta.uitpasClientCredentialsStatus = UitpasClientCredentialsStatus.NotConfigured;
+            await organization.save();
+            const resp = new UitpasSetClientCredentialsResponse();
+            resp.status = UitpasClientCredentialsStatus.NotConfigured;
+            return new Response(resp);
+        }
+        if (!request.body.clientId) {
+            throw new SimpleError({
+                message: 'You must provide a client id',
+                code: 'missing_client_id',
+                human: $t('Je moet een client id opgeven.'),
+                field: 'clientId',
+            });
+        }
+        if (!request.body.clientSecret) {
+            throw new SimpleError({
+                message: 'You must provide a client secret',
+                code: 'missing_client_secret',
+                human: $t('Je moet een client secret opgeven.'),
+                field: 'clientSecret',
+            });
+        }
+        if (request.body.clientSecret === UitpasClientIdAndSecret.placeholderClientSecret && (await UitpasService.getClientIdFor(organization.id)) !== request.body.clientId) {
+            throw new SimpleError({
+                message: 'You cannot use the placeholder client secret for a different client id',
+                code: 'invalid_client_secret',
+                human: $t('Je kan niet enkel de client id wijzigen. Geef ook de client secret in.'),
+                field: 'clientSecret',
+            });
+        }
+        const reEvaluation = request.body.clientSecret === UitpasClientIdAndSecret.placeholderClientSecret;
+
+        if (!organization.meta.uitpasOrganizerId) {
+            throw new SimpleError({
+                message: 'This organization does not have a uitpas organizer id set',
+                code: 'missing_uitpas_organizer_id',
+                human: $t('Stel eerst een UiTPAS-organisator in.'),
+            });
+        }
+
+        // store the client credentials and store new status in one operation
+        if (!reEvaluation) {
+            const valid = await UitpasService.storeIfValid(organization.id, request.body.clientId, request.body.clientSecret);
+            if (!valid) {
+                throw new SimpleError({
+                    message: 'The provided client credentials are not valid',
+                    code: 'invalid_client_credentials',
+                    human: $t('De opgegeven client credentials zijn niet geldig.'),
+                });
+            }
+        }
+        organization.meta.uitpasClientCredentialsStatus = UitpasClientCredentialsStatus.NotChecked;
+        await organization.save();
+
+        // now we update the status (but if this fails, the status will safely remain NOT_CHECKED)
+        const { status, human } = await UitpasService.checkPermissionsFor(organization.id, organization.meta.uitpasOrganizerId);
+        organization.meta.uitpasClientCredentialsStatus = status;
+        await organization.save(); // save the organization to update the status
+
+        const resp = new UitpasSetClientCredentialsResponse();
+        resp.status = status;
+        resp.human = human;
+        return new Response(resp);
+    }
+}

package/src/endpoints/organization/dashboard/payments/GetPaymentsEndpoint.ts

@@ -2,7 +2,7 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Payment } from '@stamhoofd/models';
-import { SQL, compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { SQL, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, TransferSettings, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalancesEndpoint.ts

@@ -2,14 +2,13 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { CachedBalance } from '@stamhoofd/models';
-import { compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { assertSort, CountFilteredRequest, DetailedReceivableBalance, getSortFilter, LimitedFilteredRequest, PaginatedResponse, ReceivableBalance as ReceivableBalanceStruct, StamhoofdFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 import { receivableBalanceFilterCompilers } from '../../../../sql-filters/receivable-balances';
 import { receivableBalanceSorters } from '../../../../sql-sorters/receivable-balances';
-import { BalanceItemService } from '../../../../services/BalanceItemService';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;

package/src/endpoints/organization/dashboard/registration-periods/GetOrganizationRegistrationPeriodsEndpoint.ts

@@ -1,6 +1,7 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, PaginatedResponse, StamhoofdFilter } from '@stamhoofd/structures';
 
+import { Decoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { OrganizationRegistrationPeriod } from '@stamhoofd/models';
 import { applySQLSorter, compileToSQLFilter, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
@@ -8,7 +9,6 @@ import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStruct
 import { Context } from '../../../../helpers/Context';
 import { organizationRegistrationPeriodFilterCompilers } from '../../../../sql-filters/organization-registration-periods';
 import { organizationRegistrationPeriodSorters } from '../../../../sql-sorters/organization-registration-periods';
-import { Decoder } from '@simonbackx/simple-encoding';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;

package/src/endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint.ts

@@ -3,7 +3,7 @@ import { GroupPrivateSettings, Group as GroupStruct, GroupType, OrganizationRegi
 
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Group, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from '@stamhoofd/models';
+import { Event, Group, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 import { SetupStepUpdater } from '../../../../helpers/SetupStepUpdater';
@@ -212,6 +212,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
 
             for (const groupPut of patch.groups.getPuts()) {
                 shouldUpdateSetupSteps = true;
+                groupPut.put.settings.throwIfInvalidPrices();
                 const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(groupPut.put, organization.id, period, { allowedIds });
                 deleteUnreachable = true;
                 forceGroupIds.push(group.id);
@@ -349,6 +350,12 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
 
         model.deletedAt = new Date();
         await model.save();
+
+        const events = await Event.select().where('groupId', id).fetch();
+        for (const event of events) {
+            event.groupId = null;
+            await event.save();
+        }
     }
 
     static async patchGroup(struct: AutoEncoderPatchType<GroupStruct>, period?: RegistrationPeriod | null) {
@@ -479,6 +486,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             }
         }
 
+        model.settings.throwIfInvalidPrices();
         await model.updateOccupancy();
         await model.save();
 

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

@@ -1,9 +1,10 @@
-import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { assertSort, CountFilteredRequest, getOrderSearchFilter, getSortFilter, LimitedFilteredRequest, PaginatedResponse, PrivateOrder, StamhoofdFilter } from '@stamhoofd/structures';
 
 import { Order } from '@stamhoofd/models';
-import { compileToSQLFilter, applySQLSorter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { applySQLSorter, compileToSQLFilter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+
+import { Decoder } from '@simonbackx/simple-encoding';
 import { parsePhoneNumber } from 'libphonenumber-js/max';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';

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

@@ -3,7 +3,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { Ticket } from '@stamhoofd/models';
 import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, PaginatedResponse, TicketPrivate } from '@stamhoofd/structures';
 
-import { compileToSQLFilter, applySQLSorter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { applySQLSorter, compileToSQLFilter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 import { LimitedFilteredRequestHelper } from '../../../../helpers/LimitedFilteredRequestHelper';

package/src/endpoints/organization/webshops/GetWebshopEndpoint.test.ts

@@ -30,11 +30,11 @@ describe('Endpoint.GetWebshop', () => {
         expect((response.body as any).privateMeta).toBeUndefined();
     });
 
-    test('Allow access without organization scope in old v243', async () => {
+    test('Allow access without organization scope', async () => {
         const organization = await new OrganizationFactory({}).create();
         const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
 
-        const r = Request.buildJson('GET', '/v243/webshop/' + webshop.id);
+        const r = Request.buildJson('GET', '/webshop/' + webshop.id);
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
@@ -43,13 +43,6 @@ describe('Endpoint.GetWebshop', () => {
         expect((response.body as any).privateMeta).toBeUndefined();
     });
 
-    test('Do not allow access without organization scope in v244', async () => {
-        const organization = await new OrganizationFactory({}).create();
-        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
-        const r = Request.buildJson('GET', '/v244/webshop/' + webshop.id);
-        await expect(testServer.test(endpoint, r)).rejects.toThrow('Please specify the organization in the hostname');
-    });
-
     test('Get webshop as admin', async () => {
         const organization = await new OrganizationFactory({}).create();
         const user = await new UserFactory({

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

@@ -26,13 +26,7 @@ export class GetWebshopEndpoint extends Endpoint<Params, Query, Body, ResponseBo
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        if (Context.version < 244) {
-            await Context.setOptionalOrganizationScope();
-        }
-        else {
-            await Context.setOrganizationScope();
-        }
-
+        await Context.setOptionalOrganizationScope(); // editing webshop from the admin panel -> no scope
         await Context.optionalAuthenticate();
 
         const webshop = await Webshop.getByID(request.params.id);

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

@@ -3,7 +3,7 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Email } from '@stamhoofd/email';
-import { BalanceItem, BalanceItemPayment, MolliePayment, MollieToken, Order, PayconiqPayment, Payment, RateLimiter, Webshop, WebshopDiscountCode } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, MolliePayment, MollieToken, Order, PayconiqPayment, Payment, RateLimiter, Webshop, WebshopDiscountCode, WebshopUitpasNumber } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { AuditLogSource, BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, OrderData, OrderResponse, Order as OrderStruct, PaymentCustomer, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, TranslatedString, Version, WebshopAuthType, Webshop as WebshopStruct } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
@@ -12,6 +12,7 @@ import { BuckarooHelper } from '../../../helpers/BuckarooHelper';
 import { Context } from '../../../helpers/Context';
 import { StripeHelper } from '../../../helpers/StripeHelper';
 import { AuditLogService } from '../../../services/AuditLogService';
+import { UitpasService } from '../../../services/uitpas/UitpasService';
 
 type Params = { id: string };
 type Query = undefined;
@@ -132,6 +133,72 @@ export class PlaceOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             request.body.validate(webshopStruct, organization.meta, request.i18n, false, Context.user?.getStructure());
             request.body.update(webshopStruct);
 
+            // UiTPAS numbers validation
+            const articlesWithUitpasSocialTariff = request.body.cart.items.filter(item => item.productPrice.uitpasBaseProductPriceId !== null);
+            for (const item of articlesWithUitpasSocialTariff) {
+                const uitpasNumbersOnly = item.uitpasNumbers.map(p => p.uitpasNumber);
+
+                // verify the amount of UiTPAS numbers
+                if (uitpasNumbersOnly.length !== item.amount) {
+                    throw new SimpleError({
+                        code: 'amount_of_uitpas_numbers_mismatch',
+                        message: 'The number of UiTPAS numbers and items with UiTPAS social tariff does not match',
+                        human: $t('6140c642-69b2-43d6-80ba-2af4915c5837'),
+                        field: 'cart.items.uitpasNumbers',
+                    });
+                }
+
+                // verify the UiTPAS numbers are unique (within the order)
+                if (uitpasNumbersOnly.length !== Formatter.uniqueArray(uitpasNumbersOnly).length) {
+                    throw new SimpleError({
+                        code: 'duplicate_uitpas_numbers',
+                        message: 'Duplicate uitpas numbers used',
+                        human: $t('d9ec27f3-dafa-41e8-bcfb-9da564a4a675'),
+                        field: 'cart.items.uitpasNumbers',
+                    });
+                }
+
+                // verify the UiTPAS numbers are not already used for this product
+                const hasBeenUsed = await WebshopUitpasNumber.areUitpasNumbersUsed(webshop.id, item.product.id, uitpasNumbersOnly);
+                if (hasBeenUsed) {
+                    throw new SimpleError({
+                        code: 'uitpas_number_already_used',
+                        message: 'One or more uitpas numbers are already used',
+                        human: $t('1ef059c2-e758-4cfa-bc2b-16a581029450'),
+                        field: 'cart.items.uitpasNumbers',
+                    });
+                }
+
+                // verify the UiTPAS numbers are valid for social tariff (static check + API call to UiTPAS)
+                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);
+                    if (reducedPrices.length < expectedReducedPrices.length) {
+                        // should not happen
+                        throw new SimpleError({
+                            code: 'uitpas_social_tariff_price_mismatch',
+                            message: 'UiTPAS wrong number of prices retruned',
+                            human: $t('Het kansentarief voor sommige UiTPAS-nummers kon niet worden opgehaald.'),
+                            field: 'cart.items.uitpasNumbers',
+                        });
+                    }
+                    for (let i = 0; i < expectedReducedPrices.length; i++) {
+                        if (reducedPrices[i] !== expectedReducedPrices[i]) {
+                            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]) }),
+                                field: 'uitpasNumbers.' + i.toString(),
+                            });
+                        }
+                    }
+                }
+                else {
+                    await UitpasService.checkUitpasNumbers(uitpasNumbersOnly); // Throws if invalid
+                }
+            }
+
             const order = new Order().setRelation(Order.webshop, webshop);
             order.data = request.body; // TODO: validate
             order.organizationId = organization.id;

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

@@ -1,9 +1,10 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { UitpasPriceCheckRequest, UitpasPriceCheckResponse } from '@stamhoofd/structures';
 
-import { UitpasNumberValidator } from '../../../helpers/UitpasNumberValidator';
 import { Decoder } from '@simonbackx/simple-encoding';
+import { UitpasService } from '../../../services/uitpas/UitpasService';
+import { Context } from '../../../helpers/Context';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = UitpasPriceCheckRequest;
@@ -26,30 +27,44 @@ export class RetrieveUitpasSocialTariffPricesEndpoint extends Endpoint<Params, Q
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        if (request.body.uitpasEventId) {
+        if (request.body.uitpasEventUrl) {
             // OFFICIAL FLOW
             if (!request.body.uitpasNumbers) {
                 // STATIC CHECK
                 // request shouldn't include a reduced price
+
+                // this call should be authenticated, as it is done from the webshop settings
+                const organization = await Context.setOrganizationScope({ willAuthenticate: true });
+                await Context.authenticate();
+                const reducedPrice = await UitpasService.getSocialTariffForEvent(
+                    organization.id,
+                    request.body.basePrice,
+                    request.body.uitpasEventUrl,
+                );
+                const uitpasPriceCheckResponse = UitpasPriceCheckResponse.create({
+                    prices: [reducedPrice], // Convert to cents
+                });
+                return new Response(uitpasPriceCheckResponse);
             }
             else {
                 // OFFICIAL FLOW with an UiTPAS number
                 // request should include a reduced price (estimate by the frontend)
+                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,
+                });
+                return new Response(uitpasPriceCheckResponse);
             }
-            throw new SimpleError({
-                code: 'not_implemented',
-                message: 'Official flow not yet implemented',
-                human: 'De officiële flow voor het valideren van een UiTPAS-nummer wordt nog niet ondersteund.',
-            });
         }
         else {
             // NON-OFFICIAL FLOW
             // request should include UiTPAS-numbers, reduced price AND base price
-            if (!request.body.reducedPrice) {
+            if (request.body.reducedPrice === null) {
                 throw new SimpleError({
                     code: 'missing_reduced_price',
                     message: 'Reduced price must be provided for non-official flow.',
-                    human: $t('Je moet een verlaagd tarief opgeven voor de UiTPAS.'),
+                    human: $t('c66d114d-2ef3-476f-ad00-98fbe3195365'),
                 });
             }
             const reducedPrice = request.body.reducedPrice;
@@ -57,18 +72,10 @@ export class RetrieveUitpasSocialTariffPricesEndpoint extends Endpoint<Params, Q
                 throw new SimpleError({
                     code: 'missing_uitpas_numbers',
                     message: 'Uitpas numbers must be provided for non-official flow.',
-                    human: $t('Je moet UiTPAS-nummers opgeven.'),
+                    human: $t('f792eda7-03b9-465d-807d-3d08ba148c8b'),
                 });
             }
-            try {
-                await UitpasNumberValidator.checkUitpasNumbers(request.body.uitpasNumbers); // Throws if invalid
-            }
-            catch (e) {
-                if (isSimpleError(e) || isSimpleErrors(e)) {
-                    e.addNamespace('uitpasNumbers');
-                }
-                throw e;
-            }
+            await UitpasService.checkUitpasNumbers(request.body.uitpasNumbers); // Throws if invalid
             const uitpasPriceCheckResponse = UitpasPriceCheckResponse.create({
                 prices: request.body.uitpasNumbers.map(_ => reducedPrice), // All reduced prices are the same in this non-official flow
             });