@stamhoofd/backend 2.19.0 → 2.21.0

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

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

@@ -262,7 +262,7 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                     }
                 }
 
-                if (request.body.meta?.tags) {
+                if (request.body.meta?.tags && (Array.isArray(request.body.meta?.tags) || request.body.meta?.tags.changes.length > 0)) {
                     if (!Context.auth.hasPlatformFullAccess()) {
                         throw Context.auth.error()
                     }

package/src/endpoints/organization/dashboard/registration-periods/SetupStepReviewEndpoint.ts

@@ -42,7 +42,7 @@ export class SetupStepReviewEndpoint extends Endpoint<Params, Query, Body, Respo
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        const { user } = await Context.authenticate()
 
         if (!await Context.auth.hasFullAccess(organization.id)) {
             throw Context.auth.error()
@@ -64,7 +64,10 @@ export class SetupStepReviewEndpoint extends Endpoint<Params, Query, Body, Respo
         const setupSteps = organizationPeriod.setupSteps;
 
         if(isReviewed) {
-            setupSteps.markReviewed(stepType);
+            setupSteps.markReviewed(stepType, {
+                userId: user.id,
+                userName: user.name ?? '?'
+            });
         } else {
             setupSteps.resetReviewed(stepType);
         } 

package/src/endpoints/organization/shared/ExchangePaymentEndpoint.ts

@@ -2,19 +2,15 @@ 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 { BalanceItem, BalanceItemPayment, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, STPendingInvoice } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { PaymentGeneral, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, STInvoiceItem } from "@stamhoofd/structures";
+import { PaymentGeneral, PaymentMethod, PaymentProvider, PaymentStatus } from "@stamhoofd/structures";
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { BuckarooHelper } from '../../../helpers/BuckarooHelper';
 import { Context } from '../../../helpers/Context';
 import { StripeHelper } from '../../../helpers/StripeHelper';
 
-function calculateFee(totalPrice: number, fixed: number, percentageTimes100: number) {
-    return Math.round(fixed + Math.max(1, totalPrice * percentageTimes100 / 100 / 100)); // € 0,21 + 0,2%
-}
-
 type Params = {id: string};
 class Query extends AutoEncoder {
     @field({ decoder: BooleanDecoder, optional: true })
@@ -77,7 +73,7 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
         if (payment.status === status) {
             return;
         }
-        const wasPaid = payment.paidAt !== null
+        // const wasPaid = payment.paidAt !== null
         if (status === PaymentStatus.Succeeded) {
             payment.status = PaymentStatus.Succeeded
             payment.paidAt = new Date()
@@ -97,31 +93,31 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
                 await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
             })
 
-            if (!wasPaid && payment.provider === PaymentProvider.Buckaroo && payment.method) {
-                // Charge transaction fees
-                let fee = 0
-
-                if (payment.method === PaymentMethod.iDEAL) {
-                    fee = calculateFee(payment.price, 21, 20); // € 0,21 + 0,2%
-                } else if (payment.method === PaymentMethod.Bancontact || payment.method === PaymentMethod.Payconiq) {
-                    fee = calculateFee(payment.price, 24, 20); // € 0,24 + 0,2%
-                } else {
-                    fee = calculateFee(payment.price, 25, 150); // € 0,25 + 1,5%
-                }
-
-                const name = "Transactiekosten voor "+PaymentMethodHelper.getName(payment.method)
-                const item = STInvoiceItem.create({
-                    name,
-                    description: "Via Buckaroo",
-                    amount: 1,
-                    unitPrice: fee,
-                    canUseCredits: false
-                })
-                console.log("Scheduling transaction fee charge for ", payment.id, item)
-                await QueueHandler.schedule("billing/invoices-"+organization.id, async () => {
-                    await STPendingInvoice.addItems(organization, [item])
-                });
-            }
+            //if (!wasPaid && payment.provider === PaymentProvider.Buckaroo && payment.method) {
+            //    // Charge transaction fees
+            //    let fee = 0
+            //
+            //    if (payment.method === PaymentMethod.iDEAL) {
+            //        fee = calculateFee(payment.price, 21, 20); // € 0,21 + 0,2%
+            //    } else if (payment.method === PaymentMethod.Bancontact || payment.method === PaymentMethod.Payconiq) {
+            //        fee = calculateFee(payment.price, 24, 20); // € 0,24 + 0,2%
+            //    } else {
+            //        fee = calculateFee(payment.price, 25, 150); // € 0,25 + 1,5%
+            //    }
+            //
+            //    const name = "Transactiekosten voor "+PaymentMethodHelper.getName(payment.method)
+            //    const item = STInvoiceItem.create({
+            //        name,
+            //        description: "Via Buckaroo",
+            //        amount: 1,
+            //        unitPrice: fee,
+            //        canUseCredits: false
+            //    })
+            //    console.log("Scheduling transaction fee charge for ", payment.id, item)
+            //    await QueueHandler.schedule("billing/invoices-"+organization.id, async () => {
+            //        await STPendingInvoice.addItems(organization, [item])
+            //    });
+            //}
             return;
         }
 

package/src/helpers/AdminPermissionChecker.ts

@@ -1,6 +1,6 @@
 import { AutoEncoderPatchType, PatchMap } from "@simonbackx/simple-encoding"
 import { SimpleError } from "@simonbackx/simple-errors"
-import { BalanceItem, Document, DocumentTemplate, EmailTemplate, Event, Group, Member, MemberWithRegistrations, Order, Organization, Payment, Registration, User, Webshop } from "@stamhoofd/models"
+import { BalanceItem, Document, DocumentTemplate, EmailTemplate, Event, Group, Member, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, User, Webshop } from "@stamhoofd/models"
 import { AccessRight, FinancialSupportSettings, GroupCategory, GroupStatus, MemberWithRegistrationsBlob, PermissionLevel, PermissionsResourceType, Platform as PlatformStruct, RecordCategory } from "@stamhoofd/structures"
 import { Formatter } from "@stamhoofd/utility"
 
@@ -75,6 +75,11 @@ export class AdminPermissionChecker {
         return result;
     }
 
+    async getOrganizationCurrentPeriod(id: string|Organization): Promise<OrganizationRegistrationPeriod> {
+        const organization = await this.getOrganization(id); 
+        return await organization.getPeriod()
+    }
+
     error(message?: string): SimpleError {
         return new SimpleError({
             code: "permission_denied",
@@ -171,7 +176,8 @@ export class AdminPermissionChecker {
         }
 
         // Check parent categories
-        const parentCategories = group.getParentCategories(organization.meta.categories)
+        const organizationPeriod = await this.getOrganizationCurrentPeriod(organization)
+        const parentCategories = group.getParentCategories(organizationPeriod.settings.categories)
         for (const category of parentCategories) {
             if (organizationPermissions.hasResourceAccess(PermissionsResourceType.GroupCategories, category.id, permissionLevel)) {
                 return true
@@ -677,11 +683,22 @@ export class AdminPermissionChecker {
             return false;
         }
 
-        if (!organizationPermissions.hasResourceAccessRight(PermissionsResourceType.GroupCategories, category.id, AccessRight.OrganizationCreateGroups)) {
-            return false;
+        if (organizationPermissions.hasResourceAccessRight(PermissionsResourceType.GroupCategories, category.id, AccessRight.OrganizationCreateGroups)) {
+            return true;
         }
 
-        return true;
+        // Check parents
+        const organization = await this.getOrganization(organizationId)
+        const organizationPeriod = await this.getOrganizationCurrentPeriod(organization)
+        const parentCategories = category.getParentCategories(organizationPeriod.settings.categories)
+
+        for (const parentCategory of parentCategories) {
+            if (organizationPermissions.hasResourceAccessRight(PermissionsResourceType.GroupCategories, parentCategory.id, AccessRight.OrganizationCreateGroups)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     canUpload() {

package/src/helpers/AuthenticatedStructures.ts

@@ -238,11 +238,12 @@ export class AuthenticatedStructures {
                     }
                 }
             }
-
+            member.registrations = member.registrations.filter(r => (Context.auth.organization && Context.auth.organization.active && r.organizationId === Context.auth.organization.id) || (organizations.get(r.organizationId)?.active ?? false))
             const blob = member.getStructureWithRegistrations()
             memberBlobs.push(
                 await Context.auth.filterMemberData(member, blob)
             )
+
         }
 
         // Load responsibilities
@@ -268,7 +269,7 @@ export class AuthenticatedStructures {
 
         return MembersBlob.create({
             members: memberBlobs,
-            organizations: await Promise.all([...organizations.values()].map(o => this.organization(o)))
+            organizations: await Promise.all([...organizations.values()].filter(o => o.active).map(o => this.organization(o)))
         })
     }