@stamhoofd/backend 2.1.2 → 2.2.0

package/.env.json

@@ -23,14 +23,14 @@
         "demoApi": "api.stamhoofd",
         "rendererApi": "renderer.stamhoofd"
     },
-        "translationNamespace": "stamhoofd",
+        "translationNamespace": "digit",
     "userMode": "organization",
     
     "PORT": 9091,
     "DB_HOST": "127.0.0.1",
     "DB_USER": "root",
     "DB_PASS": "root",
-    "DB_DATABASE": "stamhoofd1",
+    "DB_DATABASE": "stamhoofd",
 
     "SMTP_HOST": "0.0.0.0",
     "SMTP_USERNAME": "username",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.1.2",
+    "version": "2.2.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -50,5 +50,5 @@
         "postmark": "4.0.2",
         "stripe": "^11.5.0"
     },
-    "gitHead": "2332fe7ce5922e32a7e9c5c947fdde572aadcc03"
+    "gitHead": "d67b2ac7c63880195902d29df682a2f2a709b82b"
 }

package/src/endpoints/admin/invoices/GetInvoicesCountEndpoint.ts

@@ -0,0 +1,47 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
+
+import { Context } from '../../../helpers/Context';
+import { GetInvoicesEndpoint } from './GetInvoicesEndpoint';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetInvoicesCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/admin/invoices/count", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate()
+
+        if (!Context.auth.hasPlatformFullAccess()) {
+            throw Context.auth.error()
+        }
+        
+        const query = GetInvoicesEndpoint.buildQuery(request.query)
+        
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count
+            })
+        );
+    }
+}

package/src/endpoints/admin/invoices/GetInvoicesEndpoint.ts

@@ -0,0 +1,185 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Organization, Payment, STInvoice } from '@stamhoofd/models';
+import { SQL, SQLFilterDefinitions, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions, baseSQLFilterCompilers, compileToSQLFilter, compileToSQLSorter, createSQLExpressionFilterCompiler } from "@stamhoofd/sql";
+import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, Payment as PaymentStruct, STInvoicePrivate, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
+
+import { Context } from '../../../helpers/Context';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = undefined;
+type ResponseBody = PaginatedResponse<STInvoicePrivate[], LimitedFilteredRequest>
+
+export const filterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLExpressionFilterCompiler(
+        SQL.column('stamhoofd_invoices', 'id')
+    ),
+    number: createSQLExpressionFilterCompiler(
+        SQL.column('stamhoofd_invoices', 'number')
+    )
+}
+
+const sorters: SQLSortDefinitions<STInvoice> = {
+    'id': {
+        getValue(a) {
+            return a.id
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction
+            })
+        }
+    },
+    'number': {
+        getValue(a) {
+            return a.number
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('number'),
+                direction
+            })
+        }
+    }
+}
+
+export class GetInvoicesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/admin/invoices", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    static buildQuery(q: CountFilteredRequest|LimitedFilteredRequest) {        
+        const query = SQL
+            .select(
+                SQL.wildcard('stamhoofd_invoices')
+            )
+            .from(
+                SQL.table('stamhoofd_invoices')
+            )
+            .whereNot(SQL.column('stamhoofd_invoices', 'number'), null);
+
+
+        if (q.filter) {
+            query.where(compileToSQLFilter(q.filter, filterCompilers))
+        }
+
+        if (q.search) {
+            let searchFilter: StamhoofdFilter|null = null
+
+            // todo: auto detect e-mailaddresses and search on admins
+            searchFilter = {
+                name: {
+                    $contains: q.search
+                }
+            }
+
+            if (searchFilter) {
+                query.where(compileToSQLFilter(searchFilter, filterCompilers))
+            }
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
+            }
+
+            query.orderBy(compileToSQLSorter(q.sort, sorters))
+            query.limit(q.limit)
+        }
+       
+        return query
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate()
+
+        if (!Context.auth.hasPlatformFullAccess()) {
+            throw Context.auth.error()
+        }
+
+        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
+
+        if (request.query.limit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit
+            })
+        }
+        
+        if (request.query.limit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1'
+            })
+        }
+        
+        const data = await GetInvoicesEndpoint.buildQuery(request.query).fetch()
+        const invoices = STInvoice.fromRows(data, 'stamhoofd_invoices');
+
+        let next: LimitedFilteredRequest|undefined;
+
+        if (invoices.length >= request.query.limit) {
+            const lastObject = invoices[invoices.length - 1];
+            const nextFilter = getSortFilter(lastObject, sorters, request.query.sort);
+
+            next = new LimitedFilteredRequest({
+                filter: request.query.filter,
+                pageFilter: nextFilter,
+                sort: request.query.sort,
+                limit: request.query.limit,
+                search: request.query.search
+            })
+
+            if (JSON.stringify(nextFilter) === JSON.stringify(request.query.pageFilter)) {
+                console.error('Found infinite loading loop for', request.query);
+                next = undefined;
+            }
+        }
+        
+        // Get payments + organizations
+        const paymentIds = invoices.flatMap(i => i.paymentId ? [i.paymentId] : [])
+        const organizationIds = invoices.flatMap(i => i.organizationId ? [i.organizationId] : [])
+
+        const payments = await Payment.getByIDs(...paymentIds)
+        const organizations = await Organization.getByIDs(...organizationIds)
+
+        const structures: STInvoicePrivate[] = []
+        for (const invoice of invoices) {
+            const payment = payments.find(p => p.id === invoice.paymentId)
+            const organization = organizations.find(p => p.id === invoice.organizationId)
+            structures.push(
+                STInvoicePrivate.create({
+                    ...invoice,
+                    payment: payment ? PaymentStruct.create(payment) : null,
+                    organization: organization ? (await organization.getStructure({emptyGroups: true})) : undefined,
+                    settlement: payment?.settlement ?? null,
+                })
+            )
+        }
+
+        return new Response(
+            new PaginatedResponse<STInvoicePrivate[], LimitedFilteredRequest>({
+                results: structures,
+                next
+            })
+        );
+    }
+}

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -0,0 +1,88 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SQL, SQLAlias, SQLSum, SQLCount, SQLDistinct, SQLSelectAs } from '@stamhoofd/sql';
+import { ChargeMembershipsSummary } from '@stamhoofd/structures';
+import { Context } from '../../../helpers/Context';
+
+
+type Params = Record<string, never>;
+type Query = Record<string, never>;
+type Body = undefined;
+type ResponseBody = ChargeMembershipsSummary;
+
+export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/admin/charge-memberships/summary", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate()
+
+        if (!Context.auth.hasPlatformFullAccess()) {
+            throw Context.auth.error()
+        }
+        
+        const query = SQL
+            .select(
+                new SQLSelectAs(
+                    new SQLCount(
+                        new SQLDistinct(
+                            SQL.column('member_platform_memberships', 'id')
+                        )
+                    ),
+                    new SQLAlias('data__memberships')
+                ),
+                new SQLSelectAs(
+                    new SQLCount(
+                        new SQLDistinct(
+                            SQL.column('member_platform_memberships', 'memberId')
+                        )
+                    ),
+                    new SQLAlias('data__members')
+                ),
+                new SQLSelectAs(
+                    new SQLCount(
+                        new SQLDistinct(
+                            SQL.column('member_platform_memberships', 'organizationId')
+                        )
+                    ),
+                    new SQLAlias('data__organizations')
+                ),
+                new SQLSelectAs(
+                    new SQLSum(
+                        SQL.column('member_platform_memberships', 'price')
+                    ),
+                    new SQLAlias('data__price')
+                )
+            )
+            .from(
+                SQL.table('member_platform_memberships')
+            )
+            .where(SQL.column('invoiceId'), null)
+            .andWhere(SQL.column('invoiceItemDetailId'), null);
+
+
+        const result = await query.fetch();
+        const members = result[0]['data']['members'] as number;
+        const memberships = result[0]['data']['memberships'] as number;
+        const organizations = result[0]['data']['organizations'] as number;
+        const price = result[0]['data']['price'] as number;
+
+        return new Response(
+            ChargeMembershipsSummary.create({
+                memberships: memberships ?? 0,
+                members: members ?? 0,
+                price: price ?? 0,
+                organizations: organizations ?? 0
+            })
+        );
+    }
+}

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.ts

@@ -271,11 +271,13 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.authenticate()
 
-        if (request.query.limit > 100) {
+        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
+
+        if (request.query.limit > maxLimit) {
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
-                message: 'Limit can not be more than 100'
+                message: 'Limit can not be more than ' + maxLimit
             })
         }
 

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

@@ -48,6 +48,7 @@ const registrationFilterCompilers: SQLFilterDefinitions = {
         status: createSQLExpressionFilterCompiler(
             SQL.column('groups', 'status')
         ),
+        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId')),
     })
 }
 
@@ -125,6 +126,49 @@ const filterCompilers: SQLFilterDefinitions = {
         }
     ),
 
+    responsibilities: createSQLRelationFilterCompiler(
+        SQL.select()
+        .from(
+            SQL.table('member_responsibility_records')
+        )
+        .where(
+            SQL.column('memberId'),
+            SQL.column('members', 'id'),
+        ),
+        {
+            ...baseSQLFilterCompilers,
+            // Alias for responsibilityId
+            "id": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
+            "responsibilityId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
+            "organizationId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'organizationId')),
+            "startDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'startDate')),
+            "endDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'endDate')),
+        }
+    ),
+
+    platformMemberships: createSQLRelationFilterCompiler(
+        SQL.select()
+        .from(
+            SQL.table('member_platform_memberships')
+        )
+        .where(
+            SQL.column('memberId'),
+            SQL.column('members', 'id'),
+        ),
+        {
+            ...baseSQLFilterCompilers,
+            "id": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'id')),
+            "membershipTypeId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'membershipTypeId')),
+            "organizationId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'organizationId')),
+            "periodId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'periodId')),
+            "price": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'price')),
+            "invoiceId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'invoiceId')),
+            "startDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'startDate')),
+            "endDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'endDate')),
+            "expireDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'expireDate')),
+        }
+    ),
+
     /**
      * @deprecated?
      */
@@ -270,6 +314,11 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                             periodId: platform.periodId,
                             registeredAt: {
                                 $neq: null
+                            },
+                            group: {
+                                defaultAgeGroupId: {
+                                    $neq: null
+                                }
                             }
                         }
                     }
@@ -363,11 +412,13 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         await Context.setOptionalOrganizationScope();
         await Context.authenticate()
 
-        if (request.query.limit > 100) {
+        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
+
+        if (request.query.limit > maxLimit) {
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
-                message: 'Limit can not be more than 100'
+                message: 'Limit can not be more than ' + maxLimit
             })
         }
 

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

@@ -2,8 +2,8 @@ import { OneToManyRelation } from '@simonbackx/simple-database';
 import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from "@simonbackx/simple-errors";
-import { BalanceItem, BalanceItemPayment, Document, Group, Member, MemberFactory, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Payment, Platform, Registration, User } from '@stamhoofd/models';
-import { BalanceItemStatus, MemberWithRegistrationsBlob, MembersBlob, PaymentMethod, PaymentStatus, PermissionLevel, Registration as RegistrationStruct, User as UserStruct } from "@stamhoofd/structures";
+import { BalanceItem, MemberPlatformMembership, BalanceItemPayment, Document, Group, Member, MemberFactory, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Payment, Platform, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
+import { BalanceItemStatus, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, PaymentMethod, PaymentStatus, PermissionLevel, Registration as RegistrationStruct, User as UserStruct } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -52,6 +52,8 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
         const members: MemberWithRegistrations[] = []
 
+        const platform = await Platform.getShared()
+
         // Cache
         const groups: Group[] = []
         
@@ -71,6 +73,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
         const balanceItemMemberIds: string[] = []
         const balanceItemRegistrationIdsPerOrganization: Map<string, string[]> = new Map()
+        const updateMembershipMemberIds = new Set<string>()
 
         function addBalanceItemRegistrationId(organizationId: string, registrationId: string) {
             const existing = balanceItemRegistrationIdsPerOrganization.get(organizationId);
@@ -121,6 +124,14 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     throw Context.auth.notFoundOrNoAccess("Je hebt niet voldoende rechten om leden toe te voegen in deze groep")
                 }
 
+                const period = await RegistrationPeriod.getByID(group.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
+
                 // Set organization id of member based on registrations
                 if (!organization && STAMHOOFD.userMode !== 'platform' && !member.organizationId) {
                     member.organizationId = group.organizationId
@@ -161,6 +172,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             await member.save()
             members.push(member)
             balanceItemMemberIds.push(member.id)
+            updateMembershipMemberIds.add(member.id)
 
             // Add registrations
             for (const registrationStruct of struct.registrations) {
@@ -224,7 +236,12 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 }
 
                 let group: Group | null = null
-                
+
+                console.log('Patch registration', patchRegistration)
+
+                if (patchRegistration.group) {
+                    patchRegistration.groupId = patchRegistration.group.id
+                }
 
                 if (patchRegistration.groupId) {
                     group = await getGroup(patchRegistration.groupId)
@@ -263,6 +280,14 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     })
                 }
 
+                const period = await RegistrationPeriod.getByID(group.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
+
                 // TODO: allow group changes
                 registration.waitingList = patchRegistration.waitingList ?? registration.waitingList
 
@@ -275,6 +300,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 }
                 registration.cycle = patchRegistration.cycle ?? registration.cycle
                 registration.groupId = patchRegistration.groupId ?? registration.groupId
+                registration.group = group
                 registration.organizationId = patchRegistration.organizationId ?? registration.organizationId
 
                 // Check if we should create a placeholder payment?
@@ -322,6 +348,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 }
 
                 await registration.save()
+                updateMembershipMemberIds.add(member.id)
             }
 
             for (const deleteId of patch.registrations.getDeletes()) {
@@ -337,13 +364,21 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 if (!await Context.auth.canAccessRegistration(registration, PermissionLevel.Write)) {
                     throw Context.auth.error("Je hebt niet voldoende rechten om deze inschrijving te verwijderen")
                 }
+                const oldGroup = await getGroup(registration.groupId)
+                const period = oldGroup && await RegistrationPeriod.getByID(oldGroup.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
 
-                balanceItemMemberIds.push(member.id)                
+                balanceItemMemberIds.push(member.id)     
+                updateMembershipMemberIds.add(member.id)           
                 await BalanceItem.deleteForDeletedRegistration(registration.id)
                 await registration.delete()
                 member.registrations = member.registrations.filter(r => r.id !== deleteId)
 
-                const oldGroup = await getGroup(registration.groupId)
                 if (oldGroup) {
                     // We need to update this group occupancy because we moved one member away from it
                     updateGroups.set(oldGroup.id, oldGroup)
@@ -358,9 +393,17 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 if (!group || group.organizationId !== struct.organizationId || !await Context.auth.canAccessGroup(group, PermissionLevel.Write)) {
                     throw Context.auth.error("Je hebt niet voldoende rechten om inschrijvingen in deze groep te maken")
                 }
+                const period = await RegistrationPeriod.getByID(group.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
 
                 const reg = await this.addRegistration(member, struct, group)
                 balanceItemMemberIds.push(member.id)
+                updateMembershipMemberIds.add(member.id)
                 addBalanceItemRegistrationId(reg.organizationId, reg.id)
 
                 // We need to update this group occupancy because we moved one member away from it
@@ -476,6 +519,97 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 await PatchOrganizationMembersEndpoint.updateManagers(member)
             }
 
+            // Add platform memberships
+            for (const {put} of patch.platformMemberships.getPuts()) {
+                if (put.periodId !== platform.periodId) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "Invalid period",
+                        human: "Je kan geen aansluitingen maken voor een andere werkjaar dan het actieve werkjaar",
+                        field: "periodId"
+                    })
+                }
+
+                if (organization && put.organizationId !== organization.id) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "Invalid organization",
+                        human: "Je kan geen aansluitingen maken voor een andere vereniging",
+                        field: "organizationId"
+                    })
+                }
+
+                if (!await Context.auth.hasFullAccess(put.organizationId)) {
+                    throw Context.auth.error("Je hebt niet voldoende rechten om deze aansluiting toe te voegen")
+                }
+
+                if (!platform.config.membershipTypes.find(t => t.id === put.membershipTypeId)) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        field: "membershipTypeId",
+                        message: "Invalid membership type",
+                        human: "Dit aansluitingstype bestaat niet"
+                    })
+                }
+                
+                // Check duplicate memberships
+
+                // Check dates
+
+                // Calculate prices
+
+                const membership = new MemberPlatformMembership()
+                membership.id = put.id
+                membership.memberId = member.id
+                membership.membershipTypeId = put.membershipTypeId
+                membership.organizationId = put.organizationId
+                membership.periodId = put.periodId
+
+                membership.startDate = put.startDate
+                membership.endDate = put.endDate
+                membership.expireDate = put.expireDate
+
+                await membership.calculatePrice()
+                await membership.save()
+            }
+
+            // Delete platform memberships
+            for (const id of patch.platformMemberships.getDeletes()) {
+                const membership = await MemberPlatformMembership.getByID(id)
+
+                if (!membership || membership.memberId !== member.id) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        field: "id",
+                        message: "Invalid id",
+                        human: "Deze aansluiting bestaat niet"
+                    })
+                }
+
+                if (!await Context.auth.hasFullAccess(membership.organizationId)) {
+                    throw Context.auth.error("Je hebt niet voldoende rechten om deze aansluiting te verwijderen")
+                }
+
+                if (membership.periodId !== platform.periodId) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "Invalid period",
+                        human: "Je kan geen aansluitingen meer verwijderen voor een ander werkjaar dan het actieve werkjaar",
+                        field: "periodId"
+                    })
+                }
+
+                if (membership.invoiceId || membership.invoiceItemDetailId) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "Invalid invoice",
+                        human: "Je kan geen aansluiting verwijderen die al werd gefactureerd",
+                    })
+                }
+
+                await membership.delete()
+            }
+
             if (!members.find(m => m.id === member.id)) {
                 members.push(member)
             }
@@ -523,6 +657,12 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             }
         }
 
+        for (const member of members) {
+            if (updateMembershipMemberIds.has(member.id)) {
+                await member.updateMemberships()
+            }
+        }
+
         return new Response(
             await AuthenticatedStructures.membersBlob(members)
         );

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

@@ -1,9 +1,10 @@
 import { AutoEncoderPatchType, Decoder, patchObject } from "@simonbackx/simple-encoding";
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Platform } from "@stamhoofd/models";
+import { Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { Platform as PlatformStruct } from "@stamhoofd/structures";
 
 import { Context } from "../../../helpers/Context";
+import { SimpleError } from "@simonbackx/simple-errors";
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -57,6 +58,17 @@ export class PatchPlatformEndpoint extends Endpoint<Params, Query, Body, Respons
             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 (!period || period.organizationId) {
+                throw new SimpleError({
+                    code: "invalid_period",
+                    message: "Invalid period"
+                })
+            }
+            platform.periodId = period.id
+        }
+
         await platform.save()
         return new Response(await Platform.getSharedPrivateStruct());
     }

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -200,11 +200,17 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
 
             if (item.waitingList) {
                 registration.waitingList = true
+                registration.canRegister = false
                 registration.reservedUntil = null
                 await registration.save()
             } else {
-                registration.waitingList = false
-                registration.canRegister = false
+                if (registration.waitingList && registration.canRegister) {
+                    // Keep data: otherwise people cannot retry if the payment fails
+                    // We'll mark the registration as valid after the payment
+                } else {
+                    registration.waitingList = false
+                    registration.canRegister = false
+                }
                 registration.price = item.calculatedPrice
                 payRegistrations.push({
                     registration,
@@ -286,6 +292,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                 // registration.paymentId = payment.id
 
                 registration.reservedUntil = null
+                registration.canRegister = false
 
                 if (payment.method == PaymentMethod.Transfer || payment.method == PaymentMethod.PointOfSale || payment.status == PaymentStatus.Succeeded) {
                     await registration.markValid()

package/src/endpoints/global/registration-periods/PatchRegistrationPeriodsEndpoint.ts

@@ -4,7 +4,7 @@ import { RegistrationPeriod as RegistrationPeriodStruct } from "@stamhoofd/struc
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
-import { RegistrationPeriod } from '@stamhoofd/models';
+import { Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;
@@ -107,6 +107,9 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
             await model.delete();
         }
 
+        // Clear platform cache
+        Platform.clearCache()
+
         return new Response(
             periods.map(p => p.getStructure())
         );

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

@@ -1,8 +1,8 @@
 import { AutoEncoderPatchType, Decoder, ObjectData, patchObject } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
-import { Group, Organization,PayconiqPayment, Platform, StripeAccount, Token, User, Webshop } from '@stamhoofd/models';
-import { BuckarooSettings, GroupPrivateSettings, Organization as OrganizationStruct, OrganizationPatch, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, Permissions, PermissionsResourceType,ResourcePermissions, UserPermissions, Version, OrganizationMetaData } from "@stamhoofd/structures";
+import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, StripeAccount, User, Webshop } from '@stamhoofd/models';
+import { BuckarooSettings, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, UserPermissions } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
@@ -297,6 +297,36 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 organization.uri = request.body.uri
             }
 
+            if (request.body.period && request.body.period.id !== organization.periodId) {
+                const organizationPeriod = await OrganizationRegistrationPeriod.getByID(request.body.period.id)
+                if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "De periode die je wilt instellen bestaat niet (meer)",
+                        field: "period"
+                    })
+                }
+
+                const period = await RegistrationPeriod.getByID(organizationPeriod.periodId)
+                if (!period || (period.organizationId && period.organizationId !== organization.id)) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "De periode die je wilt instellen bestaat niet (meer)",
+                        field: "period"
+                    })
+                }
+
+                if (period.locked) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "De periode die je wilt instellen is reeds afgesloten",
+                        field: "period"
+                    })
+                }
+
+                organization.periodId = period.id
+            }
+
             // Save the organization
             await organization.save()
         } else {

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

@@ -3,7 +3,7 @@ import { GroupPrivateSettings, OrganizationRegistrationPeriod as OrganizationReg
 
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from "@simonbackx/simple-encoding";
 import { Context } from "../../../../helpers/Context";
-import { Group, OrganizationRegistrationPeriod, RegistrationPeriod } from "@stamhoofd/models";
+import { Group, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { SimpleError } from "@simonbackx/simple-errors";
 
 type Params = Record<string, never>;
@@ -37,10 +37,70 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
 
         if (!await Context.auth.hasFullAccess(organization.id)) {
             throw Context.auth.error()
-        } 
+        }
+
+        const platform = await Platform.getShared()
+
+        function validateDefaultGroupId(id: string|null): string|null {
+            if (id === null) {
+                return id;
+            }
+
+            if (platform.config.defaultAgeGroups.find(g => g.id === id)) {
+                return id;
+            }
+
+            throw new SimpleError({
+                code: "invalid_default_age_group",
+                message: "Invalid default age group",
+                human: "De standaard leeftijdsgroep is ongeldig",
+                statusCode: 400
+            })
+        }
 
         const structs: OrganizationRegistrationPeriodStruct[] = [];
 
+        for (const {put} of request.body.getPuts()) {
+            if (!await Context.auth.hasFullAccess(organization.id)) {
+                throw Context.auth.error()
+            }
+            const period = await RegistrationPeriod.getByID(put.period.id);
+
+            if (!period) {
+                throw new SimpleError({
+                    code: "not_found",
+                    message: "Period not found",
+                    statusCode: 404
+                })
+            }
+
+            const organizationPeriod = new OrganizationRegistrationPeriod();
+            organizationPeriod.id = put.id;
+            organizationPeriod.organizationId = organization.id;
+            organizationPeriod.periodId = put.period.id;
+            organizationPeriod.settings = put.settings;
+            await organizationPeriod.save();
+
+            for (const struct of put.groups) {
+                const model = new Group()
+                model.id = struct.id
+                model.organizationId = organization.id
+                model.defaultAgeGroupId = validateDefaultGroupId(struct.defaultAgeGroupId)
+                model.periodId = organizationPeriod.periodId
+                model.settings = struct.settings
+                model.privateSettings = struct.privateSettings ?? GroupPrivateSettings.create({})
+                model.status = struct.status
+                await model.updateOccupancy()
+                await model.save();
+            }
+            const groups = await Group.getAll(organization.id, organizationPeriod.periodId)
+
+            // Delete unreachable categories first
+            await organizationPeriod.cleanCategories(groups);
+            await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
+            structs.push(organizationPeriod.getStructure(period, groups));
+        }
+
         for (const patch of request.body.getPatches()) {
             const organizationPeriod = await OrganizationRegistrationPeriod.getByID(patch.id);
             if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
@@ -112,6 +172,7 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                 const model = new Group()
                 model.id = struct.id
                 model.organizationId = organization.id
+                model.defaultAgeGroupId = validateDefaultGroupId(struct.defaultAgeGroupId)
                 model.periodId = organizationPeriod.periodId
                 model.settings = struct.settings
                 model.privateSettings = struct.privateSettings ?? GroupPrivateSettings.create({})
@@ -181,6 +242,10 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                 if (struct.deletedAt !== undefined) {
                     model.deletedAt = struct.deletedAt
                 }
+
+                if (struct.defaultAgeGroupId !== undefined) {
+                    model.defaultAgeGroupId = validateDefaultGroupId(struct.defaultAgeGroupId)
+                }
                 
                 await model.updateOccupancy()
                 await model.save();
@@ -191,15 +256,13 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
 
             if (deleteUnreachable) {
                 // Delete unreachable categories first
-                await organization.cleanCategories(groups);
+                await organizationPeriod.cleanCategories(groups);
                 await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
             }
 
             if (period) {
-
                 structs.push(organizationPeriod.getStructure(period, groups));
             }
-
         }
 
         return new Response(

package/src/helpers/AuthenticatedStructures.ts

@@ -1,6 +1,6 @@
 import { SimpleError } from "@simonbackx/simple-errors";
-import { Group, MemberResponsibilityRecord, MemberWithRegistrations, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from "@stamhoofd/models";
-import { OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, MemberResponsibilityRecord as MemberResponsibilityRecordStruct, User as UserStruct, Group as GroupStruct, MembersBlob, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateWebshop, Webshop as WebshopStruct,WebshopPreview, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+import { Group, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from "@stamhoofd/models";
+import { MemberPlatformMembership as MemberPlatformMembershipStruct, MemberResponsibilityRecord as MemberResponsibilityRecordStruct, MemberWithRegistrationsBlob, MembersBlob, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateWebshop, User as UserStruct, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
 
 import { Context } from "./Context";
 
@@ -144,10 +144,12 @@ export class AuthenticatedStructures {
         }
 
         // Load responsibilities
-        const responsibilities = await MemberResponsibilityRecord.where({ memberId: { sign: 'IN', value: members.map(m => m.id) } })
+        const responsibilities = members.length > 0 ? await MemberResponsibilityRecord.where({ memberId: { sign: 'IN', value: members.map(m => m.id) } }) : []
+        const platformMemberships = members.length > 0 ? await MemberPlatformMembership.where({ memberId: { sign: 'IN', value: members.map(m => m.id) } }) : []
 
         for (const blob of memberBlobs) {
             blob.responsibilities = responsibilities.filter(r => r.memberId == blob.id).map(r => MemberResponsibilityRecordStruct.create(r))
+            blob.platformMemberships = platformMemberships.filter(r => r.memberId == blob.id).map(r => MemberPlatformMembershipStruct.create(r))
         }
 
         return MembersBlob.create({