@stamhoofd/backend 2.92.0 → 2.94.0

package/src/sql-filters/email-recipients.ts

@@ -0,0 +1,59 @@
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLConcat, SQLFilterDefinitions, SQLScalar, SQLValueType } from '@stamhoofd/sql';
+
+export const emailRecipientsFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    email: createColumnFilter({
+        expression: SQL.column('email'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    name: createColumnFilter({
+        expression: new SQLConcat(
+            SQL.column('firstName'),
+            new SQLScalar(' '),
+            SQL.column('lastName'),
+        ),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    emailId: createColumnFilter({
+        expression: SQL.column('emailId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    sentAt: createColumnFilter({
+        expression: SQL.column('sentAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    failError: createColumnFilter({
+        expression: SQL.column('failError'),
+        type: SQLValueType.JSONObject,
+        nullable: true,
+    }),
+    spamComplaintError: createColumnFilter({
+        expression: SQL.column('spamComplaintError'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    softBounceError: createColumnFilter({
+        expression: SQL.column('softBounceError'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    hardBounceError: createColumnFilter({
+        expression: SQL.column('hardBounceError'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+};

package/src/sql-filters/emails.ts

@@ -47,11 +47,36 @@ export const emailFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: false,
     }),
-    recipientCount: createColumnFilter({
-        expression: SQL.column('recipientCount'),
+    emailRecipientsCount: createColumnFilter({
+        expression: SQL.column('emailRecipientsCount'),
         type: SQLValueType.Number,
         nullable: true,
     }),
+    failedCount: createColumnFilter({
+        expression: SQL.column('failedCount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    softFailedCount: createColumnFilter({
+        expression: SQL.column('softFailedCount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    hardBouncesCount: createColumnFilter({
+        expression: SQL.column('hardBouncesCount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    softBouncesCount: createColumnFilter({
+        expression: SQL.column('softBouncesCount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    spamComplaintsCount: createColumnFilter({
+        expression: SQL.column('spamComplaintsCount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
     createdAt: createColumnFilter({
         expression: SQL.column('createdAt'),
         type: SQLValueType.Datetime,
@@ -62,4 +87,14 @@ export const emailFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Datetime,
         nullable: true,
     }),
+    senderId: createColumnFilter({
+        expression: SQL.column('senderId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    deletedAt: createColumnFilter({
+        expression: SQL.column('deletedAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
 };

package/src/sql-filters/events.ts

@@ -52,6 +52,16 @@ export const eventFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
+    'minAge': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('meta'), '$.value.minAge'),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
+    'maxAge': createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('meta'), '$.value.maxAge'),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
     'meta.visible': createColumnFilter({
         expression: SQL.jsonValue(SQL.column('meta'), '$.value.visible'),
         type: SQLValueType.JSONBoolean,

package/src/sql-filters/members.ts

@@ -1,5 +1,5 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Member } from '@stamhoofd/models';
+import { Email, Member } from '@stamhoofd/models';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLAge, SQLCast, SQLConcat, SQLFilterDefinitions, SQLValueType, SQLScalar, createWildcardColumnFilter, SQLJsonExtract } from '@stamhoofd/sql';
 import { AccessRight } from '@stamhoofd/structures';
 import { Context } from '../helpers/Context';
@@ -413,6 +413,47 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             ),
         organizationFilterCompilers,
     ),
+    'emails': createExistsFilter(
+        SQL.select()
+            .from(
+                SQL.table('email_recipients'),
+            ).where(
+                SQL.column('memberId'),
+                SQL.column('members', 'id'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            id: createColumnFilter({
+                expression: SQL.column('emailId'),
+                type: SQLValueType.String,
+                nullable: false,
+                checkPermission: async (filter) => {
+                    if (typeof filter !== 'string') {
+                        throw new SimpleError({
+                            code: 'invalid_filter',
+                            message: 'This filter structure is not supported here.',
+                        });
+                    }
+                    const id = filter;
+                    const email = await Email.getByID(id);
+                    if (!email) {
+                        throw new SimpleError({
+                            code: 'not_found',
+                            message: 'This email does not exist.',
+                            human: $t('Deze e-mail bestaat niet (meer)'),
+                            statusCode: 404,
+                        });
+                    }
+                    if (!await Context.auth.canAccessEmail(email)) {
+                        throw Context.auth.error({
+                            message: 'No permissions to access this email.',
+                            human: $t('Je hebt niet voldoende toegangsrechten om te filteren op deze e-mail'),
+                        });
+                    }
+                },
+            }),
+        },
+    ),
     'details': {
         ...baseSQLFilterCompilers,
         recordAnswers: createWildcardColumnFilter(

package/src/sql-filters/registration-periods.ts

@@ -7,6 +7,11 @@ export const registrationPeriodFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: false,
     }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
     startDate: createColumnFilter({
         expression: SQL.column('startDate'),
         type: SQLValueType.Datetime,

package/src/sql-sorters/email-recipients.ts

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

package/src/seeds/1734596144-fill-previous-period-id.ts

@@ -1,55 +0,0 @@
-import { Migration } from '@simonbackx/simple-database';
-import { logger } from '@simonbackx/simple-logging';
-import { Platform, RegistrationPeriod } from '@stamhoofd/models';
-
-export default new Migration(async () => {
-    if (STAMHOOFD.environment == 'test') {
-        console.log('skipped in tests');
-        return;
-    }
-
-    process.stdout.write('\n');
-    let c = 0;
-    let id: string = '';
-
-    await logger.setContext({ tags: ['seed'] }, async () => {
-        while (true) {
-            const items = await RegistrationPeriod.where({
-                id: {
-                    value: id,
-                    sign: '>',
-                },
-            }, { limit: 1000, sort: ['id'] });
-
-            if (items.length === 0) {
-                break;
-            }
-
-            process.stdout.write('.');
-
-            for (const item of items) {
-                await item.setPreviousPeriodId();
-                if (await item.save()) {
-                    c += 1;
-                }
-            }
-
-            if (items.length < 1000) {
-                break;
-            }
-            id = items[items.length - 1].id;
-        }
-    });
-
-    console.log('Updated ' + c + ' registration periods');
-
-    // Now update platform
-    const platform = await Platform.getForEditing();
-    await platform.setPreviousPeriodId();
-    await platform.save();
-
-    console.log('Updated platform');
-
-    // Do something here
-    return Promise.resolve();
-});