@stamhoofd/backend 2.18.0 → 2.20.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/billing/GetDetailedBillingStatusEndpoint.ts

@@ -1,5 +1,5 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { OrganizationDetailedBillingStatus, OrganizationDetailedBillingStatusItem, PaymentMethod } from "@stamhoofd/structures";
+import { OrganizationDetailedBillingStatus, OrganizationDetailedBillingStatusItem, PaymentMethod, PaymentStatus } from "@stamhoofd/structures";
 
 import { BalanceItem, Organization, Payment } from "@stamhoofd/models";
 import { SQL } from "@stamhoofd/sql";
@@ -41,8 +41,7 @@ export class GetDetailedBillingStatusEndpoint extends Endpoint<Params, Query, Bo
         const paymentModels = await Payment.select()
             .where('payingOrganizationId', organization.id)
             .andWhere(
-                SQL.whereNot('paidAt', null)
-                    .or('method', [PaymentMethod.Transfer, PaymentMethod.DirectDebit, PaymentMethod.PointOfSale, PaymentMethod.Unknown])
+                SQL.whereNot('status', PaymentStatus.Failed)
             )
             .fetch()
 

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

package/src/helpers/MembershipCharger.ts

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