@stamhoofd/backend 2.111.0 → 2.112.0

package/src/services/uitpas/checkUitpasNumbers.ts

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

package/src/services/uitpas/handleUitpasResponse.ts

@@ -0,0 +1,89 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+
+type UitpasErrorResponse = {
+    type: string;
+    title: string;
+    endUserMessage?: {
+        nl: string;
+    };
+};
+
+/**
+ * Throws a SimpleError if the response is not ok
+ * @param response
+ * @returns json
+ */
+export async function handleUitpasResponse(response: Response) {
+    if (response.ok) {
+        const json = await response.json();
+        return json;
+    }
+
+    const error = await uitpasErrorToSimpleError(response);
+    throw error;
+}
+
+async function uitpasErrorToSimpleError(response: Response) {
+    const json: unknown = await response.json().catch(() => { /* ignore */ });
+    console.error('[UITPAS ERROR]', json);
+
+    const statusCode = response.status;
+    let human: string | undefined;
+    let message: string | undefined;
+    let code: string | undefined;
+
+    if (json) {
+        const uitpasError = jsonToUitpasErrorResponse(json);
+        if (uitpasError.endUserMessage) {
+            human = uitpasError.endUserMessage.nl;
+        }
+        message = uitpasError.title;
+        code = uitpasError.type;
+    }
+
+    return new SimpleError({
+        statusCode,
+        code: code ?? 'get-uitpas-error',
+        message: message ?? `Error when retrieving pass by UiTPAS number`,
+        human: human ?? $t('2fcd8eb2-603e-44bb-8b8d-faa131936888'),
+    });
+}
+
+function jsonToUitpasErrorResponse(json: unknown): UitpasErrorResponse {
+    assertValidUitpasError(json);
+    return {
+        type: json.type,
+        title: json.title,
+        endUserMessage: json.endUserMessage
+            ? {
+                    nl: json.endUserMessage.nl,
+                }
+            : undefined,
+    };
+}
+
+function assertValidUitpasError(json: unknown): asserts json is UitpasErrorResponse {
+    if (json === null || typeof json !== 'object') {
+        throw new Error('Not an object');
+    }
+
+    const stringProperties = ['title', 'type'];
+
+    stringProperties.forEach((key) => {
+        if (typeof json[key] !== 'string') {
+            throw new Error(`Invalid ${key}`);
+        }
+    });
+
+    const endUserMessage = json['endUserMessage'];
+    if (endUserMessage !== undefined) {
+        if (typeof endUserMessage !== 'object' || endUserMessage === null) {
+            throw new Error('Invalid endUserMessage');
+        }
+
+        const nl = endUserMessage['nl'];
+        if (typeof nl !== 'string') {
+            throw new Error('Invalid endUserMessage nl');
+        }
+    }
+}

package/src/sql-filters/invoiced-balance-items.ts

@@ -0,0 +1,20 @@
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+
+export const invoicedBalanceItemCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    name: createColumnFilter({
+        expression: SQL.column('name'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    description: createColumnFilter({
+        expression: SQL.column('description'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+};

package/src/sql-filters/invoices.ts

@@ -0,0 +1,122 @@
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
+import { invoicedBalanceItemCompilers } from './invoiced-balance-items.js';
+
+/**
+ * Defines how to filter payments in the database from StamhoofdFilter objects
+ */
+export const invoiceFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    number: createColumnFilter({
+        expression: SQL.column('number'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+
+    totalWithVAT: createColumnFilter({
+        expression: SQL.column('totalWithVAT'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    totalWithoutVAT: createColumnFilter({
+        expression: SQL.column('totalWithoutVAT'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    VATTotalAmount: createColumnFilter({
+        expression: SQL.column('VATTotalAmount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    invoicedAt: createColumnFilter({
+        expression: SQL.column('invoicedAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    customer: {
+        ...baseSQLFilterCompilers,
+        email: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.email'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        firstName: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.firstName'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        lastName: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.lastName'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        name: createColumnFilter({
+            expression: new SQLCast(
+                new SQLConcat(
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.firstName')),
+                    new SQLScalar(' '),
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.lastName')),
+                ),
+                'CHAR',
+            ),
+            type: SQLValueType.String,
+            nullable: true,
+        }),
+        company: {
+            ...baseSQLFilterCompilers,
+            name: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.name'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            VATNumber: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.VATNumber'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            companyNumber: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.companyNumber'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            administrationEmail: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.administrationEmail'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+        },
+    },
+    items: createExistsFilter(
+        SQL.select()
+            .from(
+                SQL.table('invoiced_balance_items'),
+            ).where(
+                SQL.column('invoiceId'),
+                SQL.parentColumn('id'),
+            ),
+        invoicedBalanceItemCompilers,
+    ),
+};

package/src/sql-filters/payments.ts

@@ -1,5 +1,5 @@
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
-import { balanceItemPaymentsCompilers } from './balance-item-payments';
+import { balanceItemPaymentsCompilers } from './balance-item-payments.js';
 
 /**
  * Defines how to filter payments in the database from StamhoofdFilter objects
@@ -16,6 +16,11 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: false,
     }),
+    type: createColumnFilter({
+        expression: SQL.column('type'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
     status: createColumnFilter({
         expression: SQL.column('status'),
         type: SQLValueType.String,
@@ -56,6 +61,11 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    hasInvoice: createColumnFilter({
+        expression: SQL.isNull(SQL.column('invoiceId')),
+        type: SQLValueType.Boolean,
+        nullable: false,
+    }),
     customer: {
         ...baseSQLFilterCompilers,
         email: createColumnFilter({

package/src/sql-sorters/invoices.ts

@@ -0,0 +1,83 @@
+import { Invoice } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+
+export const invoiceSorters: SQLSortDefinitions<Invoice> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields.
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
+    id: {
+        getValue(a) {
+            return a.id;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction,
+            });
+        },
+    },
+    invoicedAt: {
+        getValue(a) {
+            return a.invoicedAt !== null ? Formatter.dateTimeIso(a.invoicedAt, 'UTC') : null;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('invoicedAt'),
+                direction,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
+
+    totalWithVAT: {
+        getValue(a) {
+            return a.totalWithVAT;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('totalWithVAT'),
+                direction,
+            });
+        },
+    },
+
+    totalWithoutVAT: {
+        getValue(a) {
+            return a.totalWithoutVAT;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('totalWithoutVAT'),
+                direction,
+            });
+        },
+    },
+
+    VATTotalAmount: {
+        getValue(a) {
+            return a.VATTotalAmount;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('VATTotalAmount'),
+                direction,
+            });
+        },
+    },
+};

package/src/sql-sorters/payments.ts

@@ -55,4 +55,37 @@ export const paymentSorters: SQLSortDefinitions<Payment> = {
             });
         },
     },
+    hasInvoice: {
+        getValue(a) {
+            return a.invoiceId ? 1 : 0;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.isNull(SQL.column('invoiceId')),
+                direction,
+            });
+        },
+    },
+    method: {
+        getValue(a) {
+            return a.method;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('method'),
+                direction,
+            });
+        },
+    },
+    type: {
+        getValue(a) {
+            return a.type;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('type'),
+                direction,
+            });
+        },
+    },
 };

package/tests/e2e/bundle-discounts.test.ts

@@ -2,14 +2,14 @@ import { Request } from '@simonbackx/simple-endpoints';
 import { BalanceItem, BalanceItemFactory, GroupFactory, MemberFactory, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { AccessRight, AppliedRegistrationDiscount, BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, BooleanStatus, GroupPriceDiscount, GroupPriceDiscountType, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, PaymentMethod, PermissionLevel, Permissions, PermissionsResourceType, ReduceablePrice, ResourcePermissions } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
-import { RegisterMembersEndpoint } from '../../src/endpoints/global/registration/RegisterMembersEndpoint';
-import { assertBalances } from '../assertions/assertBalances';
-import { testServer } from '../helpers/TestServer';
-import { initBundleDiscount } from '../init/initBundleDiscount';
-import { initStripe } from '../init/initStripe';
-import { initAdmin } from '../init/initAdmin';
-import { BalanceItemService } from '../../src/services/BalanceItemService';
-import { initPermissionRole } from '../init';
+import { RegisterMembersEndpoint } from '../../src/endpoints/global/registration/RegisterMembersEndpoint.js';
+import { BalanceItemService } from '../../src/services/BalanceItemService.js';
+import { assertBalances } from '../assertions/assertBalances.js';
+import { testServer } from '../helpers/TestServer.js';
+import { initAdmin } from '../init/initAdmin.js';
+import { initBundleDiscount } from '../init/initBundleDiscount.js';
+import { initPermissionRole } from '../init/initPermissionRole.js';
+import { initStripe } from '../init/initStripe.js';
 
 const baseUrl = `/members/register`;
 

package/tests/e2e/tests-disable-net-connect.test.ts

@@ -0,0 +1,5 @@
+test('Should disallow net connect if request is not mocked', async () => {
+    const promise = fetch('https://www.google.com');
+
+    await expect(promise).rejects.toThrow(/Disallowed net connect/);
+});

package/tests/helpers/StripeMocker.ts

@@ -4,9 +4,10 @@ import nock from 'nock';
 import qs from 'qs';
 import { v4 as uuidv4 } from 'uuid';
 
-import { StripeWebookEndpoint } from '../../src/endpoints/global/payments/StripeWebhookEndpoint';
-import { StripeHelper } from '../../src/helpers/StripeHelper';
-import { testServer } from './TestServer';
+import { StripeWebookEndpoint } from '../../src/endpoints/global/payments/StripeWebhookEndpoint.js';
+import { StripeHelper } from '../../src/helpers/StripeHelper.js';
+import { testServer } from './TestServer.js';
+import { resetNock } from './resetNock.js';
 
 export class StripeMocker {
     paymentIntents: { id: string }[] = [];
@@ -215,8 +216,7 @@ export class StripeMocker {
     }
 
     stop() {
-        nock.cleanAll();
-        nock.disableNetConnect();
+        resetNock();
     }
 }