@stamhoofd/backend 2.58.0 → 2.60.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/updateSetupSteps.ts

@@ -1,4 +1,4 @@
-import { SetupStepUpdater } from '@stamhoofd/models';
+import { SetupStepUpdater } from '../helpers/SetupStepUpdater.js';
 
 export async function updateSetupSteps() {
     if (STAMHOOFD.userMode !== 'platform') {

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

@@ -2,8 +2,8 @@ import { OneToManyRelation } from '@simonbackx/simple-database';
 import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, mergeTwoMembers, Organization, Platform, RateLimiter, Registration, SetupStepUpdater, User } from '@stamhoofd/models';
-import { AuditLogType, GroupType, MembersBlob, MemberWithRegistrationsBlob, PermissionLevel } from '@stamhoofd/structures';
+import { BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, mergeTwoMembers, Organization, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
+import { GroupType, MembersBlob, MemberWithRegistrationsBlob, PermissionLevel } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { Email } from '@stamhoofd/email';
@@ -13,7 +13,9 @@ import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructure
 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';
+import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 
 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,10 +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';
-import { AuditLogType } from '@stamhoofd/structures';
 
 type Params = Record<string, never>;
 class Body extends AutoEncoder {
@@ -87,17 +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) {
-                        const beforeMeta = model.meta.clone();
-                        model.setMetaFromStripeAccount(account);
-                        if (await model.save()) {
-                            // Track audit log
-                            await AuditLogService.log({
-                                type: AuditLogType.StripeAccountEdited,
-                                stripeAccount: model,
-                                oldData: beforeMeta,
-                                patch: model.meta,
-                            });
-                        }
+                        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,16 @@
 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 { Organization, Platform, RegistrationPeriod } from '@stamhoofd/models';
+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';
+import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -49,7 +49,6 @@ export class PatchPlatformEndpoint extends Endpoint<
         }
 
         const platform = await Platform.getShared();
-        const initialStruct = (await Platform.getSharedPrivateStruct()).clone();
 
         if (request.body.privateConfig) {
             // Did we patch roles?
@@ -206,7 +205,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);
             }
         }
@@ -223,12 +222,6 @@ export class PatchPlatformEndpoint extends Endpoint<
             SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod().catch(console.error);
         }
 
-        await AuditLogService.log({
-            type: AuditLogType.PlatformSettingsChanged,
-            oldData: initialStruct,
-            patch: request.body,
-        });
-
         return new Response(await Platform.getSharedPrivateStruct());
     }
 

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