@stamhoofd/models 2.1.1

package/src/models/BalanceItem.ts

@@ -0,0 +1,392 @@
+import { column, Database, Model } from '@simonbackx/simple-database';
+import { BalanceItemStatus, MemberBalanceItem, MemberBalanceItemPayment, OrderStatus, Payment as PaymentStruct, PaymentMethod, PaymentStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from "uuid";
+
+import { Organization, Payment, Webshop } from './';
+
+/**
+ * Keeps track of how much a member/user owes or needs to be reimbursed.
+ */
+export class BalanceItem extends Model {
+    static table = "balance_items"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    organizationId: string
+
+    @column({ type: "string", nullable: true })
+    memberId: string | null = null;
+
+    @column({ type: "string", nullable: true })
+    userId: string | null = null;
+
+    /**
+     * The registration ID that is linked to this balance item
+     */
+    @column({ type: "string", nullable: true })
+    registrationId: string | null = null;
+
+    /**
+     * The order ID that is linked to this balance item
+     */
+    @column({ type: "string", nullable: true })
+    orderId: string | null = null;
+
+    @column({ type: "string" })
+    description = "";
+
+    /**
+     * Total prices
+     */
+    @column({ type: "integer" })
+    price: number;
+
+    /**
+     * Cached value, for optimizations
+     */
+    @column({ type: "integer" })
+    pricePaid = 0
+
+    @column({ type: "string" })
+    status = BalanceItemStatus.Pending
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    async markUpdated(payment: Payment, organization: Organization) {
+        // For orders: mark order as changed (so they are refetched in front ends)
+        if (this.orderId) {
+            const {Order} = await import("./Order");
+            const order = await Order.getByID(this.orderId);
+            if (order) {
+                await order.paymentChanged(payment, organization)
+            }
+        }
+    }
+
+    async markPaid(payment: Payment, organization: Organization) {
+        // status and pricePaid changes are handled inside balanceitempayment
+
+        // If registration
+        if (this.registrationId) {
+            const {Registration} = await import("./Registration");
+            const registration = await Registration.getByID(this.registrationId);
+
+            if (registration) {
+                // 1. Mark registration as being valid
+                if (registration.registeredAt === null) {
+                    await registration.markValid()
+
+                    const {Group} = await import("./Group");
+
+                    // Update group occupancy
+                    // TODO: maybe we should schedule this, to prevent doing many updates at once
+                    const group = await Group.getByID(registration.groupId)
+                    if (group) {
+                        await group.updateOccupancy()
+                        await group.save()
+                    }
+                }
+
+                // 2. Update registration cached prices  
+                // TODO          
+            }
+        }
+
+        // If order
+        if (this.orderId) {
+            const {Order} = await import("./Order");
+            const order = await Order.getByID(this.orderId);
+            if (order) {
+                await order.markPaid(payment, organization)
+
+                // Save number in balacance description
+                if (order.number !== null) {
+                    const webshop = await Webshop.getByID(order.webshopId)
+
+                    if (webshop) {
+                        this.description = order.generateBalanceDescription(webshop)
+                        await this.save()
+                    }
+                }
+            }
+        }
+    }
+
+    async undoPaid(payment: Payment, organization: Organization) {
+        // If order
+        if (this.orderId) {
+            const {Order} = await import("./Order");
+            const order = await Order.getByID(this.orderId);
+            if (order) {
+                await order.undoPaid(payment, organization)
+            }
+        }
+    }
+
+    async markFailed(payment: Payment, organization: Organization) {
+        // If order
+        if (this.orderId) {
+            const {Order} = await import("./Order");
+            const order = await Order.getByID(this.orderId);
+            if (order) {
+                await order.onPaymentFailed(payment, organization)
+
+                if (order.status === OrderStatus.Deleted) {
+                    this.status = BalanceItemStatus.Hidden
+                    await this.save()
+                }
+            }
+        }
+    }
+
+    async undoFailed(payment: Payment, organization: Organization) {
+        // If order
+        if (this.orderId) {
+            const {Order} = await import("./Order");
+            const order = await Order.getByID(this.orderId);
+            if (order) {
+                await order.undoPaymentFailed(payment, organization)
+            }
+        }
+    }
+
+    updateStatus() {
+        this.status = this.pricePaid >= this.price ? BalanceItemStatus.Paid : BalanceItemStatus.Pending;
+    }
+
+    static async deleteItems(items: BalanceItem[]) {
+        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.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()
+            }
+        }
+
+        // Set other items to zero (the balance item payments keep the real price)
+        for (const item of items) {
+            // 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))
+
+            if (relatedPayments.length === 0 || !relatedPayments.find(p => p.status === PaymentStatus.Succeeded)) {
+                // No paid payments associated with this item
+                item.status = BalanceItemStatus.Hidden
+                await item.save()
+            }
+        }
+    }
+
+    static async reactivateItems(items: BalanceItem[]) {
+        // Set other items to zero (the balance item payments keep the real price)
+        for (const item of items) {
+            if (item.status === BalanceItemStatus.Hidden) {
+                item.status = BalanceItemStatus.Pending
+                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()
+            }
+        }
+    }
+
+    static async undoForDeletedOrders(orderIds: string[]) {
+        if (orderIds.length === 0) {
+            return
+        }
+        const items = await BalanceItem.where({ orderId: { sign: 'IN', value: orderIds } })
+        await this.reactivateItems(items)
+    }
+
+    static async deleteForDeletedOrders(orderIds: string[]) {
+        if (orderIds.length === 0) {
+            return
+        }
+        const items = await BalanceItem.where({ orderId: { sign: 'IN', value: orderIds } })
+        await this.deleteItems(items)
+    }
+
+    static async deleteForDeletedMember(memberId: string) {
+        const items = await BalanceItem.where({ memberId })
+        await this.deleteItems(items)
+    }
+
+    static async deleteForDeletedRegistration(registrationId: string) {
+        const items = await BalanceItem.where({ registrationId })
+        await this.deleteItems(items)
+    }
+
+    static async getForRegistration(registrationId: string) {
+        const items = await BalanceItem.where({ registrationId })
+        return {
+            items,
+            ...(await this.loadPayments(items))
+        }
+    }
+
+    static async loadPayments(items: BalanceItem[]) {
+        if (items.length == 0) {
+            return {balanceItemPayments: [], payments: []}
+        }
+
+        // Load balance payment items
+        const {BalanceItemPayment} = await import('./BalanceItemPayment');
+        const balanceItemPayments = await BalanceItemPayment.where({ balanceItemId: {sign: 'IN', value: items.map(i => i.id)} })
+
+        const payments = await Payment.getByIDs(...balanceItemPayments.map(p => p.paymentId))
+
+        return {payments, balanceItemPayments}
+    }
+
+    static async getMemberStructure(items: BalanceItem[]): Promise<MemberBalanceItem[]> {
+        if (items.length == 0) {
+            return []
+        }
+
+        const {Registration} = await import("./Registration");
+        const {Order} = await import("./Order");
+        const {Group} = await import("./Group");
+
+        const {payments, balanceItemPayments} = await BalanceItem.loadPayments(items)
+        
+        // Load members and orders
+        const registrationIds = Formatter.uniqueArray(items.flatMap(b => b.registrationId ? [b.registrationId] : []))
+        const orderIds = Formatter.uniqueArray(items.flatMap(b => b.orderId ? [b.orderId] : []))
+
+        const registrations = await Registration.getByIDs(...registrationIds)
+        const orders = await Order.getByIDs(...orderIds)
+
+        const groupIds = Formatter.uniqueArray(registrations.map(r => r.groupId))
+        const groups = await Group.getByIDs(...groupIds)
+    
+        return items.map(item => {
+            const thisBalanceItemPayments = balanceItemPayments.filter(p => p.balanceItemId === item.id)
+            const registration = registrations.find(r => r.id === item.registrationId)
+            const group = registration ? groups.find(g => g.id === registration.groupId) : null
+
+            return MemberBalanceItem.create({
+                ...item,
+                registration: registration && group ? registration.setRelation(Registration.group, group).getStructure() : null,
+                order: orders.find(o => o.id === item.orderId)?.getStructureWithoutPayment() ?? null,
+                payments: thisBalanceItemPayments.map(p => {
+                    const payment = payments.find(pp => pp.id === p.paymentId)!
+                    return MemberBalanceItemPayment.create({
+                        ...p,
+                        payment: PaymentStruct.create(payment)
+                    })
+                })
+            })
+        })
+    }
+
+    static async balanceItemsForUsersAndMembers(organizationId: string|null, userIds: string[], memberIds: string[]): Promise<BalanceItem[]> {
+        if (memberIds.length == 0 && userIds.length == 0) {
+            return []
+        }
+        
+        const params: any[] = [];
+        const where: string[] = [];
+
+        if (memberIds.length) {
+            if (memberIds.length == 1) {
+                where.push(`memberId = ?`)
+                params.push(memberIds[0]);
+            } else {
+                where.push(`memberId IN (?)`)
+                params.push(memberIds);
+            }
+        }
+
+        // Note here, we don't search for memberId IS NULL restriction in MySQL because it slows down the query too much (500ms)
+        // Better if we do it in code here
+        if (userIds.length) {
+            if (userIds.length == 1) {
+                where.push('userId = ?')
+                params.push(userIds[0]);
+            } else {
+                where.push('userId IN (?)')
+                params.push(userIds);
+            }
+        }
+
+        const requiredWhere: string[] = [];
+
+        if (organizationId) {
+            requiredWhere.push('organizationId = ?')
+            params.push(organizationId);
+        }
+        
+        const query = `SELECT ${BalanceItem.getDefaultSelect()} FROM ${BalanceItem.table} WHERE (${where.join(" OR ")}) ${requiredWhere.length ? (' AND ' + requiredWhere.join(' AND ')) : ''} AND ${BalanceItem.table}.status != ?`;
+        params.push(BalanceItemStatus.Hidden);
+        
+        const [rows] = await Database.select(query, params);
+        const balanceItems = BalanceItem.fromRows(rows, BalanceItem.table);
+
+        // Filter out items of other members
+        if (memberIds.length) {
+            return balanceItems.filter(b => !b.memberId || memberIds.includes(b.memberId))
+        }
+        return balanceItems;
+    }
+}

package/src/models/BalanceItemPayment.ts

@@ -0,0 +1,106 @@
+import { column, ManyToOneRelation, Model } from '@simonbackx/simple-database';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+
+import { BalanceItem, Organization, Payment } from './';
+
+/**
+ * Keeps track of all the created payments of a balance item, which contains the (tries) to pay a balance item.
+ * It also keeps track of how much a given payment is split between multiple balance items, which makes it possible to pay a balance item partially.
+ */
+export class BalanceItemPayment extends Model {
+    static table = "balance_item_payments"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    organizationId: string
+
+    @column({ type: "string", foreignKey: BalanceItemPayment.payment })
+    paymentId: string;
+
+    @column({ type: "string", foreignKey: BalanceItemPayment.balanceItem })
+    balanceItemId: string;
+
+    /**
+     * Part of price of the payment that is used to 'pay' the balance item
+     */
+    @column({ type: "integer" })
+    price = 0
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({
+        type: "datetime", beforeSave() {
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    static balanceItem = new ManyToOneRelation(BalanceItem, "balanceItem")
+    static payment = new ManyToOneRelation(Payment, "payment")
+
+    async markPaid(this: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Update cached amountPaid of the balance item
+        this.balanceItem.pricePaid += this.price
+
+        // Update status
+        const old = this.balanceItem.status;
+        this.balanceItem.updateStatus();
+        await this.balanceItem.save();
+
+        // Do logic of balance item
+        if (this.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid) {
+            await this.balanceItem.markPaid(this.payment, organization)
+        } else {
+            await this.balanceItem.markUpdated(this.payment, organization)
+        }
+    }
+
+    /**
+     * Call this once a earlier succeeded payment is no longer succeeded
+     */
+    async undoPaid(this: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Update cached amountPaid of the balance item
+        this.balanceItem.pricePaid -= this.price
+
+        // Update status
+        this.balanceItem.status = this.balanceItem.pricePaid >= this.balanceItem.price ? BalanceItemStatus.Paid : BalanceItemStatus.Pending;
+
+        await this.balanceItem.save();
+
+        await this.balanceItem.undoPaid(this.payment, organization)
+    }
+
+    async markFailed(this: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Do logic of balance item
+        await this.balanceItem.markFailed(this.payment, organization)
+    }
+
+    async undoFailed(this: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Reactivate deleted items
+        await this.balanceItem.undoFailed(this.payment, organization)
+    }
+
+}
+
+type Loaded<T> = (T) extends ManyToOneRelation<infer Key, infer Model> ? Record<Key, Model> : never;
+

package/src/models/BuckarooPayment.ts

@@ -0,0 +1,19 @@
+import { column,Model } from "@simonbackx/simple-database";
+import { v4 as uuidv4 } from "uuid";
+
+export class BuckarooPayment extends Model {
+    static table = "buckaroo_payments";
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    paymentId: string;
+
+    @column({ type: "string" })
+    transactionKey: string;
+}