@stamhoofd/backend 2.19.0 → 2.20.0

package/.env.template.json

@@ -58,7 +58,7 @@
     "LATEST_IOS_VERSION": 0,
     "LATEST_ANDROID_VERSION": 0,
 
-    "NOLT_SSO_SECRET_KEY": "",
+    "NOLT_SSO_SECRET_KEY": "optional",
     "INTERNAL_SECRET_KEY": "",
     "CRONS_DISABLED": false,
     "WHITELISTED_EMAIL_DESTINATIONS": ["*"],

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.19.0",
+    "version": "2.20.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -39,10 +39,10 @@
         "@stamhoofd/backend-i18n": "^2.17.0",
         "@stamhoofd/backend-middleware": "^2.17.0",
         "@stamhoofd/email": "^2.17.0",
-        "@stamhoofd/models": "^2.19.0",
+        "@stamhoofd/models": "^2.20.0",
         "@stamhoofd/queues": "^2.17.3",
-        "@stamhoofd/sql": "^2.18.0",
-        "@stamhoofd/structures": "^2.19.0",
+        "@stamhoofd/sql": "^2.20.0",
+        "@stamhoofd/structures": "^2.20.0",
         "@stamhoofd/utility": "^2.17.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
@@ -60,5 +60,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "876e7b976122e1c2f67d4cceebe92ec2af2bc35a"
+    "gitHead": "946c0ddcaa7cdc9b769d4dc9083a517fe7ad19f8"
 }

package/src/crons.ts

@@ -1,21 +1,14 @@
 import { Database } from '@simonbackx/simple-database';
 import { logger, StyledText } from "@simonbackx/simple-logging";
 import { I18n } from '@stamhoofd/backend-i18n';
-import { Email } from '@stamhoofd/email';
-import { EmailAddress } from '@stamhoofd/email';
-import { Group, STPackage, Webshop } from '@stamhoofd/models';
-import { Organization } from '@stamhoofd/models';
-import { Payment } from '@stamhoofd/models';
-import { Registration } from '@stamhoofd/models';
-import { STInvoice } from '@stamhoofd/models';
-import { STPendingInvoice } from '@stamhoofd/models';
+import { Email, EmailAddress } from '@stamhoofd/email';
+import { Group, Organization, Payment, Registration, STPackage, STPendingInvoice, Webshop } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
 import { PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
 import { Formatter, sleep } from '@stamhoofd/utility';
 import AWS from 'aws-sdk';
 import { DateTime } from 'luxon';
 
-import { ExchangeSTPaymentEndpoint } from './endpoints/global/payments/ExchangeSTPaymentEndpoint';
 import { ExchangePaymentEndpoint } from './endpoints/organization/shared/ExchangePaymentEndpoint';
 import { checkSettlements } from './helpers/CheckSettlements';
 import { ForwardHandler } from './helpers/ForwardHandler';
@@ -471,12 +464,7 @@ async function checkPayments() {
                     continue;
                 }
             } else {
-                // Try stamhoofd payment
-                const invoices = await STInvoice.where({ paymentId: payment.id })
-                if (invoices.length === 1) {
-                    await ExchangeSTPaymentEndpoint.pollStatus(payment, invoices[0])
-                    continue
-                }
+                // deprecated
             }
 
             // Check expired
@@ -599,52 +587,6 @@ async function checkReservedUntil() {
     }
 }
 
-
-// Wait for midnight before checking billing
-let lastBillingCheck: Date | null = new Date()
-let lastBillingId = ""
-async function checkBilling() {
-    if (STAMHOOFD.environment === "development") {
-        return
-    }
-
-    console.log("[BILLING] Checking billing...")
-
-    // Wait for the next day before doing a new check
-    if (lastBillingCheck && Formatter.dateIso(lastBillingCheck) === Formatter.dateIso(new Date())) {
-        console.log("[BILLING] Billing check done for today")
-        return
-    }
-    
-    const organizations = await Organization.where({ id: { sign: '>', value: lastBillingId } }, {
-        limit: 10,
-        sort: ["id"]
-    })
-
-    if (organizations.length == 0) {
-        // Wait again until next day
-        lastBillingId = ""
-        lastBillingCheck = new Date()
-        return
-    }
-
-    for (const organization of organizations) {
-        console.log("[BILLING] Checking billing for "+organization.name)
-
-        try {
-            await QueueHandler.schedule("billing/invoices-"+organization.id, async () => {
-                await STPendingInvoice.addAutomaticItems(organization)
-            });
-        } catch (e) {
-            console.error(e)
-        }
-        
-    }
-
-    lastBillingId = organizations[organizations.length - 1].id
-    
-}
-
 let lastDripCheck: Date | null = null
 let lastDripId = ""
 async function checkDrips() {
@@ -723,12 +665,6 @@ registeredCronJobs.push({
     running: false
 });
 
-registeredCronJobs.push({
-    name: 'checkBilling',
-    method: checkBilling,
-    running: false
-});
-
 registeredCronJobs.push({
     name: 'checkReservedUntil',
     method: checkReservedUntil,

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -9,6 +9,7 @@ import { Formatter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
+import { SetupStepUpdater } from '../../../helpers/SetupStepsUpdater';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -150,6 +151,8 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             await MemberUserSyncer.onChangeMember(member)
         }
 
+        let shouldUpdateSetupSteps = false;
+
         // Loop all members one by one
         for (let patch of request.body.getPatches()) {
             const member = members.find(m => m.id === patch.id) ?? await Member.getWithRegistrations(patch.id)
@@ -223,6 +226,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 }
 
                 await responsibilityRecord.save()
+                shouldUpdateSetupSteps = true;
             }
 
             // Create responsibilities
@@ -323,6 +327,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 model.startDate = put.startDate
 
                 await model.save()
+                shouldUpdateSetupSteps = true;
             }
 
             // Auto link users based on data
@@ -443,7 +448,6 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 updateMembershipMemberIds.add(member.id)
             }
 
-
             if (!members.find(m => m.id === member.id)) {
                 members.push(member)
             }
@@ -460,6 +464,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             await User.deleteForDeletedMember(member.id)
             await BalanceItem.deleteForDeletedMember(member.id)
             await member.delete()
+            shouldUpdateSetupSteps = true
 
             // Update occupancy of this member because we removed registrations
             const groupIds = member.registrations.flatMap(r => r.groupId)
@@ -498,6 +503,10 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             }
         }
 
+        if(shouldUpdateSetupSteps && organization) {
+            SetupStepUpdater.updateForOrganization(organization).catch(console.error);
+        }
+
         return new Response(
             await AuthenticatedStructures.membersBlob(members)
         );

package/src/endpoints/global/organizations/CreateOrganizationEndpoint.test.ts

@@ -1,15 +1,10 @@
 
 import { Request } from "@simonbackx/simple-endpoints";
-import { Organization, OrganizationFactory, RegisterCodeFactory, STCredit } from "@stamhoofd/models";
 import { Address, Country, CreateOrganization, NewUser, Organization as OrganizationStruct, Version } from "@stamhoofd/structures";
 
 import { testServer } from "../../../../tests/helpers/TestServer";
 import { CreateOrganizationEndpoint } from "./CreateOrganizationEndpoint";
 
-function expect_toBeDefined<T>(arg: T): asserts arg is NonNullable<T> {
-  expect(arg).toBeDefined();
-}
-
 describe("Endpoint.CreateOrganization", () => {
     // Test endpoint
     const endpoint = new CreateOrganizationEndpoint();
@@ -60,46 +55,4 @@ describe("Endpoint.CreateOrganization", () => {
 
         await expect(testServer.test(endpoint, r)).rejects.toThrow(/name/);
     });
-
-    test("Can create an organization with a register code and apply the discount", async () => {
-        const otherOrganization =  await new OrganizationFactory({}).create();
-        const code = await new RegisterCodeFactory({organization: otherOrganization}).create();
-        const uri = 'my-organization-with-a-discount';
-
-        const r = Request.buildJson(
-            "POST", 
-            "/organizations", 
-            "todo-host.be", 
-            CreateOrganization.create({
-                organization: OrganizationStruct.create({
-                    name: "My organization with a discount",
-                    uri,
-                    address: Address.create({
-                        street: "My street",
-                        number: "1",
-                        postalCode: "9000",
-                        city: "Gent",
-                        country: Country.Belgium
-                    }),
-                }),
-                user: NewUser.create({
-                    email: "voorbeeld@stamhoofd.be",
-                    password: "My user password",
-                }),
-                registerCode: code.code
-            })
-        );
-
-        const response = await testServer.test(endpoint, r);
-        expect(response.body.token).not.toBeEmpty();
-
-        const organization = await Organization.getByURI(uri);
-        expect_toBeDefined(organization);
-
-        // 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/global/organizations/CreateOrganizationEndpoint.ts

@@ -1,9 +1,7 @@
-import { Model } from '@simonbackx/simple-database';
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Email, EmailInterfaceBase } from '@stamhoofd/email';
-import { EmailVerificationCode, Organization, RegisterCode, User } from '@stamhoofd/models';
+import { EmailVerificationCode, Organization, User } from '@stamhoofd/models';
 import { CreateOrganization, PermissionLevel, Permissions, SignupResponse, UserPermissions } from "@stamhoofd/structures";
 import { Formatter } from "@stamhoofd/utility";
 
@@ -83,14 +81,14 @@ export class CreateOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
         organization.name = request.body.organization.name;
 
         // Delay save until after organization is saved, but do validations before the organization is saved
-        let registerCodeModels: Model[] = []
-        let delayEmails: EmailInterfaceBase[] = []
+        // let registerCodeModels: Model[] = []
+        // let delayEmails: EmailInterfaceBase[] = []
 
-        if (request.body.registerCode) {
-            const applied = await RegisterCode.applyRegisterCode(organization, request.body.registerCode)
-            registerCodeModels = applied.models
-            delayEmails = applied.emails
-        }
+        //if (request.body.registerCode) {
+        //    const applied = await RegisterCode.applyRegisterCode(organization, request.body.registerCode)
+        //    registerCodeModels = applied.models
+        //    delayEmails = applied.emails
+        //}
 
         organization.uri = uri;
         organization.meta = request.body.organization.meta
@@ -126,16 +124,16 @@ export class CreateOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
         user.permissions.organizationPermissions.set(organization.id, Permissions.create({ level: PermissionLevel.Full }))
         await user.save()
 
-        for (const model of registerCodeModels) {
-            await model.save()
-        }
+        // for (const model of registerCodeModels) {
+        //     await model.save()
+        // }
 
         const code = await EmailVerificationCode.createFor(user, user.email)
         code.send(user, organization, request.i18n)
 
-        for (const email of delayEmails) {
-            Email.sendInternal(email, organization.i18n)
-        }
+        // for (const email of delayEmails) {
+        //     Email.sendInternal(email, organization.i18n)
+        // }
 
         return new Response(SignupResponse.create({
             token: code.token

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.ts

@@ -45,7 +45,7 @@ export class SearchOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
         };
 
         // We had to add an order by in the query to fix the limit. MySQL doesn't want to limit the results correctly if we don't explicitly sort the results on their relevance
-        const organizations = await Organization.where({ searchIndex: match }, {
+        const organizations = await Organization.where({ searchIndex: match, active: 1 }, {
             limit: 15,
             sort: [
                 {

package/src/endpoints/global/platform/PatchPlatformEnpoint.ts

@@ -1,7 +1,7 @@
 import { AutoEncoderPatchType, Decoder, patchObject } from "@simonbackx/simple-encoding";
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { Organization, Platform, RegistrationPeriod } from "@stamhoofd/models";
-import { PlatformPremiseType, Platform as PlatformStruct } from "@stamhoofd/structures";
+import { MemberResponsibility, PlatformConfig, PlatformPremiseType, Platform as PlatformStruct } from "@stamhoofd/structures";
 
 import { SimpleError } from "@simonbackx/simple-errors";
 import { Context } from "../../../helpers/Context";
@@ -12,8 +12,15 @@ type Query = undefined;
 type Body = AutoEncoderPatchType<PlatformStruct>;
 type ResponseBody = PlatformStruct;
 
-export class PatchPlatformEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = PlatformStruct.patchType() as Decoder<AutoEncoderPatchType<PlatformStruct>>
+export class PatchPlatformEndpoint extends Endpoint<
+    Params,
+    Query,
+    Body,
+    ResponseBody
+> {
+    bodyDecoder = PlatformStruct.patchType() as Decoder<
+        AutoEncoderPatchType<PlatformStruct>
+    >;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method != "PATCH") {
@@ -29,65 +36,102 @@ export class PatchPlatformEndpoint extends Endpoint<Params, Query, Body, Respons
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
+        await Context.authenticate();
 
         // Fast throw first (more in depth checking for patches later)
         if (!Context.auth.hasPlatformFullAccess()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
-        const platform = await Platform.getShared()
+        const platform = await Platform.getShared();
 
         if (request.body.privateConfig) {
             // Did we patch roles?
             if (request.body.privateConfig.roles) {
                 if (!Context.auth.canManagePlatformAdmins()) {
-                    throw Context.auth.error()
+                    throw Context.auth.error();
                 }
 
                 // Update roles
-                platform.privateConfig.roles = patchObject(platform.privateConfig.roles, request.body.privateConfig.roles)
+                platform.privateConfig.roles = patchObject(
+                    platform.privateConfig.roles,
+                    request.body.privateConfig.roles
+                );
             }
 
             if (request.body.privateConfig.emails) {
                 if (!Context.auth.hasPlatformFullAccess()) {
-                    throw Context.auth.error()
+                    throw Context.auth.error();
                 }
 
                 // Update roles
-                platform.privateConfig.emails = patchObject(platform.privateConfig.emails, request.body.privateConfig.emails)
+                platform.privateConfig.emails = patchObject(
+                    platform.privateConfig.emails,
+                    request.body.privateConfig.emails
+                );
             }
         }
 
+        let shouldUpdateSetupSteps = false;
+
         if (request.body.config) {
             if (!Context.auth.hasPlatformFullAccess()) {
-                throw Context.auth.error()
+                throw Context.auth.error();
             }
 
+            const newConfig = request.body.config;
+
             // Update config
-            if(request.body.config.premiseTypes) {
-                const oldConfig = platform.config.clone();
-                platform.config = patchObject(platform.config, request.body.config);
-                const newPremiseTypes = platform.config.premiseTypes;
-
-                // update setup step premise types
-                if(this.shouldUpdateSetupStepPremise(newPremiseTypes, oldConfig.premiseTypes)) {
-                    await SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod({premiseTypes: newPremiseTypes});
+            if (newConfig) {
+                if (newConfig.premiseTypes || newConfig.responsibilities) {
+                    const oldConfig = platform.config.clone();
+                    platform.config = patchObject(platform.config, newConfig);
+                    const currentConfig = platform.config;
+
+                    shouldUpdateSetupSteps = this.shouldUpdateSetupSteps(
+                        currentConfig,
+                        newConfig,
+                        oldConfig
+                    );
+                } else {
+                    platform.config = patchObject(platform.config, newConfig);
                 }
-            } else {
-                platform.config = patchObject(platform.config, request.body.config)
             }
         }
 
-        if (request.body.period && request.body.period.id !== platform.periodId) {
-            const period = await RegistrationPeriod.getByID(request.body.period.id)
+        if (
+            request.body.period &&
+            request.body.period.id !== platform.periodId
+        ) {
+            const period = await RegistrationPeriod.getByID(
+                request.body.period.id
+            );
             if (!period || period.organizationId) {
                 throw new SimpleError({
                     code: "invalid_period",
-                    message: "Invalid period"
-                })
+                    message: "Invalid period",
+                });
+            }
+            platform.periodId = period.id;
+        }
+
+        if (request.body.membershipOrganizationId !== undefined) {
+            if (!Context.auth.hasPlatformFullAccess()) {
+                throw Context.auth.error()
+            }
+
+            if (request.body.membershipOrganizationId) {
+                const organization = await Organization.getByID(request.body.membershipOrganizationId)
+                if (!organization) {
+                    throw new SimpleError({
+                        code: "invalid_organization",
+                        message: "Invalid organization"
+                    })
+                }
+                platform.membershipOrganizationId = organization.id
+            } else {
+                platform.membershipOrganizationId = null
             }
-            platform.periodId = period.id
         }
 
         if (request.body.membershipOrganizationId !== undefined) {
@@ -109,35 +153,126 @@ export class PatchPlatformEndpoint extends Endpoint<Params, Query, Body, Respons
             }
         }
 
-        await platform.save()
+        await platform.save();
+
+        if(shouldUpdateSetupSteps) {
+            SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod().catch(console.error);
+        }
+
         return new Response(await Platform.getSharedPrivateStruct());
     }
 
-    private shouldUpdateSetupStepPremise(newPremiseTypes: PlatformPremiseType[], oldPremiseTypes: PlatformPremiseType[]) {
-        for(const premiseType of newPremiseTypes) {
+    private shouldUpdateSetupSteps(
+        currentConfig: PlatformConfig,
+        newConfig: PlatformConfig | AutoEncoderPatchType<PlatformConfig>,
+        oldConfig: PlatformConfig
+    ): boolean {
+        let shouldUpdate = false;
+        const premiseTypes: PlatformPremiseType[] = currentConfig.premiseTypes;
+        const responsibilities: MemberResponsibility[] =
+            currentConfig.responsibilities;
+
+        if (
+            newConfig.premiseTypes &&
+            this.shouldUpdateSetupStepPremise(
+                premiseTypes,
+                oldConfig.premiseTypes
+            )
+        ) {
+            shouldUpdate = true;
+        }
+
+        if (
+            !shouldUpdate &&
+            newConfig.responsibilities &&
+            this.shouldUpdateSetupStepFunctions(
+                responsibilities,
+                oldConfig.responsibilities
+            )
+        ) {
+            shouldUpdate = true;
+        }
+
+        return shouldUpdate;
+    }
+
+    private shouldUpdateSetupStepPremise(
+        newPremiseTypes: PlatformPremiseType[],
+        oldPremiseTypes: PlatformPremiseType[]
+    ) {
+        for (const premiseType of newPremiseTypes) {
             const id = premiseType.id;
-            const oldVersion = oldPremiseTypes.find(x => x.id === id);
+            const oldVersion = oldPremiseTypes.find((x) => x.id === id);
 
             // if premise type is not new
-            if(oldVersion) {
-                if(oldVersion.min !== premiseType.min || oldVersion.max !== premiseType.max) {
+            if (oldVersion) {
+                if (
+                    oldVersion.min !== premiseType.min ||
+                    oldVersion.max !== premiseType.max
+                ) {
                     return true;
                 }
                 continue;
             }
 
             // if premise type is new
-            if(premiseType.min || premiseType.max) {
+            if (premiseType.min || premiseType.max) {
                 return true;
             }
         }
 
-        for(const oldPremiseType of oldPremiseTypes) {
+        for (const oldPremiseType of oldPremiseTypes) {
             const id = oldPremiseType.id;
 
             // if premise type is removed
-            if(!newPremiseTypes.some(x => x.id === id)) {
-                if(oldPremiseType.min || oldPremiseType.max) {
+            if (!newPremiseTypes.some((x) => x.id === id)) {
+                if (oldPremiseType.min || oldPremiseType.max) {
+                    return true;
+                }
+            }
+        }
+    }
+
+    private shouldUpdateSetupStepFunctions(
+        newResponsibilities: MemberResponsibility[],
+        oldResponsibilities: MemberResponsibility[]
+    ) {
+        for (const responsibility of newResponsibilities) {
+            const id = responsibility.id;
+            const oldVersion = oldResponsibilities.find((x) => x.id === id);
+
+            // if responsibility is not new
+            if (oldVersion) {
+                // if restrictions changed
+                if (
+                    oldVersion.minimumMembers !==
+                        responsibility.minimumMembers ||
+                    oldVersion.maximumMembers !== responsibility.maximumMembers
+                ) {
+                    return true;
+                }
+                continue;
+            }
+
+            // if responsibility is new
+            if (
+                responsibility.minimumMembers ||
+                responsibility.maximumMembers
+            ) {
+                return true;
+            }
+        }
+
+        for (const oldResponsibility of oldResponsibilities) {
+            const id = oldResponsibility.id;
+
+            // if responsibility is removed
+            if (!newResponsibilities.some((x) => x.id === id)) {
+                // if responsibility had restrictions
+                if (
+                    oldResponsibility.minimumMembers ||
+                    oldResponsibility.maximumMembers
+                ) {
                     return true;
                 }
             }

package/src/endpoints/organization/dashboard/nolt/CreateNoltTokenEndpoint.ts

@@ -3,6 +3,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import jwt from 'jsonwebtoken';
 
 import { Context } from '../../../../helpers/Context';
+import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -39,7 +40,7 @@ export class CreateNoltTokenEndpoint extends Endpoint<Params, Query, Body, Respo
         if (!await Context.auth.hasSomeAccess(organization.id)) {
             throw Context.auth.error()
         }
-
+        
         // Create token
         const payload = {
             // The ID that you use in your app for this user