@stamhoofd/backend 2.64.0 → 2.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.64.0",
+    "version": "2.65.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -37,14 +37,14 @@
         "@simonbackx/simple-encoding": "2.19.0",
         "@simonbackx/simple-endpoints": "1.15.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.64.0",
-        "@stamhoofd/backend-middleware": "2.64.0",
-        "@stamhoofd/email": "2.64.0",
-        "@stamhoofd/models": "2.64.0",
-        "@stamhoofd/queues": "2.64.0",
-        "@stamhoofd/sql": "2.64.0",
-        "@stamhoofd/structures": "2.64.0",
-        "@stamhoofd/utility": "2.64.0",
+        "@stamhoofd/backend-i18n": "2.65.0",
+        "@stamhoofd/backend-middleware": "2.65.0",
+        "@stamhoofd/email": "2.65.0",
+        "@stamhoofd/models": "2.65.0",
+        "@stamhoofd/queues": "2.65.0",
+        "@stamhoofd/sql": "2.65.0",
+        "@stamhoofd/structures": "2.65.0",
+        "@stamhoofd/utility": "2.65.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "80eebbb0b4fb84ac979041c3f8c7762863622367"
+    "gitHead": "16bb6a7ce183c964158cee5d1581de6e7575133d"
 }

package/src/audit-logs/EmailLogger.ts

@@ -8,6 +8,7 @@ export const EmailLogger = new ModelLogger(Email, {
         if (event.type === 'deleted') {
             return;
         }
+
         let oldStatus = EmailStatus.Draft;
 
         if (event.type === 'updated') {
@@ -35,6 +36,11 @@ export const EmailLogger = new ModelLogger(Email, {
             };
         }
 
+        if (event.model.emailType) {
+            // don't log the scheduled part of automated emails
+            return;
+        }
+
         return {
             type: AuditLogType.EmailSending,
             data: {
@@ -48,7 +54,7 @@ export const EmailLogger = new ModelLogger(Email, {
         const map = new Map([
             ['e', AuditLogReplacement.create({
                 id: model.id,
-                value: model.subject || '',
+                value: replaceHtml(model.subject ?? '', options.data.recipient?.replacements ?? []),
                 type: AuditLogReplacementType.Email,
             })],
             ['c', AuditLogReplacement.create({

package/src/audit-logs/ModelLogger.ts

@@ -113,8 +113,23 @@ export class ModelLogger<ModelType extends typeof Model, M extends InstanceType<
         try {
             const context = ContextInstance.optional;
             const log = new AuditLog();
-            const settings = AuditLogService.getContext();
-            const userId = settings?.userId !== undefined ? settings?.userId : (context?.optionalAuth?.user?.id ?? settings?.fallbackUserId ?? null);
+            let settings = AuditLogService.getContext();
+            let userId = settings?.userId !== undefined ? settings?.userId : (context?.optionalAuth?.user?.id ?? settings?.fallbackUserId ?? null);
+
+            if (userId === '1') {
+                // System user
+                userId = null;
+
+                if (!settings?.source) {
+                    if (settings) {
+                        settings.source = AuditLogSource.System;
+                    }
+                    else {
+                        settings = { source: AuditLogSource.System };
+                    }
+                }
+            }
+
             log.userId = userId;
 
             log.organizationId = context?.organization?.id ?? settings?.fallbackOrganizationId ?? null;

package/src/crons/balance-emails.ts

@@ -0,0 +1,232 @@
+import { registerCron } from '@stamhoofd/crons';
+import { CachedBalance, Email, EmailRecipient, Organization, Platform, User } from '@stamhoofd/models';
+import { IterableSQLSelect, readDynamicSQLExpression, SQL, SQLCalculation, SQLPlusSign } from '@stamhoofd/sql';
+import { EmailRecipientFilter, EmailRecipientFilterType, EmailRecipientSubfilter, EmailTemplateType, OrganizationEmail, ReceivableBalanceType, StamhoofdFilter } from '@stamhoofd/structures';
+import { ContextInstance } from '../helpers/Context';
+
+registerCron('balanceEmails', balanceEmails);
+
+let lastFullRun = new Date(0);
+let savedIterator: IterableSQLSelect<Organization> | null = null;
+
+const bootAt = new Date();
+
+async function balanceEmails() {
+    // Do not run within 30 minutes after boot to avoid creating multiple email models for emails that failed to send
+    if (bootAt.getTime() > new Date().getTime() - 1000 * 60 * 30 && STAMHOOFD.environment !== 'development') {
+        console.log('Boot time is too recent, skipping.');
+        return;
+    }
+
+    if (lastFullRun.getTime() > new Date().getTime() - 1000 * 60 * 60 * 12 && STAMHOOFD.environment !== 'development') {
+        console.log('Already ran today, skipping.');
+        return;
+    }
+
+    if ((new Date().getHours() > 10 || new Date().getHours() < 6) && STAMHOOFD.environment !== 'development') {
+        console.log('Not between 6 and 10 AM, skipping.');
+        return;
+    }
+
+    // Get the next x organization to send e-mails for
+    if (savedIterator === null) {
+        console.log('Starting new iterator');
+        savedIterator = Organization.select().limit(10).all();
+    }
+
+    const platform = await Platform.getSharedPrivateStruct();
+
+    if (!platform.config.featureFlags.includes('balance-emails')) {
+        console.log('Feature flag not enabled, skipping.');
+        return;
+    }
+    const systemUser = await User.getSystem();
+
+    for await (const organization of savedIterator.maxQueries(5)) {
+        if (!organization.privateMeta.balanceNotificationSettings.enabled || organization.privateMeta.balanceNotificationSettings.maximumReminderEmails <= 0 || organization.privateMeta.balanceNotificationSettings.minimumDaysBetween <= 0) {
+            continue;
+        }
+
+        const selectedEmailAddress = organization.privateMeta.balanceNotificationSettings.emailId ? organization.privateMeta.emails.find(e => e.id === organization.privateMeta.balanceNotificationSettings.emailId) : null;
+        const emailAddress = selectedEmailAddress ?? organization.privateMeta.emails.find(e => e.default) ?? null;
+
+        if (!emailAddress) {
+            // No emailadres set
+            console.warn('Skipped organization', organization.id, 'because no email address is set');
+            continue;
+        }
+
+        // First emails
+        await sendTemplate({
+            objectType: ReceivableBalanceType.user,
+            organization,
+            emailAddress,
+            systemUser,
+            templateType: EmailTemplateType.UserBalanceIncreaseNotification,
+            filter: {
+                reminderAmountIncreased: true,
+                reminderEmailCount: 0,
+            },
+        });
+        await sendTemplate({
+            objectType: ReceivableBalanceType.organization,
+            organization,
+            emailAddress,
+            systemUser,
+            templateType: EmailTemplateType.OrganizationBalanceIncreaseNotification,
+            filter: {
+                reminderAmountIncreased: true,
+                reminderEmailCount: 0,
+            },
+        });
+        const maximumEmailCount = organization.privateMeta.balanceNotificationSettings.maximumReminderEmails;
+
+        // Reminder emails
+        if (maximumEmailCount > 1) {
+            await sendTemplate({
+                objectType: ReceivableBalanceType.user,
+                organization,
+                emailAddress,
+                systemUser,
+                templateType: EmailTemplateType.UserBalanceReminder,
+                filter: {
+                    $and: [
+                        {
+                            reminderEmailCount: { $gt: 0 },
+                        }, {
+                            reminderEmailCount: { $lt: maximumEmailCount },
+                        },
+                    ],
+                },
+            });
+            await sendTemplate({
+                objectType: ReceivableBalanceType.organization,
+                organization,
+                emailAddress,
+                systemUser,
+                templateType: EmailTemplateType.OrganizationBalanceReminder,
+                filter: {
+                    $and: [
+                        {
+                            reminderEmailCount: { $gt: 0 },
+                        }, {
+                            reminderEmailCount: { $lt: maximumEmailCount },
+                        },
+                    ],
+                },
+            });
+        }
+    }
+
+    if (savedIterator.isDone) {
+        savedIterator = null;
+        lastFullRun = new Date();
+
+        console.log('All done!');
+    }
+}
+
+async function sendTemplate({
+    organization,
+    emailAddress,
+    systemUser,
+    templateType,
+    filter,
+    objectType,
+}: {
+    objectType: ReceivableBalanceType;
+    organization: Organization;
+    emailAddress: OrganizationEmail;
+    systemUser: User;
+    templateType: EmailTemplateType;
+    filter: StamhoofdFilter;
+}) {
+    // Do not send to persons that already received a similar email before this date
+    const weekAgo = new Date(new Date().getTime() - 1000 * 60 * 60 * 24 * organization.privateMeta.balanceNotificationSettings.minimumDaysBetween); // 5 instead of 7 so the email received is on another working day
+
+    const model = new Email();
+    model.userId = null; // This is a system e-mail
+    model.organizationId = organization?.id ?? null;
+    model.emailType = templateType;
+
+    model.recipientFilter = EmailRecipientFilter.create({
+        filters: [
+            EmailRecipientSubfilter.create({
+                type: EmailRecipientFilterType.ReceivableBalances,
+                filter: {
+                    $and: [
+                        {
+                            amountOpen: { $gt: 0 },
+                            objectType,
+                        },
+                        {
+                            // Never send more than minimumDaysBetween
+                            $or: [
+                                { lastReminderEmail: null },
+                                { lastReminderEmail: { $lt: weekAgo } },
+                            ],
+                        },
+                        filter,
+                        /* {
+                            // Do not send if already received any email very recently
+                            $not: {
+                                emails: {
+                                    $elemMatch: {
+                                        sentAt: {
+                                            $gt: weekAgo,
+                                        },
+                                    },
+                                },
+                            },
+                        }, */
+                    ],
+
+                },
+            }),
+        ],
+    });
+
+    if (!await model.setFromTemplate(templateType)) {
+        console.warn('Skipped organization: email template not found', organization.id);
+        return;
+    }
+
+    model.fromAddress = emailAddress.email;
+    model.fromName = emailAddress.name ?? organization.name;
+
+    try {
+        const upToDate = await ContextInstance.startForUser(systemUser, organization, async () => {
+            return await model.send();
+        });
+
+        if (!upToDate) {
+            console.log('No recipients found for organization', organization.name, organization.id);
+        }
+        else {
+            // Set last balance amount for all these recipients
+            for await (const batch of EmailRecipient.select().where('emailId', upToDate.id).limit(100).allBatched()) {
+                const balanceItemIds = batch.flatMap(b => b.objectId ? [b.objectId] : []);
+
+                console.log('Marking balances as reminded...');
+                await CachedBalance.update()
+                    .set('lastReminderEmail', new Date())
+                    .set('lastReminderAmountOpen', SQL.column('amountOpen'))
+                    .set(
+                        'reminderEmailCount',
+                        new SQLCalculation(
+                            SQL.column('reminderEmailCount'),
+                            new SQLPlusSign(),
+                            readDynamicSQLExpression(1),
+                        ),
+                    )
+                    .where('id', balanceItemIds)
+                    .where('organizationId', organization.id)
+                    .where('objectType', objectType)
+                    .update();
+            }
+        }
+    }
+    catch (e) {
+        console.error('Error sending email for organization', e, organization.name, organization.id);
+    }
+}

package/src/crons/index.ts

@@ -3,3 +3,4 @@ import './clearExcelCache.js';
 import './endFunctionsOfUsersWithoutRegistration.js';
 import './postmark.js';
 import './update-cached-balances.js';
+import './balance-emails.js';

package/src/email-recipient-loaders/members.ts

@@ -1,14 +1,24 @@
 import { Email } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
-import { EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, mergeFilters } from '@stamhoofd/structures';
+import { EmailRecipient, EmailRecipientFilterType, LimitedFilteredRequest, MembersBlob, PaginatedResponse, mergeFilters } from '@stamhoofd/structures';
 import { GetMembersEndpoint } from '../endpoints/global/members/GetMembersEndpoint';
 
+async function getRecipients(result: PaginatedResponse<MembersBlob, LimitedFilteredRequest>, type: 'member' | 'parents' | 'unverified') {
+    const recipients: EmailRecipient[] = [];
+
+    for (const member of result.results.members) {
+        const memberRecipients = member.getEmailRecipients([type]);
+        recipients.push(...memberRecipients);
+    }
+    return recipients;
+}
+
 Email.recipientLoaders.set(EmailRecipientFilterType.Members, {
     fetch: async (query: LimitedFilteredRequest) => {
         const result = await GetMembersEndpoint.buildData(query);
 
         return new PaginatedResponse({
-            results: result.results.members.flatMap(m => m.getEmailRecipients(['member'])),
+            results: await getRecipients(result, 'member'),
             next: result.next,
         });
     },
@@ -29,7 +39,7 @@ Email.recipientLoaders.set(EmailRecipientFilterType.MemberParents, {
         const result = await GetMembersEndpoint.buildData(query);
 
         return new PaginatedResponse({
-            results: result.results.members.flatMap(m => m.getEmailRecipients(['parents'])),
+            results: await getRecipients(result, 'parents'),
             next: result.next,
         });
     },
@@ -47,7 +57,7 @@ Email.recipientLoaders.set(EmailRecipientFilterType.MemberUnverified, {
         const result = await GetMembersEndpoint.buildData(query);
 
         return new PaginatedResponse({
-            results: result.results.members.flatMap(m => m.getEmailRecipients(['unverified'])),
+            results: await getRecipients(result, 'unverified'),
             next: result.next,
         });
     },

package/src/email-recipient-loaders/receivable-balances.ts

@@ -1,7 +1,7 @@
-import { Email } from '@stamhoofd/models';
-import { receivableBalanceObjectContactInMemoryFilterCompilers, compileToInMemoryFilter, EmailRecipient, EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, Replacement, StamhoofdFilter } from '@stamhoofd/structures';
-import { GetReceivableBalancesEndpoint } from '../endpoints/organization/dashboard/receivable-balances/GetReceivableBalancesEndpoint';
+import { CachedBalance, Email } from '@stamhoofd/models';
+import { BalanceItem as BalanceItemStruct, compileToInMemoryFilter, EmailRecipient, EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, receivableBalanceObjectContactInMemoryFilterCompilers, Replacement, StamhoofdFilter } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
+import { GetReceivableBalancesEndpoint } from '../endpoints/organization/dashboard/receivable-balances/GetReceivableBalancesEndpoint';
 
 async function fetch(query: LimitedFilteredRequest, subfilter: StamhoofdFilter | null) {
     const result = await GetReceivableBalancesEndpoint.buildData(query);
@@ -9,10 +9,19 @@ async function fetch(query: LimitedFilteredRequest, subfilter: StamhoofdFilter |
     // Map all contacts to recipients
     const compiledFilter = compileToInMemoryFilter(subfilter, receivableBalanceObjectContactInMemoryFilterCompilers);
 
-    return new PaginatedResponse({
-        results: result.results.flatMap((balance) => {
-            return balance.object.contacts.filter(c => compiledFilter(c)).flatMap((contact) => {
-                return contact.emails.map(email => EmailRecipient.create({
+    // const balanceItemModels = await CachedBalance.balanceForObjects(organization.id, [request.params.id], request.params.type);
+    // const balanceItems = await BalanceItem.getStructureWithPayments(balanceItemModels);
+
+    const recipients: EmailRecipient[] = [];
+    for (const balance of result.results) {
+        const balanceItemModels = await CachedBalance.balanceForObjects(balance.organizationId, [balance.object.id], balance.objectType, true);
+        const balanceItems = balanceItemModels.map(i => i.getStructure());
+
+        const filteredContacts = balance.object.contacts.filter(c => compiledFilter(c));
+        for (const contact of filteredContacts) {
+            for (const email of contact.emails) {
+                const recipient = EmailRecipient.create({
+                    objectId: balance.id, // Note: not set member, user or organization id here - should be the queryable balance id
                     firstName: contact.firstName,
                     lastName: contact.lastName,
                     email,
@@ -21,15 +30,15 @@ async function fetch(query: LimitedFilteredRequest, subfilter: StamhoofdFilter |
                             token: 'objectName',
                             value: balance.object.name,
                         }),
-                        Replacement.create({
-                            // Deprecated: for backwards compatibility
-                            token: 'organizationName',
-                            value: balance.object.name,
-                        }),
                         Replacement.create({
                             token: 'outstandingBalance',
                             value: Formatter.price(balance.amountOpen),
                         }),
+                        Replacement.create({
+                            token: 'balanceTable',
+                            value: '',
+                            html: BalanceItemStruct.getDetailsHTMLTable(balanceItems),
+                        }),
                         ...(contact.meta && contact.meta.url && typeof contact.meta.url === 'string'
                             ? [Replacement.create({
                                     token: 'paymentUrl',
@@ -37,9 +46,14 @@ async function fetch(query: LimitedFilteredRequest, subfilter: StamhoofdFilter |
                                 })]
                             : []),
                     ],
-                }));
-            });
-        }),
+                });
+                recipients.push(recipient);
+            }
+        }
+    }
+
+    return new PaginatedResponse({
+        results: recipients,
         next: result.next,
     });
 }

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -1,5 +1,5 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { SQL, SQLAlias, SQLCount, SQLDistinct, SQLSelectAs, SQLSum } from '@stamhoofd/sql';
+import { SQL, SQLAlias, SQLCount, SQLDistinct, SQLSelectAs, SQLSum, SQLWhereSign } from '@stamhoofd/sql';
 import { ChargeMembershipsSummary, ChargeMembershipsTypeSummary } from '@stamhoofd/structures';
 import { Context } from '../../../helpers/Context';
 import { QueueHandler } from '@stamhoofd/queues';
@@ -43,6 +43,29 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
         const platform = await Platform.getShared();
         const chargeVia = platform.membershipOrganizationId;
 
+        const total = await this.fetchTotal(chargeVia, false);
+        const totalTrials = await this.fetchTotal(chargeVia, true);
+
+        return new Response(
+            ChargeMembershipsSummary.create({
+                running: false,
+                memberships: total.memberships ?? 0,
+                members: total.members ?? 0,
+                price: total.price ?? 0,
+                organizations: total.organizations ?? 0,
+                membershipsPerType: await this.fetchPerType(chargeVia),
+                trials: ChargeMembershipsTypeSummary.create({
+                    memberships: totalTrials.memberships ?? 0,
+                    members: totalTrials.members ?? 0,
+                    price: totalTrials.price ?? 0,
+                    organizations: totalTrials.organizations ?? 0,
+                }),
+            }),
+        );
+    }
+
+    async fetchTotal(chargeVia: string | null, trial = false) {
+        const noTrial = SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date());
         const query = SQL
             .select(
                 new SQLSelectAs(
@@ -81,25 +104,29 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
             .where('deletedAt', null)
             .whereNot('organizationId', chargeVia);
 
+        if (!trial) {
+            query.where(noTrial);
+        }
+        else {
+            query.whereNot(noTrial);
+        }
+
         const result = await query.fetch();
         const members = result[0]['data']['members'] as number;
         const memberships = result[0]['data']['memberships'] as number;
         const organizations = result[0]['data']['organizations'] as number;
         const price = result[0]['data']['price'] as number;
 
-        return new Response(
-            ChargeMembershipsSummary.create({
-                running: false,
-                memberships: memberships ?? 0,
-                members: members ?? 0,
-                price: price ?? 0,
-                organizations: organizations ?? 0,
-                membershipsPerType: await this.fetchPerType(chargeVia),
-            }),
-        );
+        return {
+            members,
+            memberships,
+            organizations,
+            price,
+        };
     }
 
-    async fetchPerType(chargeVia: string | null) {
+    async fetchPerType(chargeVia: string | null, trial = false) {
+        const trialQ = SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date());
         const query = SQL
             .select(
                 SQL.column('member_platform_memberships', 'membershipTypeId'),
@@ -137,11 +164,19 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
             .from('member_platform_memberships')
             .where('balanceItemId', null)
             .where('deletedAt', null)
+            .where(trialQ)
             .whereNot('organizationId', chargeVia)
             .groupBy(
                 SQL.column('member_platform_memberships', 'membershipTypeId'),
             );
 
+        if (!trial) {
+            query.where(trialQ);
+        }
+        else {
+            query.whereNot(trialQ);
+        }
+
         const result = await query.fetch();
         const membershipsPerType = new Map<string, ChargeMembershipsTypeSummary>();
 

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

@@ -88,24 +88,8 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
         // Check default
         if (JSON.stringify(model.json).length < 3 && model.recipientFilter.filters[0].type && EmailTemplateStruct.getDefaultForRecipient(model.recipientFilter.filters[0].type)) {
             const type = EmailTemplateStruct.getDefaultForRecipient(model.recipientFilter.filters[0].type);
-
-            // Most specific template: for specific group
-            let templates = (await EmailTemplate.where({ type, organizationId: organization?.id ?? null, groupId: null }));
-
-            // Then default
-            if (templates.length == 0 && organization) {
-                templates = (await EmailTemplate.where({ type, organizationId: null, groupId: null }));
-            }
-
-            if (templates.length == 0) {
-                // No default
-            }
-            else {
-                const defaultTemplate = templates[0];
-                model.html = defaultTemplate.html;
-                model.text = defaultTemplate.text;
-                model.subject = defaultTemplate.subject;
-                model.json = defaultTemplate.json;
+            if (type) {
+                await model.setFromTemplate(type);
             }
         }
 

package/src/endpoints/organization/dashboard/email-templates/GetEmailTemplatesEndpoint.ts

@@ -95,7 +95,7 @@ export class GetEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, Res
                         : []
                 );
 
-        const defaultTemplateTypes = organization ? types.filter(type => EmailTemplateStruct.isSavedEmail(type)) : types;
+        const defaultTemplateTypes = organization ? types.filter(type => !EmailTemplateStruct.isSavedEmail(type)) : types;
         const defaultTemplates = defaultTemplateTypes.length === 0
             ? []
             : (await EmailTemplate.where({
@@ -106,6 +106,20 @@ export class GetEmailTemplatesEndpoint extends Endpoint<Params, Query, Body, Res
                     },
                 }));
 
+        if (organization && (request.query.webshopId || request.query.groupIds)) {
+            const orgDefaults = (await EmailTemplate.where({
+                organizationId: organization.id,
+                webshopId: null,
+                groupId: null,
+                type: {
+                    sign: 'IN',
+                    value: defaultTemplateTypes,
+                },
+            }));
+
+            defaultTemplates.unshift(...orgDefaults);
+        }
+
         return new Response(templates.concat(defaultTemplates).map(template => EmailTemplateStruct.create(template)));
     }
 }

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -125,6 +125,7 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 organization.privateMeta.inheritedResponsibilityRoles = request.body.privateMeta.inheritedResponsibilityRoles.applyTo(organization.privateMeta.inheritedResponsibilityRoles);
                 organization.privateMeta.privateKey = request.body.privateMeta.privateKey ?? organization.privateMeta.privateKey;
                 organization.privateMeta.featureFlags = patchObject(organization.privateMeta.featureFlags, request.body.privateMeta.featureFlags);
+                organization.privateMeta.balanceNotificationSettings = patchObject(organization.privateMeta.balanceNotificationSettings, request.body.privateMeta.balanceNotificationSettings);
 
                 if (request.body.privateMeta.mollieProfile !== undefined) {
                     organization.privateMeta.mollieProfile = patchObject(organization.privateMeta.mollieProfile, request.body.privateMeta.mollieProfile);

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint.ts

@@ -37,7 +37,7 @@ export class GetReceivableBalanceEndpoint extends Endpoint<Params, Query, Body,
             throw Context.auth.error();
         }
 
-        const balanceItemModels = await CachedBalance.balanceForObjects(organization.id, [request.params.id], request.params.type);
+        const balanceItemModels = await CachedBalance.balanceForObjects(organization.id, [request.params.id], request.params.type, true);
         let paymentModels: Payment[] = [];
 
         switch (request.params.type) {

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalancesEndpoint.ts

@@ -48,16 +48,6 @@ export class GetReceivableBalancesEndpoint extends Endpoint<Params, Query, Body,
 
         scopeFilter = {
             organizationId: organization.id,
-            $or: {
-                amountOpen: { $neq: 0 },
-                amountPending: { $neq: 0 },
-                nextDueAt: { $neq: null },
-            },
-            $not: {
-                objectType: {
-                    $in: Context.auth.hasSomePlatformAccess() ? [ReceivableBalanceType.registration] : [ReceivableBalanceType.organization, ReceivableBalanceType.registration],
-                },
-            },
         };
 
         const query = CachedBalance

package/src/helpers/EmailResumer.ts

@@ -12,13 +12,9 @@ export async function resumeEmails() {
     const emails = Email.fromRows(result, Email.table);
 
     for (const email of emails) {
-        if (!email.userId) {
-            console.warn('Cannot retry sending email because userId is not set - which is required for setting the scope', email.id);
-            continue;
-        }
         console.log('Resuming email that has sending status on boot', email.id);
 
-        const user = await User.getByID(email.userId);
+        const user = email.userId ? (await User.getByID(email.userId)) : await User.getSystem();
         if (!user) {
             console.warn('Cannot retry sending email because user not found', email.id);
             continue;