@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/Payment.ts

@@ -1,217 +1,217 @@
 import { column, Model, SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import { BalanceItemDetailed, BalanceItemPaymentDetailed, PaymentCustomer, PaymentGeneral, PaymentMethod, PaymentProvider, PaymentStatus, Settlement, TransferSettings } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 
 import { Organization } from './';
 import { SQL, SQLSelect } from '@stamhoofd/sql';
 
 export class Payment extends Model {
-    static table = "payments"
+    static table = 'payments';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     method: PaymentMethod;
 
-    @column({ type: "json", decoder: PaymentCustomer, nullable: true })
-    customer: PaymentCustomer | null = null
+    @column({ type: 'json', decoder: PaymentCustomer, nullable: true })
+    customer: PaymentCustomer | null = null;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     provider: PaymentProvider | null = null;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     status: PaymentStatus;
 
-    @column({ type: "string", nullable: true })
-    organizationId: string| null = null
+    @column({ type: 'string', nullable: true })
+    organizationId: string | null = null;
 
     /**
      * payingUserId
      */
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     payingUserId: string | null = null;
 
     /**
      * @deprecated
      */
     get userId() {
-        return this.payingUserId
+        return this.payingUserId;
     }
 
     /**
      * @deprecated
      */
-    set userId(id: string|null) {
-        this.payingUserId = id
+    set userId(id: string | null) {
+        this.payingUserId = id;
     }
 
     /**
      * If an organization paid, this contains the organization id
      */
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     payingOrganizationId: string | null = null;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     stripeAccountId: string | null = null;
 
     /**
      * Total price
      */
-    @column({ type: "integer" })
+    @column({ type: 'integer' })
     price: number;
 
     /**
      * Fee paid to the payment provider (if available, otherwise set to 0)
      */
-    @column({ type: "integer" })
-    transferFee = 0
+    @column({ type: 'integer' })
+    transferFee = 0;
 
     /**
      * Included in the total price
      */
-    @column({ type: "integer", nullable: true })
+    @column({ type: 'integer', nullable: true })
     freeContribution: number | null = null;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     transferDescription: string | null = null;
 
-    @column({ type: "json", nullable: true, decoder: TransferSettings })
+    @column({ type: 'json', nullable: true, decoder: TransferSettings })
     transferSettings: TransferSettings | null = null;
 
     @column({
-        type: "datetime", beforeSave(old?: any) {
+        type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
                 return old;
             }
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
-        }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
     })
-    createdAt: Date
+    createdAt: Date;
 
-    _forceUpdatedAt: Date | null = null
+    _forceUpdatedAt: Date | null = null;
 
     @column({
-        type: "datetime", beforeSave() {
+        type: 'datetime', beforeSave() {
             if (this._forceUpdatedAt) {
-                return this._forceUpdatedAt
+                return this._forceUpdatedAt;
             }
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 
-    @column({ type: "datetime", nullable: true })
-    paidAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    paidAt: Date | null = null;
 
     /// Settlement meta data
-    @column({ type: "json", decoder: Settlement, nullable: true })
+    @column({ type: 'json', decoder: Settlement, nullable: true })
     settlement: Settlement | null = null;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     iban: string | null = null;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     ibanName: string | null = null;
 
     generateDescription(organization: Organization, reference: string, replacements: { [key: string]: string } = {}) {
-        const settings = this.transferSettings ?? organization.meta.transferSettings
-        this.transferDescription = settings.generateDescription(reference, organization.address.country, replacements)
+        const settings = this.transferSettings ?? organization.meta.transferSettings;
+        this.transferDescription = settings.generateDescription(reference, organization.address.country, replacements);
     }
 
     static async getGeneralStructure(payments: Payment[], includeSettlements = false): Promise<PaymentGeneral[]> {
         if (payments.length === 0) {
-            return []
+            return [];
         }
 
-        const {balanceItemPayments, balanceItems} = await Payment.loadBalanceItems(payments)
-        
+        const { balanceItemPayments, balanceItems } = await Payment.loadBalanceItems(payments);
+
         return this.getGeneralStructureFromRelations({
             payments,
             balanceItemPayments,
-            balanceItems
-        }, includeSettlements)
+            balanceItems,
+        }, includeSettlements);
     }
 
-    static getGeneralStructureFromRelations({payments, balanceItemPayments, balanceItems}: {
+    static getGeneralStructureFromRelations({ payments, balanceItemPayments, balanceItems }: {
         payments: Payment[];
-        balanceItemPayments: import("./BalanceItemPayment").BalanceItemPayment[];
-        balanceItems: import("./BalanceItem").BalanceItem[];
+        balanceItemPayments: import('./BalanceItemPayment').BalanceItemPayment[];
+        balanceItems: import('./BalanceItem').BalanceItem[];
     }, includeSettlements = false): PaymentGeneral[] {
         if (payments.length === 0) {
-            return []
+            return [];
         }
 
-        return payments.map(payment => {
+        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 balanceItem = balanceItems.find(b => b.id === item.balanceItemId);
 
                     return BalanceItemPaymentDetailed.create({
                         ...item,
                         balanceItem: BalanceItemDetailed.create({
-                            ...balanceItem
-                        })
-                    })
+                            ...balanceItem,
+                        }),
+                    });
                 }),
-                ...(payment.provider !== PaymentProvider.Stripe ? {stripeAccountId: null} : {}),
-                ...(!includeSettlements) ? {settlement: null, transferFee: 0, stripeAccountId: null} : {}
-            })
-        })
+                ...(payment.provider !== PaymentProvider.Stripe ? { stripeAccountId: null } : {}),
+                ...(!includeSettlements) ? { settlement: null, transferFee: 0, stripeAccountId: null } : {},
+            });
+        });
     }
 
     /**
-     * 
+     *
      * @param checkPermissions Only set to undefined when not returned in the API + not for public use
-     * @returns 
+     * @returns
      */
     async getGeneralStructure(): Promise<PaymentGeneral> {
-        return (await Payment.getGeneralStructure([this], false))[0]
+        return (await Payment.getGeneralStructure([this], false))[0];
     }
 
     static async loadBalanceItems(payments: Payment[]) {
         if (payments.length === 0) {
-            return {balanceItemPayments: [], balanceItems: []}
+            return { balanceItemPayments: [], balanceItems: [] };
         }
-        const {BalanceItemPayment} = await import("./BalanceItemPayment");
-        const {BalanceItem} = await import("./BalanceItem");
+        const { BalanceItemPayment } = await import('./BalanceItemPayment');
+        const { BalanceItem } = await import('./BalanceItem');
 
         // Load all the related models from the database so we can build the structures
         const balanceItemPayments = await BalanceItemPayment.where({
             paymentId: {
                 sign: 'IN',
-                value: payments.map(p => p.id)
-            }
-        })
+                value: payments.map(p => p.id),
+            },
+        });
         const ids = Formatter.uniqueArray(balanceItemPayments.flatMap(p => p.balanceItemId));
         const balanceItems = await BalanceItem.getByIDs(...ids);
 
-        return {balanceItemPayments, balanceItems}
+        return { balanceItemPayments, balanceItems };
     }
 
-    static async loadBalanceItemRelations(balanceItems: import("./BalanceItem").BalanceItem[]) {
-        const {Order} = await import("./Order");
-        const {Member} = await import("./Member");
+    static async loadBalanceItemRelations(balanceItems: import('./BalanceItem').BalanceItem[]) {
+        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 registrationIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.registrationId ? [b.registrationId] : []));
+        const orderIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.orderId ? [b.orderId] : []));
 
-        const registrations = await Member.getRegistrationWithMembersByIDs(registrationIds)
-        const orders = await Order.getByIDs(...orderIds)
+        const registrations = await Member.getRegistrationWithMembersByIDs(registrationIds);
+        const orders = await Order.getByIDs(...orderIds);
 
-        return {registrations, orders}
+        return { registrations, orders };
     }
 
     /**
@@ -219,16 +219,16 @@ export class Payment extends Model {
      */
     static select() {
         const transformer = (row: SQLResultNamespacedRow): Payment => {
-            const d = (this as typeof Payment & typeof Model).fromRow(row[this.table] as any) as Payment|undefined
+            const d = (this as typeof Payment & typeof Model).fromRow(row[this.table] as any) as Payment | undefined;
 
             if (!d) {
-                throw new Error("EmailTemplate not found")
+                throw new Error('EmailTemplate not found');
             }
 
             return d;
-        }
-        
-        const select = new SQLSelect(transformer, SQL.wildcard())
-        return select.from(SQL.table(this.table))
+        };
+
+        const select = new SQLSelect(transformer, SQL.wildcard());
+        return select.from(SQL.table(this.table));
     }
 }

package/src/models/Platform.ts

@@ -1,31 +1,30 @@
-import { column, Model } from "@simonbackx/simple-database";
-import { QueueHandler } from "@stamhoofd/queues";
-import { Platform as PlatformStruct,PlatformConfig, PlatformPrivateConfig } from "@stamhoofd/structures";
-import { v4 as uuidv4 } from "uuid";
-import { RegistrationPeriod } from "./RegistrationPeriod";
-
+import { column, Model } from '@simonbackx/simple-database';
+import { QueueHandler } from '@stamhoofd/queues';
+import { Platform as PlatformStruct, PlatformConfig, PlatformPrivateConfig } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from 'uuid';
+import { RegistrationPeriod } from './RegistrationPeriod';
 
 export class Platform extends Model {
-    static table = "platform";
+    static table = 'platform';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "json", decoder: PlatformConfig })
-    config: PlatformConfig = PlatformConfig.create({})
+    @column({ type: 'json', decoder: PlatformConfig })
+    config: PlatformConfig = PlatformConfig.create({});
+
+    @column({ type: 'string' })
+    periodId: string;
 
-    @column({ type: "string" })
-    periodId: string
-    
-    @column({ type: "string", nullable: true })
-    membershipOrganizationId: string | null = null
+    @column({ type: 'string', nullable: true })
+    membershipOrganizationId: string | null = null;
 
-    @column({ type: "json", decoder: PlatformPrivateConfig })
-    privateConfig: PlatformPrivateConfig = PlatformPrivateConfig.create({})
+    @column({ type: 'json', decoder: PlatformPrivateConfig })
+    privateConfig: PlatformPrivateConfig = PlatformPrivateConfig.create({});
 
     static sharedStruct: PlatformStruct | null = null;
 
@@ -38,7 +37,7 @@ export class Platform extends Model {
         return clone;
     }
 
-    static async getSharedPrivateStruct(): Promise<PlatformStruct & {privateConfig: PlatformPrivateConfig}> {
+    static async getSharedPrivateStruct(): Promise<PlatformStruct & { privateConfig: PlatformPrivateConfig }> {
         if (this.sharedStruct && this.sharedStruct.privateConfig) {
             return this.sharedStruct as any;
         }
@@ -48,7 +47,7 @@ export class Platform extends Model {
             const period = await RegistrationPeriod.getByID(model.periodId);
             const struct = PlatformStruct.create({
                 ...model,
-                period: period?.getStructure() ?? undefined
+                period: period?.getStructure() ?? undefined,
             });
             this.sharedStruct = struct;
 
@@ -77,8 +76,8 @@ export class Platform extends Model {
     }
 
     async save() {
-        Platform.clearCache()
-        const s = await super.save()
+        Platform.clearCache();
+        const s = await super.save();
 
         // Force update cache immediately
         await Platform.getSharedStruct();

package/src/models/RegisterCode.ts

@@ -1,9 +1,9 @@
-import { column, Model } from "@simonbackx/simple-database";
-import basex from "base-x";
-import crypto from "crypto";
+import { column, Model } from '@simonbackx/simple-database';
+import basex from 'base-x';
+import crypto from 'crypto';
 
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-const bs58 = basex(ALPHABET)
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const bs58 = basex(ALPHABET);
 
 async function randomBytes(size: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -18,50 +18,50 @@ async function randomBytes(size: number): Promise<Buffer> {
 }
 
 export class RegisterCode extends Model {
-    static table = "register_codes";
+    static table = 'register_codes';
 
-    @column({ type: "string", primary: true })
+    @column({ type: 'string', primary: true })
     code: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     description: string;
 
-    @column({ type: "string", nullable: true })
-    customMessage: string|null = null;
+    @column({ type: 'string', nullable: true })
+    customMessage: string | null = null;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     organizationId: string | null;
 
-    @column({ type: "integer" })
+    @column({ type: 'integer' })
     value: number;
 
     /**
      * Invoice usages to the owning organization
      */
-    @column({ type: "integer", nullable: true })
-    invoiceValue: number|null = null
+    @column({ type: 'integer', nullable: true })
+    invoiceValue: number | null = null;
 
     @column({
-        type: "datetime", beforeSave(old?: any) {
+        type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
                 return old;
             }
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
-        }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
     })
-    createdAt: Date
+    createdAt: Date;
 
     @column({
-        type: "datetime", beforeSave() {
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+        type: 'datetime', beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 
     async generateCode() {
         this.code = bs58.encode(await randomBytes(8)).toUpperCase();