@stamhoofd/backend 2.19.0 → 2.21.0

package/src/helpers/SetupStepsUpdater.ts

@@ -1,38 +1,41 @@
 import {
+    Group,
+    MemberResponsibilityRecord,
     Organization,
     OrganizationRegistrationPeriod,
-    Platform,
+    Platform
 } from "@stamhoofd/models";
 import { QueueHandler } from "@stamhoofd/queues";
+import { SQL, SQLWhereSign } from "@stamhoofd/sql";
 import {
-    PlatformPremiseType,
+    MemberResponsibility,
     Platform as PlatformStruct,
     SetupStepType,
-    SetupSteps,
+    SetupSteps
 } from "@stamhoofd/structures";
 
-type SetupStepOperation = (setupSteps: SetupSteps, organization: Organization, platform: PlatformStruct) => void;
+type SetupStepOperation = (setupSteps: SetupSteps, organization: Organization, platform: PlatformStruct) => void | Promise<void>;
 
 export class SetupStepUpdater {
     private static readonly STEP_TYPE_OPERATIONS: Record<
         SetupStepType,
         SetupStepOperation
     > = {
+        [SetupStepType.Functions]: this.updateStepFunctions,
+        [SetupStepType.Companies]: this.updateStepCompanies,
         [SetupStepType.Groups]: this.updateStepGroups,
         [SetupStepType.Premises]: this.updateStepPremises,
     };
 
     static async updateSetupStepsForAllOrganizationsInCurrentPeriod({
-        batchSize, premiseTypes
-    }: { batchSize?: number, premiseTypes?: PlatformPremiseType[] } = {}) {
+        batchSize
+    }: { batchSize?: number } = {}) {
         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 = "";
@@ -136,7 +139,7 @@ export class SetupStepUpdater {
         );
     }
 
-    static async updateFor(
+    private static async updateFor(
         organizationRegistrationPeriod: OrganizationRegistrationPeriod,
         platform: PlatformStruct,
         organization: Organization
@@ -147,13 +150,13 @@ export class SetupStepUpdater {
         for (const stepType of Object.values(SetupStepType)) {
             console.log(`[STEP TYPE] ${stepType}`);
             const operation = this.STEP_TYPE_OPERATIONS[stepType];
-            operation(setupSteps, organization, platform);
+            await operation(setupSteps, organization, platform);
         }
 
         await organizationRegistrationPeriod.save();
     }
 
-    static updateStepPremises(
+    private static updateStepPremises(
         setupSteps: SetupSteps,
         organization: Organization,
         platform: PlatformStruct
@@ -165,6 +168,8 @@ export class SetupStepUpdater {
 
         for (const premiseType of premiseTypes) {
             const { min, max } = premiseType;
+
+            // only add step if premise type has restrictions
             if (min === null && max === null) {
                 continue;
             }
@@ -197,7 +202,7 @@ export class SetupStepUpdater {
         });
     }
 
-    static updateStepGroups(
+    private static updateStepGroups(
         setupSteps: SetupSteps,
         _organization: Organization,
         _platform: PlatformStruct
@@ -207,4 +212,101 @@ export class SetupStepUpdater {
             finishedSteps: 0,
         });
     }
+
+    private static updateStepCompanies(
+        setupSteps: SetupSteps,
+        _organization: Organization,
+        _platform: PlatformStruct
+    ) {
+        setupSteps.update(SetupStepType.Companies, {
+            totalSteps: 0,
+            finishedSteps: 0,
+        });
+    }
+
+    private static async updateStepFunctions(
+        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 records = await MemberResponsibilityRecord.select()
+            .where('responsibilityId', responsibilityIds)
+            .where('organizationId', organization.id)
+            .where(SQL.where('endDate', SQLWhereSign.Greater, now).or('endDate', null))
+            .fetch();
+
+        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 && max === null) {
+                continue;
+            }
+
+            totalSteps++;
+
+            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) {
+                continue;
+            }
+
+            if (min !== null && totalRecordsWithThisResponsibility < min) {
+                continue;
+            }
+
+            finishedSteps++;
+        }
+
+        setupSteps.update(SetupStepType.Functions, {
+            totalSteps,
+            finishedSteps,
+        });
+    }
 }

package/src/endpoints/global/payments/ExchangeSTPaymentEndpoint.ts

@@ -1,153 +0,0 @@
-import { createMollieClient } from '@mollie/api-client';
-import { AutoEncoder, BooleanDecoder,Decoder,field } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
-import { MolliePayment, Organization } from "@stamhoofd/models";
-import { Payment } from "@stamhoofd/models";
-import { STInvoice } from "@stamhoofd/models";
-import { QueueHandler } from '@stamhoofd/queues';
-import { PaymentMethod,PaymentProvider,PaymentStatus, STInvoice as STInvoiceStruct } from "@stamhoofd/structures";
-type Params = {id: string};
-class Query extends AutoEncoder {
-    @field({ decoder: BooleanDecoder, optional: true })
-    exchange = false
-}
-type Body = undefined
-type ResponseBody = STInvoiceStruct | undefined;
-
-/**
- * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
- */
-
-export class ExchangeSTPaymentEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = Query as Decoder<Query>
-
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, "/billing/payments/@id", {id: String});
-
-        if (params) {
-            return [true, params as Params];
-        }
-        return [false];
-    }
-
-    async handle(request: DecodedRequest<Params, Query, Body>) {        
-        const payment = await Payment.getByID(request.params.id)
-        if (!payment) {
-            throw new SimpleError({
-                code: "",
-                message: "Deze link is ongeldig"
-            })
-        }
-
-        const invoices = await STInvoice.where({ paymentId: payment.id })
-        if (invoices.length > 1) {
-            console.error("Received more than 1 invoices for the same payment. Danger zone!")
-            throw new Error("Unexpected error")
-        }
-
-        if (invoices.length == 0) {
-            console.error("Didn't found and invoice for a given payment!")
-            throw new Error("Unexpected error")
-        }
-
-        // Not method on payment because circular references (not supprted in ts)
-        const invoice = invoices[0]
-
-        if (request.query.exchange) {
-            // Don't wait for exchanges
-            ExchangeSTPaymentEndpoint.pollStatus(payment, invoice).catch(e => {
-                console.error(e)
-            })
-            return new Response(undefined);
-        }
-        
-        const updatedInvoice = await ExchangeSTPaymentEndpoint.pollStatus(payment, invoice)
-
-        if (!updatedInvoice) {
-            return new Response(undefined);
-        }
-        
-        return new Response( 
-            await updatedInvoice.getStructure()
-        );
-    }
-
-    static async pollStatus(payment: Payment, _invoice: STInvoice): Promise<STInvoice | undefined> {
-        // All invoice related logic needs to happen after each ather, not concurrently
-        return await QueueHandler.schedule("billing/invoices-"+_invoice.organizationId, async () => {
-
-            // Get a new copy of the invoice (is required to prevent concurrenty bugs)
-            const invoice = await STInvoice.getByID(_invoice.id)
-            if (!invoice || invoice.paidAt !== null) {
-                return invoice
-            }
-
-            if ((payment.provider === PaymentProvider.Mollie || (payment.provider === null && payment.method == PaymentMethod.DirectDebit)) && (payment.status == PaymentStatus.Pending || payment.status == PaymentStatus.Created || payment.status == PaymentStatus.Failed)) {    
-                if (payment.method == PaymentMethod.Bancontact || payment.method == PaymentMethod.iDEAL || payment.method == PaymentMethod.CreditCard || payment.method == PaymentMethod.DirectDebit || payment.method == PaymentMethod.Transfer) {
-                    // check status via mollie
-                    const molliePayments = await MolliePayment.where({ paymentId: payment.id}, { limit: 1 })
-                    if (molliePayments.length == 1) {
-                        const molliePayment = molliePayments[0]
-                        // check status
-                        const apiKey = STAMHOOFD.MOLLIE_API_KEY
-                        if (apiKey) {
-                            const mollieClient = createMollieClient({ apiKey });
-                            const mollieData = await mollieClient.payments.get(molliePayment.mollieId)
-
-                            console.log(mollieData) // log to log files to check issues
-
-                            const details = (mollieData.details as any) 
-                            if (details?.cardNumber) {
-                                payment.iban = "xxxx xxxx xxxx "+details.cardNumber
-                            }
-                            if (details?.cardHolder) {
-                                payment.ibanName = details.cardHolder
-                            }
-                            if (details?.consumerAccount) {
-                                payment.iban = details.consumerAccount
-                            }
-                            if (details?.consumerName) {
-                                payment.ibanName = details.consumerName
-                            }
-
-                            if (mollieData.status == "paid") {
-                                payment.status = PaymentStatus.Succeeded
-                                payment.paidAt = new Date()
-                                await payment.save();
-
-                                await invoice.markPaid()
-
-                                // Save customer id
-                                if (mollieData.customerId && _invoice.organizationId) {
-                                    const organization = await Organization.getByID(_invoice.organizationId)
-                                    if (organization) {
-                                        organization.serverMeta.mollieCustomerId = mollieData.customerId
-                                        console.log("Saving mollie customer", mollieData.customerId, "for organization", organization.id)
-                                        await organization.save()
-                                    }
-                                }
-                            } else if (mollieData.status == "failed" || mollieData.status == "expired" || mollieData.status == "canceled") {
-                                payment.status = PaymentStatus.Failed
-                                await payment.save();
-                                await invoice.markFailed(payment)
-                            }
-                        } else {
-                            console.error("Mollie api key is missing for Stamhoofd payments! "+payment.id)
-                        }
-                    } else {
-                        console.error("Couldn't find mollie payment for payment "+payment.id)
-                    }
-                } else {
-                    console.error("Payment method not supported for invoice "+invoice.id+" and payment "+payment.id)
-                    throw new Error("Unsupported payment method for invoices")
-                }
-            }
-            return invoice
-        });
-    }
-}

package/src/endpoints/organization/dashboard/organization/ApplyRegisterCodeEndpoint.test.ts

@@ -1,64 +0,0 @@
-
-import { Request } from "@simonbackx/simple-endpoints";
-import { OrganizationFactory, RegisterCodeFactory, STCredit, Token, UserFactory } from "@stamhoofd/models";
-import { PermissionLevel, Permissions } from "@stamhoofd/structures";
-
-import { testServer } from "../../../../../tests/helpers/TestServer";
-import { ApplyRegisterCodeEndpoint } from "./ApplyRegisterCodeEndpoint";
-
-describe("Endpoint.ApplyRegisterCodeEndpoint", () => {
-    // Test endpoint
-    const endpoint = new ApplyRegisterCodeEndpoint();
-
-    test("Cannot apply a register code if not platform admin", async () => {
-        const otherOrganization =  await new OrganizationFactory({}).create();
-        const code = await new RegisterCodeFactory({organization: otherOrganization}).create();
-
-        const organization =  await new OrganizationFactory({}).create();
-        const user = await new UserFactory({ organization, permissions: Permissions.create({ level: PermissionLevel.Full }) }).create()
-        const token = await Token.createToken(user)
-
-        const r = Request.buildJson(
-            "POST", 
-            "/organization/register-code", 
-            organization.getApiHost(), 
-            {
-                registerCode: code.code,
-            }
-        );
-        r.headers.authorization = "Bearer "+token.accessToken
-
-        await expect(testServer.test(endpoint, r)).rejects.toThrow("You do not have permissions for this action");
-    });
-
-    test("Can apply a register code and apply the discount", async () => {
-        const otherOrganization =  await new OrganizationFactory({}).create();
-        const code = await new RegisterCodeFactory({organization: otherOrganization}).create();
-
-        const organization =  await new OrganizationFactory({}).create();
-        const user = await new UserFactory({ 
-            organization,
-            globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
-            email: 'admin@stamhoofd.be'
-        }).create()
-        const token = await Token.createToken(user)
-
-        const r = Request.buildJson(
-            "POST", 
-            "/organization/register-code", 
-            organization.getApiHost(), 
-            {
-                registerCode: code.code,
-            }
-        );
-        r.headers.authorization = "Bearer "+token.accessToken
-
-        const response = await testServer.test(endpoint, r);
-        expect(response.body).toBeUndefined();
-
-        // Check if this organization has an open register code
-        const credits = await STCredit.getForOrganization(organization.id);
-        expect(credits.length).toBe(1);
-        expect(credits[0].change).toBe(code.value);
-    });
-});

package/src/endpoints/organization/dashboard/organization/ApplyRegisterCodeEndpoint.ts

@@ -1,84 +0,0 @@
-import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Email } from '@stamhoofd/email';
-import { RegisterCode, UsedRegisterCode } from '@stamhoofd/models';
-
-import { Context } from '../../../../helpers/Context';
-
-type Params = Record<string, never>;
-type Query = undefined;
-type ResponseBody = undefined;
-
-class Body extends AutoEncoder {
-    @field({ decoder: StringDecoder })
-    registerCode: string
-}
-
-/**
- * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
- */
-
-export class ApplyRegisterCodeEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = Body as Decoder<Body>
-
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, "/organization/register-code", {});
-
-        if (params) {
-            return [true, params as Params];
-        }
-        return [false];
-    }
-
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
-
-        if (!Context.auth.hasPlatformFullAccess()) {
-            throw Context.auth.error()
-        }
-
-        let code = request.body.registerCode;
-
-        if (code.startsWith('https:')) {
-            try {
-                const url = new URL(code);
-                const codeParam = url.searchParams.get('code');
-                if (codeParam) {
-                    console.log('Parsed code from URL', codeParam)
-                    code = codeParam;
-                }
-            } catch (e) {
-                console.error('Tried parsing code as URL but failed', code)
-            }
-        }
-
-        const {models, emails} = await RegisterCode.applyRegisterCode(organization, code)
-
-        for (const model of models) {
-            await model.save();
-        }
-
-        for (const email of emails) {
-            Email.sendInternal(email, organization.i18n)
-        }
-
-        if (organization.meta.packages.isPaid) {
-            // Already bought something: apply credit to other organization immediately
-            const code = await UsedRegisterCode.getFor(organization.id)
-            if (code && !code.creditId) {
-                console.log("Rewarding code "+code.id+" for payment")
-
-                // Deze code werd nog niet beloond
-                await code.reward()
-            }
-        }
-
-        return new Response(undefined);
-    }
-}
-

package/src/endpoints/organization/dashboard/organization/GetRegisterCodeEndpoint.ts

@@ -1,65 +0,0 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { Organization, RegisterCode, STCredit, UsedRegisterCode } from '@stamhoofd/models';
-import { RegisterCodeStatus, UsedRegisterCode as UsedRegisterCodeStruct } from '@stamhoofd/structures';
-
-import { Context } from '../../../../helpers/Context';
-
-type Params = Record<string, never>;
-type Query = undefined;
-type Body = undefined;
-type ResponseBody = RegisterCodeStatus;
-
-export class GetRegisterCodeEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, "/register-code", {});
-
-        if (params) {
-            return [true, params as Params];
-        }
-        return [false];
-    }
-
-    async handle(_: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
-
-        if (!await Context.auth.hasSomeAccess(organization.id)) {
-            throw Context.auth.error()
-        }
-
-        const codes = await RegisterCode.where({ organizationId: organization.id })
-        let code = codes[0]
-
-        if (codes.length == 0) {
-            code = new RegisterCode()
-            code.organizationId = organization.id
-            code.description = "Doorverwezen door "+ organization.name
-            code.value = 2500
-            await code.generateCode()
-            await code.save()
-        }
-
-        const usedCodes = await UsedRegisterCode.getAll(code.code)
-        const allOrganizations = await Organization.getByIDs(...usedCodes.flatMap(u => u.organizationId ? [u.organizationId] : []))
-        const allCredits = await STCredit.getByIDs(...usedCodes.flatMap(u => u.creditId ? [u.creditId] : []))
-
-        return new Response(RegisterCodeStatus.create({
-            code: code.code,
-            value: code.value,
-            invoiceValue: code.invoiceValue,
-            usedCodes: usedCodes.map(c => {
-                return UsedRegisterCodeStruct.create({ 
-                    id: c.id,
-                    organizationName: allOrganizations.find(o => o.id === c.organizationId)?.name ?? "Onbekend",
-                    createdAt: c.createdAt,
-                    creditValue: (c.creditId ? allCredits.find(credit => credit.id === c.creditId)?.change : null) ?? null
-                })
-            })
-        }))
-    }
-}