@stamhoofd/backend 2.93.0 → 2.94.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.93.0",
+    "version": "2.94.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -45,14 +45,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.93.0",
-        "@stamhoofd/backend-middleware": "2.93.0",
-        "@stamhoofd/email": "2.93.0",
-        "@stamhoofd/models": "2.93.0",
-        "@stamhoofd/queues": "2.93.0",
-        "@stamhoofd/sql": "2.93.0",
-        "@stamhoofd/structures": "2.93.0",
-        "@stamhoofd/utility": "2.93.0",
+        "@stamhoofd/backend-i18n": "2.94.0",
+        "@stamhoofd/backend-middleware": "2.94.0",
+        "@stamhoofd/email": "2.94.0",
+        "@stamhoofd/models": "2.94.0",
+        "@stamhoofd/queues": "2.94.0",
+        "@stamhoofd/sql": "2.94.0",
+        "@stamhoofd/structures": "2.94.0",
+        "@stamhoofd/utility": "2.94.0",
         "archiver": "^7.0.1",
         "axios": "^1.8.2",
         "cookie": "^0.7.0",
@@ -70,5 +70,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "05b8228a7fc3871aa767609a95a2c1511132e548"
+    "gitHead": "7a1a0be03249d69ad0664ee85d446c7b596768f0"
 }

package/src/endpoints/global/email/CreateEmailEndpoint.ts

@@ -130,6 +130,24 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
             await model.queueForSending();
         }
 
+        // Delete open drafts with the same content, from the same user
+        const duplicates = await Email.select()
+            .where('userId', user.id)
+            .where('organizationId', model.organizationId)
+            .where('status', EmailStatus.Draft)
+            .where('subject', model.subject)
+            .where('html', model.html)
+            .where('text', model.text)
+            .where('deletedAt', null)
+            .whereNot('id', model.id)
+            .limit(100)
+            .fetch();
+
+        for (const duplicate of duplicates) {
+            duplicate.deletedAt = new Date();
+            await duplicate.save();
+        }
+
         return new Response(await model.getPreviewStructure());
     }
 }

package/src/endpoints/global/email/GetAdminEmailsEndpoint.ts

@@ -104,7 +104,8 @@ export class GetAdminEmailsEndpoint extends Endpoint<Params, Query, Body, Respon
             };
         }
 
-        const query = Email.select();
+        const query = Email.select()
+            .where('deletedAt', null);
 
         if (scopeFilter) {
             query.where(await compileToSQLFilter(scopeFilter, filterCompilers));

package/src/endpoints/global/email/PatchEmailEndpoint.ts

@@ -50,15 +50,6 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             throw Context.auth.error();
         }
 
-        if (model.status !== EmailStatus.Draft) {
-            throw new SimpleError({
-                code: 'not_draft',
-                human: 'Email is not a draft',
-                message: $t(`298b5a46-2899-4aa1-89df-9b634c20806b`),
-                statusCode: 400,
-            });
-        }
-
         let rebuild = false;
 
         if (request.body.subject !== undefined) {
@@ -78,6 +69,11 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                 model.senderId = sender.id;
                 model.fromAddress = sender.email;
                 model.fromName = sender.name;
+
+                // Check if we still have write access to the email
+                if (!await Context.auth.canAccessEmail(model, PermissionLevel.Write)) {
+                    throw Context.auth.error();
+                }
             }
             else {
                 throw new SimpleError({
@@ -138,6 +134,13 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             model.validateAttachments();
         }
 
+        if (request.body.deletedAt !== undefined) {
+            if (!await Context.auth.canAccessEmail(model, PermissionLevel.Full)) {
+                throw Context.auth.error();
+            }
+            model.deletedAt = request.body.deletedAt;
+        }
+
         await model.save();
 
         if (rebuild) {

package/src/endpoints/global/registration-periods/PatchRegistrationPeriodsEndpoint.ts

@@ -92,9 +92,8 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                 }
             }
 
-            await period.setPreviousPeriodId();
-
             await period.save();
+            await period.updatePreviousNextPeriods();
             periods.push(period);
         }
 
@@ -138,7 +137,7 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                 model.settings = patchObject(model.settings, patch.settings);
             }
 
-            await model.setPreviousPeriodId();
+            await model.updatePreviousNextPeriods();
             await model.save();
 
             // Schedule patch of all groups in this period
@@ -156,23 +155,13 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                 });
             }
 
-            // Get before deleting the model
-            const updateWhere = await RegistrationPeriod.where({ previousPeriodId: model.id });
-
             // Now delete the model
             await model.delete();
-
-            // Update all previous period ids
-            await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
-                for (const period of updateWhere) {
-                    await period.setPreviousPeriodId();
-                    await period.save();
-                }
-            });
+            await RegistrationPeriod.updatePreviousNextPeriods(model.organizationId);
         }
 
         // Clear platform cache
-        Platform.clearCache();
+        await Platform.clearCache();
 
         return new Response(
             periods.map(p => p.getStructure()),

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

@@ -531,6 +531,8 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         model.type = struct.type;
         model.settings.period = period.getBaseStructure();
         model.settings.endDate = period.endDate;
+        model.settings.registeredMembers = 0;
+        model.settings.reservedMembers = 0;
 
         // Note: start date is curomizable, as long as it stays between period start and end
         if (model.settings.startDate < period.startDate || model.settings.startDate > period.endDate) {

package/src/helpers/AdminPermissionChecker.ts

@@ -883,6 +883,10 @@ export class AdminPermissionChecker {
             return false;
         }
 
+        if (email.deletedAt) {
+            return false;
+        }
+
         if (email.userId === this.user.id) {
             // User can always read their own emails
             // Note; for sending we'll always need to use 'canSendEmailsFrom' externally

package/src/helpers/AuthenticatedStructures.ts

@@ -604,7 +604,7 @@ export class AuthenticatedStructures {
 
             const registration = memberBlob.registrations.find(r => r.id === id);
             if (!registration) {
-                throw new Error('Registration not found');
+                throw new Error('Registration not found: ' + id);
             }
 
             return RegistrationWithMemberBlob.create({

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/emails.ts

@@ -92,4 +92,9 @@ export const emailFilterCompilers: SQLFilterDefinitions = {
         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/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();
-});