@stamhoofd/backend 2.39.1 → 2.40.0

package/.eslintrc.js

@@ -1,61 +0,0 @@
-module.exports = {
-    root: true,
-    ignorePatterns: ["dist/", "node_modules/"],
-    parserOptions: {
-        "ecmaVersion": 2017
-    },
-    env: {
-        "es6": true,
-        "node": true,
-    },
-    extends: [
-        "eslint:recommended",
-    ],
-    plugins: [],
-    rules: {
-        "no-console": "off",
-        "no-debugger": process.env.NODE_ENV === "production" ? "error" : "off",
-        "sort-imports": "off",
-        "import/order": "off"
-    },
-    overrides: [
-        {
-            // Rules for TypeScript and vue
-            files: ["*.ts"],
-            parser: "@typescript-eslint/parser",
-            parserOptions: {
-                project: ["./tsconfig.json"]
-            },
-            plugins: ["@typescript-eslint", "jest"],
-            extends: [
-                "eslint:recommended",
-                "plugin:@typescript-eslint/eslint-recommended",
-                "plugin:@typescript-eslint/recommended",
-                "plugin:@typescript-eslint/recommended-requiring-type-checking",
-                "plugin:jest/recommended",
-            ],
-            rules: {
-                "no-console": "off",
-                "no-debugger": process.env.NODE_ENV === "production" ? "error" : "off",
-                "sort-imports": "off",
-                "import/order": "off",
-                "@typescript-eslint/explicit-function-return-type": "off",
-                "@typescript-eslint/no-explicit-any": "off",
-                "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
-                "@typescript-eslint/no-namespace": "off",
-                "@typescript-eslint/no-floating-promises": "error",
-                "@typescript-eslint/no-misused-promises": "error",
-                "@typescript-eslint/prefer-for-of": "warn",
-                "@typescript-eslint/no-empty-interface": "off", // It is convenient to have placeholder interfaces
-                "@typescript-eslint/no-this-alias": "off", // No idea why we need this. This breaks code that is just fine. Prohibit the use of function() instead of this rule
-                "@typescript-eslint/unbound-method": "off", // Methods are automatically bound in vue, it would break removeEventListeners if we bound it every time unless we save every method in variables again...
-                "@typescript-eslint/no-unsafe-assignment": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/no-unsafe-return": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/no-unsafe-call": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/no-unsafe-member-access": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/restrict-plus-operands": "off", // bullshit one
-                "@typescript-eslint/explicit-module-boundary-types": "off",
-            },
-        }
-    ]
-};

package/jest.config.js

@@ -1,11 +0,0 @@
-
-module.exports = {
-    roots: ["<rootDir>/dist"],
-    testEnvironment: "node",
-    setupFilesAfterEnv: [
-        "jest-extended/all",
-        "./dist/tests/jest.setup.js",
-    ],
-    globalSetup:  "./dist/tests/jest.global.setup.js"
-    //verbose: true,
-};

package/src/helpers/SetupStepsUpdater.ts

@@ -1,359 +0,0 @@
-import {
-    Group,
-    Member,
-    MemberResponsibilityRecord,
-    Organization,
-    OrganizationRegistrationPeriod,
-    Platform
-} from "@stamhoofd/models";
-import { QueueHandler } from "@stamhoofd/queues";
-import { SQL, SQLWhereSign } from "@stamhoofd/sql";
-import {
-    GroupType,
-    MemberResponsibility,
-    Platform as PlatformStruct,
-    SetupStepType,
-    SetupSteps
-} from "@stamhoofd/structures";
-import { Formatter } from "@stamhoofd/utility";
-
-type SetupStepOperation = (setupSteps: SetupSteps, organization: Organization, platform: PlatformStruct) => void | Promise<void>;
-
-export class SetupStepUpdater {
-    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
-    };
-
-    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 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
-    ) {
-        const setupSteps = organizationRegistrationPeriod.setupSteps;
-
-        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,
-            });
-
-            setupSteps.markReviewed(SetupStepType.Emails, {userId: 'backend', userName: 'backend'});
-    }
-
-    private static updateStepPayment(setupSteps: SetupSteps,
-        _organization: Organization,
-        _platform: PlatformStruct) {
-            setupSteps.update(SetupStepType.Payment, {
-                totalSteps: 0,
-                finishedSteps: 0,
-            });
-    }
-}

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

@@ -1,16 +0,0 @@
-import { Migration } from '@simonbackx/simple-database';
-import { SetupStepUpdater } from '../helpers/SetupStepsUpdater';
-
-export default new Migration(async () => {
-    if (STAMHOOFD.environment == "test") {
-        console.log("skipped in tests")
-        return;
-    }
-
-    if(STAMHOOFD.userMode !== "platform") {
-        console.log("skipped seed setup-steps because usermode not platform")
-        return;
-    }
-
-    await SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod();
-})