@stamhoofd/backend 2.55.2 → 2.57.0

package/src/seeds/1732117645-move-rrn.ts

@@ -0,0 +1,77 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Member } from '@stamhoofd/models';
+import { MemberUserSyncer } from '../helpers/MemberUserSyncer';
+import { logger } from '@simonbackx/simple-logging';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    if (STAMHOOFD.userMode !== 'platform') {
+        console.log('skipped seed update-membership because usermode not platform');
+        return;
+    }
+
+    process.stdout.write('\n');
+    let c = 0;
+    let id: string = '';
+
+    await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
+        while (true) {
+            const rawMembers = await Member.where({
+                id: {
+                    value: id,
+                    sign: '>',
+                },
+            }, { limit: 500, sort: ['id'] });
+
+            if (rawMembers.length === 0) {
+                break;
+            }
+
+            const promises: Promise<any>[] = [];
+
+            for (const member of rawMembers) {
+                promises.push((async () => {
+                    const idR = '2b7d8f1c-ce67-4612-880b-fb1fb19affbb';
+                    const valR = member.details.recordAnswers.get(idR);
+
+                    const idRS = 'd381acce-9603-4246-af62-f3ea5292eec7';
+                    const valRS = member.details.recordAnswers.get(idRS);
+
+                    let save = false;
+
+                    if (valR && !member.details.nationalRegisterNumber) {
+                        member.details.nationalRegisterNumber = valR.stringValue;
+                        save = true;
+                    }
+
+                    if (valRS && member.details.parents.length > 0 && !member.details.parents.find(p => p.nationalRegisterNumber)) {
+                        member.details.parents[0].nationalRegisterNumber = valRS.stringValue;
+                        save = true;
+                    }
+
+                    if (save) {
+                        await member.save();
+                    }
+                    c++;
+
+                    if (c % 1000 === 0) {
+                        process.stdout.write('.');
+                    }
+                    if (c % 10000 === 0) {
+                        process.stdout.write('\n');
+                    }
+                })());
+            }
+
+            await Promise.all(promises);
+            id = rawMembers[rawMembers.length - 1].id;
+        }
+    });
+
+    // Do something here
+    return Promise.resolve();
+});

package/src/services/AuditLogService.ts

@@ -0,0 +1,232 @@
+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;
+};
+
+export type MemberEditedAuditOptions = {
+    type: AuditLogType.MemberEdited;
+    member: Member;
+    oldMemberDetails: MemberDetails;
+    memberDetailsPatch: AutoEncoderPatchType<MemberDetails>;
+};
+
+export type MemberRegisteredAuditOptions = {
+    type: AuditLogType.MemberRegistered | AuditLogType.MemberUnregistered;
+    member: Member;
+    group: Group;
+    registration: Registration;
+};
+
+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>;
+};
+
+export type GroupAuditOptions = {
+    type: AuditLogType.GroupAdded | AuditLogType.GroupEdited | AuditLogType.GroupDeleted;
+    group: Group;
+    oldData?: AutoEncoder;
+    patch?: AutoEncoder | AutoEncoderPatchType<AutoEncoder>;
+};
+
+export type AuditLogOptions = GroupAuditOptions | EventAuditOptions | MemberAddedAuditOptions | MemberEditedAuditOptions | MemberRegisteredAuditOptions | PlatformConfigChangeAuditOptions | OrganizationConfigChangeAuditOptions;
+
+export const AuditLogService = {
+    async log(options: AuditLogOptions) {
+        try {
+            const userId = Context.optionalAuth?.user?.id ?? null;
+            const organizationId = Context.organization?.id ?? null;
+
+            const model = new AuditLog();
+
+            model.type = options.type;
+            model.userId = userId;
+            model.organizationId = organizationId;
+
+            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);
+        }
+
+        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 (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;
+            }
+        }
+
+        model.replacements = new Map([
+            ['g', AuditLogReplacement.create({
+                id: options.group.id,
+                value: options.group.settings.name,
+                type: AuditLogReplacementType.Group,
+            })],
+        ]);
+    },
+};

package/src/services/BalanceItemPaymentService.ts

@@ -0,0 +1,45 @@
+import { ManyToOneRelation } from '@simonbackx/simple-database';
+import { BalanceItemPayment, Organization } from '@stamhoofd/models';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+import { BalanceItemService } from './BalanceItemService';
+
+type Loaded<T> = (T) extends ManyToOneRelation<infer Key, infer Model> ? Record<Key, Model> : never;
+
+export const BalanceItemPaymentService = {
+    async markPaid(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Update cached amountPaid of the balance item (balanceItemPayment will get overwritten later, but we need it to calculate the status)
+        balanceItemPayment.balanceItem.pricePaid += balanceItemPayment.price;
+
+        // Update status
+        const old = balanceItemPayment.balanceItem.status;
+        balanceItemPayment.balanceItem.updateStatus();
+        await balanceItemPayment.balanceItem.save();
+
+        // Do logic of balance item
+        if (balanceItemPayment.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid) {
+            // Only call markPaid once (if it wasn't (partially) paid before)
+            await BalanceItemService.markPaid(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+        }
+        else {
+            await BalanceItemService.markUpdated(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+        }
+    },
+
+    /**
+     * Call balanceItemPayment once a earlier succeeded payment is no longer succeeded
+     */
+    async undoPaid(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        await BalanceItemService.undoPaid(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+    },
+
+    async markFailed(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Do logic of balance item
+        await BalanceItemService.markFailed(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+    },
+
+    async undoFailed(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Reactivate deleted items
+        await BalanceItemService.undoFailed(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+    },
+
+};

package/src/services/BalanceItemService.ts

@@ -0,0 +1,88 @@
+import { BalanceItem, Order, Organization, Payment, Webshop } from '@stamhoofd/models';
+import { BalanceItemStatus, OrderStatus } from '@stamhoofd/structures';
+import { RegistrationService } from './RegistrationService';
+
+export const BalanceItemService = {
+    async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+        if (balanceItem.status === BalanceItemStatus.Hidden) {
+            await BalanceItem.reactivateItems([balanceItem]);
+        }
+
+        // status and pricePaid changes are handled inside balanceitempayment
+        if (balanceItem.dependingBalanceItemId) {
+            const depending = await BalanceItem.getByID(balanceItem.dependingBalanceItemId);
+            if (depending && depending.status === BalanceItemStatus.Hidden) {
+                await BalanceItem.reactivateItems([depending]);
+            }
+        }
+
+        // If registration
+        if (balanceItem.registrationId) {
+            await RegistrationService.markValid(balanceItem.registrationId);
+        }
+
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.markPaid(payment, organization);
+
+                // Save number in balance description
+                if (order.number !== null) {
+                    const webshop = await Webshop.getByID(order.webshopId);
+
+                    if (webshop) {
+                        balanceItem.description = order.generateBalanceDescription(webshop);
+                        await balanceItem.save();
+                    }
+                }
+            }
+        }
+    },
+
+    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);
+            }
+        }
+    },
+
+    async undoPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.undoPaid(payment, organization);
+            }
+        }
+    },
+
+    async markFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.onPaymentFailed(payment, organization);
+
+                if (order.status === OrderStatus.Deleted) {
+                    balanceItem.status = BalanceItemStatus.Hidden;
+                    await balanceItem.save();
+                }
+            }
+        }
+    },
+
+    async undoFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.undoPaymentFailed(payment, organization);
+            }
+        }
+    },
+
+};

package/src/services/GroupService.ts

@@ -0,0 +1,13 @@
+import { Group } from '@stamhoofd/models';
+
+export const GroupService = {
+    async updateOccupancy(groupId: string) {
+        const group = await Group.getByID(groupId);
+        if (group) {
+            // todo: implementation should move to the service
+            await group.updateOccupancy();
+            await group.save();
+        }
+        return group;
+    },
+};