@stamhoofd/backend 2.90.3 → 2.92.0

package/src/services/uitpas/searchUitpasOrganizers.ts

@@ -25,7 +25,7 @@ function assertIsOrganizersResponse(json: unknown): asserts json is OrganizersRe
         throw new SimpleError({
             code: 'invalid_response_searching_uitpas_organizers',
             message: `Invalid response when searching for UiTPAS organizers`,
-            human: $t(`Er is een fout opgetreden bij het zoeken naar UiTPAS-organisaties. Probeer het later opnieuw.`),
+            human: $t(`e1aab1a7-fded-4e5e-b994-6607684764ac`),
         });
     }
 }
@@ -37,7 +37,7 @@ export async function searchUitpasOrganizers(access_token: string, name: string)
         throw new SimpleError({
             code: 'empty_uitpas_organizer_name',
             message: `Empty name when searching for UiTPAS organizers`,
-            human: $t(`Je moet een naam opgeven om UiTPAS-organisaties te zoeken.`),
+            human: $t(`963105d8-a70a-4ba4-9ddc-b7f908d44664`),
         });
     }
     const baseUrl = 'https://api-test.uitpas.be/organizers';
@@ -66,7 +66,7 @@ export async function searchUitpasOrganizers(access_token: string, name: string)
         throw new SimpleError({
             code: 'unsuccessful_response_searching_uitpas_organizers',
             message: `Unsuccessful response when searching for UiTPAS organizers`,
-            human: $t(`Er is een fout opgetreden bij het verbinden met UiTPAS. Probeer het later opnieuw.`),
+            human: $t(`ed4e876c-6a40-49a7-ab65-2a4d5f31c13f`),
         });
     }
     const json = await response.json().catch(() => {

package/src/sql-filters/emails.ts

@@ -0,0 +1,65 @@
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+
+export const emailFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    userId: createColumnFilter({
+        expression: SQL.column('userId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    emailType: createColumnFilter({
+        expression: SQL.column('emailType'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    subject: createColumnFilter({
+        expression: SQL.column('subject'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    fromAddress: createColumnFilter({
+        expression: SQL.column('fromAddress'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    text: createColumnFilter({
+        expression: SQL.column('text'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    recipientStatus: createColumnFilter({
+        expression: SQL.column('recipientStatus'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    recipientCount: createColumnFilter({
+        expression: SQL.column('recipientCount'),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    sentAt: createColumnFilter({
+        expression: SQL.column('sentAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+};

package/src/sql-filters/members.ts

@@ -457,7 +457,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                         throw new SimpleError({
                             code: 'permission_denied',
                             message: 'No permissions for financial support filter (organization scope).',
-                            human: result.record ? $t(`Je hebt niet voldoende toegangsrechten om te filteren op {recordName}`, { recordName: result.record.name }) : $t(`Je hebt niet voldoende toegangsrechten om te filteren op dit gegevensveld`),
+                            human: result.record ? $t(`3560487e-3f2c-4cc9-ad7f-4e9a0fc1bbb8`, { recordName: result.record.name }) : $t(`Je hebt niet voldoende toegangsrechten om te filteren op dit gegevensveld`),
                             statusCode: 400,
                         });
                     }

package/src/sql-filters/organizations.ts

@@ -187,4 +187,56 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
             }),
         },
     ),
+    companies: createExistsFilter(
+        /**
+         * There is a bug in MySQL 8 that is fixed in 9.3
+         * where EXISTS (select * from json_table(...)) does not work
+         * To fix this, we do a double select with join inside the select
+         * It is a bit slower, but it works for now.
+         */
+        SQL.select()
+            .from('organizations', 'innerOrganizations')
+            .join(
+                SQL.join(
+                    SQL.jsonTable(
+                        SQL.jsonValue(SQL.column('innerOrganizations', 'meta'), '$.value.companies'),
+                        'companies',
+                    )
+                        .addColumn(
+                            'companyNumber',
+                            'TEXT',
+                            '$.companyNumber',
+                        )
+                        .addColumn(
+                            'VATNumber',
+                            'TEXT',
+                            '$.VATNumber',
+                        )
+                        .addColumn(
+                            'name',
+                            'TEXT',
+                            '$.name',
+                        ),
+                ),
+            )
+            .where(SQL.column('innerOrganizations', 'id'), SQL.column('organizations', 'id')),
+        {
+            ...baseSQLFilterCompilers,
+            name: createColumnFilter({
+                expression: SQL.column('companies', 'name'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            companyNumber: createColumnFilter({
+                expression: SQL.column('companies', 'companyNumber'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            VATNumber: createColumnFilter({
+                expression: SQL.column('companies', 'VATNumber'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+        },
+    ),
 };

package/src/sql-sorters/emails.ts

@@ -0,0 +1,47 @@
+import { Email } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+
+export const emailSorters: SQLSortDefinitions<Email> = {
+    // 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,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
+    sentAt: {
+        getValue(a) {
+            return a.sentAt ? Formatter.dateTimeIso(a.sentAt, 'UTC') : null;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('sentAt'),
+                direction,
+            });
+        },
+    },
+};

package/tests/e2e/register.test.ts

@@ -1195,7 +1195,7 @@ describe('E2E.Register', () => {
                 expect(trialUntil).not.toBeNull();
                 expect(trialUntil!.getFullYear()).toBe(2023);
                 expect(trialUntil!.getMonth()).toBe(4);
-                expect(trialUntil!.getDate()).toBe(24);
+                expect(trialUntil!.getDate()).toBe(19);
             }
             finally {
                 jest.useRealTimers().resetAllMocks();