@stamhoofd/models 2.5.0 → 2.6.0

package/dist/src/models/StripePaymentIntent.js.map

@@ -1 +1 @@
-{"version":3,"file":"StripePaymentIntent.js","sourceRoot":"","sources":["../../../src/models/StripePaymentIntent.ts"],"names":[],"mappings":";;;;AAAA,iEAA2D;AAC3D,+BAAoC;AAEpC,MAAa,mBAAoB,SAAQ,uBAAK;IAA9C;;QAiBI,mBAAc,GAAkB,IAAI,CAAC;IACzC,CAAC;;AAlBD,kDAkBC;AAjBU,yBAAK,GAAG,wBAAwB,AAA3B,CAA4B;AAOxC;IALC,IAAA,wBAAM,EAAC;QACJ,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK;YAC3C,OAAO,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,IAAA,SAAM,GAAE,CAAC;QAC7B,CAAC;KACJ,CAAC;+CACU;AAGZ;IADC,IAAA,wBAAM,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;sDACT;AAGlB;IADC,IAAA,wBAAM,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;2DACJ;AAGvB;IADC,IAAA,wBAAM,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;2DACN"}
+{"version":3,"file":"StripePaymentIntent.js","sourceRoot":"","sources":["../../../src/models/StripePaymentIntent.ts"],"names":[],"mappings":";;;;AAAA,iEAA2D;AAC3D,+BAAoC;AAEpC,MAAa,mBAAoB,SAAQ,uBAAK;IAA9C;;QAiBI,mBAAc,GAAkB,IAAI,CAAC;QAErC;;WAEG;QAEH,cAAS,GAAgB,IAAI,CAAA;IACjC,CAAC;;AAxBD,kDAwBC;AAvBU,yBAAK,GAAG,wBAAwB,AAA3B,CAA4B;AAOxC;IALC,IAAA,wBAAM,EAAC;QACJ,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK;YAC3C,OAAO,KAAK,aAAL,KAAK,cAAL,KAAK,GAAI,IAAA,SAAM,GAAE,CAAC;QAC7B,CAAC;KACJ,CAAC;+CACU;AAGZ;IADC,IAAA,wBAAM,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;sDACT;AAGlB;IADC,IAAA,wBAAM,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;2DACJ;AAGvB;IADC,IAAA,wBAAM,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;2DACN;AAMrC;IADC,IAAA,wBAAM,EAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;sDACd"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/models",
-    "version": "2.5.0",
+    "version": "2.6.0",
     "main": "./dist/src/index.js",
     "types": "./dist/src/index.d.ts",
     "license": "UNLICENCED",
@@ -27,5 +27,5 @@
     "devDependencies": {
         "@simonbackx/simple-database": "1.24.0"
     },
-    "gitHead": "07cc26af0e3036e4ae4309a268fbf57b7f6ac2ed"
+    "gitHead": "7a3f9f6c08058dc8b671befbfad73184afdc6d7c"
 }

package/src/migrations/1722845608-registration-stock-reservations.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `registrations`
+ADD COLUMN `stockReservations` json NOT NULL DEFAULT ('{"value": [], "version": 0}');

package/src/migrations/1722845609-group-stock-reservations.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `groups`
+ADD COLUMN `stockReservations` json NOT NULL DEFAULT ('{"value": [], "version": 0}');

package/src/migrations/1722852362-stripe-intents-account-id.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `stripe_payment_intents`
+ADD COLUMN `accountId` varchar(100) NULL;

package/src/migrations/1722852363-stripe-checkout-sessions-account-id.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `stripe_checkout_sessions`
+ADD COLUMN `accountId` varchar(100) NULL;

package/src/models/BalanceItem.ts

@@ -107,6 +107,12 @@ export class BalanceItem extends Model {
 
     async markPaid(payment: Payment, organization: Organization) {
         // status and pricePaid changes are handled inside balanceitempayment
+        if (this.dependingBalanceItemId) {
+            const depending = await BalanceItem.getByID(this.dependingBalanceItemId)
+            if (depending && depending.status === BalanceItemStatus.Hidden) {
+                await BalanceItem.reactivateItems([depending])
+            }
+        }
 
         // If registration
         if (this.registrationId) {
@@ -115,7 +121,7 @@ export class BalanceItem extends Model {
 
             if (registration) {
                 // 1. Mark registration as being valid
-                if (registration.registeredAt === null) {
+                if (registration.registeredAt === null || registration.deactivatedAt) {
                     await registration.markValid()
 
                     const {Group} = await import("./Group");
@@ -219,72 +225,48 @@ export class BalanceItem extends Model {
     }
 
     static async deleteItems(items: BalanceItem[]) {
-        const {payments} = await BalanceItem.loadPayments(items)
+        const {balanceItemPayments} = await BalanceItem.loadPayments(items)
 
-        // Load all balance items
-        const {balanceItems, balanceItemPayments: allBalanceItemPayments} = await Payment.loadBalanceItems(payments)
-        for (const payment of payments) {
-            if (payment.status === PaymentStatus.Succeeded) {
-                continue;
-            }
-            if (!(payment.method === PaymentMethod.PointOfSale || payment.method === PaymentMethod.Transfer || payment.method === PaymentMethod.Unknown)) {
-                continue;
-            }
-            const bip = allBalanceItemPayments.filter(p => p.paymentId == payment.id)
-            const bis = balanceItems.filter(b => b.status !== BalanceItemStatus.Hidden && bip.find(p => p.balanceItemId == b.id))
-
-            const remainingAfterDelete = bis.filter(b => !items.find(i => i.id == b.id))
-            if (remainingAfterDelete.length == 0) {
-                // Delete payment
-                payment.status = PaymentStatus.Failed
-                payment._forceUpdatedAt = new Date(1900, 0, 1)
-                await payment.save()
-            }
-        }
+        // todo: in the future we could automatically delete payments that are not needed anymore and weren't paid yet -> to prevent leaving ghost payments
+        // for now, an admin can manually cancel those payments
+        let needsUpdate = false
 
         // Set other items to zero (the balance item payments keep the real price)
         for (const item of items) {
+            needsUpdate = needsUpdate || (item.price > 0 && item.status !== BalanceItemStatus.Hidden)
+
             // Don't change status of items that are already paid or are partially paid
             // Not using item.paidPrice, since this is cached
-            const bip = allBalanceItemPayments.filter(p => p.balanceItemId == item.id)
-            const relatedPayments = payments.filter(p => bip.find(b => b.paymentId == p.id))
+            const bip = balanceItemPayments.filter(p => p.balanceItemId == item.id)
 
-            if (relatedPayments.length === 0 || !relatedPayments.find(p => p.status === PaymentStatus.Succeeded)) {
-                // No paid payments associated with this item
+            if (bip.length === 0) {
+                // No payments associated with this item
                 item.status = BalanceItemStatus.Hidden
+                item.price = 0
+                await item.save()
+            } else {
+                item.price = 0
                 await item.save()
             }
         }
+
+        if (needsUpdate) {
+            await this.updateOutstanding(items)
+        }
     }
 
     static async reactivateItems(items: BalanceItem[]) {
-        // Set other items to zero (the balance item payments keep the real price)
+        let needsUpdate = false
         for (const item of items) {
             if (item.status === BalanceItemStatus.Hidden) {
                 item.status = BalanceItemStatus.Pending
+                needsUpdate = needsUpdate || item.price > 0
                 await item.save()
             }
         }
 
-        const {payments} = await BalanceItem.loadPayments(items)
-
-        // Load all balance items
-        const {balanceItems, balanceItemPayments: allBalanceItemPayments} = await Payment.loadBalanceItems(payments)
-        for (const payment of payments) {
-            if (payment.status !== PaymentStatus.Failed) {
-                continue;
-            }
-            if (!(payment.method === PaymentMethod.PointOfSale || payment.method === PaymentMethod.Transfer || payment.method === PaymentMethod.Unknown)) {
-                continue;
-            }
-            const bip = allBalanceItemPayments.filter(p => p.paymentId == payment.id)
-            const bis = balanceItems.filter(b => b.status !== BalanceItemStatus.Hidden && bip.find(p => p.balanceItemId == b.id))
-
-            if (bis.length > 0) {
-                // Undo failed
-                payment.status = PaymentStatus.Created
-                await payment.save()
-            }
+        if (needsUpdate) {
+            await this.updateOutstanding(items)
         }
     }
 
@@ -322,6 +304,18 @@ export class BalanceItem extends Model {
         }
     }
 
+    static async updateOutstanding(items: BalanceItem[], organizationId?: string) {
+        const Member = (await import('./Member')).Member;
+
+        // Update outstanding amount of related members and registrations
+        const memberIds: string[] = Formatter.uniqueArray(items.map(p => p.memberId).filter(id => id !== null)) as any
+        await Member.updateOutstandingBalance(memberIds)
+
+        const {Registration} = await import('./Registration');
+        const registrationIds: string[] = Formatter.uniqueArray(items.map(p => p.registrationId).filter(id => id !== null)) as any
+        await Registration.updateOutstandingBalance(registrationIds, organizationId)
+    }
+
     static async loadPayments(items: BalanceItem[]) {
         if (items.length == 0) {
             return {balanceItemPayments: [], payments: []}

package/src/models/DocumentTemplate.ts

@@ -426,7 +426,7 @@ export class DocumentTemplate extends Model {
 
             for (const groupDefinition of this.privateSettings.groups) {
                 // Get the registrations for this group with this cycle
-                const registrations = await Member.getRegistrationWithMembersForGroup(groupDefinition.groupId, groupDefinition.cycle)
+                const registrations = await Member.getRegistrationWithMembersForGroup(groupDefinition.groupId)
 
                 for (const registration of registrations) {
                     const document = await this.generateForRegistration(registration)

package/src/models/Event.ts

@@ -55,6 +55,9 @@ export class Event extends Model {
     })
     updatedAt: Date
 
+    /**
+     * @deprecated
+     */
     getStructure(group?: Group|null) {
         return EventStruct.create({
             ...this,
@@ -62,10 +65,38 @@ export class Event extends Model {
         })
     }
 
+    /**
+     * @deprecated
+     */
     getPrivateStructure(group?: Group|null) {
         return EventStruct.create({
             ...this,
             group: group ? group.getPrivateStructure() : null
         })
     }
+
+    async syncGroupRequirements(group: Group|null) {
+        if (!group) {
+            return;
+        }
+
+        group.settings.requireDefaultAgeGroupIds = this.meta.defaultAgeGroupIds ?? []
+        group.settings.requireGroupIds = this.meta.groupIds ?? []
+
+        if (this.organizationId) {
+            // This is a not-national event, so require the organization
+            group.settings.requireOrganizationIds = this.meta.organizationTagIds ?? []
+            group.settings.requireOrganizationTags = []
+            group.settings.requirePlatformMembershipOn = null
+        } else {
+            group.settings.requireOrganizationTags = this.meta.organizationTagIds ?? []
+
+            // Everyone can register
+            group.settings.requireOrganizationIds = []
+
+            // But they need a valid platform membership
+            group.settings.requirePlatformMembershipOn = this.endDate
+        }
+        await group.save()
+    }
 }

package/src/models/Group.ts

@@ -1,9 +1,11 @@
 import { column, Database, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
-import { GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType } from '@stamhoofd/structures';
+import { GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType, StockReservation } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from "uuid";
 
 import { Formatter } from '@stamhoofd/utility';
 import { Member, MemberWithRegistrations, OrganizationRegistrationPeriod, Payment, Registration, User } from './';
+import { QueueHandler } from '@stamhoofd/queues';
+import { ArrayDecoder } from '@simonbackx/simple-encoding';
 
 if (Member === undefined) {
     throw new Error("Import Member is undefined")
@@ -85,17 +87,20 @@ export class Group extends Model {
     })
     deletedAt: Date | null = null
 
-    /**
-     * Every time a new registration period starts, this number increases. This is used to mark all older registrations as 'out of date' automatically
-     */
     @column({ type: "string" })
     status = GroupStatus.Open;
 
+    /**
+     * Editing this field is only allowed when running inside the QueueHandler
+     */
+    @column({ type: "json", decoder: new ArrayDecoder(StockReservation) })
+    stockReservations: StockReservation[] = []
+
     static async getAll(organizationId: string, periodId: string|null, active = true) {
         const w: any = periodId ? {periodId} : {}
         if (active) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return await Group.where({ organizationId, deletedAt: null, ...w, status: {sign: '!=', value: GroupStatus.Archived} })
+            return await Group.where({ organizationId, deletedAt: null, ...w })
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return await Group.where({ organizationId, ...w })
@@ -216,18 +221,13 @@ export class Group extends Model {
 
     async updateOccupancy() {
         this.settings.registeredMembers = await Group.getCount(
-            "groupId = ? and cycle = ? and waitingList = 0 and registeredAt is not null",
-            [this.id, this.cycle]
+            "groupId = ? and registeredAt is not null AND deactivatedAt is null",
+            [this.id]
         )
 
         this.settings.reservedMembers = await Group.getCount(
-            "groupId = ? and cycle = ? and ((waitingList = 0 and registeredAt is null AND reservedUntil >= ?) OR (waitingList = 1 and canRegister = 1))",
-            [this.id, this.cycle, new Date()]
-        )
-
-        this.settings.waitingListSize = await Group.getCount(
-            "groupId = ? and cycle = ? and waitingList = 1",
-            [this.id, this.cycle, new Date()]
+            "groupId = ? and registeredAt is null AND (canRegister = 1 OR reservedUntil >= ?)",
+            [this.id, new Date()]
         )
     }
 
@@ -280,6 +280,28 @@ export class Group extends Model {
         }
     }
 
+    static async applyStockReservations(groupId: string, addStockReservations: StockReservation[], free = false) {
+        await QueueHandler.schedule('group-stock-update-'+groupId, async () => {
+            const updatedGroup = await Group.getByID(groupId)
+            if (!updatedGroup) {
+                throw new Error("Expected group")
+            }
+
+            if (!free) {
+                updatedGroup.stockReservations = StockReservation.added(updatedGroup.stockReservations, addStockReservations)
+            } else {
+                updatedGroup.stockReservations = StockReservation.removed(updatedGroup.stockReservations, addStockReservations)
+            }
+            await updatedGroup.save()
+        })
+
+    }
+
+    static async freeStockReservations(groupId: string, reservations: StockReservation[]) {
+        return await this.applyStockReservations(groupId, reservations, true)
+    }
+
+
 }
 
 Registration.group = new ManyToOneRelation(Group, "group")

package/src/models/Member.ts

@@ -1,6 +1,6 @@
 import { column, Database, ManyToManyRelation, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
 import { SQL } from "@stamhoofd/sql";
-import { Member as MemberStruct, MemberDetails, MemberWithRegistrationsBlob, RegistrationWithMember as RegistrationWithMemberStruct, User as UserStruct, GroupStatus } from '@stamhoofd/structures';
+import { Member as MemberStruct, MemberDetails, MemberWithRegistrationsBlob, RegistrationWithMember as RegistrationWithMemberStruct, User as UserStruct, GroupStatus, TinyMember } from '@stamhoofd/structures';
 import { Formatter, Sorter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from "uuid";
 
@@ -144,7 +144,7 @@ export class Member extends Model {
         }
         let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
         
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`
+        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`
 
         // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
         query += `where \`${Registration.table}\`.\`${Registration.primary.name}\` IN (?)`
@@ -177,15 +177,15 @@ export class Member extends Model {
     /**
      * Fetch all registrations with members with their corresponding (valid) registrations
      */
-    static async getRegistrationWithMembersForGroup(groupId: string, cycle: number): Promise<RegistrationWithMember[]> {
+    static async getRegistrationWithMembersForGroup(groupId: string): Promise<RegistrationWithMember[]> {
         let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
         
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`
+        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`
 
         // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `where \`${Registration.table}\`.\`groupId\` = ? AND \`${Registration.table}\`.\`cycle\` = ?`
+        query += `where \`${Registration.table}\`.\`groupId\` = ?`
 
-        const [results] = await Database.select(query, [groupId, cycle])
+        const [results] = await Database.select(query, [groupId])
         const registrations: RegistrationWithMember[] = []
 
          // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
@@ -261,7 +261,7 @@ export class Member extends Model {
             return []
         }
         let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()}, ${User.getDefaultSelect()}  from \`${Member.table}\`\n`;
-        query += `LEFT JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`
+        query += `LEFT JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`
         query += Member.users.joinQuery(Member.table, User.table)+"\n"
 
         // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
@@ -380,7 +380,11 @@ export class Member extends Model {
         return RegistrationWithMemberStruct.create({
             ...registration.getStructure(),
             cycle: registration.cycle,
-            member: MemberStruct.create(registration.member),
+            member: TinyMember.create({
+                id: registration.member.id,
+                firstName: registration.member.firstName,
+                lastName: registration.member.lastName,
+            }),
         })
     }
 
@@ -415,10 +419,9 @@ export class Member extends Model {
     }
 
     async updateMemberships(this: MemberWithRegistrations) {
-        console.log('Updating memberships for member: ' + this.id)
         return await QueueHandler.schedule('updateMemberships-' + this.id, async () => {
             const platform = await Platform.getShared()
-            const registrations = this.registrations.filter(r => r.group.periodId == platform.periodId && !r.waitingList && r.registeredAt && !r.deactivatedAt)
+            const registrations = this.registrations.filter(r => r.group.periodId == platform.periodId && r.registeredAt && !r.deactivatedAt)
 
             const defaultMemberships = registrations.flatMap(r => {
                 if (!r.group.defaultAgeGroupId) {

package/src/models/Payment.ts

@@ -110,39 +110,37 @@ export class Payment extends Model {
         }
 
         const {balanceItemPayments, balanceItems} = await Payment.loadBalanceItems(payments)
-        const {registrations, orders, members, groups} = await Payment.loadBalanceItemRelations(balanceItems);
+        const {registrations, orders, groups} = await Payment.loadBalanceItemRelations(balanceItems);
         
-        return this.getGeneralStructureFromRelations({
+        return await this.getGeneralStructureFromRelations({
             payments,
             registrations,
             orders,
-            members,
             balanceItemPayments,
             balanceItems,
             groups
         }, includeSettlements)
     }
 
-    static getGeneralStructureFromRelations({payments, registrations, orders, members, balanceItemPayments, balanceItems, groups}: {
+    static async getGeneralStructureFromRelations({payments, registrations, orders, balanceItemPayments, balanceItems, groups}: {
         payments: Payment[];
-        registrations: import("./Registration").Registration[];
+        registrations: import("./Member").RegistrationWithMember[];
         orders: import("./Order").Order[];
-        members: import("./Member").Member[];
         balanceItemPayments: import("./BalanceItemPayment").BalanceItemPayment[];
         balanceItems: import("./BalanceItem").BalanceItem[];
         groups: import("./Group").Group[];
-    }, includeSettlements = false): PaymentGeneral[] {
+    }, includeSettlements = false): Promise<PaymentGeneral[]> {
         if (payments.length === 0) {
             return []
         }
+        const {Member} = (await import("./Member"));
 
         return payments.map(payment => {
             return PaymentGeneral.create({
                 ...payment,
                 balanceItemPayments: balanceItemPayments.filter(item => item.paymentId === payment.id).map((item) => {
                     const balanceItem = balanceItems.find(b => b.id === item.balanceItemId)
-                    const registration = balanceItem?.registrationId && registrations.find(r => r.id === balanceItem.registrationId)
-                    const member = balanceItem?.memberId ? members.find(r => r.id === balanceItem.memberId) : undefined
+                    const registration = balanceItem?.registrationId ? registrations.find(r => r.id === balanceItem.registrationId) : null
                     const order = balanceItem?.orderId && orders.find(r => r.id === balanceItem.orderId)
                     const group = registration ? groups.find(g => g.id === registration.groupId) : null
 
@@ -154,8 +152,7 @@ export class Payment extends Model {
                         ...item,
                         balanceItem: BalanceItemDetailed.create({
                             ...balanceItem,
-                            registration: registration ? registration.setRelation(Registration.group, group!).getStructure() : null,
-                            member: member ? MemberStruct.create(member) : null,
+                            registration: registration ? Member.getRegistrationWithMemberStructure(registration.setRelation(Registration.group, group!)) : null,
                             order: order ? OrderStruct.create({...order, payment: null}) : null
                         })
                     })
@@ -195,22 +192,19 @@ export class Payment extends Model {
     }
 
     static async loadBalanceItemRelations(balanceItems: import("./BalanceItem").BalanceItem[]) {
-        const {Registration} = await import("./Registration");
         const {Order} = await import("./Order");
         const {Member} = await import("./Member");
 
         // Load members and orders
         const registrationIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.registrationId ? [b.registrationId] : []))
         const orderIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.orderId ? [b.orderId] : []))
-        const memberIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.memberId ? [b.memberId] : []))
 
-        const registrations = await Registration.getByIDs(...registrationIds)
+        const registrations = await Member.getRegistrationWithMembersByIDs(registrationIds)
         const orders = await Order.getByIDs(...orderIds)
-        const members = await Member.getByIDs(...memberIds)
 
         const groupIds = Formatter.uniqueArray(registrations.map(r => r.groupId))
         const groups = await (await import("./Group")).Group.getByIDs(...groupIds)
 
-        return {registrations, orders, members, groups}
+        return {registrations, orders, groups}
     }
 }

package/src/models/Registration.ts

@@ -1,11 +1,13 @@
 import { column, Database, ManyToOneRelation, Model } from '@simonbackx/simple-database';
 import { Email } from '@stamhoofd/email';
-import { EmailTemplateType, PaymentMethod, PaymentMethodHelper, Recipient, Registration as RegistrationStructure, Replacement } from '@stamhoofd/structures';
+import { EmailTemplateType, PaymentMethod, PaymentMethodHelper, Recipient, Registration as RegistrationStructure, Replacement, StockReservation } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from "uuid";
 
 import { getEmailBuilder } from '../helpers/EmailBuilder';
-import { Document, EmailTemplate, Organization, User } from './';
+import { Document, EmailTemplate, Group, Organization, User } from './';
+import { ArrayDecoder } from '@simonbackx/simple-encoding';
+import { QueueHandler } from '@stamhoofd/queues';
 
 export class Registration extends Model {
     static table = "registrations"
@@ -69,6 +71,9 @@ export class Registration extends Model {
     @column({ type: "datetime", nullable: true })
     reservedUntil: Date | null = null
 
+    /**
+     * @deprecated - replaced by group type
+     */
     @column({ type: "boolean" })
     waitingList = false
 
@@ -88,6 +93,12 @@ export class Registration extends Model {
     @column({ type: "integer" })
     pricePaid = 0
 
+    /**
+     * Set to null if no reservations are made, to help faster querying
+     */
+    @column({ type: "json", decoder: new ArrayDecoder(StockReservation), nullable: true })
+    stockReservations: StockReservation[] = []
+
     static group: ManyToOneRelation<"group", import('./Group').Group>
 
     getStructure(this: Registration & {group: import('./Group').Group}) {
@@ -101,7 +112,7 @@ export class Registration extends Model {
     /**
      * Update the outstanding balance of multiple members in one go (or all members)
      */
-    static async updateOutstandingBalance(registrationIds: string[] | 'all', organizationId: string) {
+    static async updateOutstandingBalance(registrationIds: string[] | 'all', organizationId?: string) {
         if (registrationIds !== 'all' && registrationIds.length == 0) {
             return
         }
@@ -136,7 +147,7 @@ export class Registration extends Model {
         
         await Database.update(query, params)
 
-        if (registrationIds !== 'all') {
+        if (registrationIds !== 'all' && organizationId) {
             await Document.updateForRegistrations(registrationIds, organizationId)
         }
     }
@@ -149,7 +160,7 @@ export class Registration extends Model {
         const query = `
         SELECT COUNT(DISTINCT \`${Registration.table}\`.memberId) as c FROM \`${Registration.table}\` 
         JOIN \`groups\` ON \`groups\`.id = \`${Registration.table}\`.groupId
-        WHERE \`groups\`.organizationId = ? AND \`${Registration.table}\`.cycle = \`groups\`.cycle AND \`groups\`.deletedAt is null AND \`groups\`.status != 'Archived' AND \`${Registration.table}\`.registeredAt is not null AND \`${Registration.table}\`.waitingList = 0`
+        WHERE \`groups\`.organizationId = ? AND \`${Registration.table}\`.cycle = \`groups\`.cycle AND \`groups\`.deletedAt is null AND \`${Registration.table}\`.registeredAt is not null AND \`${Registration.table}\`.deactivatedAt is null`
         
         const [results] = await Database.select(query, [organizationId])
         const count = results[0]['']['c'];
@@ -163,19 +174,17 @@ export class Registration extends Model {
     }
 
     async markValid(this: Registration) {
-        if (this.registeredAt !== null) {
+        if (this.registeredAt !== null && this.deactivatedAt === null) {
             await this.save();
             return false;
         }
 
-        if (this.waitingList && this.canRegister) {
-            this.waitingList = false
-        }
-        
         this.reservedUntil = null
-        this.registeredAt = new Date()
+        this.registeredAt =  this.registeredAt ?? new Date()
+        this.deactivatedAt = null
         this.canRegister = false
         await this.save();
+        this.scheduleStockUpdate()
 
         await this.sendEmailTemplate({
             type: EmailTemplateType.RegistrationConfirmation
@@ -408,4 +417,55 @@ export class Registration extends Model {
 
         Email.schedule(builder)
     }
+
+    shouldIncludeStock() {
+        return (this.registeredAt !== null && this.deactivatedAt === null) || this.canRegister || (this.reservedUntil && this.reservedUntil > new Date())
+    }
+
+
+
+    /**
+     * Adds or removes the order to the stock of the webshop (if it wasn't already included). If amounts were changed, only those
+     * changes will get added
+     * Should always happen in the webshop-stock queue to prevent multiple webshop writes at the same time
+     * + in combination with validation and reading the webshop
+     */
+    scheduleStockUpdate() {
+        const id = this.id;
+
+        QueueHandler.cancel('registration-stock-update-'+id);
+        QueueHandler.schedule('registration-stock-update-'+id, async function(this: undefined) {
+            const updated = await Registration.getByID(id);
+
+            if (!updated) {
+                return;
+            }
+            
+            // Start with clearing all the stock reservations we've already made
+            if (updated.stockReservations) {
+                const groupIds = Formatter.uniqueArray(updated.stockReservations.flatMap(r => r.objectType === 'Group' ? [r.objectId] : []));
+                for (const groupId of groupIds) {
+                    const stocks = StockReservation.filter('Group', groupId, updated.stockReservations);
+                    
+                    // Technically we don't need to await this, but okay...
+                    await Group.freeStockReservations(groupId, stocks);
+                }
+            }
+
+            if (updated.shouldIncludeStock()) {
+                const myStockReservations: StockReservation[] = [];
+
+                // todo: build
+
+                updated.stockReservations = myStockReservations;
+                await updated.save();
+            } else {
+                if (updated.stockReservations.length) {
+                    updated.stockReservations = [];
+                    await updated.save();
+                }
+            }
+
+        }).catch(console.error)
+    }
 }

package/src/models/StripeAccount.ts

@@ -68,4 +68,4 @@ export class StripeAccount extends Model {
             bank_account_bank_name: account.external_accounts?.data[0]?.bank_name ?? this.meta.bank_account_bank_name ?? "",
         });
     }
-}
+}

package/src/models/StripeCheckoutSession.ts

@@ -19,4 +19,10 @@ export class StripeCheckoutSession extends Model {
 
     @column({ type: "string", nullable: true })
     organizationId: string | null = null;
+
+    /**
+     * For direct charges, this should be set
+     */
+    @column({ type: "string", nullable: true })
+    accountId: string|null = null
 }

package/src/models/StripePaymentIntent.ts

@@ -19,4 +19,10 @@ export class StripePaymentIntent extends Model {
 
     @column({ type: "string", nullable: true })
     organizationId: string | null = null;
+
+    /**
+     * For direct charges, this should be set
+     */
+    @column({ type: "string", nullable: true })
+    accountId: string|null = null
 }