@stamhoofd/backend 2.17.4 → 2.19.0

package/src/helpers/MembershipCharger.ts

@@ -0,0 +1,126 @@
+import { SimpleError } from "@simonbackx/simple-errors";
+import { BalanceItem, Member, MemberPlatformMembership, Platform } from "@stamhoofd/models";
+import { SQL, SQLOrderBy, SQLWhereSign } from "@stamhoofd/sql";
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType } from "@stamhoofd/structures";
+import { Formatter } from "@stamhoofd/utility";
+
+export const MembershipCharger = {
+    async charge() {
+        console.log('Charging memberships...')
+        
+        // Loop all
+        let lastId = "";
+        const platform = await Platform.getShared()
+        const chargeVia = platform.membershipOrganizationId
+
+        if (!chargeVia) {
+            throw new SimpleError({
+                code: 'missing_membership_organization',
+                message: 'Missing membershipOrganizationId',
+                human: 'Er is geen lokale groep verantwoordelijk voor de aanrekening van aansluitingen geconfigureerd'
+            })
+        }
+
+        function getType(id: string) {
+            return platform.config.membershipTypes.find(t => t.id === id)
+        }
+
+        let createdCount = 0;
+        let createdPrice = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const memberships = await MemberPlatformMembership.select()
+                .where('id', SQLWhereSign.Greater, lastId)
+                .where('balanceItemId', null)
+                .limit(100)
+                .orderBy(
+                    new SQLOrderBy({
+                        column: SQL.column('id'),
+                        direction: 'ASC'
+                    })
+                )
+                .fetch();
+        
+            if (memberships.length === 0) {
+                break;
+            }
+
+            const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId))
+            const members = await Member.getByIDs(...memberIds)
+            const createdBalanceItems: BalanceItem[] = []
+
+            for (const membership of memberships) {
+                // charge
+                if (membership.balanceItemId) {
+                    continue;
+                }
+                const type = getType(membership.membershipTypeId);
+                if (!type) {
+                    console.error('Unknown membership type id ', membership.membershipTypeId)
+                    continue;
+                }
+
+                if (membership.organizationId === chargeVia) {
+                    continue;
+                }
+
+                const member = members.find(m => m.id === membership.memberId)
+
+                if (!member) {
+                    console.error('Unexpected missing member id ', membership.memberId, 'for membership', membership.id)
+                    continue;
+                }
+
+                const balanceItem = new BalanceItem();
+                balanceItem.unitPrice = membership.price
+                balanceItem.amount = 1
+                balanceItem.description = Formatter.dateNumber(membership.startDate, true) + " tot " + Formatter.dateNumber(membership.expireDate ?? membership.endDate, true)
+                balanceItem.relations = new Map([
+                    [
+                        BalanceItemRelationType.Member, 
+                        BalanceItemRelation.create({
+                            id: member.id,
+                            name: member.details.name
+                        })
+                    ],
+                    [
+                        BalanceItemRelationType.MembershipType, 
+                        BalanceItemRelation.create({
+                            id: type.id,
+                            name: type.name
+                        })
+                    ]
+                ])
+
+                balanceItem.type = BalanceItemType.PlatformMembership
+                balanceItem.organizationId = chargeVia
+                balanceItem.payingOrganizationId = membership.organizationId
+
+                await balanceItem.save();
+                membership.balanceItemId = balanceItem.id;
+                await membership.save()
+
+                createdBalanceItems.push(balanceItem)
+
+                createdCount += 1;
+                createdPrice += membership.price
+            }
+
+            await BalanceItem.updateOutstanding(createdBalanceItems)
+
+            if (memberships.length < 100) {
+                break;
+            }
+            
+            const z = lastId;
+            lastId = memberships[memberships.length - 1].id;
+
+            if (lastId === z) {
+                throw new Error('Unexpected infinite loop found in MembershipCharger')
+            }
+        }
+
+        console.log('Charged ' + Formatter.integer(createdCount) +'  memberships, for a total value of ' + Formatter.price(createdPrice))
+    }
+};

package/src/helpers/SetupStepsUpdater.ts

@@ -0,0 +1,210 @@
+import {
+    Organization,
+    OrganizationRegistrationPeriod,
+    Platform,
+} from "@stamhoofd/models";
+import { QueueHandler } from "@stamhoofd/queues";
+import {
+    PlatformPremiseType,
+    Platform as PlatformStruct,
+    SetupStepType,
+    SetupSteps,
+} from "@stamhoofd/structures";
+
+type SetupStepOperation = (setupSteps: SetupSteps, organization: Organization, platform: PlatformStruct) => void;
+
+export class SetupStepUpdater {
+    private static readonly STEP_TYPE_OPERATIONS: Record<
+        SetupStepType,
+        SetupStepOperation
+    > = {
+        [SetupStepType.Groups]: this.updateStepGroups,
+        [SetupStepType.Premises]: this.updateStepPremises,
+    };
+
+    static async updateSetupStepsForAllOrganizationsInCurrentPeriod({
+        batchSize, premiseTypes
+    }: { batchSize?: number, premiseTypes?: PlatformPremiseType[] } = {}) {
+        const tag = "updateSetupStepsForAllOrganizationsInCurrentPeriod";
+        QueueHandler.cancel(tag);
+
+        await QueueHandler.schedule(tag, async () => {
+            const platform = (await Platform.getSharedPrivateStruct()).clone();
+            if(premiseTypes) {
+                platform.config.premiseTypes = premiseTypes;
+            }
+            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
+        );
+    }
+
+    static async updateFor(
+        organizationRegistrationPeriod: OrganizationRegistrationPeriod,
+        platform: PlatformStruct,
+        organization: Organization
+    ) {
+        const setupSteps = organizationRegistrationPeriod.setupSteps;
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        for (const stepType of Object.values(SetupStepType)) {
+            console.log(`[STEP TYPE] ${stepType}`);
+            const operation = this.STEP_TYPE_OPERATIONS[stepType];
+            operation(setupSteps, organization, platform);
+        }
+
+        await organizationRegistrationPeriod.save();
+    }
+
+    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;
+            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,
+        });
+    }
+
+    static updateStepGroups(
+        setupSteps: SetupSteps,
+        _organization: Organization,
+        _platform: PlatformStruct
+    ) {
+        setupSteps.update(SetupStepType.Groups, {
+            totalSteps: 0,
+            finishedSteps: 0,
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+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();
+})

package/src/endpoints/admin/invoices/GetInvoicesCountEndpoint.ts

@@ -1,47 +0,0 @@
-import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
-
-import { Context } from '../../../helpers/Context';
-import { GetInvoicesEndpoint } from './GetInvoicesEndpoint';
-
-type Params = Record<string, never>;
-type Query = CountFilteredRequest;
-type Body = undefined;
-type ResponseBody = CountResponse;
-
-export class GetInvoicesCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>
-
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, "/admin/invoices/count", {});
-
-        if (params) {
-            return [true, params as Params];
-        }
-        return [false];
-    }
-
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
-
-        if (!Context.auth.hasPlatformFullAccess()) {
-            throw Context.auth.error()
-        }
-        
-        const query = GetInvoicesEndpoint.buildQuery(request.query)
-        
-        const count = await query
-            .count();
-
-        return new Response(
-            CountResponse.create({
-                count
-            })
-        );
-    }
-}

package/src/endpoints/admin/invoices/GetInvoicesEndpoint.ts

@@ -1,185 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { SimpleError } from '@simonbackx/simple-errors';
-import { Organization, Payment, STInvoice } from '@stamhoofd/models';
-import { SQL, SQLFilterDefinitions, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions, baseSQLFilterCompilers, compileToSQLFilter, compileToSQLSorter, createSQLExpressionFilterCompiler } from "@stamhoofd/sql";
-import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, Payment as PaymentStruct, STInvoicePrivate, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
-
-import { Context } from '../../../helpers/Context';
-
-type Params = Record<string, never>;
-type Query = LimitedFilteredRequest;
-type Body = undefined;
-type ResponseBody = PaginatedResponse<STInvoicePrivate[], LimitedFilteredRequest>
-
-export const filterCompilers: SQLFilterDefinitions = {
-    ...baseSQLFilterCompilers,
-    id: createSQLExpressionFilterCompiler(
-        SQL.column('stamhoofd_invoices', 'id')
-    ),
-    number: createSQLExpressionFilterCompiler(
-        SQL.column('stamhoofd_invoices', 'number')
-    )
-}
-
-const sorters: SQLSortDefinitions<STInvoice> = {
-    'id': {
-        getValue(a) {
-            return a.id
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('id'),
-                direction
-            })
-        }
-    },
-    'number': {
-        getValue(a) {
-            return a.number
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('number'),
-                direction
-            })
-        }
-    }
-}
-
-export class GetInvoicesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
-
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, "/admin/invoices", {});
-
-        if (params) {
-            return [true, params as Params];
-        }
-        return [false];
-    }
-
-    static buildQuery(q: CountFilteredRequest|LimitedFilteredRequest) {        
-        const query = SQL
-            .select(
-                SQL.wildcard('stamhoofd_invoices')
-            )
-            .from(
-                SQL.table('stamhoofd_invoices')
-            )
-            .whereNot(SQL.column('stamhoofd_invoices', 'number'), null);
-
-
-        if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers))
-        }
-
-        if (q.search) {
-            let searchFilter: StamhoofdFilter|null = null
-
-            // todo: auto detect e-mailaddresses and search on admins
-            searchFilter = {
-                name: {
-                    $contains: q.search
-                }
-            }
-
-            if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers))
-            }
-        }
-
-        if (q instanceof LimitedFilteredRequest) {
-            if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
-            }
-
-            query.orderBy(compileToSQLSorter(q.sort, sorters))
-            query.limit(q.limit)
-        }
-       
-        return query
-    }
-
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
-
-        if (!Context.auth.hasPlatformFullAccess()) {
-            throw Context.auth.error()
-        }
-
-        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
-
-        if (request.query.limit > maxLimit) {
-            throw new SimpleError({
-                code: 'invalid_field',
-                field: 'limit',
-                message: 'Limit can not be more than ' + maxLimit
-            })
-        }
-        
-        if (request.query.limit < 1) {
-            throw new SimpleError({
-                code: 'invalid_field',
-                field: 'limit',
-                message: 'Limit can not be less than 1'
-            })
-        }
-        
-        const data = await GetInvoicesEndpoint.buildQuery(request.query).fetch()
-        const invoices = STInvoice.fromRows(data, 'stamhoofd_invoices');
-
-        let next: LimitedFilteredRequest|undefined;
-
-        if (invoices.length >= request.query.limit) {
-            const lastObject = invoices[invoices.length - 1];
-            const nextFilter = getSortFilter(lastObject, sorters, request.query.sort);
-
-            next = new LimitedFilteredRequest({
-                filter: request.query.filter,
-                pageFilter: nextFilter,
-                sort: request.query.sort,
-                limit: request.query.limit,
-                search: request.query.search
-            })
-
-            if (JSON.stringify(nextFilter) === JSON.stringify(request.query.pageFilter)) {
-                console.error('Found infinite loading loop for', request.query);
-                next = undefined;
-            }
-        }
-        
-        // Get payments + organizations
-        const paymentIds = invoices.flatMap(i => i.paymentId ? [i.paymentId] : [])
-        const organizationIds = invoices.flatMap(i => i.organizationId ? [i.organizationId] : [])
-
-        const payments = await Payment.getByIDs(...paymentIds)
-        const organizations = await Organization.getByIDs(...organizationIds)
-
-        const structures: STInvoicePrivate[] = []
-        for (const invoice of invoices) {
-            const payment = payments.find(p => p.id === invoice.paymentId)
-            const organization = organizations.find(p => p.id === invoice.organizationId)
-            structures.push(
-                STInvoicePrivate.create({
-                    ...invoice,
-                    payment: payment ? PaymentStruct.create(payment) : null,
-                    organization: organization ? organization.getBaseStructure() : undefined,
-                    settlement: payment?.settlement ?? null,
-                })
-            )
-        }
-
-        return new Response(
-            new PaginatedResponse<STInvoicePrivate[], LimitedFilteredRequest>({
-                results: structures,
-                next
-            })
-        );
-    }
-}