@stamhoofd/backend 2.57.1 → 2.59.0

package/src/seeds/1726572303-schedule-stock-updates.ts

@@ -1,5 +1,6 @@
 import { Migration } from '@simonbackx/simple-database';
 import { Registration } from '@stamhoofd/models';
+import { RegistrationService } from '../services/RegistrationService';
 
 export default new Migration(async () => {
     if (STAMHOOFD.environment == 'test') {
@@ -27,7 +28,7 @@ export default new Migration(async () => {
         const registrations = await Registration.getByIDs(...rawRegistrations.map(g => g.id));
 
         for (const registration of registrations) {
-            registration.scheduleStockUpdate();
+            RegistrationService.scheduleStockUpdate(registration.id);
 
             c++;
 

package/src/services/AuditLogService.ts

@@ -1,232 +1,105 @@
-import { AutoEncoder, AutoEncoderPatchType } from '@simonbackx/simple-encoding';
-import { AuditLog, Group, Member, Organization, Registration, Event } from '@stamhoofd/models';
-import { AuditLogReplacement, AuditLogReplacementType, AuditLogType, GroupType, MemberDetails, OrganizationMetaData, OrganizationPrivateMetaData, PlatformConfig, PlatformPrivateConfig } from '@stamhoofd/structures';
-import { Context } from '../helpers/Context';
-import { explainPatch } from './explainPatch';
-
-export type MemberAddedAuditOptions = {
-    type: AuditLogType.MemberAdded;
-    member: Member;
+import { Model, ModelEvent } from '@simonbackx/simple-database';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { RegistrationLogger } from '../audit-logs/RegistrationLogger';
+import { GroupLogger } from '../audit-logs/GroupLogger';
+import { OrganizationLogger } from '../audit-logs/OrganizationLogger';
+import { PlatformLogger } from '../audit-logs/PlatformLogger';
+import { EventLogger } from '../audit-logs/EventLogger';
+import { RegistrationPeriodLogger } from '../audit-logs/RegistrationPeriodLogger';
+import { OrganizationRegistrationPeriodLogger } from '../audit-logs/OrganizationRegistrationPeriodLogger';
+import { StripeAccountLogger } from '../audit-logs/StripeAccountLogger';
+import { MemberLogger } from '../audit-logs/MemberLogger';
+import { WebshopLogger } from '../audit-logs/WebshopLogger';
+import { OrderLogger } from '../audit-logs/OrderLogger';
+import { AuditLogSource } from '@stamhoofd/structures';
+import { PaymentLogger } from '../audit-logs/PaymentLogger';
+import { MemberPlatformMembershipLogger } from '../audit-logs/MemberPlatformMembershipLogger';
+import { MemberResponsibilityRecordLogger } from '../audit-logs/MemberResponsibilityRecordLogger';
+
+export type AuditLogContextSettings = {
+    disable?: boolean;
+    source?: AuditLogSource;
+    userId?: string | null;
+
+    // If no userId is known, fallback to this userId
+    // this is useful e.g. for side effects of webhooks where the webhook calls but we don't have the userid in the request, still the action is tied to a user
+    fallbackUserId?: string | null;
+    fallbackOrganizationId?: string | null;
 };
 
-export type MemberEditedAuditOptions = {
-    type: AuditLogType.MemberEdited;
-    member: Member;
-    oldMemberDetails: MemberDetails;
-    memberDetailsPatch: AutoEncoderPatchType<MemberDetails>;
-};
+export class AuditLogService {
+    private constructor() { }
+    static disableLocalStore = new AsyncLocalStorage<AuditLogContextSettings>();
 
-export type MemberRegisteredAuditOptions = {
-    type: AuditLogType.MemberRegistered | AuditLogType.MemberUnregistered;
-    member: Member;
-    group: Group;
-    registration: Registration;
-};
+    static disable<T>(run: () => T): T {
+        return this.setContext({ disable: true }, run);
+    }
 
-export type PlatformConfigChangeAuditOptions = {
-    type: AuditLogType.PlatformSettingsChanged;
-} & ({
-    oldConfig: PlatformPrivateConfig;
-    patch: PlatformPrivateConfig | AutoEncoderPatchType<PlatformPrivateConfig>;
-} | {
-    oldConfig: PlatformConfig;
-    patch: PlatformConfig | AutoEncoderPatchType<PlatformConfig>;
-});
-
-export type OrganizationConfigChangeAuditOptions = {
-    type: AuditLogType.OrganizationSettingsChanged;
-    organization: Organization;
-} & ({
-    oldMeta: OrganizationMetaData;
-    patch: OrganizationMetaData | AutoEncoderPatchType<OrganizationMetaData>;
-} | {
-    oldMeta: OrganizationPrivateMetaData;
-    patch: OrganizationPrivateMetaData | AutoEncoderPatchType<OrganizationPrivateMetaData>;
-});
-
-export type EventAuditOptions = {
-    type: AuditLogType.EventAdded | AuditLogType.EventEdited | AuditLogType.EventDeleted;
-    event: Event;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
+    static setContext<T>(context: AuditLogContextSettings, run: () => T): T {
+        const currentContext = this.getContext() ?? {};
+        return this.disableLocalStore.run({ ...currentContext, ...context }, () => {
+            return run();
+        });
+    }
 
-export type GroupAuditOptions = {
-    type: AuditLogType.GroupAdded | AuditLogType.GroupEdited | AuditLogType.GroupDeleted;
-    group: Group;
-    oldData?: AutoEncoder;
-    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
-};
+    static isDisabled(): boolean {
+        const c = this.getContext();
 
-export type AuditLogOptions = GroupAuditOptions | EventAuditOptions | MemberAddedAuditOptions | MemberEditedAuditOptions | MemberRegisteredAuditOptions | PlatformConfigChangeAuditOptions | OrganizationConfigChangeAuditOptions;
+        if (c && c.disable === true) {
+            return true;
+        }
 
-export const AuditLogService = {
-    async log(options: AuditLogOptions) {
-        try {
-            const userId = Context.optionalAuth?.user?.id ?? null;
-            const organizationId = Context.organization?.id ?? null;
+        return false;
+    }
 
-            const model = new AuditLog();
+    static getContext(): AuditLogContextSettings | null {
+        const c = this.disableLocalStore.getStore();
+        return c ?? null;
+    }
 
-            model.type = options.type;
-            model.userId = userId;
-            model.organizationId = organizationId;
+    static listening = false;
 
-            if (options.type === AuditLogType.MemberRegistered) {
-                this.fillForMemberRegistered(model, options);
-            }
-            else if (options.type === AuditLogType.MemberUnregistered) {
-                this.fillForMemberRegistered(model, options);
-            }
-            else if (options.type === AuditLogType.MemberEdited) {
-                this.fillForMemberEdited(model, options);
-            }
-            else if (options.type === AuditLogType.MemberAdded) {
-                this.fillForMemberAdded(model, options);
-            }
-            else if (options.type === AuditLogType.PlatformSettingsChanged) {
-                this.fillForPlatformConfig(model, options);
-            }
-            else if (options.type === AuditLogType.OrganizationSettingsChanged) {
-                this.fillForOrganizationConfig(model, options);
-            }
-            else if (options.type === AuditLogType.EventAdded || options.type === AuditLogType.EventEdited || options.type === AuditLogType.EventDeleted) {
-                this.fillForEvent(model, options);
-            }
-            else if (options.type === AuditLogType.GroupAdded || options.type === AuditLogType.GroupEdited || options.type === AuditLogType.GroupDeleted) {
-                this.fillForGroup(model, options);
-            }
-
-            // In the future we might group these saves together in one query to improve performance
-            await model.save();
-
-            console.log('Audit log', model.id, options);
-        }
-        catch (e) {
-            console.error('Failed to save log', options, e);
-        }
-    },
-
-    fillForMemberRegistered(model: AuditLog, options: MemberRegisteredAuditOptions) {
-        model.objectId = options.member.id;
-        model.replacements = new Map([
-            ['m', AuditLogReplacement.create({
-                id: options.member.id,
-                value: options.member.details.name,
-                type: AuditLogReplacementType.Member,
-            })],
-            ['g', AuditLogReplacement.create({
-                id: options.group.id,
-                value: options.group.settings.name,
-                type: AuditLogReplacementType.Group,
-            })],
-        ]);
-
-        const registrationStructure = options.registration.setRelation(Registration.group, options.group).getStructure();
-        if (registrationStructure.description) {
-            model.description = registrationStructure.description;
-        }
-    },
-
-    fillForMemberEdited(model: AuditLog, options: MemberEditedAuditOptions) {
-        model.objectId = options.member.id;
-
-        model.replacements = new Map([
-            ['m', AuditLogReplacement.create({
-                id: options.member.id,
-                value: options.member.details.name,
-                type: AuditLogReplacementType.Member,
-            })],
-        ]);
-
-        // Generate changes list
-        model.patchList = explainPatch(options.oldMemberDetails, options.memberDetailsPatch);
-    },
-
-    fillForMemberAdded(model: AuditLog, options: MemberAddedAuditOptions) {
-        model.objectId = options.member.id;
-
-        model.replacements = new Map([
-            ['m', AuditLogReplacement.create({
-                id: options.member.id,
-                value: options.member.details.name,
-                type: AuditLogReplacementType.Member,
-            })],
-        ]);
-
-        // Generate changes list
-        model.patchList = explainPatch(null, options.member.details);
-    },
-
-    fillForPlatformConfig(model: AuditLog, options: PlatformConfigChangeAuditOptions) {
-        model.objectId = null;
-
-        // Generate changes list
-        model.patchList = explainPatch(options.oldConfig, options.patch);
-    },
-
-    fillForOrganizationConfig(model: AuditLog, options: OrganizationConfigChangeAuditOptions) {
-        model.objectId = options.organization.id;
-        model.organizationId = options.organization.id;
-
-        model.replacements = new Map([
-            ['o', AuditLogReplacement.create({
-                id: options.organization.id,
-                value: options.organization.name,
-                type: AuditLogReplacementType.Organization,
-            })],
-        ]);
-
-        // Generate changes list
-        model.patchList = explainPatch(options.oldMeta, options.patch);
-    },
-
-    fillForEvent(model: AuditLog, options: EventAuditOptions) {
-        model.objectId = options.event.id;
-
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
+    static listen() {
+        if (this.listening) {
+            return;
         }
+        this.listening = true;
+        Model.modelEventBus.addListener(this, async (event) => {
+            const modelType = event.model.static as typeof Model;
+            const definition = modelLogDefinitions.get(modelType);
 
-        model.replacements = new Map([
-            ['e', AuditLogReplacement.create({
-                id: options.event.id,
-                value: options.event.name,
-                type: AuditLogReplacementType.Event,
-            })],
-        ]);
-    },
-
-    fillForGroup(model: AuditLog, options: GroupAuditOptions) {
-        model.objectId = options.group.id;
-
-        if (options.patch) {
-            // Generate changes list
-            model.patchList = explainPatch(options.oldData ?? null, options.patch);
-        }
+            if (!definition) {
+                return;
+            }
+
+            console.log('Model event', {
+                ...event,
+                model: event.model.static.name,
+            });
 
-        if (options.group.type === GroupType.WaitingList) {
-            // Change event type
-            switch (options.type) {
-                case AuditLogType.GroupAdded:
-                    model.type = AuditLogType.WaitingListAdded;
-                    break;
-                case AuditLogType.GroupEdited:
-                    model.type = AuditLogType.WaitingListEdited;
-                    break;
-                case AuditLogType.GroupDeleted:
-                    model.type = AuditLogType.WaitingListDeleted;
-                    break;
+            if (this.isDisabled()) {
+                console.log('Audit log disabled');
+                return;
             }
-        }
 
-        model.replacements = new Map([
-            ['g', AuditLogReplacement.create({
-                id: options.group.id,
-                value: options.group.settings.name,
-                type: AuditLogReplacementType.Group,
-            })],
-        ]);
-    },
+            await definition.logEvent(event);
+        });
+    }
 };
+
+const modelLogDefinitions = new Map<typeof Model, { logEvent: (event: ModelEvent) => Promise<any> }>();
+
+modelLogDefinitions.set(RegistrationLogger.model, RegistrationLogger);
+modelLogDefinitions.set(GroupLogger.model, GroupLogger);
+modelLogDefinitions.set(OrganizationLogger.model, OrganizationLogger);
+modelLogDefinitions.set(PlatformLogger.model, PlatformLogger);
+modelLogDefinitions.set(EventLogger.model, EventLogger);
+modelLogDefinitions.set(RegistrationPeriodLogger.model, RegistrationPeriodLogger);
+modelLogDefinitions.set(OrganizationRegistrationPeriodLogger.model, OrganizationRegistrationPeriodLogger);
+modelLogDefinitions.set(StripeAccountLogger.model, StripeAccountLogger);
+modelLogDefinitions.set(MemberLogger.model, MemberLogger);
+modelLogDefinitions.set(WebshopLogger.model, WebshopLogger);
+modelLogDefinitions.set(OrderLogger.model, OrderLogger);
+modelLogDefinitions.set(PaymentLogger.model, PaymentLogger);
+modelLogDefinitions.set(MemberPlatformMembershipLogger.model, MemberPlatformMembershipLogger);
+modelLogDefinitions.set(MemberResponsibilityRecordLogger.model, MemberResponsibilityRecordLogger);

package/src/services/BalanceItemPaymentService.ts

@@ -16,7 +16,7 @@ export const BalanceItemPaymentService = {
         await balanceItemPayment.balanceItem.save();
 
         // Do logic of balance item
-        if (balanceItemPayment.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid) {
+        if (balanceItemPayment.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid && balanceItemPayment.price >= 0) {
             // Only call markPaid once (if it wasn't (partially) paid before)
             await BalanceItemService.markPaid(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
         }

package/src/services/BalanceItemService.ts

@@ -1,6 +1,7 @@
 import { BalanceItem, Order, Organization, Payment, Webshop } from '@stamhoofd/models';
-import { BalanceItemStatus, OrderStatus } from '@stamhoofd/structures';
+import { AuditLogSource, BalanceItemStatus, OrderStatus } from '@stamhoofd/structures';
 import { RegistrationService } from './RegistrationService';
+import { AuditLogService } from './AuditLogService';
 
 export const BalanceItemService = {
     async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
@@ -16,6 +17,10 @@ export const BalanceItemService = {
             }
         }
 
+        // It is possible this balance item was earlier paid
+        // and later the regigstration / order has been canceled and it became a negative balance item - which as some point has been reembursed and marked as 'paid'
+        // in that case, we should be careful not to mark the registration as valid again
+
         // If registration
         if (balanceItem.registrationId) {
             await RegistrationService.markValid(balanceItem.registrationId);
@@ -43,10 +48,14 @@ export const BalanceItemService = {
     async markUpdated(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
         // For orders: mark order as changed (so they are refetched in front ends)
         if (balanceItem.orderId) {
-            const order = await Order.getByID(balanceItem.orderId);
-            if (order) {
-                await order.paymentChanged(payment, organization);
-            }
+            await AuditLogService.setContext({ source: AuditLogSource.Payment }, async () => {
+                if (balanceItem.orderId) {
+                    const order = await Order.getByID(balanceItem.orderId);
+                    if (order) {
+                        await order.paymentChanged(payment, organization);
+                    }
+                }
+            });
         }
     },
 

package/src/services/MemberNumberService.ts

@@ -0,0 +1,120 @@
+import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
+import { Member, MemberPlatformMembership, Organization } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { SQL, SQLWhereLike, scalarToSQLExpression } from '@stamhoofd/sql';
+
+export class MemberNumberService {
+    static async assignMemberNumber(member: Member, membership: MemberPlatformMembership) {
+        if (member.details?.memberNumber) {
+            console.log('Member already has member number, should not happen');
+            return;
+        }
+
+        return await QueueHandler.schedule('assignMemberNumber', async function (this: undefined) {
+            try {
+                const memberNumber = await MemberNumberService.createMemberNumber(member, membership);
+                member.details.memberNumber = memberNumber;
+                await member.save();
+            }
+            catch (error) {
+                if (isSimpleError(error) || isSimpleErrors(error)) {
+                    throw error;
+                }
+                else {
+                    console.error(error);
+                    throw new SimpleError({
+                        code: 'assign_member_number',
+                        message: error.message,
+                        human: 'Er is iets misgegaan bij het aanmaken van het lidnummer.',
+                    });
+                }
+            }
+        });
+    }
+
+    static async createMemberNumber(member: Member, membership: MemberPlatformMembership): Promise<string> {
+        // example: 5301-101012-1
+
+        // #region get birth date part (ddmmjj)
+        const birthDay = member.details?.birthDay;
+        if (!birthDay) {
+            throw new SimpleError({
+                code: 'assign_member_number',
+                message: 'Missing birthDay',
+                human: 'Er kon geen lidnummer aangemaakt worden omdat er geen geboortedatum is ingesteld.',
+            });
+        }
+
+        const dayPart = birthDay.getDate().toString().padStart(2, '0');
+        const monthPart = (birthDay.getMonth() + 1).toString().padStart(2, '0');
+        const yearPart = birthDay.getFullYear().toString().slice(2, 4);
+        const birthDatePart = `${dayPart}${monthPart}${yearPart}`;
+        // #endregion
+
+        // #region get group number
+        const organizationId = membership.organizationId;
+        const organization = await Organization.getByID(organizationId);
+        if (!organization) {
+            throw new Error(`Organization with id ${organizationId} not found`);
+        }
+        const groupNumber = organization.uri;
+        // #endregion
+
+        // #region get follow up number
+        const firstPart = `${groupNumber}-${birthDatePart}-`;
+
+        const query = SQL.select()
+            .from(SQL.table('members'))
+            .where(
+                new SQLWhereLike(
+                    SQL.column('members', 'memberNumber'),
+                    scalarToSQLExpression(`${SQLWhereLike.escape(firstPart)}%`),
+                ),
+            );
+
+        const count = await query.count();
+        console.log(`Found ${count} members with a memberNumber starting with ${firstPart}`);
+
+        let followUpNumber = count;
+        // #endregion
+
+        // #region check if memberNumber is unique
+        let doesExist = true;
+        let memberNumber: string = '';
+        let tries = 0;
+
+        while (doesExist) {
+            followUpNumber++;
+            memberNumber = firstPart + followUpNumber;
+
+            const result = await SQL.select()
+                .from(SQL.table('members'))
+                .where(
+                    SQL.column('members', 'memberNumber'),
+                    scalarToSQLExpression(memberNumber),
+                )
+                .first(false);
+
+            console.log(`Is ${memberNumber} unique? ${result === null}`);
+
+            if (result !== null) {
+                tries++;
+                if (tries > 9) {
+                    throw new SimpleError({
+                        code: 'assign_member_number',
+                        message: `Duplicate member numbers (last try: ${memberNumber}, tries: ${tries})`,
+                        human: 'Er kon geen uniek lidnummer aangemaakt worden. Mogelijks zijn er teveel leden met dezelfde geboortedatum. Neem contact op met de vereniging.',
+                    });
+                }
+            }
+            else {
+                doesExist = false;
+            }
+        }
+        // #endregion
+
+        console.log(`Created member number: ${memberNumber}`);
+
+        return memberNumber;
+    }
+}