@stamhoofd/backend 2.93.0 → 2.95.0

package/src/seeds/1756293699-fill-previous-next-period-id.ts

@@ -0,0 +1,34 @@
+import { Migration } from '@simonbackx/simple-database';
+import { logger } from '@simonbackx/simple-logging';
+import { Organization, Platform, RegistrationPeriod } from '@stamhoofd/models';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    process.stdout.write('\n');
+
+    await logger.setContext({ tags: ['seed'] }, async () => {
+        if (STAMHOOFD.userMode === 'platform') {
+            await RegistrationPeriod.updatePreviousNextPeriods(null);
+        }
+        else {
+            for await (const organization of Organization.select().all()) {
+                await RegistrationPeriod.updatePreviousNextPeriods(organization.id);
+            }
+        }
+    });
+    console.log('Updated 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();
+});

package/src/seeds/1756303697-update-email-counts.ts

@@ -0,0 +1,76 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Email, EmailRecipient } from '@stamhoofd/models';
+import { SQL, SQLAlias, SQLCount, SQLSelectAs } from '@stamhoofd/sql';
+import { EmailStatus } from '@stamhoofd/structures';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    console.log('Start setting counts of emails.');
+
+    const batchSize = 100;
+    let count = 0;
+
+    for await (const email of Email.select()
+        .where('status', EmailStatus.Sent)
+        .where('succeededCount', 0)
+        .where('failedCount', 0)
+        .where('emailRecipientsCount', '!=', 0)
+        .where('emailRecipientsCount', '!=', null)
+        .where('createdAt', '<', new Date('2025-08-28 00:00:00')).limit(batchSize).all()) {
+        const query = SQL.select(
+            new SQLSelectAs(
+                new SQLCount(
+                    SQL.column('failError'),
+                ),
+                new SQLAlias('data__failedCount'),
+            ),
+            // If the current amount_due is negative, we can ignore that negative part if there is a future due item
+            new SQLSelectAs(
+                new SQLCount(
+                    SQL.column('sentAt'),
+                ),
+                new SQLAlias('data__succeededCount'),
+            ),
+        )
+            .from(EmailRecipient.table)
+            .where('emailId', email.id);
+
+        const result = await query.fetch();
+        if (result.length !== 1) {
+            console.error('Unexpected result', result);
+            continue;
+        }
+        const row = result[0]['data'];
+        if (!row) {
+            console.error('Unexpected result row', result);
+            continue;
+        }
+
+        let failedCount = row['failedCount'];
+        const succeededCount = row['succeededCount'];
+
+        if (typeof failedCount !== 'number' || typeof succeededCount !== 'number') {
+            console.error('Unexpected result values', row);
+            return;
+        }
+
+        if (email.emailRecipientsCount !== null && failedCount + succeededCount !== email.emailRecipientsCount) {
+            console.warn(`Email ${email.id} has ${email.emailRecipientsCount} recipients, but ${failedCount} failed and ${succeededCount} succeeded. Correcting failedCount to `, email.emailRecipientsCount - succeededCount);
+            failedCount = email.emailRecipientsCount - succeededCount;
+        }
+
+        // Send an update query
+        await Email.update()
+            .where('id', email.id)
+            .set('succeededCount', succeededCount)
+            .set('failedCount', failedCount)
+            .update();
+        count += 1;
+    }
+
+    console.log('Finished saving ' + count + ' emails.');
+});

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

@@ -7,11 +7,31 @@ export const emailRecipientsFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: false,
     }),
+    memberId: createColumnFilter({
+        expression: SQL.column('memberId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    userId: createColumnFilter({
+        expression: SQL.column('userId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     email: createColumnFilter({
         expression: SQL.column('email'),
         type: SQLValueType.String,
         nullable: true,
     }),
+    firstName: createColumnFilter({
+        expression: SQL.column('firstName'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    lastName: createColumnFilter({
+        expression: SQL.column('lastName'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     name: createColumnFilter({
         expression: new SQLConcat(
             SQL.column('firstName'),
@@ -26,6 +46,11 @@ export const emailRecipientsFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    duplicateOfRecipientId: createColumnFilter({
+        expression: SQL.column('duplicateOfRecipientId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     emailId: createColumnFilter({
         expression: SQL.column('emailId'),
         type: SQLValueType.String,

package/src/sql-filters/emails.ts

@@ -1,12 +1,32 @@
-import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { emailRecipientsFilterCompilers } from './email-recipients';
 
-export const emailFilterCompilers: SQLFilterDefinitions = {
+export const userEmailFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
     id: createColumnFilter({
         expression: SQL.column('id'),
         type: SQLValueType.String,
         nullable: false,
     }),
+    sentAt: createColumnFilter({
+        expression: SQL.column('sentAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    senderId: createColumnFilter({
+        expression: SQL.column('senderId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+};
+
+export const emailFilterCompilers: SQLFilterDefinitions = {
+    ...userEmailFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
     organizationId: createColumnFilter({
         expression: SQL.column('organizationId'),
         type: SQLValueType.String,
@@ -92,4 +112,22 @@ export const emailFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    deletedAt: createColumnFilter({
+        expression: SQL.column('deletedAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    recipients: createExistsFilter(
+        SQL.select()
+            .from(
+                SQL.table('email_recipients'),
+            )
+            .where(
+                SQL.column('emailId'),
+                SQL.parentColumn('id'),
+            ),
+        {
+            ...emailRecipientsFilterCompilers,
+        },
+    ),
 };

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/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();
-});