@stamhoofd/models 2.4.0 → 2.6.0

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
 }