@stamhoofd/backend 2.1.3 → 2.3.1

package/.env.json

@@ -24,13 +24,13 @@
         "rendererApi": "renderer.stamhoofd"
     },
         "translationNamespace": "digit",
-    "userMode": "organization",
+    "userMode": "platform",
     
     "PORT": 9091,
     "DB_HOST": "127.0.0.1",
     "DB_USER": "root",
     "DB_PASS": "root",
-    "DB_DATABASE": "stamhoofd",
+    "DB_DATABASE": "ksa-stamhoofd",
 
     "SMTP_HOST": "0.0.0.0",
     "SMTP_USERNAME": "username",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.1.3",
+    "version": "2.3.1",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -50,5 +50,5 @@
         "postmark": "4.0.2",
         "stripe": "^11.5.0"
     },
-    "gitHead": "b5773c547dceaae52b9c2a098b222417fcd42e4f"
+    "gitHead": "9a2484194d078935d8b50c4aee790196d798435e"
 }

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

@@ -22,6 +22,9 @@ export const filterCompilers: SQLFilterDefinitions = {
     name: createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'name')
     ),
+    active: createSQLExpressionFilterCompiler(
+        SQL.column('organizations', 'active')
+    ),
     city: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
         undefined,
@@ -271,11 +274,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

@@ -136,6 +136,7 @@ const filterCompilers: SQLFilterDefinitions = {
             SQL.column('members', 'id'),
         ),
         {
+            ...baseSQLFilterCompilers,
             // Alias for responsibilityId
             "id": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
             "responsibilityId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
@@ -145,6 +146,29 @@ const filterCompilers: SQLFilterDefinitions = {
         }
     ),
 
+    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?
      */
@@ -388,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, RegistrationPeriod, 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);
@@ -169,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) {
@@ -232,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)
@@ -291,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?
@@ -338,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()) {
@@ -362,7 +373,8 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     })
                 }
 
-                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)
@@ -391,6 +403,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
                 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
@@ -506,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)
             }
@@ -553,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/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/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";
 
@@ -145,9 +145,11 @@ export class AuthenticatedStructures {
 
         // Load responsibilities
         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({