@stamhoofd/backend 2.57.1 → 2.59.0

package/src/audit-logs/OrganizationRegistrationPeriodLogger.ts

@@ -0,0 +1,77 @@
+import { Organization, OrganizationRegistrationPeriod, RegistrationPeriod } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogPatchItem, AuditLogPatchItemType, AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.OrganizationEdited,
+    updated: AuditLogType.OrganizationEdited,
+    deleted: AuditLogType.OrganizationEdited,
+});
+
+export const OrganizationRegistrationPeriodLogger = new ModelLogger(OrganizationRegistrationPeriod, {
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        // Load data
+        const organization = await Organization.getByID(event.model.organizationId);
+        if (!organization) {
+            return;
+        }
+
+        const period = await RegistrationPeriod.getByID(event.model.periodId);
+        if (!period) {
+            return;
+        }
+
+        return {
+            ...result,
+            data: {
+                organization,
+                period,
+            },
+        };
+    },
+
+    createReplacements(_, { data }) {
+        return new Map([
+            ['o', AuditLogReplacement.create({
+                id: data.organization.id,
+                value: data.organization.name,
+                type: AuditLogReplacementType.Organization,
+            })],
+        ]);
+    },
+
+    postProcess(event, options, log) {
+        const prependKey = AuditLogReplacement.create({
+            id: event.model.periodId,
+            value: options.data.period.getStructure().name,
+            type: AuditLogReplacementType.RegistrationPeriod,
+        });
+
+        // Prefix changes
+        for (const item of log.patchList) {
+            item.key = item.key.prepend(prependKey);
+        }
+
+        if (event.type === 'created') {
+            // Add create patch
+            log.patchList.push(AuditLogPatchItem.create({
+                key: prependKey,
+                type: AuditLogPatchItemType.Added,
+            }));
+        }
+
+        if (event.type === 'deleted') {
+            // Add delete patch
+            log.patchList.push(AuditLogPatchItem.create({
+                key: prependKey,
+                type: AuditLogPatchItemType.Removed,
+            }));
+        }
+    },
+});

package/src/audit-logs/PaymentLogger.ts

@@ -0,0 +1,43 @@
+import { Payment } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, PaymentMethod, PaymentMethodHelper, PaymentStatusHelper } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+
+export const PaymentLogger = new ModelLogger(Payment, {
+    skipKeys: ['transferFee'],
+
+    optionsGenerator: getDefaultGenerator({
+        created: AuditLogType.PaymentAdded,
+        updated: AuditLogType.PaymentEdited,
+        deleted: AuditLogType.PaymentDeleted,
+    }),
+
+    generateDescription(event, options) {
+        if (event.type === 'created') {
+            let description = `Status: ${PaymentStatusHelper.getNameCapitalized(event.model.status)}\n`
+                + `Bedrag: ${Formatter.price(event.model.price)}`;
+
+            if (event.model.method === PaymentMethod.Transfer && event.model.transferDescription) {
+                description += `\nMededeling: ${event.model.transferDescription}`;
+            }
+
+            return description;
+        }
+    },
+
+    createReplacements(model, options) {
+        let name = `${PaymentMethodHelper.getPaymentName(model.method)}`;
+
+        if (model.customer?.dynamicName) {
+            name += ` van ${model.customer.dynamicName}`;
+        }
+
+        return new Map([
+            ['p', AuditLogReplacement.create({
+                id: model.id,
+                value: name,
+                type: AuditLogReplacementType.Payment,
+            })],
+        ]);
+    },
+});

package/src/audit-logs/PlatformLogger.ts

@@ -0,0 +1,13 @@
+import { Platform } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogType } from '@stamhoofd/structures';
+
+export const PlatformLogger = new ModelLogger(Platform, {
+    optionsGenerator: getDefaultGenerator({
+        updated: AuditLogType.PlatformSettingsChanged,
+    }),
+
+    postProcess(event, options, log) {
+        log.organizationId = null;
+    },
+});

package/src/audit-logs/RegistrationLogger.ts

@@ -0,0 +1,53 @@
+import { Group, Member, Registration } from '@stamhoofd/models';
+import { ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+export const RegistrationLogger = new ModelLogger(Registration, {
+    async optionsGenerator(event) {
+        if (event.type === 'created' && event.model.registeredAt === null) {
+            // Ignored for now
+            return;
+        }
+        const wasActive = event.type === 'updated' ? (!event.originalFields.deactivatedAt && !!event.originalFields.registeredAt) : true;
+        const isActive = event.type === 'deleted' ? false : (!event.model.deactivatedAt && !!event.model.registeredAt);
+
+        if (wasActive === isActive) {
+            return;
+        }
+
+        const member = await Member.getByID(event.model.memberId);
+        const group = await Group.getByID(event.model.groupId);
+
+        if (!member || !group) {
+            return;
+        }
+
+        return {
+            type: wasActive ? AuditLogType.MemberUnregistered : AuditLogType.MemberRegistered,
+            generatePatchList: false,
+            data: { member, group },
+            objectId: member.id,
+        };
+    },
+
+    createReplacements(_, { data }) {
+        return new Map([
+            ['m', AuditLogReplacement.create({
+                id: data.member.id,
+                value: data.member.details.name,
+                type: AuditLogReplacementType.Member,
+            })],
+            ['g', AuditLogReplacement.create({
+                id: data.group.id,
+                value: data.group.settings.name,
+                type: AuditLogReplacementType.Group,
+            })],
+        ]);
+    },
+
+    generateDescription(event, options) {
+        const d = event.model.setRelation(Registration.group, options.data.group).getStructure();
+        return d.description;
+    },
+
+});

package/src/audit-logs/RegistrationPeriodLogger.ts

@@ -0,0 +1,21 @@
+import { RegistrationPeriod } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+export const RegistrationPeriodLogger = new ModelLogger(RegistrationPeriod, {
+    optionsGenerator: getDefaultGenerator({
+        created: AuditLogType.RegistrationPeriodAdded,
+        updated: AuditLogType.RegistrationPeriodEdited,
+        deleted: AuditLogType.RegistrationPeriodDeleted,
+    }),
+
+    createReplacements(model) {
+        return new Map([
+            ['p', AuditLogReplacement.create({
+                id: model.id,
+                value: model.getStructure().nameShort,
+                type: AuditLogReplacementType.RegistrationPeriod,
+            })],
+        ]);
+    },
+});

package/src/audit-logs/StripeAccountLogger.ts

@@ -0,0 +1,47 @@
+import { StripeAccount } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType } from '@stamhoofd/structures';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.StripeAccountAdded,
+    updated: AuditLogType.StripeAccountEdited,
+    deleted: AuditLogType.StripeAccountDeleted,
+});
+
+export const StripeAccountLogger = new ModelLogger(StripeAccount, {
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        if (event.type === 'updated' && 'status' in event.changedFields && event.changedFields.status === 'deleted') {
+            result.type = AuditLogType.StripeAccountDeleted;
+            result.generatePatchList = false;
+        }
+
+        return result;
+    },
+
+    createReplacements(model) {
+        return new Map([
+            ['a', AuditLogReplacement.create({
+                id: model.id,
+                value: model.accountId,
+                type: AuditLogReplacementType.StripeAccount,
+            })],
+        ]);
+    },
+
+    postProcess: (event, _options, log) => {
+        if (log.type === AuditLogType.StripeAccountEdited) {
+            // Never caused by a user
+            log.userId = null;
+
+            if (log.source === AuditLogSource.User) {
+                log.source = AuditLogSource.System;
+            }
+        }
+    },
+});

package/src/audit-logs/WebshopLogger.ts

@@ -0,0 +1,35 @@
+import { Webshop } from '@stamhoofd/models';
+import { getDefaultGenerator, ModelLogger } from './ModelLogger';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogType } from '@stamhoofd/structures';
+
+const defaultGenerator = getDefaultGenerator({
+    created: AuditLogType.WebshopAdded,
+    updated: AuditLogType.WebshopEdited,
+    deleted: AuditLogType.WebshopDeleted,
+});
+
+export const WebshopLogger = new ModelLogger(Webshop, {
+    skipKeys: [],
+    async optionsGenerator(event) {
+        const result = await defaultGenerator(event);
+
+        if (!result) {
+            return;
+        }
+
+        // todo: when placing an order / marking an order as paid
+        // we should not log any stock changes
+
+        return result;
+    },
+
+    createReplacements: (model) => {
+        return new Map([
+            ['w', AuditLogReplacement.create({
+                id: model.id,
+                value: model.meta.name,
+                type: AuditLogReplacementType.Webshop,
+            })],
+        ]);
+    },
+});

package/src/crons.ts

@@ -14,6 +14,7 @@ import { ExchangePaymentEndpoint } from './endpoints/organization/shared/Exchang
 import { checkSettlements } from './helpers/CheckSettlements';
 import { ForwardHandler } from './helpers/ForwardHandler';
 import { PaymentService } from './services/PaymentService';
+import { RegistrationService } from './services/RegistrationService';
 
 // Importing postmark returns undefined (this is a bug, so we need to use require)
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -595,7 +596,7 @@ async function checkReservedUntil() {
     });
 
     for (const registration of registrations) {
-        registration.scheduleStockUpdate();
+        RegistrationService.scheduleStockUpdate(registration.id);
     }
 
     // Update occupancy

package/src/endpoints/global/events/PatchEventsEndpoint.ts

@@ -1,7 +1,7 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Event, Group, Platform, RegistrationPeriod } from '@stamhoofd/models';
-import { Event as EventStruct, GroupType, NamedObject, Group as GroupStruct, AuditLogType } from '@stamhoofd/structures';
+import { Event as EventStruct, GroupType, NamedObject, Group as GroupStruct, AuditLogType, AuditLogSource } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
@@ -96,7 +96,9 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     put.group.organizationId,
                     period,
                 );
-                await event.syncGroupRequirements(group);
+                await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+                    await event.syncGroupRequirements(group);
+                });
                 event.groupId = group.id;
             }
 
@@ -107,15 +109,9 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             await event.save();
 
             events.push(event);
-
-            await AuditLogService.log({
-                type: AuditLogType.EventAdded,
-                event,
-            });
         }
 
         const patchingEvents = await Event.getByIDs(...request.body.getPatches().map(p => p.id));
-        const initialStructs = (await AuthenticatedStructures.events(patchingEvents)).map(e => e.clone()); // Clone is required for audit log (otherwise references might change)
 
         for (const patch of request.body.getPatches()) {
             const event = patchingEvents.find(e => e.id === patch.id);
@@ -232,7 +228,11 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     // Correct period id if needed
                     const period = await RegistrationPeriod.getByDate(event.startDate);
                     if (event.groupId) {
-                        await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(GroupStruct.patch({ id: event.groupId }), period);
+                        await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+                            if (event.groupId) {
+                                await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(GroupStruct.patch({ id: event.groupId }), period);
+                            }
+                        });
                     }
                 }
             }
@@ -246,20 +246,13 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             if (event.groupId) {
                 const group = await Group.getByID(event.groupId);
                 if (group) {
-                    await event.syncGroupRequirements(group);
+                    await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+                        await event.syncGroupRequirements(group);
+                    });
                 }
             }
 
             events.push(event);
-
-            const struct = initialStructs.find(e => e.id === patch.id);
-
-            await AuditLogService.log({
-                type: AuditLogType.EventEdited,
-                event,
-                oldData: struct,
-                patch,
-            });
         }
 
         for (const id of request.body.getDeletes()) {
@@ -276,11 +269,6 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             }
 
             await event.delete();
-
-            await AuditLogService.log({
-                type: AuditLogType.EventDeleted,
-                event,
-            });
         }
 
         const structures = await AuthenticatedStructures.events(events);

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -14,6 +14,8 @@ import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { AuditLogService } from '../../../services/AuditLogService';
+import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
+import { RegistrationService } from '../../../services/RegistrationService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -143,13 +145,6 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
             // Auto link users based on data
             await MemberUserSyncer.onChangeMember(member);
-
-            if (!duplicate) {
-                await AuditLogService.log({
-                    type: AuditLogType.MemberAdded,
-                    member: member,
-                });
-            }
         }
 
         let shouldUpdateSetupSteps = false;
@@ -205,15 +200,6 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
             await member.save();
 
-            if (patch.details) {
-                await AuditLogService.log({
-                    type: AuditLogType.MemberEdited,
-                    member: member,
-                    oldMemberDetails: originalDetails,
-                    memberDetailsPatch: patch.details,
-                });
-            }
-
             // Update documents
             await Document.updateForMember(member.id);
 
@@ -553,7 +539,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
         for (const member of members) {
             if (updateMembershipMemberIds.has(member.id)) {
-                await member.updateMemberships();
+                await PlatformMembershipService.updateMembershipsForId(member.id);
             }
         }
 
@@ -600,7 +586,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
         }
 
         for (const registration of updateRegistrations.values()) {
-            registration.scheduleStockUpdate();
+            RegistrationService.scheduleStockUpdate(registration.id);
         }
 
         const groups = await Group.getByIDs(...Array.from(updateGroups));

package/src/endpoints/global/payments/StripeWebhookEndpoint.ts

@@ -5,8 +5,9 @@ import { Organization, StripeAccount, StripeCheckoutSession, StripePaymentIntent
 import { isDebouncedError, QueueHandler } from '@stamhoofd/queues';
 
 import { StripeHelper } from '../../../helpers/StripeHelper';
-import { ExchangePaymentEndpoint } from '../../organization/shared/ExchangePaymentEndpoint';
 import { PaymentService } from '../../../services/PaymentService';
+import { AuditLog, AuditLogSource } from '@stamhoofd/structures';
+import { AuditLogService } from '../../../services/AuditLogService';
 
 type Params = Record<string, never>;
 class Body extends AutoEncoder {
@@ -85,8 +86,10 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
                     const id = account.id as string;
                     const [model] = await StripeAccount.where({ accountId: id }, { limit: 1 });
                     if (model) {
-                        model.setMetaFromStripeAccount(account);
-                        await model.save();
+                        await AuditLogService.setContext({ userId: null, source: AuditLogSource.System }, async () => {
+                            model.setMetaFromStripeAccount(account);
+                            await model.save();
+                        });
                     }
                     else {
                         console.warn('Could not find stripe account with id', id);

package/src/endpoints/global/platform/PatchPlatformEnpoint.ts

@@ -1,16 +1,15 @@
 import { AutoEncoderPatchType, Decoder, isPatchableArray, patchObject } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Organization, Platform, RegistrationPeriod, SetupStepUpdater } from '@stamhoofd/models';
-import { AuditLogType, MemberResponsibility, PlatformConfig, PlatformPremiseType, Platform as PlatformStruct } from '@stamhoofd/structures';
+import { MemberResponsibility, PlatformConfig, PlatformPremiseType, Platform as PlatformStruct } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
 import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
-import { MembershipHelper } from '../../../helpers/MembershipHelper';
 import { PeriodHelper } from '../../../helpers/PeriodHelper';
 import { TagHelper } from '../../../helpers/TagHelper';
-import { AuditLogService } from '../../../services/AuditLogService';
+import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -51,8 +50,6 @@ export class PatchPlatformEndpoint extends Endpoint<
         const platform = await Platform.getShared();
 
         if (request.body.privateConfig) {
-            const oldConfig = platform.privateConfig.clone();
-
             // Did we patch roles?
             if (request.body.privateConfig.roles) {
                 if (!Context.auth.canManagePlatformAdmins()) {
@@ -77,12 +74,6 @@ export class PatchPlatformEndpoint extends Endpoint<
                     request.body.privateConfig.emails,
                 );
             }
-
-            await AuditLogService.log({
-                type: AuditLogType.PlatformSettingsChanged,
-                oldConfig,
-                patch: request.body.privateConfig,
-            });
         }
 
         let shouldUpdateSetupSteps = false;
@@ -116,12 +107,6 @@ export class PatchPlatformEndpoint extends Endpoint<
                 else {
                     platform.config = patchObject(platform.config, newConfig);
                 }
-
-                await AuditLogService.log({
-                    type: AuditLogType.PlatformSettingsChanged,
-                    oldConfig,
-                    patch: newConfig,
-                });
             }
 
             if (newConfig.tags && isPatchableArray(newConfig.tags) && newConfig.tags.changes.length > 0) {
@@ -219,7 +204,7 @@ export class PatchPlatformEndpoint extends Endpoint<
             if (!QueueHandler.isRunning('update-membership-prices')) {
                 QueueHandler.schedule('update-membership-prices', async () => {
                     await MembershipCharger.updatePrices();
-                    await MembershipHelper.updateAll();
+                    await PlatformMembershipService.updateAll();
                 }).catch(console.error);
             }
         }

package/src/endpoints/global/registration/PatchUserMembersEndpoint.ts

@@ -69,11 +69,6 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
 
             await member.save();
             addedMembers.push(member);
-
-            await AuditLogService.log({
-                type: AuditLogType.MemberAdded,
-                member: member,
-            });
         }
 
         // Modify members
@@ -90,7 +85,6 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             }
             const securityCode = struct.details?.securityCode; // will get cleared after the filter
             struct = await Context.auth.filterMemberPatch(member, struct);
-            const originalDetails = member.details.clone();
 
             if (struct.details) {
                 if (struct.details.isPut()) {
@@ -129,15 +123,6 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             await member.save();
             await MemberUserSyncer.onChangeMember(member);
 
-            if (struct.details) {
-                await AuditLogService.log({
-                    type: AuditLogType.MemberEdited,
-                    member: member,
-                    oldMemberDetails: originalDetails,
-                    memberDetailsPatch: struct.details,
-                });
-            }
-
             // Update documents
             await Document.updateForMember(member.id);
         }

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -583,10 +583,13 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         let paymentUrl: string | null = null;
         let payment: Payment | null = null;
 
-        // Delaying markign as valid as late as possible so any errors will prevent creating valid balance items
+        // Delay marking as valid as late as possible so any errors will prevent creating valid balance items
+        // Keep a copy because createdBalanceItems will be altered - and we don't want to mark added items as valid
+        const markValidList = [...createdBalanceItems, ...unrelatedCreatedBalanceItems];
+
         async function markValidIfNeeded() {
             if (shouldMarkValid) {
-                for (const balanceItem of [...createdBalanceItems, ...unrelatedCreatedBalanceItems]) {
+                for (const balanceItem of markValidList) {
                     // Mark valid
                     await BalanceItemService.markPaid(balanceItem, payment, organization);
                 }

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

@@ -1,11 +1,12 @@
 import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder, patchObject } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { RegistrationPeriod as RegistrationPeriodStruct } from '@stamhoofd/structures';
+import { AuditLogType, RegistrationPeriod as RegistrationPeriodStruct } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { Context } from '../../../helpers/Context';
 import { PeriodHelper } from '../../../helpers/PeriodHelper';
+import { AuditLogService } from '../../../services/AuditLogService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -74,7 +75,6 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                     message: 'Registration period not found',
                 });
             }
-
             if (patch.startDate !== undefined) {
                 model.startDate = patch.startDate;
             }