@stamhoofd/models 2.34.1 → 2.36.0

package/src/models/BalanceItemPayment.ts

@@ -59,7 +59,7 @@ export class BalanceItemPayment extends Model {
     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
+        // Update cached amountPaid of the balance item (this will get overwritten later, but we need it to calculate the status)
         this.balanceItem.pricePaid += this.price
 
         // Update status
@@ -69,6 +69,7 @@ export class BalanceItemPayment extends Model {
 
         // Do logic of balance item
         if (this.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid) {
+            // Only call markPaid once (if it wasn't (partially) paid before)
             await this.balanceItem.markPaid(this.payment, organization)
         } else {
             await this.balanceItem.markUpdated(this.payment, organization)
@@ -79,14 +80,6 @@ export class BalanceItemPayment extends Model {
      * 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)
     }
 

package/src/models/CachedOutstandingBalance.ts

@@ -0,0 +1,239 @@
+import { column, Model, SQLResultNamespacedRow } from '@simonbackx/simple-database';
+import { SQL, SQLAlias, SQLCalculation, SQLMinusSign, SQLMultiplicationSign, SQLSelect, SQLSelectAs, SQLSum, SQLWhere } from '@stamhoofd/sql';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+import { BalanceItem } from './BalanceItem';
+
+
+export type CachedOutstandingBalanceType = 'organization'|'member'|'user' 
+
+/**
+ * Keeps track of how much a member/user owes or needs to be reimbursed.
+ */
+export class CachedOutstandingBalance extends Model {
+    static table = "cached_outstanding_balances"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    organizationId: string
+
+    @column({ type: "string" })
+    objectId: string 
+
+    /**
+     * Defines which field to select
+     * organization: payingOrganizationId
+     * member: member id
+     * user: all balance items with that user id, but without a member id
+     */
+    @column({ type: "string" })
+    objectType: CachedOutstandingBalanceType
+
+    @column({ type: "integer" })
+    amount = 0
+
+    @column({ type: "integer" })
+    amountPending = 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 async getForObjects(objectIds: string[], limitOrganizationId?: string|null): Promise<CachedOutstandingBalance[]> {
+        const query = this.select()
+            .where("objectId", objectIds);
+
+        if (limitOrganizationId) {
+            query.where("organizationId", limitOrganizationId);
+        }
+
+        return await query.fetch();
+    }
+
+    static async updateForObjects(organizationId: string, objectIds: string[], objectType: CachedOutstandingBalanceType) {
+        switch (objectType) {
+            case 'organization':
+                await this.updateForOrganizations(organizationId, objectIds);
+                break;
+            case 'member':
+                await this.updateForMembers(organizationId, objectIds);
+                break;
+            case 'user':
+                await this.updateForUsers(organizationId, objectIds);
+                break;
+        }
+    }
+
+    private static async fetchForObjects(organizationId: string, objectIds: string[], columnName: string, customWhere?: SQLWhere) {
+        const query = SQL.select(
+                SQL.column(columnName),
+                new SQLSelectAs(
+                    new SQLCalculation(
+                        new SQLSum(
+                            new SQLCalculation(
+                                SQL.column('unitPrice'),
+                                new SQLMultiplicationSign(),
+                                SQL.column('amount')
+                            )
+                        ), 
+                        new SQLMinusSign(),
+                        new SQLSum(
+                            SQL.column('pricePaid')
+                        ), 
+                    ),
+                    new SQLAlias('data__amount')
+                ),
+                new SQLSelectAs(
+                    new SQLSum(
+                        SQL.column('pricePending')
+                    ),
+                    new SQLAlias('data__amountPending')
+                )
+            )
+            .from(BalanceItem.table)
+            .where("organizationId", organizationId)
+            .where(columnName, objectIds)
+            .whereNot("status", BalanceItemStatus.Hidden)
+            .groupBy(SQL.column(columnName));
+        
+        if (customWhere) {
+            query.where(customWhere);
+        }
+
+        const result = await query.fetch();
+
+        const results: [string, {amount: number, amountPending: number}][] = [];
+        for (const row of result) {
+            if (!row["data"]) {
+                throw new Error("Invalid data namespace");
+            }
+
+            if (!row[BalanceItem.table]) {
+                throw new Error("Invalid "+ BalanceItem.table +" namespace");
+            }
+
+            const objectId = row[BalanceItem.table][columnName];
+            const amount = row["data"]["amount"];
+            const amountPending = row["data"]["amountPending"];
+
+            if (typeof objectId !== "string") {
+                throw new Error("Invalid objectId");
+            }
+
+            if (typeof amount !== "number") {
+                throw new Error("Invalid amount");
+            }
+
+            if (typeof amountPending !== "number") {
+                throw new Error("Invalid amountPending");
+            }
+
+            results.push([objectId, {amount, amountPending}]);
+        }
+            
+        return results;
+    }
+
+    private static async setForResults(organizationId: string, result: [string, {amount: number, amountPending: number}][], objectType: CachedOutstandingBalanceType) {
+        if (result.length === 0) {
+            return;
+        }
+        const query = SQL.insert(this.table)
+            .columns(
+                "id",
+                "organizationId", 
+                "objectId", 
+                "objectType", 
+                "amount",
+                "amountPending",
+                "createdAt",
+                "updatedAt"
+            )
+            .values(...result.map(([objectId, {amount, amountPending}]) => {
+                return [
+                    uuidv4(),
+                    organizationId,
+                    objectId,
+                    objectType,
+                    amount,
+                    amountPending,
+                    new Date(),
+                    new Date()
+                ]
+            }))
+            .as('v')
+            .onDuplicateKeyUpdate(
+                SQL.assignment("amount", SQL.column("v", "amount")),
+                SQL.assignment("amountPending", SQL.column("v", "amountPending")),
+                SQL.assignment("updatedAt", SQL.column("v", "updatedAt"))
+            )
+
+        await query.insert()
+    }
+
+    static async updateForOrganizations(organizationId: string, organizationIds: string[]) {
+        if (organizationIds.length === 0) {
+            return;
+        }
+        const results = await this.fetchForObjects(organizationId, organizationIds, "payingOrganizationId");
+        await this.setForResults(organizationId, results, "organization");
+    }
+
+    static async updateForMembers(organizationId: string, memberIds: string[]) {
+        if (memberIds.length === 0) {
+            return;
+        }
+        const results = await this.fetchForObjects(organizationId, memberIds, "memberId");
+        await this.setForResults(organizationId, results, "member");
+    }
+
+    static async updateForUsers(organizationId: string, userIds: string[]) {
+        if (userIds.length === 0) {
+            return;
+        }
+        const results = await this.fetchForObjects(organizationId, userIds, "userId", SQL.where("memberId", null));
+        await this.setForResults(organizationId, results, "user");
+    }
+
+    /**
+     * Experimental: needs to move to library
+     */
+    static select() {
+        const transformer = (row: SQLResultNamespacedRow): CachedOutstandingBalance => {
+            const d = (this as typeof CachedOutstandingBalance & typeof Model).fromRow(row[this.table] as any) as CachedOutstandingBalance|undefined
+
+            if (!d) {
+                throw new Error("EmailTemplate not found")
+            }
+
+            return d;
+        }
+        
+        const select = new SQLSelect(transformer, SQL.wildcard())
+        return select.from(SQL.table(this.table))
+    }
+}

package/src/models/Member.ts

@@ -353,7 +353,7 @@ export class Member extends Model {
      /**
      * Fetch all members with their corresponding (valid) registrations or waiting lists and payments
      */
-    static async getMembersWithRegistrationForUser(user: User): Promise<MemberWithRegistrations[]> {
+     static async getMemberIdsWithRegistrationForUser(user: User): Promise<string[]> {
         const query = SQL
             .select('id')
             .from(Member.table)
@@ -370,7 +370,14 @@ export class Member extends Model {
             )
 
         const data = await query.fetch()
-        return this.getBlobByIds(...data.map((r) => r.members.id as string));
+        return data.map((r) => r.members.id as string)
+    }
+
+     /**
+     * Fetch all members with their corresponding (valid) registrations or waiting lists and payments
+     */
+    static async getMembersWithRegistrationForUser(user: User): Promise<MemberWithRegistrations[]> {
+        return this.getBlobByIds(...(await this.getMemberIdsWithRegistrationForUser(user)));
     }
 
     getStructureWithRegistrations(this: MemberWithRegistrations, forOrganization: null | boolean = null) {

package/src/models/Organization.ts

@@ -3,7 +3,7 @@ import { DecodedRequest } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { I18n } from "@stamhoofd/backend-i18n";
 import { Email, EmailInterfaceRecipient } from "@stamhoofd/email";
-import { AccessRight, Address, Country, DNSRecordStatus, EmailTemplateType, OrganizationEmail, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, PrivatePaymentConfiguration, Recipient, Replacement, STPackageType, TransferSettings } from "@stamhoofd/structures";
+import { Address, Country, DNSRecordStatus, EmailTemplateType, OrganizationEmail, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, PrivatePaymentConfiguration, Recipient, Replacement, STPackageType, TransferSettings } from "@stamhoofd/structures";
 import { AWSError } from 'aws-sdk';
 import SES from 'aws-sdk/clients/sesv2';
 import { PromiseResult } from 'aws-sdk/lib/request';
@@ -13,7 +13,7 @@ import { QueueHandler } from "@stamhoofd/queues";
 import { validateDNSRecords } from "../helpers/DNSValidator";
 import { getEmailBuilderForTemplate } from "../helpers/EmailBuilder";
 import { OrganizationServerMetaData } from '../structures/OrganizationServerMetaData';
-import { Group, OrganizationRegistrationPeriod, StripeAccount } from "./";
+import { OrganizationRegistrationPeriod, StripeAccount } from "./";
 
 export class Organization extends Model {
     static table = "organizations";

package/src/models/Registration.ts

@@ -1,5 +1,4 @@
 import { column, Database, ManyToOneRelation, Model } from '@simonbackx/simple-database';
-import { Email } from '@stamhoofd/email';
 import { EmailTemplateType, GroupPrice, PaymentMethod, PaymentMethodHelper, Recipient, RegisterItemOption, Registration as RegistrationStructure, Replacement, StockReservation } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from "uuid";
@@ -396,6 +395,7 @@ export class Registration extends Model {
                 type: EmailTemplateType.RegistrationTransferDetails,
                 group
             },
+            type: "transactional",
             recipients
         })
     }
@@ -436,7 +436,7 @@ export class Registration extends Model {
 
             if (updated.shouldIncludeStock()) {
                 const groupStockReservations: StockReservation[] = [
-                    // Group level stock reservatiosn (stored in the group)
+                    // Group level stock reservations (stored in the group)
                     StockReservation.create({
                         objectId: updated.groupPrice.id,
                         objectType: 'GroupPrice',

package/src/models/index.ts

@@ -52,3 +52,4 @@ export * from "./MemberPlatformMembership"
 export * from "./Email"
 export * from "./EmailRecipient"
 export * from "./Event"
+export * from "./CachedOutstandingBalance"