@stamhoofd/backend 2.17.3 → 2.18.0

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/sql-filters/members.ts

@@ -9,6 +9,8 @@ import { registrationFilterCompilers } from "./registrations";
 export const memberFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
     id: createSQLColumnFilterCompiler('id'),
+    firstName: createSQLColumnFilterCompiler('firstName'),
+    lastName: createSQLColumnFilterCompiler('lastName'),
     name: createSQLExpressionFilterCompiler(
         new SQLConcat(
             SQL.column('firstName'),

package/src/sql-sorters/members.ts

@@ -3,6 +3,14 @@ import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamh
 import { Formatter } from "@stamhoofd/utility"
 
 export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields. 
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
     'id': {
         getValue(a) {
             return a.id
@@ -14,22 +22,26 @@ export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
             })
         }
     },
-    'name': {
+    'firstName': {
+        getValue(a) {
+            return a.firstName
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('firstName'),
+                direction
+            })
+        }
+    },
+    'lastName': {
         getValue(a) {
-            // Note: we should not use 'name' here (that will remove the in between space if one is missing), because we need to use Exactly the same value as the filter will use
-            return a.firstName + ' ' + a.lastName
+            return a.lastName
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return SQLOrderBy.combine([
-                new SQLOrderBy({
-                    column: SQL.column('firstName'),
-                    direction
-                }),
-                new SQLOrderBy({
-                    column: SQL.column('lastName'),
-                    direction
-                })
-            ])
+            return new SQLOrderBy({
+                column: SQL.column('lastName'),
+                direction
+            })
         }
     },
     'birthDay': {
@@ -43,5 +55,4 @@ export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
             })
         }
     }
-    // Note: never add mapped sortings, that should happen in the frontend -> e.g. map age to birthDay
 }

package/src/sql-sorters/organizations.ts

@@ -2,6 +2,14 @@ import { Organization } from "@stamhoofd/models"
 import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
 
 export const organizationSorters: SQLSortDefinitions<Organization> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields. 
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+    
     'id': {
         getValue(a) {
             return a.id

package/src/sql-sorters/payments.ts

@@ -3,6 +3,14 @@ import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamh
 import { Formatter } from "@stamhoofd/utility"
 
 export const paymentSorters: SQLSortDefinitions<Payment> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields. 
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
     'id': {
         getValue(a) {
             return a.id

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
-            })
-        );
-    }
-}