@stamhoofd/backend 2.4.0 → 2.6.0

package/src/endpoints/global/webshops/GetWebshopFromDomainEndpoint.ts

@@ -78,7 +78,7 @@ export class GetWebshopFromDomainEndpoint extends Endpoint<Params, Query, Body,
                     }
 
                     return new Response(GetWebshopFromDomainResult.create({
-                        organization: await organization.getStructure({emptyGroups: true}),
+                        organization: organization.getBaseStructure(),
                         webshop: WebshopStruct.create(webshop)
                     }));
                 }
@@ -113,14 +113,14 @@ export class GetWebshopFromDomainEndpoint extends Endpoint<Params, Query, Body,
             if (!webshop) {
                 // Return organization, so we know the locale + can do some custom logic
                 return new Response(GetWebshopFromDomainResult.create({
-                    organization: await organization.getStructure({emptyGroups: true}),
+                    organization: organization.getBaseStructure(),
                     webshop: null,
                     webshops: []
                 }));
             }
 
             return new Response(GetWebshopFromDomainResult.create({
-                organization: await organization.getStructure({emptyGroups: true}),
+                organization: organization.getBaseStructure(),
                 webshop: WebshopStruct.create(webshop)
             }));
         }
@@ -156,7 +156,7 @@ export class GetWebshopFromDomainEndpoint extends Endpoint<Params, Query, Body,
 
                 // Return organization, and the known webshops on this domain
                 return new Response(GetWebshopFromDomainResult.create({
-                    organization: await organization.getStructure({emptyGroups: true}),
+                    organization: organization.getBaseStructure(),
                     webshop: null,
                     webshops: webshops.map(w => WebshopPreview.create(w)).filter(w => w.isClosed(0) === false).sort((a, b) => Sorter.byStringValue(a.meta.name, b.meta.name))
                 }));
@@ -180,7 +180,7 @@ export class GetWebshopFromDomainEndpoint extends Endpoint<Params, Query, Body,
         }
 
         return new Response(GetWebshopFromDomainResult.create({
-            organization: await organization.getStructure({emptyGroups: true}),
+            organization: organization.getBaseStructure(),
             webshop: WebshopStruct.create(webshop)
         }));
     }

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

@@ -1,10 +1,11 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Group as GroupStruct, GroupPrivateSettings, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, PermissionLevel, PermissionsResourceType, ResourcePermissions, Version } from "@stamhoofd/structures";
+import { Group as GroupStruct, GroupPrivateSettings, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, PermissionLevel, PermissionsResourceType, ResourcePermissions, Version, GroupType } from "@stamhoofd/structures";
 
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from "@simonbackx/simple-encoding";
 import { Context } from "../../../../helpers/Context";
 import { Group, Member, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { SimpleError } from "@simonbackx/simple-errors";
+import { AuthenticatedStructures } from "../../../../helpers/AuthenticatedStructures";
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -33,13 +34,13 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        const {user} = await Context.authenticate()
+        await Context.authenticate()
 
         if (!await Context.auth.hasFullAccess(organization.id)) {
             throw Context.auth.error()
         }
 
-        const structs: OrganizationRegistrationPeriodStruct[] = [];
+        const periods: OrganizationRegistrationPeriod[] = [];
 
         for (const {put} of request.body.getPuts()) {
             if (!await Context.auth.hasFullAccess(organization.id)) {
@@ -70,7 +71,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             // Delete unreachable categories first
             await organizationPeriod.cleanCategories(groups);
             await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
-            structs.push(organizationPeriod.getPrivateStructure(period, groups));
+            periods.push(organizationPeriod);
         }
 
         for (const patch of request.body.getPatches()) {
@@ -131,28 +132,27 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
 
             for (const groupPut of patch.groups.getPuts()) {
                 await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(groupPut.put, organization.id, organizationPeriod.periodId, {allowedIds})
+                deleteUnreachable = true
             }
 
             for (const struct of patch.groups.getPatches()) {
                 await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(struct)
             }
 
-            const period = await RegistrationPeriod.getByID(organizationPeriod.periodId);
-            const groups = await Group.getAll(organization.id, organizationPeriod.periodId)
 
             if (deleteUnreachable) {
+                const groups = await Group.getAll(organization.id, organizationPeriod.periodId)
+
                 // Delete unreachable categories first
                 await organizationPeriod.cleanCategories(groups);
                 await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
             }
 
-            if (period) {
-                structs.push(organizationPeriod.getPrivateStructure(period, groups));
-            }
+            periods.push(organizationPeriod);
         }
 
         return new Response(
-            structs
+            await AuthenticatedStructures.organizationRegistrationPeriods(periods),
         );
     }
 
@@ -223,10 +223,64 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         if (struct.defaultAgeGroupId !== undefined) {
             model.defaultAgeGroupId = await this.validateDefaultGroupId(struct.defaultAgeGroupId)
         }
+
+        const patch = struct;
+        if (patch.waitingList !== undefined) {
+            if (patch.waitingList === null) {
+                // delete
+                if (model.waitingListId) {
+                    // for now don't delete, as waiting lists can be shared between multiple groups
+                    // await PatchOrganizationRegistrationPeriodsEndpoint.deleteGroup(model.waitingListId)
+                    model.waitingListId = null;
+                }
+
+            } else if (patch.waitingList.isPatch()) {
+                if (!model.waitingListId) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        field: 'waitingList',
+                        message: 'Cannot patch waiting list before it is created'
+                    })
+                }
+                patch.waitingList.id = model.waitingListId
+                patch.waitingList.type = GroupType.WaitingList
+                await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(patch.waitingList)
+            } else {
+                if (model.waitingListId) {
+                    // for now don't delete, as waiting lists can be shared between multiple groups
+                    // await PatchOrganizationRegistrationPeriodsEndpoint.deleteGroup(model.waitingListId)
+                    model.waitingListId = null;
+                }
+                patch.waitingList.type = GroupType.WaitingList
+
+                const existing = await Group.getByID(patch.waitingList.id)
+                if (existing) {
+                    if (existing.organizationId !== model.organizationId) {
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            field: 'waitingList',
+                            message: 'Waiting list group is already used in another organization'
+                        })
+                    }
+
+                    model.waitingListId = existing.id
+                } else {
+                    const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(
+                        patch.waitingList,
+                        model.organizationId,
+                        model.periodId
+                    )
+                    model.waitingListId = group.id
+                }
+            }
+        }
         
         await model.updateOccupancy()
         await model.save();
-        Member.updateMembershipsForGroupId(model.id)
+
+        if (struct.deletedAt !== undefined || struct.defaultAgeGroupId !== undefined) {
+            Member.updateMembershipsForGroupId(model.id)
+        }
     }
 
 
@@ -278,6 +332,29 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             })
         }
 
+        if (struct.waitingList) {
+            const existing = await Group.getByID(struct.waitingList.id)
+            if (existing) {
+                if (existing.organizationId !== model.organizationId) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        field: 'waitingList',
+                        message: 'Waiting list group is already used in another organization'
+                    })
+                }
+
+                model.waitingListId = existing.id
+            } else {
+                struct.waitingList.type = GroupType.WaitingList
+                const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(
+                    struct.waitingList,
+                    model.organizationId,
+                    model.periodId
+                )
+                model.waitingListId = group.id
+            }
+        }
+
         await model.updateOccupancy()
         await model.save();
         return model;

package/src/endpoints/organization/dashboard/stripe/ConnectStripeEndpoint.ts

@@ -46,17 +46,22 @@ export class ConnectMollieEndpoint extends Endpoint<Params, Query, Body, Respons
             })
         }
 
-        const type = 'express'
+        const type = STAMHOOFD.STRIPE_CONNECT_METHOD
 
-        let expressData: Stripe.AccountCreateParams = {
-            country: organization.address.country,
-            // Problem: we cannot set company or business_type, because then it defaults the structure of the company to one that requires a company number
+        const sharedData: Stripe.AccountCreateParams = {
             capabilities: {
                 card_payments: { requested: true },
                 transfers: { requested: true },
                 bancontact_payments: { requested: true },
                 ideal_payments: { requested: true },
             },
+        }
+
+        let expressData: Stripe.AccountCreateParams = {
+            country: organization.address.country,
+            controller: {
+                requirement_collection: 'application',
+            },
             settings: {
                 payouts: {
                     schedule: {
@@ -76,6 +81,7 @@ export class ConnectMollieEndpoint extends Endpoint<Params, Query, Body, Respons
         const stripe = StripeHelper.getInstance()
         const account = await stripe.accounts.create({
             type,
+            ...sharedData,
             ...expressData
         });
 

package/src/endpoints/organization/dashboard/stripe/GetStripeAccountLinkEndpoint.ts

@@ -68,7 +68,10 @@ export class GetStripeAccountLinkEndpoint extends Endpoint<Params, Query, Body,
             refresh_url: request.body.refreshUrl,
             return_url: request.body.returnUrl,
             type: 'account_onboarding',
-            collect: model.meta.type === 'express' ? 'eventually_due' : undefined, // Collect all at the start
+            collection_options: {
+                fields: 'eventually_due',
+                future_requirements: 'include'
+            }
         });
 
         return new Response(ResponseBody.create({

package/src/endpoints/organization/dashboard/stripe/GetStripeLoginLinkEndpoint.ts

@@ -59,6 +59,12 @@ export class GetStripeLoginLinkEndpoint extends Endpoint<Params, Query, Body, Re
             })
         }
 
+        if (model.meta.type === 'standard') {
+            return new Response(ResponseBody.create({
+                url: 'https://dashboard.stripe.com/'
+            }));
+        }
+
         const stripe = StripeHelper.getInstance()
         const accountLink = await stripe.accounts.createLoginLink(model.accountId);
 

package/src/endpoints/organization/dashboard/webshops/PatchWebshopOrdersEndpoint.ts

@@ -243,13 +243,18 @@ export class PatchWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Re
                 // Update balance item prices for this order if price has changed
                 if (previousToPay !== model.totalToPay) {
                     const items = await BalanceItem.where({ orderId: model.id })
-                    if (items.length === 1) {
+                    if (items.length >= 1) {
                         model.markUpdated()
                         items[0].price = model.totalToPay
                         items[0].description = model.generateBalanceDescription(webshop)
                         items[0].updateStatus();
                         await items[0].save()
-                    } else if (items.length === 0 && model.totalToPay > 0) {
+
+                        // Zero out the other items
+                        const otherItems = items.slice(1)
+                        await BalanceItem.deleteItems(otherItems)
+                    } else if (items.length === 0
+                         && model.totalToPay > 0) {
                         model.markUpdated()
                         const balanceItem = new BalanceItem();
                         balanceItem.orderId = model.id;

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

@@ -2,11 +2,11 @@ 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, Member, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Registration, STPendingInvoice } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, STPendingInvoice } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { Payment as PaymentStruct, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, STInvoiceItem } from "@stamhoofd/structures";
-import { Formatter } from '@stamhoofd/utility';
+import { PaymentGeneral, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, STInvoiceItem } from "@stamhoofd/structures";
 
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { BuckarooHelper } from '../../../helpers/BuckarooHelper';
 import { Context } from '../../../helpers/Context';
 import { StripeHelper } from '../../../helpers/StripeHelper';
@@ -27,7 +27,7 @@ class Query extends AutoEncoder {
     cancel = false
 }
 type Body = undefined
-type ResponseBody = PaymentStruct | undefined;
+type ResponseBody = PaymentGeneral | 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
@@ -51,6 +51,9 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope()
+        if (!request.query.exchange) {
+            await Context.authenticate()
+        }
         
         // Not method on payment because circular references (not supprted in ts)
         const payment = await ExchangePaymentEndpoint.pollStatus(request.params.id, organization, request.query.cancel)
@@ -66,28 +69,9 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
         }
         
         return new Response( 
-            PaymentStruct.create({
-                id: payment.id,
-                method: payment.method,
-                provider: payment.provider,
-                status: payment.status,
-                price: payment.price,
-                transferDescription: payment.transferDescription,
-                paidAt: payment.paidAt,
-                createdAt: payment.createdAt,
-                updatedAt: payment.updatedAt
-            })
+            await AuthenticatedStructures.paymentGeneral(payment, true)
         );
     }
-    
-    static async updateOutstanding(items: BalanceItem[], organizationId: string) {
-        // Update outstanding amount of related members and registrations
-        const memberIds: string[] = Formatter.uniqueArray(items.map(p => p.memberId).filter(id => id !== null)) as any
-        await Member.updateOutstandingBalance(memberIds)
-
-        const registrationIds: string[] = Formatter.uniqueArray(items.map(p => p.registrationId).filter(id => id !== null)) as any
-        await Registration.updateOutstandingBalance(registrationIds, organizationId)
-    }
 
     static async handlePaymentStatusUpdate(payment: Payment, organization: Organization, status: PaymentStatus) {
         if (payment.status === status) {
@@ -101,15 +85,16 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
 
             // Prevent concurrency issues
             await QueueHandler.schedule("balance-item-update/"+organization.id, async () => {
+                const unloaded = (await BalanceItemPayment.where({paymentId: payment.id})).map(r => r.setRelation(BalanceItemPayment.payment, payment))
                 const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
-                    (await BalanceItemPayment.where({paymentId: payment.id})).map(r => r.setRelation(BalanceItemPayment.payment, payment))
+                    unloaded
                 );
 
                 for (const balanceItemPayment of balanceItemPayments) {
                     await balanceItemPayment.markPaid(organization);
                 }
 
-                await this.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
+                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
             })
 
             if (!wasPaid && payment.provider === PaymentProvider.Buckaroo && payment.method) {
@@ -152,7 +137,7 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
                     await balanceItemPayment.undoPaid(organization);
                 }
 
-                await this.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
+                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
             })
         }
         
@@ -166,7 +151,7 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
                     await balanceItemPayment.markFailed(organization);
                 }
 
-                await this.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
+                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem), organization.id)
             })
         }
 

package/src/helpers/AdminPermissionChecker.ts

@@ -224,6 +224,12 @@ export class AdminPermissionChecker {
             return true
         }
 
+        if (member.registrations.length === 0 && permissionLevel !== PermissionLevel.Full && (this.organization && await this.hasFullAccess(this.organization.id, PermissionLevel.Full))) {
+            // Everyone with at least full access to at least one organization can access this member
+            // This allows organizations to register new members themselves
+            return true;
+        }
+
         for (const registration of member.registrations) {
             if (await this.canAccessRegistration(registration, permissionLevel)) {
                 return true;
@@ -360,8 +366,7 @@ export class AdminPermissionChecker {
         permissionLevel: PermissionLevel = PermissionLevel.Read,
         data?: {
             registrations: Registration[],
-            orders: Order[],
-            members: Member[]
+            orders: Order[]
         }
     ): Promise<boolean> {
         for (const balanceItem of balanceItems) {
@@ -397,7 +402,7 @@ export class AdminPermissionChecker {
         }
 
         // Slight optimization possible here
-        const {registrations, orders, members} = data ?? (this.user.permissions || permissionLevel === PermissionLevel.Read) ? (await Payment.loadBalanceItemRelations(balanceItems)) : {registrations: [], members: [] as Member[], orders: []}
+        const {registrations, orders} = data ?? (this.user.permissions || permissionLevel === PermissionLevel.Read) ? (await Payment.loadBalanceItemRelations(balanceItems)) : {registrations: [], orders: []}
 
         if (this.user.permissions) {
             // We grant permission for a whole payment when the user has at least permission for a part of that payment.
@@ -425,7 +430,7 @@ export class AdminPermissionChecker {
             // Check members
             const userMembers = await Member.getMembersWithRegistrationForUser(this.user)
             for (const member of userMembers) {
-                if (members.find(m => m.id === member.id)) {
+                if (balanceItems.find(m => m.memberId === member.id)) {
                     return true;
                 }
             }

package/src/helpers/AuthenticatedStructures.ts

@@ -1,6 +1,7 @@
 import { SimpleError } from "@simonbackx/simple-errors";
 import { Event, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from "@stamhoofd/models";
 import { Event as EventStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberResponsibilityRecord as MemberResponsibilityRecordStruct, MemberWithRegistrationsBlob, MembersBlob, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateWebshop, User as UserStruct, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType } from '@stamhoofd/structures';
 
 import { Context } from "./Context";
 import { Formatter } from "@stamhoofd/utility";
@@ -25,11 +26,11 @@ export class AuthenticatedStructures {
         }
 
         const {balanceItemPayments, balanceItems} = await Payment.loadBalanceItems(payments)
-        const {registrations, orders, members, groups} = await Payment.loadBalanceItemRelations(balanceItems);
+        const {registrations, orders, groups} = await Payment.loadBalanceItemRelations(balanceItems);
 
         if (checkPermissions) {
             // Note: permission checking is moved here for performacne to avoid loading the data multiple times
-            if (!(await Context.auth.canAccessBalanceItems(balanceItems, PermissionLevel.Read, {registrations, orders, members}))) {
+            if (!(await Context.auth.canAccessBalanceItems(balanceItems, PermissionLevel.Read, {registrations, orders}))) {
                 throw new SimpleError({
                     code: "not_found",
                     message: "Payment not found",
@@ -40,22 +41,82 @@ export class AuthenticatedStructures {
 
         const includeSettlements = checkPermissions && !!Context.user && !!Context.user.permissions
 
-        return Payment.getGeneralStructureFromRelations({
+        return await Payment.getGeneralStructureFromRelations({
             payments,
             balanceItemPayments,
             balanceItems,
             registrations,
             orders,
-            members,
             groups
         }, includeSettlements)
     }
 
     static async group(group: Group) {
-        if (!await Context.optionalAuth?.canAccessGroup(group)) {
-            return group.getStructure()
+        return (await this.groups([group]))[0]
+    }
+
+    static async groups(groups: Group[]) {
+        const waitingListIds = Formatter.uniqueArray(groups.map(g => g.waitingListId).filter(id => id !== null) as string[])
+        const waitingLists = waitingListIds.length > 0 ? await Group.getByIDs(...waitingListIds) : []
+
+        const structs: GroupStruct[] = []
+        for (const group of groups) {
+            const waitingList = waitingLists.find(g => g.id == group.waitingListId) ?? null
+            const waitingListStruct = waitingList ? GroupStruct.create(waitingList) : null
+            if (waitingList && waitingListStruct && !await Context.optionalAuth?.canAccessGroup(waitingList)) {
+                waitingListStruct.privateSettings = null;
+            }
+
+            const struct = GroupStruct.create({
+                ...group,
+                waitingList: waitingListStruct
+            })
+
+            if (!await Context.optionalAuth?.canAccessGroup(group)) {
+                struct.privateSettings = null;
+            }
+
+            structs.push(struct)
+        }
+
+        return structs;
+    }
+
+    static async organizationRegistrationPeriods(organizationRegistrationPeriods: OrganizationRegistrationPeriod[]) {
+        if (organizationRegistrationPeriods.length === 0) {
+            return [];
+        }
+
+        const periodIds = Formatter.uniqueArray(organizationRegistrationPeriods.map(p => p.periodId))
+        const periods = await RegistrationPeriod.getByIDs(...periodIds)
+
+        const groupIds = Formatter.uniqueArray(organizationRegistrationPeriods.flatMap(p => p.settings.categories.flatMap(c => c.groupIds)))
+        const groups = groupIds.length ? await Group.getByIDs(...groupIds) : []
+
+        const groupStructs = await this.groups(groups)
+
+        const structs: OrganizationRegistrationPeriodStruct[] = []
+        for (const organizationPeriod of organizationRegistrationPeriods) {
+            const period = periods.find(p => p.id == organizationPeriod.periodId) ?? null
+            if (!period) {
+                continue
+            }
+            const groupIds = Formatter.uniqueArray(organizationPeriod.settings.categories.flatMap(c => c.groupIds))
+
+            structs.push(
+                OrganizationRegistrationPeriodStruct.create({
+                    ...organizationPeriod,
+                    period: period.getStructure(),
+                    groups: groupStructs.filter(gg => groupIds.includes(gg.id)).sort(GroupStruct.defaultSort)
+                })
+            )
         }
-        return group.getPrivateStructure()
+
+        return structs
+    }
+
+    static async organizationRegistrationPeriod(organizationRegistrationPeriod: OrganizationRegistrationPeriod) {
+        return (await this.organizationRegistrationPeriods([organizationRegistrationPeriod]))[0]
     }
 
     static async webshop(webshop: Webshop) {
@@ -66,6 +127,8 @@ export class AuthenticatedStructures {
     }
 
     static async organization(organization: Organization): Promise<OrganizationStruct> {
+        const organizationPeriod = await organization.getPeriod()
+
         if (await Context.optionalAuth?.canAccessPrivateOrganizationData(organization)) {
             const webshops = await Webshop.where({ organizationId: organization.id }, { select: Webshop.selectColumnsWithout(undefined, "products", "categories")})
             const webshopStructures: WebshopPreview[] = [] 
@@ -77,35 +140,29 @@ export class AuthenticatedStructures {
                 webshopStructures.push(WebshopPreview.create(w))
             }
 
-            const {groups, organizationPeriod, period} = await organization.getPeriod({emptyGroups: false})
-
             return OrganizationStruct.create({
-                id: organization.id,
-                name: organization.name,
-                meta: organization.meta,
-                address: organization.address,
-                registerDomain: organization.registerDomain,
-                uri: organization.uri,
-                website: organization.website,
+                ...organization.getBaseStructure(),
                 privateMeta: organization.privateMeta,
                 webshops: webshopStructures,
-                createdAt: organization.createdAt,
-                period: organizationPeriod.getPrivateStructure(period, groups)
+                period: await this.organizationRegistrationPeriod(organizationPeriod)
             })
         }
         
-        return await organization.getStructure()
+        return OrganizationStruct.create({
+            ...organization.getBaseStructure(),
+            period: await this.organizationRegistrationPeriod(organizationPeriod)
+        })
     }
 
     static async adminOrganizations(organizations: Organization[]): Promise<OrganizationStruct[]> {
         const structs: OrganizationStruct[] = [];
 
         for (const organization of organizations) {
-            const base = await organization.getStructure({emptyGroups: true})
+            const base = organization.getBaseStructure()
             structs.push(base)
         }
         
-        return structs
+        return Promise.resolve(structs)
     }
 
     static async userWithMembers(user: User): Promise<UserWithMembers> {
@@ -114,7 +171,9 @@ export class AuthenticatedStructures {
         return UserWithMembers.create({
             ...user,
             hasAccount: user.hasAccount(),
-            members: await this.membersBlob(members, false, user)
+
+            // Always include the current context organization - because it is possible we switch organization and we don't want to refetch every time
+            members: await this.membersBlob(members, true, user)
         })
     }
 
@@ -207,17 +266,19 @@ export class AuthenticatedStructures {
         // Load groups
         const groupIds = events.map(e => e.groupId).filter(id => id !== null) as string[]
         const groups = groupIds.length > 0 ? await Group.getByIDs(...groupIds) : []
+        const groupStructs = await this.groups(groups)
 
         const result: EventStruct[] = []
 
         for (const event of events) {
-            const group = groups.find(g => g.id == event.groupId) ?? null
+            const group = groupStructs.find(g => g.id == event.groupId) ?? null
 
-            if (group && await Context.auth.canAccessGroup(group)) {
-                result.push(event.getPrivateStructure(group))
-            } else {
-                result.push(event.getStructure(group))
-            }
+            const struct = EventStruct.create({
+                ...event,
+                group
+            })
+
+            result.push(struct)
         }
         
         return result