@stamhoofd/backend 2.25.2 → 2.27.2

package/LICENSE

@@ -1,4 +1,8 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
+This license applies to the entire repository except for subfolders that
+have their own license file. In such cases, the license file in the 
+subfolder takes precedence.
+
+                    GNU AFFERO GENERAL PUBLIC LICENSE                    
                        Version 3, 19 November 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
@@ -658,4 +662,4 @@ specific requirements.
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
+<https://www.gnu.org/licenses/>.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.25.2",
+    "version": "2.27.2",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -36,14 +36,14 @@
         "@simonbackx/simple-encoding": "2.15.1",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.25.2",
-        "@stamhoofd/backend-middleware": "2.25.2",
-        "@stamhoofd/email": "2.25.2",
-        "@stamhoofd/models": "2.25.2",
-        "@stamhoofd/queues": "2.25.2",
-        "@stamhoofd/sql": "2.25.2",
-        "@stamhoofd/structures": "2.25.2",
-        "@stamhoofd/utility": "2.25.2",
+        "@stamhoofd/backend-i18n": "2.27.2",
+        "@stamhoofd/backend-middleware": "2.27.2",
+        "@stamhoofd/email": "2.27.2",
+        "@stamhoofd/models": "2.27.2",
+        "@stamhoofd/queues": "2.27.2",
+        "@stamhoofd/sql": "2.27.2",
+        "@stamhoofd/structures": "2.27.2",
+        "@stamhoofd/utility": "2.27.2",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -60,5 +60,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "2eda2d1bc9aa4ea061b002d265a5615a87eeef8b"
+    "gitHead": "4c7804970b02fa339d884ace0105a6efc6dab179"
 }

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

@@ -3,6 +3,8 @@ import { SQL, SQLAlias, SQLCount, SQLDistinct, SQLSelectAs, SQLSum } from '@stam
 import { ChargeMembershipsSummary, ChargeMembershipsTypeSummary } from '@stamhoofd/structures';
 import { Context } from '../../../helpers/Context';
 import { QueueHandler } from '@stamhoofd/queues';
+import { Platform } from '@stamhoofd/models';
+import { SimpleError } from '@simonbackx/simple-errors';
 
 
 type Params = Record<string, never>;
@@ -39,6 +41,9 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
             );
         }
         
+        const platform = await Platform.getShared()
+        const chargeVia = platform.membershipOrganizationId
+
         const query = SQL
             .select(
                 new SQLSelectAs(
@@ -73,7 +78,9 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
                 )
             )
             .from('member_platform_memberships')
-            .where('balanceItemId', null);
+            .where('balanceItemId', null)
+            .where('deletedAt', null)
+            .whereNot('organizationId', chargeVia)
 
         const result = await query.fetch();
         const members = result[0]['data']['members'] as number;
@@ -88,12 +95,12 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
                 members: members ?? 0,
                 price: price ?? 0,
                 organizations: organizations ?? 0,
-                membershipsPerType: await this.fetchPerType()
+                membershipsPerType: await this.fetchPerType(chargeVia)
             })
         );
     }
 
-    async fetchPerType() {
+    async fetchPerType(chargeVia: string|null) {
         const query = SQL
             .select(
                 SQL.column('member_platform_memberships', 'membershipTypeId'),
@@ -130,6 +137,8 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
             )
             .from('member_platform_memberships')
             .where('balanceItemId', null)
+            .where('deletedAt', null)
+            .whereNot('organizationId', chargeVia)
             .groupBy(
                 SQL.column('member_platform_memberships', 'membershipTypeId')
             );

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

@@ -4,7 +4,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Organization } from '@stamhoofd/models';
 import { SQL, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
-import { CountFilteredRequest, LimitedFilteredRequest, Organization as OrganizationStruct, PaginatedResponse, PermissionLevel, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
+import { CountFilteredRequest, LimitedFilteredRequest, Organization as OrganizationStruct, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
@@ -88,6 +88,7 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
                 query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
             }
 
+            q.sort = assertSort(q.sort, [{key: 'id'}])
             query.orderBy(compileToSQLSorter(q.sort, sorters))
             query.limit(q.limit)
         }

package/src/endpoints/global/events/GetEventsEndpoint.ts

@@ -3,85 +3,21 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Event } from '@stamhoofd/models';
-import { SQL, SQLFilterDefinitions, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions, baseSQLFilterCompilers, compileToSQLFilter, compileToSQLSorter, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler } from "@stamhoofd/sql";
-import { CountFilteredRequest, Event as EventStruct, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
-import { Formatter } from '@stamhoofd/utility';
+import { SQL, SQLFilterDefinitions, SQLSortDefinitions, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
+import { CountFilteredRequest, Event as EventStruct, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
+import { eventFilterCompilers } from '../../../sql-filters/events';
+import { eventSorters } from '../../../sql-sorters/events';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<EventStruct[], LimitedFilteredRequest>
 
-const filterCompilers: SQLFilterDefinitions = {
-    ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    name: createSQLColumnFilterCompiler('name'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    startDate: createSQLColumnFilterCompiler('startDate'),
-    endDate: createSQLColumnFilterCompiler('endDate'),
-    groupIds: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
-        {isJSONValue: true, isJSONObject: true}
-    ),
-    defaultAgeGroupIds: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
-        {isJSONValue: true, isJSONObject: true}
-    ),
-    organizationTagIds: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
-        {isJSONValue: true, isJSONObject: true}
-    )
-}
-
-const sorters: SQLSortDefinitions<Event> = {
-    'id': {
-        getValue(a) {
-            return a.id
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('id'),
-                direction
-            })
-        }
-    },
-    'name': {
-        getValue(a) {
-            return a.name
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('name'),
-                direction
-            })
-        }
-    },
-    'startDate': {
-        getValue(a) {
-            return Formatter.dateTimeIso(a.startDate)
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('startDate'),
-                direction
-            })
-        }
-    },
-    'endDate': {
-        getValue(a) {
-            return Formatter.dateTimeIso(a.endDate)
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('endDate'),
-                direction
-            })
-        }
-    },
-}
+const filterCompilers: SQLFilterDefinitions = eventFilterCompilers
+const sorters: SQLSortDefinitions<Event> = eventSorters
 
 export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
@@ -112,7 +48,7 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
                     {
                         organizationId: null
                     }
-                ]
+                ],
             };
         }
 
@@ -152,6 +88,7 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
                 query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
             }
 
+            q.sort = assertSort(q.sort, [{key: 'id'}])
             query.orderBy(compileToSQLSorter(q.sort, sorters))
             query.limit(q.limit)
         }

package/src/endpoints/global/events/PatchEventsEndpoint.ts

@@ -104,7 +104,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(
                     put.group,
                     put.group.organizationId,
-                    period.id
+                    period
                 )
                 await event.syncGroupRequirements(group)
                 event.groupId = group.id
@@ -199,7 +199,9 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     }
                     patch.group.id = event.groupId
                     patch.group.type = GroupType.EventRegistration
-                    await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(patch.group)
+
+                    const period = await RegistrationPeriod.getByDate(event.startDate)
+                    await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(patch.group, period)
                 } else {
                     if (event.groupId) {
                         // need to delete old group first
@@ -222,7 +224,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(
                         patch.group,
                         patch.group.organizationId,
-                        period.id
+                        period
                     )
                     event.groupId = group.id
                 }

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

@@ -4,7 +4,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Member, Platform } from '@stamhoofd/models';
 import { SQL, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
-import { CountFilteredRequest, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
+import { CountFilteredRequest, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 import { DataValidator } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -174,6 +174,7 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                 query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
             }
 
+            q.sort = assertSort(q.sort, [{key: 'id'}])
             query.orderBy(compileToSQLSorter(q.sort, sorters))
             query.limit(q.limit)
         }

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

@@ -171,8 +171,13 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     })
                 }
                 
+                const wasReduced = member.details.shouldApplyReducedPrice
                 member.details.patchOrPut(patch.details)
                 member.details.cleanData()
+
+                if (wasReduced !== member.details.shouldApplyReducedPrice) {
+                    updateMembershipMemberIds.add(member.id)
+                }
             }
             
             await member.save();
@@ -213,10 +218,13 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 }
 
                 if (patchResponsibility.startDate !== undefined) {
-
-                    if (patchResponsibility.startDate > new Date()) {
+                    if (patchResponsibility.startDate.getTime() > Date.now() + 5 * 60 * 1000) {
                         throw Context.auth.error("Je kan de startdatum van een functie niet in de toekomst zetten")
                     }
+                    if (patchResponsibility.startDate.getTime() > Date.now()) {
+                        patchResponsibility.startDate = new Date() // force now
+                    }
+
                     const daysDiff = Math.abs((new Date().getTime() - patchResponsibility.startDate.getTime()) / (1000 * 60 * 60 * 24))
 
                     if (daysDiff > 60 && !Context.auth.hasPlatformFullAccess()) {
@@ -343,10 +351,14 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 // Allow patching begin and end date
                 model.endDate = put.endDate
 
-                if (put.startDate > new Date()) {
+                if (put.startDate.getTime() > Date.now() + 5 * 60 * 1000) {
                     throw Context.auth.error("Je kan de startdatum van een functie niet in de toekomst zetten")
                 }
 
+                if (put.startDate.getTime() > Date.now()) {
+                    put.startDate = new Date() // force now
+                }
+
                 if (put.endDate && put.endDate > new Date(Date.now() + 60*1000)) {
                     throw Context.auth.error("Je kan de einddatum van een functie niet in de toekomst zetten - kijk indien nodig je systeemtijd na")
                 }
@@ -430,7 +442,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 membership.endDate = put.endDate
                 membership.expireDate = put.expireDate
 
-                await membership.calculatePrice()
+                await membership.calculatePrice(member)
                 await membership.save()
 
                 updateMembershipMemberIds.add(member.id)           

package/src/endpoints/global/payments/StripeWebhookEndpoint.ts

@@ -6,6 +6,7 @@ import { Organization, StripeAccount, StripeCheckoutSession, StripePaymentIntent
 
 import { StripeHelper } from '../../../helpers/StripeHelper';
 import { ExchangePaymentEndpoint } from '../../organization/shared/ExchangePaymentEndpoint';
+import { QueueHandler } from '@stamhoofd/queues';
 
 type Params = Record<string, never>;
 class Body extends AutoEncoder {
@@ -19,7 +20,7 @@ class Body extends AutoEncoder {
     id: string
 
     /**
-     * Events for direct charges
+     * Set for connect events
      */
     @field({ decoder: StringDecoder, nullable: true, optional: true })
     account: string|null = null
@@ -64,7 +65,8 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
                     statusCode: 400
                 })
             }
-            event = await stripe.webhooks.constructEventAsync(await request.request.bodyPromise!, sig, STAMHOOFD.STRIPE_ENDPOINT_SECRET);
+            const secret = request.body.account ? STAMHOOFD.STRIPE_CONNECT_ENDPOINT_SECRET : STAMHOOFD.STRIPE_ENDPOINT_SECRET
+            event = await stripe.webhooks.constructEventAsync(await request.request.bodyPromise!, sig, secret);
         } catch (err) {
             throw new SimpleError({
                 code: "invalid_signature",
@@ -99,16 +101,9 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
             case "payment_intent.requires_action":
             case "payment_intent.succeeded": {
                 const intentId = request.body.data.object.id;
-                const [model] = await StripePaymentIntent.where({stripeIntentId: intentId}, {limit: 1})
-                if (model && model.organizationId) {
-                    const organization = await Organization.getByID(model.organizationId)
-                    if (organization) {
-                        await ExchangePaymentEndpoint.pollStatus(model.paymentId, organization)
-                    } else {
-                        console.warn("Could not find organization with id", model.organizationId)
-                    }
-                } else {
-                    console.warn("Could not find stripe payment intent with id", intentId)
+                
+                if (intentId && typeof intentId === "string") {
+                    await this.updateIntent(intentId)
                 }
                 break;
             }
@@ -130,6 +125,27 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
                 }
                 break;
             }
+            // Listen for charge changes (transaction fees will be added here, after the payment intent succeeded)
+            case "charge.captured":
+            case "charge.expired":
+            case "charge.failed":
+            case "charge.pending":
+            case "charge.refunded":
+            case "charge.succeeded":
+            case "charge.dispute.created":
+            case "charge.dispute.updated":
+            case "charge.dispute.closed":
+            case "charge.refund.updated":
+            case "charge.refund.succeeded":
+            case "charge.updated": {
+                const intentId = request.body.data.object.payment_intent;
+                if (intentId && typeof intentId === "string") {
+                    await this.updateIntent(intentId)
+                } else {
+                    console.log('Received charge event without payment intent', request.body)
+                }
+                break;
+            }
             default: {
                 console.log("Unhandled stripe webhook type", request.body.type);
                 break;
@@ -137,4 +153,19 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
         }
         return new Response(undefined);
     }
+
+    async updateIntent(intentId: string) {
+        console.log("[Webooks] Updating intent", intentId)
+        const [model] = await StripePaymentIntent.where({stripeIntentId: intentId}, {limit: 1})
+        if (model && model.organizationId) {
+            const organization = await Organization.getByID(model.organizationId)
+            if (organization) {
+                await ExchangePaymentEndpoint.pollStatus(model.paymentId, organization)
+            } else {
+                console.warn("Could not find organization with id", model.organizationId)
+            }
+        } else {
+            console.warn("Could not find stripe payment intent with id", intentId)
+        }
+    }
 }

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

@@ -1,4 +1,4 @@
-import { AutoEncoderPatchType, Decoder, patchObject } from "@simonbackx/simple-encoding";
+import { AutoEncoderPatchType, Decoder, isPatch, isPatchableArray, patchObject } from "@simonbackx/simple-encoding";
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { Organization, Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { MemberResponsibility, PlatformConfig, PlatformPremiseType, Platform as PlatformStruct } from "@stamhoofd/structures";
@@ -7,6 +7,7 @@ import { SimpleError } from "@simonbackx/simple-errors";
 import { Context } from "../../../helpers/Context";
 import { SetupStepUpdater } from "../../../helpers/SetupStepsUpdater";
 import { PeriodHelper } from "../../../helpers/PeriodHelper";
+import { MembershipHelper } from "../../../helpers/MembershipHelper";
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -75,6 +76,7 @@ export class PatchPlatformEndpoint extends Endpoint<
 
         let shouldUpdateSetupSteps = false;
         let shouldMoveToPeriod: RegistrationPeriod | null = null;
+        let shouldUpdateMemberships = false;
 
         if (request.body.config) {
             if (!Context.auth.hasPlatformFullAccess()) {
@@ -99,6 +101,18 @@ export class PatchPlatformEndpoint extends Endpoint<
                     platform.config = patchObject(platform.config, newConfig);
                 }
             }
+
+            if (newConfig.membershipTypes && isPatchableArray(newConfig.membershipTypes) && newConfig.membershipTypes.changes.length > 0) {
+                shouldUpdateMemberships = true;
+            }
+
+            if (newConfig.defaultAgeGroups && isPatchableArray(newConfig.defaultAgeGroups) && newConfig.defaultAgeGroups.changes.length > 0) {
+                for (const d of newConfig.defaultAgeGroups.getPatches()) {
+                    if (d.defaultMembershipTypeId !== undefined) {
+                        shouldUpdateMemberships = true;
+                    }
+                }
+            }
         }
 
         if (
@@ -159,6 +173,10 @@ export class PatchPlatformEndpoint extends Endpoint<
 
         await platform.save();
 
+        if (shouldUpdateMemberships) {
+            MembershipHelper.updateAll().catch(console.error)
+        }
+
         if (shouldMoveToPeriod) {
             PeriodHelper.moveAllOrganizationsToPeriod(shouldMoveToPeriod).catch(console.error)
         } else if(shouldUpdateSetupSteps) {

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

@@ -5,6 +5,7 @@ import { RegistrationPeriod as RegistrationPeriodStruct } from "@stamhoofd/struc
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { Context } from '../../../helpers/Context';
+import { PeriodHelper } from '../../../helpers/PeriodHelper';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -90,6 +91,9 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
             }
 
             await model.save();
+
+            // Schedule patch of all groups in this period
+            PeriodHelper.updateGroupsInPeriod(model).catch(console.error);
         }
 
         for (const id of request.body.getDeletes()) {

package/src/endpoints/organization/dashboard/payments/GetPaymentsEndpoint.ts

@@ -134,11 +134,8 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
             }
 
-            query.orderBy(compileToSQLSorter(assertSort(q.sort, [
-                {
-                    key: 'id'
-                }
-            ]), sorters))
+            q.sort = assertSort(q.sort, [{key: 'id'}])
+            query.orderBy(compileToSQLSorter(q.sort, sorters))
             query.limit(q.limit)
         }
        

package/src/endpoints/organization/dashboard/payments/PatchPaymentsEndpoint.ts

@@ -69,6 +69,7 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
             payment.organizationId = organization.id
             payment.status = PaymentStatus.Created
             payment.method = put.method
+            payment.customer = put.customer
 
             if (payment.method == PaymentMethod.Transfer) {
                 if (!put.transferSettings) {

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

@@ -81,6 +81,9 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             let deleteUnreachable = false
             const allowedIds: string[] = []
 
+            //#region prevent patch category lock if no full platform access
+            const originalCategories = organizationPeriod.settings.categories;
+
             if (await Context.auth.hasFullAccess(organization.id)) {
                 if (patch.settings) {
                     if(patch.settings.categories) {
@@ -117,6 +120,49 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
                 }
             }
 
+            //#region handle locked categories
+            if(!Context.auth.hasPlatformFullAccess()) {
+                const categoriesAfterPatch = organizationPeriod.settings.categories;
+
+                for(const categoryBefore of originalCategories) {
+                    const locked = categoryBefore.settings.locked;
+
+                    if(locked) {
+                        // todo: use existing function, now a category could still be deleted if the category is moved to another category and that catetory is deleted
+                        const categoryId = categoryBefore.id;
+                        const refCountBefore = originalCategories.filter(c => c.categoryIds.includes(categoryId)).length;
+                        const refCountAfter = categoriesAfterPatch.filter(c => c.categoryIds.includes(categoryId)).length;
+                        const isDeleted = refCountAfter < refCountBefore;
+
+                        if(isDeleted) {
+                            throw Context.auth.error('Je hebt geen toegangsrechten om deze vergrendelde categorie te verwijderen.')
+                        }
+                    }
+
+                    const categoryAfter = categoriesAfterPatch.find(c => c.id === categoryBefore.id);
+                    
+                    if(!categoryAfter) {
+                        if(locked) {
+                            throw Context.auth.error('Je hebt geen toegangsrechten om deze vergrendelde categorie te verwijderen.')
+                        }
+                    } else if(locked !== categoryAfter.settings.locked) {
+                        throw Context.auth.error('Je hebt geen toegangsrechten om deze categorie te vergrendelen of ontgrendelen.')
+                    }
+
+                    if(!locked || !categoryAfter) {
+                        continue;
+                    }
+
+                    const settingsBefore = categoryBefore.settings;
+                    const settingsAfter = categoryAfter.settings;
+
+                    if(settingsBefore.name !== settingsAfter.name) {
+                        throw Context.auth.error('Je hebt geen toegangsrechten de naam van deze vergrendelde categorie te wijzigen.')
+                    }
+                }
+            }
+            //#endregion
+
             await organizationPeriod.save();
 
             // Check changes to groups
@@ -129,12 +175,12 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             }
 
             for (const groupPut of patch.groups.getPuts()) {
-                await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(groupPut.put, organization.id, organizationPeriod.periodId, {allowedIds})
+                await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(groupPut.put, organization.id, period, {allowedIds})
                 deleteUnreachable = true
             }
 
             for (const struct of patch.groups.getPatches()) {
-                await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(struct)
+                await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(struct, period)
             }
 
 
@@ -191,7 +237,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         await organizationPeriod.save();
 
         for (const s of struct.groups) {
-            await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(s, organization.id, organizationPeriod.periodId)
+            await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(s, organization.id, period)
         }
         const groups = await Group.getAll(organization.id, organizationPeriod.periodId)
 
@@ -213,7 +259,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         Member.updateMembershipsForGroupId(id)
     }
 
-    static async patchGroup(struct: AutoEncoderPatchType<GroupStruct>) {
+    static async patchGroup(struct: AutoEncoderPatchType<GroupStruct>, period?: RegistrationPeriod | null) {
         const model = await Group.getByID(struct.id)
 
         if (!model || !await Context.auth.canAccessGroup(model, PermissionLevel.Full)) {
@@ -221,6 +267,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         }
 
         if (struct.settings) {
+            struct.settings.period = undefined // Not allowed to patch manually
             model.settings.patchOrPut(struct.settings)
         }
 
@@ -252,6 +299,15 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             model.defaultAgeGroupId = await this.validateDefaultGroupId(struct.defaultAgeGroupId)
         }
 
+        if (!period && !model.settings.period) {
+            period = await RegistrationPeriod.getByID(model.periodId)
+        }
+
+        if (period) {
+            model.periodId = period.id
+            model.settings.period = period.getBaseStructure()
+        }
+
         const patch = struct;
         if (patch.waitingList !== undefined) {
             if (patch.waitingList === null) {
@@ -272,7 +328,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
                 }
                 patch.waitingList.id = model.waitingListId
                 patch.waitingList.type = GroupType.WaitingList
-                await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(patch.waitingList)
+                await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(patch.waitingList, period)
             } else {
                 if (model.waitingListId) {
                     // for now don't delete, as waiting lists can be shared between multiple groups
@@ -302,10 +358,15 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
 
                     model.waitingListId = existing.id
                 } else {
+                    const requiredPeriod = period ?? await RegistrationPeriod.getByID(model.periodId)
+
+                    if (!requiredPeriod) {
+                        throw new Error('Unexpected missing period when creating waiting list')
+                    }
                     const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(
                         patch.waitingList,
                         model.organizationId,
-                        model.periodId
+                        requiredPeriod
                     )
                     model.waitingListId = group.id
                 }
@@ -322,7 +383,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
     }
 
 
-    static async createGroup(struct: GroupStruct, organizationId: string, periodId: string, options?: {allowedIds?: string[]}): Promise<Group> {
+    static async createGroup(struct: GroupStruct, organizationId: string, period: RegistrationPeriod, options?: {allowedIds?: string[]}): Promise<Group> {
         const allowedIds = options?.allowedIds ?? []
 
         if (!await Context.auth.hasFullAccess(organizationId)) {
@@ -339,11 +400,12 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         model.id = struct.id
         model.organizationId = organizationId
         model.defaultAgeGroupId = await this.validateDefaultGroupId(struct.defaultAgeGroupId)
-        model.periodId = periodId
+        model.periodId = period.id
         model.settings = struct.settings
         model.privateSettings = struct.privateSettings ?? GroupPrivateSettings.create({})
         model.status = struct.status
         model.type = struct.type
+        model.settings.period = period.getBaseStructure()
 
         if (!await Context.auth.canAccessGroup(model, PermissionLevel.Full)) {
             // Create a temporary permission role for this user
@@ -387,7 +449,7 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
                 const group = await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(
                     struct.waitingList,
                     model.organizationId,
-                    model.periodId
+                    period
                 )
                 model.waitingListId = group.id
             }

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

@@ -5,6 +5,7 @@ import { PermissionLevel } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
 import { StripeHelper } from '../../../../helpers/StripeHelper';
+import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = { id: string };
 type Body = undefined;
@@ -41,6 +42,14 @@ export class DeleteStripeAccountEndpoint extends Endpoint<Params, Query, Body, R
             throw Context.auth.notFoundOrNoAccess("Account niet gevonden")
         }
 
+        if (model.accountId === STAMHOOFD.STRIPE_ACCOUNT_ID) {
+            throw new SimpleError({
+                code: "invalid_request",
+                message: "Je kan het hoofdaccount van het platform niet verwijderen.",
+                statusCode: 400
+            })
+        }
+
         // For now we don't delete them in Stripe because this causes issues with data access
         const stripe = StripeHelper.getInstance()
         

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

@@ -174,6 +174,7 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
      */
     static async pollStatus(paymentId: string, organization: Organization, cancel = false): Promise<Payment | undefined> {
         // Prevent polling the same payment multiple times at the same time: create a queue to prevent races
+        QueueHandler.cancel("payments/"+paymentId); // Prevent creating more than one queue item for the same payment
         return await QueueHandler.schedule("payments/"+paymentId, async () => {
             // Get a new copy of the payment (is required to prevent concurreny bugs)
             const payment = await Payment.getByID(paymentId)
@@ -324,6 +325,14 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
                         await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed)
                     }
                 }
+            } else {
+                // Do a manual update if needed
+                if (payment.status === PaymentStatus.Succeeded) {
+                    if (payment.provider === PaymentProvider.Stripe) {
+                        // Update the status
+                        await StripeHelper.getStatus(payment, false, testMode)
+                    }
+                }
             }
             return payment
         })

package/src/helpers/AdminPermissionChecker.ts

@@ -980,7 +980,7 @@ export class AdminPermissionChecker {
 
         const hasRecordAnswers = !!data.details.recordAnswers;
         const hasNotes = data.details.notes !== undefined;
-        const isSetFinancialSupportTrue = data.details.requiresFinancialSupport?.value === true;
+        const isSetFinancialSupportTrue = data.details.shouldApplyReducedPrice;
         const isUserManager = this.isUserManager(member);
 
         if (hasRecordAnswers) {

package/src/helpers/MemberUserSyncer.ts

@@ -14,12 +14,14 @@ export class MemberUserSyncerStatic {
         // Make sure all these users have access to the member
         for (const email of userEmails) {
             // Link users that are found with these email addresses.
-            await this.linkUser(email, member, false)
+            await this.linkUser(email, member, false, true)
         }
 
         for (const email of parentAndUnverifiedEmails) {
             // Link parents and unverified emails
-            await this.linkUser(email, member, true)
+
+            // Now we add the responsibility permissions to the parent if there are no userEmails
+            await this.linkUser(email, member, userEmails.length > 0, userEmails.length > 0)
         }
 
         if (unlinkUsers && !member.details.parentsHaveAccess) {
@@ -160,7 +162,7 @@ export class MemberUserSyncerStatic {
         await this.updateInheritedPermissions(user)
     }
 
-    async linkUser(email: string, member: MemberWithRegistrations, asParent: boolean) {
+    async linkUser(email: string, member: MemberWithRegistrations, asParent: boolean, updateNameIfEqual = true) {
         let user = member.users.find(u => u.email.toLocaleLowerCase() === email.toLocaleLowerCase()) ?? await User.getForAuthentication(member.organizationId, email, {allowWithoutAccount: true})
 
         if (user) {
@@ -189,8 +191,11 @@ export class MemberUserSyncerStatic {
                         }
                     }
                 }
-                user.firstName = member.details.firstName
-                user.lastName = member.details.lastName
+
+                if (updateNameIfEqual) {
+                    user.firstName = member.details.firstName
+                    user.lastName = member.details.lastName
+                }
                 user.memberId = member.id;
                 await this.updateInheritedPermissions(user)
             } else {
@@ -203,8 +208,10 @@ export class MemberUserSyncerStatic {
                 if (!user.firstName && !user.lastName) {
                     const parents = member.details.parents.filter(p => p.email === email)
                     if (parents.length === 1) {
-                        user.firstName = parents[0].firstName
-                        user.lastName = parents[0].lastName
+                        if (updateNameIfEqual) {
+                            user.firstName = parents[0].firstName
+                            user.lastName = parents[0].lastName
+                        }
                         await user.save()
                     }
                 }
@@ -222,15 +229,19 @@ export class MemberUserSyncerStatic {
             user.email = email
 
             if (!asParent) {
-                user.firstName = member.details.firstName
-                user.lastName = member.details.lastName
+                if (updateNameIfEqual) {
+                    user.firstName = member.details.firstName
+                    user.lastName = member.details.lastName
+                }
                 user.memberId = member.id;
                 await this.updateInheritedPermissions(user)
             } else {
                 const parents = member.details.parents.filter(p => p.email === email)
                 if (parents.length === 1) {
-                    user.firstName = parents[0].firstName
-                    user.lastName = parents[0].lastName
+                    if (updateNameIfEqual) {
+                        user.firstName = parents[0].firstName
+                        user.lastName = parents[0].lastName
+                    }
                 }
 
                 if (user.firstName === member.details.firstName && user.lastName === member.details.lastName) {

package/src/helpers/MembershipCharger.ts

@@ -33,6 +33,8 @@ export const MembershipCharger = {
             const memberships = await MemberPlatformMembership.select()
                 .where('id', SQLWhereSign.Greater, lastId)
                 .where('balanceItemId', null)
+                .where('deletedAt', null)
+                .whereNot('organizationId', chargeVia)
                 .limit(100)
                 .orderBy(
                     new SQLOrderBy({

package/src/helpers/MembershipHelper.ts

@@ -0,0 +1,55 @@
+import { logger } from '@simonbackx/simple-logging';
+import { Member } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+
+export class MembershipHelper {
+    static async updateAll() {
+        console.log('Scheduling updateAllMemberships');
+
+        let c = 0;
+        let id: string = '';
+        const tag = "updateAllMemberships";
+        const batch = 100;
+
+        QueueHandler.cancel(tag);
+
+        await QueueHandler.schedule(tag, async () => {
+            console.log('Starting updateAllMemberships');
+            await logger.setContext({tags: ['silent-seed', 'seed']}, async () => {
+                while(true) {
+                    const rawMembers = await Member.where({
+                        id: {
+                            value: id,
+                            sign: '>'
+                        }
+                    }, {limit: batch, sort: ['id']});
+
+                    if (rawMembers.length === 0) {
+                        break;
+                    }
+
+                    const promises: Promise<any>[] = [];
+                    
+
+                    for (const member of rawMembers) {
+                        promises.push((async () => {
+                            await Member.updateMembershipsForId(member.id, true);
+                            c++;
+                
+                            if (c%10000 === 0) {
+                                process.stdout.write(c + ' members updated\n');
+                            }
+                        })())
+                    }
+
+                    await Promise.all(promises);
+                    id = rawMembers[rawMembers.length - 1].id;
+
+                    if (rawMembers.length < batch) {
+                        break;
+                    }
+                }
+            })
+        })
+    }
+}

package/src/helpers/PeriodHelper.ts

@@ -1,10 +1,10 @@
 
-import { Member, MemberResponsibilityRecord, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from "@stamhoofd/models";
+import { Group, Member, MemberResponsibilityRecord, Organization, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { AuthenticatedStructures } from "./AuthenticatedStructures";
 import { PatchOrganizationRegistrationPeriodsEndpoint } from "../endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint";
 import { QueueHandler } from "@stamhoofd/queues";
 import { SetupStepUpdater } from "./SetupStepsUpdater";
-import { PermissionLevel } from "@stamhoofd/structures";
+import { PermissionLevel, Group as GroupStruct } from "@stamhoofd/structures";
 import { MemberUserSyncer } from "./MemberUserSyncer";
 import { SimpleError } from "@simonbackx/simple-errors";
 
@@ -162,5 +162,41 @@ export class PeriodHelper {
         await SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod()
     }
 
-    
+    static async updateGroupsInPeriod(period: RegistrationPeriod) {
+        const tag = "updateGroupsInPeriod-"+period.id;
+        
+        if (QueueHandler.isRunning(tag)) {
+            return;
+        }
+
+        console.log(tag);
+
+        const batchSize = 100;
+        await QueueHandler.schedule(tag, async () => {
+            let lastId = "";
+
+            while (true) {
+                const groups = await Group.where(
+                    {
+                        id: { sign: ">", value: lastId },
+                        periodId: period.id
+                    },
+                    { 
+                        limit: batchSize, 
+                        sort: ["id"] 
+                    }
+                );
+
+                for (const group of groups) {
+                    await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(GroupStruct.patch({id: group.id}), period);
+                    lastId = group.id;
+                }
+
+                if (groups.length < batchSize) {
+                    break;
+                }
+
+            }
+        });
+    }
 }

package/src/helpers/SetupStepsUpdater.ts

@@ -245,7 +245,7 @@ export class SetupStepUpdater {
 
         const responsibilityIds = organizationBasedResponsibilitiesWithRestriction.map(r => r.id);
 
-        const allRecords = await MemberResponsibilityRecord.select()
+        const allRecords = responsibilityIds.length === 0 ? [] : await MemberResponsibilityRecord.select()
             .where('responsibilityId', responsibilityIds)
             .where('organizationId', organization.id)
             .where(SQL.where('endDate', SQLWhereSign.Greater, now).or('endDate', null))

package/src/helpers/StripeHelper.ts

@@ -48,6 +48,27 @@ export class StripeHelper {
         }
     }
 
+    /**
+     * Call when the charge is updated in Stripe, so we can save fee information in the payment
+     */
+    static async updateChargeInfo(model: StripePaymentIntent) {
+        const stripe = this.getInstance(model.accountId)
+
+        const intent = await stripe.paymentIntents.retrieve(model.stripeIntentId, {
+            expand: ['latest_charge.balance_transaction']
+        })
+
+        console.log(intent);
+        if (intent.status === "succeeded") {
+            if (intent.latest_charge !== null && typeof intent.latest_charge !== 'string') {
+                const payment = await Payment.getByID(model.paymentId)
+                if (payment) {
+                    await this.saveChargeInfo(model, intent.latest_charge, payment)
+                }
+            }
+        }
+    }
+
     static async getStatus(payment: Payment, cancel = false, testMode = false): Promise<PaymentStatus> {
         if (testMode && !STAMHOOFD.STRIPE_SECRET_KEY.startsWith("sk_test_")) {
             // Do not query anything
@@ -219,7 +240,7 @@ export class StripeHelper {
                 payment_method: paymentMethod.id,
                 payment_method_types: [payment.method.toLowerCase()],
                 statement_descriptor: Formatter.slug(statementDescriptor).substring(0, 22).toUpperCase(),
-                application_fee_amount: fee,
+                application_fee_amount: fee ? fee : undefined,
                 on_behalf_of: !directCharge ? stripeAccount.accountId : undefined,
                 confirm: true,
                 return_url: redirectUrl,
@@ -293,7 +314,7 @@ export class StripeHelper {
                 locale: i18n.language as 'nl',
                 payment_intent_data: {
                     on_behalf_of: !directCharge ? stripeAccount.accountId : undefined,
-                    application_fee_amount: fee,
+                    application_fee_amount: fee ? fee : undefined,
                     transfer_data: !directCharge ? {
                         destination: stripeAccount.accountId,
                     } : undefined,

package/src/seeds/1722344162-update-membership.ts

@@ -0,0 +1,17 @@
+import { Migration } from '@simonbackx/simple-database';
+import { MembershipHelper } from '../helpers/MembershipHelper';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == "test") {
+        console.log("skipped in tests")
+        return;
+    }
+
+    if(STAMHOOFD.userMode !== "platform") {
+        console.log("skipped seed update-membership because usermode not platform")
+        return;
+    }
+
+    process.stdout.write('\n');
+    await MembershipHelper.updateAll()
+})

package/src/sql-filters/events.ts

@@ -0,0 +1,26 @@
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLValueType } from "@stamhoofd/sql";
+
+export const eventFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLColumnFilterCompiler('id'),
+    name: createSQLColumnFilterCompiler('name'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    startDate: createSQLColumnFilterCompiler('startDate'),
+    endDate: createSQLColumnFilterCompiler('endDate'),
+    groupIds: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
+        {isJSONValue: true, isJSONObject: true}
+    ),
+    defaultAgeGroupIds: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
+        {isJSONValue: true, isJSONObject: true}
+    ),
+    organizationTagIds: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
+        {isJSONValue: true, isJSONObject: true}
+    ),
+    'meta.visible': createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('meta'), '$.value.visible'),
+        {isJSONValue: true, type: SQLValueType.JSONBoolean}
+    ),
+}

package/src/sql-sorters/events.ts

@@ -0,0 +1,58 @@
+import { Event } from "@stamhoofd/models"
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
+import { Formatter } from "@stamhoofd/utility"
+
+export const eventSorters: SQLSortDefinitions<Event> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields. 
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
+    'id': {
+        getValue(a) {
+            return a.id
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction
+            })
+        }
+    },
+    'name': {
+        getValue(a) {
+            return a.name
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('name'),
+                direction
+            })
+        }
+    },
+    'startDate': {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.startDate)
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('startDate'),
+                direction
+            })
+        }
+    },
+    'endDate': {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.endDate)
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('endDate'),
+                direction
+            })
+        }
+    },
+}

package/src/seeds/1722344160-update-membership.ts

@@ -1,54 +0,0 @@
-import { Migration } from '@simonbackx/simple-database';
-import { Member } from '@stamhoofd/models';
-
-export default new Migration(async () => {
-    if (STAMHOOFD.environment == "test") {
-        console.log("skipped in tests")
-        return;
-    }
-
-    if(STAMHOOFD.userMode !== "platform") {
-        console.log("skipped seed update-membership because usermode not platform")
-        return;
-    }
-
-    process.stdout.write('\n');
-    let c = 0;
-    let id: string = '';
-
-    while(true) {
-        const rawMembers = await Member.where({
-            id: {
-                value: id,
-                sign: '>'
-            }
-        }, {limit: 500, sort: ['id']});
-
-        if (rawMembers.length === 0) {
-            break;
-        }
-
-        const promises: Promise<any>[] = [];
-        
-
-        for (const member of rawMembers) {
-            promises.push((async () => {
-                await Member.updateMembershipsForId(member.id, true);
-                c++;
-    
-                if (c%1000 === 0) {
-                    process.stdout.write('.');
-                }
-                if (c%10000 === 0) {
-                    process.stdout.write('\n');
-                }
-            })())
-        }
-
-        await Promise.all(promises);
-        id = rawMembers[rawMembers.length - 1].id;
-    }
-
-    // Do something here
-    return Promise.resolve()
-})