@stamhoofd/backend 2.59.0 → 2.60.0

package/src/helpers/SetupStepUpdater.ts

@@ -0,0 +1,503 @@
+import { Model } from '@simonbackx/simple-database';
+import { SimpleError } from '@simonbackx/simple-errors';
+import {
+    Group,
+    Member,
+    MemberResponsibilityRecord,
+    Organization,
+    OrganizationRegistrationPeriod,
+    Platform,
+} from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { SQL, SQLWhereSign } from '@stamhoofd/sql';
+import {
+    AuditLogSource,
+    GroupType,
+    MemberResponsibility,
+    Platform as PlatformStruct,
+    SetupStepType,
+    SetupSteps,
+} from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { AuditLogService } from '../services/AuditLogService';
+
+type SetupStepOperation = (setupSteps: SetupSteps, organization: Organization, platform: PlatformStruct) => void | Promise<void>;
+
+/**
+ * Helper function to detect whether we should update the setup steps if a group is changed
+ */
+async function getGroupMemberCompletion(group: Group) {
+    const defaultAgeGroupId = group.defaultAgeGroupId;
+
+    if (!defaultAgeGroupId) {
+        // Not included = no step
+        return null;
+    }
+
+    if (group.deletedAt) {
+        // Not included = no step
+        return null;
+    }
+
+    const platform = await Platform.getSharedStruct();
+
+    if (group.periodId !== platform.period.id) {
+        // Not included = no step
+        return null;
+    }
+
+    const defaultAgeGroup = platform.config.defaultAgeGroups.find(g => g.id === defaultAgeGroupId);
+
+    if (!defaultAgeGroup) {
+        // Not included = no step
+        return null;
+    }
+
+    const required = defaultAgeGroup.minimumRequiredMembers;
+    if (required === 0) {
+        // Not included = no step
+        return null;
+    }
+
+    return Math.min(required, group.settings.registeredMembers ?? 0);
+}
+
+export class SetupStepUpdater {
+    static isListening = false;
+
+    static listen() {
+        if (this.isListening) {
+            return;
+        }
+        this.isListening = true;
+        Model.modelEventBus.addListener({}, async (event) => {
+            if (!(event.model instanceof Group)) {
+                return;
+            }
+
+            const before = (event.type === 'updated' ? await getGroupMemberCompletion(event.getOldModel() as Group) : (event.type === 'deleted' ? await getGroupMemberCompletion(event.model) : null));
+            const after = (event.type === 'updated' ? await getGroupMemberCompletion(event.model) : (event.type === 'created' ? await getGroupMemberCompletion(event.model) : null));
+
+            if (before !== after) {
+                console.log('Updating setups steps for organization', event.model.organizationId, 'because of change in members in group', event.model.id, 'from', before, 'to', after, '(limited)');
+                // We need to do a recalculation
+                SetupStepUpdater.updateForOrganizationId(event.model.organizationId)
+                    .catch(console.error);
+            }
+        });
+    }
+
+    private static readonly STEP_TYPE_OPERATIONS: Record<
+        SetupStepType,
+        SetupStepOperation
+    > = {
+            [SetupStepType.Responsibilities]: this.updateStepResponsibilities,
+            [SetupStepType.Companies]: this.updateStepCompanies,
+            [SetupStepType.Groups]: this.updateStepGroups,
+            [SetupStepType.Premises]: this.updateStepPremises,
+            [SetupStepType.Emails]: this.updateStepEmails,
+            [SetupStepType.Payment]: this.updateStepPayment,
+            [SetupStepType.Registrations]: this.updateStepRegistrations,
+        };
+
+    static async updateSetupStepsForAllOrganizationsInCurrentPeriod({
+        batchSize,
+    }: { batchSize?: number } = {}) {
+        const tag = 'updateSetupStepsForAllOrganizationsInCurrentPeriod';
+        QueueHandler.cancel(tag);
+
+        await QueueHandler.schedule(tag, async () => {
+            const platform = (await Platform.getSharedPrivateStruct()).clone();
+
+            const periodId = platform.period.id;
+
+            let lastId = '';
+
+            while (true) {
+                const organizationRegistrationPeriods
+                    = await OrganizationRegistrationPeriod.where(
+                        {
+                            id: { sign: '>', value: lastId },
+                            periodId: periodId,
+                        },
+                        { limit: batchSize ?? 10, sort: ['id'] },
+                    );
+
+                if (organizationRegistrationPeriods.length === 0) {
+                    lastId = '';
+                    break;
+                }
+
+                const organizationPeriodMap = new Map(
+                    organizationRegistrationPeriods.map((period) => {
+                        return [period.organizationId, period];
+                    }),
+                );
+
+                const organizations = await Organization.getByIDs(
+                    ...organizationPeriodMap.keys(),
+                );
+
+                for (const organization of organizations) {
+                    const organizationId = organization.id;
+                    const organizationRegistrationPeriod
+                        = organizationPeriodMap.get(organizationId);
+
+                    if (!organizationRegistrationPeriod) {
+                        console.error(
+                            `[FLAG-MOMENT] organizationRegistrationPeriod not found for organization with id ${organizationId}`,
+                        );
+                        continue;
+                    }
+
+                    console.log(
+                        '[FLAG-MOMENT] checking flag moments for '
+                        + organizationId,
+                    );
+
+                    await SetupStepUpdater.updateFor(
+                        organizationRegistrationPeriod,
+                        platform,
+                        organization,
+                    );
+                }
+
+                lastId
+                    = organizationRegistrationPeriods[
+                        organizationRegistrationPeriods.length - 1
+                    ].id;
+            }
+        });
+    }
+
+    static async updateForOrganizationId(id: string) {
+        const organization = await Organization.getByID(id);
+        if (!organization) {
+            throw new SimpleError({
+                code: 'not_found',
+                message: 'Organization not found',
+                human: 'De organisatie werd niet gevonden',
+            });
+        }
+
+        await this.updateForOrganization(organization);
+    }
+
+    static async updateForOrganization(
+        organization: Organization,
+        {
+            platform,
+            organizationRegistrationPeriod,
+        }: {
+            platform?: PlatformStruct;
+            organizationRegistrationPeriod?: OrganizationRegistrationPeriod;
+        } = {},
+    ) {
+        if (!platform) {
+            platform = await Platform.getSharedPrivateStruct();
+            if (!platform) {
+                console.error('No platform not found');
+                return;
+            }
+        }
+
+        if (!organizationRegistrationPeriod) {
+            const periodId = platform.period.id;
+            organizationRegistrationPeriod = (
+                await OrganizationRegistrationPeriod.where({
+                    organizationId: organization.id,
+                    periodId: periodId,
+                })
+            )[0];
+
+            if (!organizationRegistrationPeriod) {
+                console.error(
+                    `OrganizationRegistrationPeriod with organizationId ${organization.id} and periodId ${periodId} not found`,
+                );
+                return;
+            }
+        }
+
+        await this.updateFor(
+            organizationRegistrationPeriod,
+            platform,
+            organization,
+        );
+    }
+
+    private static async updateFor(
+        organizationRegistrationPeriod: OrganizationRegistrationPeriod,
+        platform: PlatformStruct,
+        organization: Organization,
+    ) {
+        console.log('Updating setup steps for organization', organization.id);
+        const setupSteps = organizationRegistrationPeriod.setupSteps;
+
+        await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+            for (const stepType of Object.values(SetupStepType)) {
+                const operation = this.STEP_TYPE_OPERATIONS[stepType];
+                await operation(setupSteps, organization, platform);
+            }
+
+            await organizationRegistrationPeriod.save();
+        });
+    }
+
+    private static updateStepPremises(
+        setupSteps: SetupSteps,
+        organization: Organization,
+        platform: PlatformStruct,
+    ) {
+        let totalSteps = 0;
+        let finishedSteps = 0;
+
+        const premiseTypes = platform.config.premiseTypes;
+
+        for (const premiseType of premiseTypes) {
+            const { min, max } = premiseType;
+
+            // only add step if premise type has restrictions
+            if (min === null && max === null) {
+                continue;
+            }
+
+            totalSteps++;
+
+            const premiseTypeId = premiseType.id;
+            let totalPremisesOfThisType = 0;
+
+            for (const premise of organization.privateMeta.premises) {
+                if (premise.premiseTypeIds.includes(premiseTypeId)) {
+                    totalPremisesOfThisType++;
+                }
+            }
+
+            if (max !== null && totalPremisesOfThisType > max) {
+                continue;
+            }
+
+            if (min !== null && totalPremisesOfThisType < min) {
+                continue;
+            }
+
+            finishedSteps++;
+        }
+
+        setupSteps.update(SetupStepType.Premises, {
+            totalSteps,
+            finishedSteps,
+        });
+    }
+
+    private static updateStepGroups(
+        setupSteps: SetupSteps,
+        _organization: Organization,
+        _platform: PlatformStruct,
+    ) {
+        setupSteps.update(SetupStepType.Groups, {
+            totalSteps: 0,
+            finishedSteps: 0,
+        });
+    }
+
+    private static updateStepCompanies(
+        setupSteps: SetupSteps,
+        organization: Organization,
+        _platform: PlatformStruct,
+    ) {
+        const totalSteps = 1;
+        let finishedSteps = 0;
+
+        if (organization.meta.companies.length) {
+            finishedSteps = 1;
+        }
+
+        setupSteps.update(SetupStepType.Companies, {
+            totalSteps,
+            finishedSteps,
+        });
+    }
+
+    private static async updateStepResponsibilities(
+        setupSteps: SetupSteps,
+        organization: Organization,
+        platform: PlatformStruct,
+    ) {
+        const now = new Date();
+        const organizationBasedResponsibilitiesWithRestriction = platform.config.responsibilities
+            .filter(r => r.organizationBased && (r.minimumMembers || r.maximumMembers));
+
+        const responsibilityIds = organizationBasedResponsibilitiesWithRestriction.map(r => r.id);
+
+        const allRecords = responsibilityIds.length === 0
+            ? []
+            : await MemberResponsibilityRecord.select()
+                .where('responsibilityId', responsibilityIds)
+                .where('organizationId', organization.id)
+                .where(SQL.where('endDate', SQLWhereSign.Greater, now).or('endDate', null))
+                .fetch();
+
+        // Remove invalid responsibilities: members that are not registered in the current period
+        const memberIds = Formatter.uniqueArray(allRecords.map(r => r.memberId));
+        const members = await Member.getBlobByIds(...memberIds);
+        const validMembers = members.filter(m => m.registrations.some(r => r.organizationId === organization.id && r.periodId === organization.periodId && r.group.type === GroupType.Membership && r.deactivatedAt === null && r.registeredAt !== null));
+
+        const validMembersIds = validMembers.map(m => m.id);
+
+        const records = allRecords.filter(r => validMembersIds.includes(r.memberId));
+
+        let totalSteps = 0;
+        let finishedSteps = 0;
+
+        const groups = await Group.getAll(organization.id, organization.periodId);
+
+        const flatResponsibilities: { responsibility: MemberResponsibility; group: Group | null }[] = organizationBasedResponsibilitiesWithRestriction
+            .flatMap((responsibility) => {
+                const defaultAgeGroupIds = responsibility.defaultAgeGroupIds;
+                if (defaultAgeGroupIds === null) {
+                    const item: { responsibility: MemberResponsibility; group: Group | null } = {
+                        responsibility,
+                        group: null,
+                    };
+                    return [item];
+                }
+
+                return groups
+                    .filter(g => g.defaultAgeGroupId !== null && defaultAgeGroupIds.includes(g.defaultAgeGroupId))
+                    .map((group) => {
+                        return {
+                            responsibility,
+                            group,
+                        };
+                    });
+            });
+
+        for (const { responsibility, group } of flatResponsibilities) {
+            const { minimumMembers: min, maximumMembers: max } = responsibility;
+
+            if (min === null) {
+                continue;
+            }
+
+            totalSteps += min;
+
+            const responsibilityId = responsibility.id;
+            let totalRecordsWithThisResponsibility = 0;
+
+            if (group === null) {
+                for (const record of records) {
+                    if (record.responsibilityId === responsibilityId) {
+                        totalRecordsWithThisResponsibility++;
+                    }
+                }
+            }
+            else {
+                for (const record of records) {
+                    if (record.responsibilityId === responsibilityId && record.groupId === group.id) {
+                        totalRecordsWithThisResponsibility++;
+                    }
+                }
+            }
+
+            if (max !== null && totalRecordsWithThisResponsibility > max) {
+                // Not added
+                continue;
+            }
+
+            finishedSteps += Math.min(min, totalRecordsWithThisResponsibility);
+        }
+
+        setupSteps.update(SetupStepType.Responsibilities, {
+            totalSteps,
+            finishedSteps,
+        });
+    }
+
+    private static updateStepEmails(setupSteps: SetupSteps,
+        organization: Organization,
+        _platform: PlatformStruct) {
+        const totalSteps = 1;
+        let finishedSteps = 0;
+
+        const emails = organization.privateMeta.emails;
+
+        // organization should have 1 default email
+        if (emails.some(e => e.default)) {
+            finishedSteps = 1;
+        }
+
+        setupSteps.update(SetupStepType.Emails, {
+            totalSteps,
+            finishedSteps,
+        });
+
+        if (finishedSteps >= totalSteps) {
+            setupSteps.markReviewed(SetupStepType.Emails, { userId: 'backend', userName: 'backend' });
+        }
+        else {
+            setupSteps.resetReviewed(SetupStepType.Emails);
+        }
+    }
+
+    private static updateStepPayment(setupSteps: SetupSteps,
+        _organization: Organization,
+        _platform: PlatformStruct) {
+        setupSteps.update(SetupStepType.Payment, {
+            totalSteps: 0,
+            finishedSteps: 0,
+        });
+    }
+
+    private static async updateStepRegistrations(setupSteps: SetupSteps,
+        organization: Organization,
+        platform: PlatformStruct) {
+        const defaultAgeGroupIds = platform.config.defaultAgeGroups.filter(g => g.minimumRequiredMembers > 0).map(x => x.id);
+
+        const groupsWithDefaultAgeGroups = defaultAgeGroupIds.length > 0
+            ? await Group.select()
+                .where('organizationId', organization.id)
+                .where('periodId', platform.period.id)
+                .where('defaultAgeGroupId', defaultAgeGroupIds)
+                .where('deletedAt', null)
+                .fetch()
+            : [];
+
+        let totalSteps = 0;
+
+        // Count per default age group, (e.g. minmium 10 means the total across all members with the same age group id should be 10, not 10 each)
+        const processedDefaultAgeGroupIds: Map<string, number> = new Map();
+
+        for (const group of groupsWithDefaultAgeGroups) {
+            const defaultAgeGroup = platform.config.defaultAgeGroups.find(g => g.id === group.defaultAgeGroupId);
+            if (!defaultAgeGroup) {
+                continue;
+            }
+            if (!processedDefaultAgeGroupIds.has(defaultAgeGroup.id)) {
+                totalSteps += defaultAgeGroup.minimumRequiredMembers;
+                processedDefaultAgeGroupIds.set(defaultAgeGroup.id, Math.min(defaultAgeGroup.minimumRequiredMembers, group.settings.registeredMembers ?? 0));
+            }
+            else {
+                processedDefaultAgeGroupIds.set(defaultAgeGroup.id,
+                    Math.min(
+                        defaultAgeGroup.minimumRequiredMembers,
+                        processedDefaultAgeGroupIds.get(defaultAgeGroup.id)! + (group.settings.registeredMembers ?? 0),
+                    ),
+                );
+            }
+        }
+
+        const finishedSteps = Array.from(processedDefaultAgeGroupIds.values()).reduce((a, b) => a + b, 0);
+
+        setupSteps.update(SetupStepType.Registrations, {
+            totalSteps,
+            finishedSteps,
+        });
+
+        if (finishedSteps >= totalSteps) {
+            setupSteps.markReviewed(SetupStepType.Registrations, { userId: 'backend', userName: 'backend' });
+        }
+        else {
+            setupSteps.resetReviewed(SetupStepType.Registrations);
+        }
+    }
+}

package/src/seeds/1726847064-setup-steps.ts

@@ -1,5 +1,5 @@
 import { Migration } from '@simonbackx/simple-database';
-import { SetupStepUpdater } from '@stamhoofd/models';
+import { SetupStepUpdater } from '../helpers/SetupStepUpdater';
 
 export default new Migration(async () => {
     if (STAMHOOFD.environment == 'test') {

package/src/seeds/1733319079-fill-paying-organization-ids.ts

@@ -0,0 +1,68 @@
+import { Migration } from '@simonbackx/simple-database';
+import { logger } from '@simonbackx/simple-logging';
+import { BalanceItem, Registration } from '@stamhoofd/models';
+import { Formatter } from '@stamhoofd/utility';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    process.stdout.write('\n');
+    let c = 0;
+    let id: string = '';
+
+    await logger.setContext({ tags: ['seed'] }, async () => {
+        while (true) {
+            const items = await BalanceItem.where({
+                id: {
+                    value: id,
+                    sign: '>',
+                },
+                registrationId: {
+                    value: null,
+                    sign: '!=',
+                },
+                payingOrganizationId: {
+                    value: null,
+                    sign: '!=',
+                },
+            }, { limit: 1000, sort: ['id'] });
+
+            if (items.length === 0) {
+                break;
+            }
+
+            process.stdout.write('.');
+
+            const registrationIds = Formatter.uniqueArray(items.map(i => i.registrationId!));
+            const registrations = await Registration.getByIDs(...registrationIds);
+
+            for (const item of items) {
+                if (!item.registrationId || !item.payingOrganizationId) {
+                    continue;
+                }
+                const registration = registrations.find(r => r.id === item.registrationId);
+                if (!registration) {
+                    continue;
+                }
+
+                registration.payingOrganizationId = item.payingOrganizationId;
+                if (await registration.save()) {
+                    c++;
+                }
+            }
+
+            if (items.length < 1000) {
+                break;
+            }
+            id = items[items.length - 1].id;
+        }
+    });
+
+    console.log('Updated ' + c + ' registrations');
+
+    // Do something here
+    return Promise.resolve();
+});

package/src/services/AuditLogService.ts

@@ -1,20 +1,21 @@
 import { Model, ModelEvent } from '@simonbackx/simple-database';
+import { AuditLogSource } from '@stamhoofd/structures';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { RegistrationLogger } from '../audit-logs/RegistrationLogger';
+import { DocumentTemplateLogger } from '../audit-logs/DocumentTemplateLogger';
+import { EventLogger } from '../audit-logs/EventLogger';
 import { GroupLogger } from '../audit-logs/GroupLogger';
+import { MemberLogger } from '../audit-logs/MemberLogger';
+import { MemberPlatformMembershipLogger } from '../audit-logs/MemberPlatformMembershipLogger';
+import { MemberResponsibilityRecordLogger } from '../audit-logs/MemberResponsibilityRecordLogger';
+import { OrderLogger } from '../audit-logs/OrderLogger';
 import { OrganizationLogger } from '../audit-logs/OrganizationLogger';
+import { OrganizationRegistrationPeriodLogger } from '../audit-logs/OrganizationRegistrationPeriodLogger';
+import { PaymentLogger } from '../audit-logs/PaymentLogger';
 import { PlatformLogger } from '../audit-logs/PlatformLogger';
-import { EventLogger } from '../audit-logs/EventLogger';
+import { RegistrationLogger } from '../audit-logs/RegistrationLogger';
 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;
@@ -72,11 +73,6 @@ export class AuditLogService {
                 return;
             }
 
-            console.log('Model event', {
-                ...event,
-                model: event.model.static.name,
-            });
-
             if (this.isDisabled()) {
                 console.log('Audit log disabled');
                 return;
@@ -103,3 +99,4 @@ modelLogDefinitions.set(OrderLogger.model, OrderLogger);
 modelLogDefinitions.set(PaymentLogger.model, PaymentLogger);
 modelLogDefinitions.set(MemberPlatformMembershipLogger.model, MemberPlatformMembershipLogger);
 modelLogDefinitions.set(MemberResponsibilityRecordLogger.model, MemberResponsibilityRecordLogger);
+modelLogDefinitions.set(DocumentTemplateLogger.model, DocumentTemplateLogger);

package/src/services/DocumentService.ts

@@ -0,0 +1,43 @@
+import { Model } from '@simonbackx/simple-database';
+import { PlainObject } from '@simonbackx/simple-encoding';
+import { Document, Group } from '@stamhoofd/models';
+
+function getGroupFieldsAffectingDocuments(group: Group): PlainObject {
+    return {
+        type: group.type,
+        startDate: group.settings.startDate.getTime(),
+        endDate: group.settings.endDate.getTime(),
+        name: group.settings.name,
+    };
+}
+
+export class DocumentService {
+    static listening = false;
+
+    static listen() {
+        if (this.listening) {
+            return;
+        }
+        this.listening = true;
+        Model.modelEventBus.addListener(this, async (event) => {
+            try {
+                if (event.model instanceof Group && event.type === 'updated' && event.changedFields.settings && !event.model.deletedAt) {
+                    const oldModel = event.getOldModel() as Group;
+                    const oldFields = getGroupFieldsAffectingDocuments(oldModel);
+                    const newFields = getGroupFieldsAffectingDocuments(event.model);
+
+                    if (JSON.stringify(oldFields) === JSON.stringify(newFields)) {
+                        console.log('Group changes cannot affect documents');
+                        return;
+                    }
+
+                    // If a group is changed - update the documents for it
+                    await Document.updateForGroup(event.model.id, event.model.organizationId);
+                }
+            }
+            catch (e) {
+                console.error('Failed to update documents after group change', e);
+            }
+        });
+    }
+};

package/src/services/RegistrationService.ts

@@ -55,6 +55,8 @@ export const RegistrationService = {
         RegistrationService.scheduleStockUpdate(registration.id);
 
         await PlatformMembershipService.updateMembershipsForId(registration.memberId);
+
+        await Document.deleteForRegistrations([registration]);
     },
 
     /**