@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/STPackage.ts

@@ -1,91 +1,92 @@
-import { column, Model } from "@simonbackx/simple-database";
-import { SimpleError } from "@simonbackx/simple-errors";
+import { column, Model } from '@simonbackx/simple-database';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { EmailTemplateType, Recipient, Replacement, STPackageMeta, STPackageStatus, STPackageType } from '@stamhoofd/structures';
-import { Formatter } from "@stamhoofd/utility";
-import { v4 as uuidv4 } from "uuid";
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
 
-import { sendEmailTemplate } from "../helpers/EmailBuilder";
-import { GroupBuilder } from "../helpers/GroupBuilder";
-import { Organization } from "./";
+import { sendEmailTemplate } from '../helpers/EmailBuilder';
+import { GroupBuilder } from '../helpers/GroupBuilder';
+import { Organization } from './';
 
 export class STPackage extends Model {
-    static table = "stamhoofd_packages";
+    static table = 'stamhoofd_packages';
 
     // Columns
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
     /**
      * We keep packages of deleted organizations for statistics, so this doesn't have a foreign key
      */
-    @column({ type: "string"})
-    organizationId: string
+    @column({ type: 'string' })
+    organizationId: string;
 
-    @column({ type: "json", decoder: STPackageMeta })
-    meta: STPackageMeta
+    @column({ type: 'json', decoder: STPackageMeta })
+    meta: STPackageMeta;
 
     @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;
 
-    @column({ type: "datetime", nullable: true })
-    validAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    validAt: Date | null = null;
 
-    @column({ type: "datetime", nullable: true })
-    validUntil: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    validUntil: Date | null = null;
 
-    @column({ type: "datetime", nullable: true })
-    removeAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    removeAt: Date | null = null;
 
-    @column({ type: "integer" })
-    emailCount = 0
+    @column({ type: 'integer' })
+    emailCount = 0;
 
-    @column({ type: "datetime", nullable: true })
-    lastEmailAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    lastEmailAt: Date | null = null;
 
     static async getForOrganization(organizationId: string) {
-        const pack1 = await STPackage.where({ organizationId, validAt: { sign: "!=", value: null }, removeAt: { sign: ">", value: new Date() }})
-        const pack2 = await STPackage.where({ organizationId, validAt: { sign: "!=", value: null }, removeAt: null })
+        const pack1 = await STPackage.where({ organizationId, validAt: { sign: '!=', value: null }, removeAt: { sign: '>', value: new Date() } });
+        const pack2 = await STPackage.where({ organizationId, validAt: { sign: '!=', value: null }, removeAt: null });
 
-        return [...pack1, ...pack2]
+        return [...pack1, ...pack2];
     }
 
     static async getForOrganizationIncludingExpired(organizationId: string) {
-        return await STPackage.where({ organizationId, validAt: { sign: "!=", value: null }}, {sort: [{column: 'validAt', direction: 'DESC'}]})
+        return await STPackage.where({ organizationId, validAt: { sign: '!=', value: null } }, { sort: [{ column: 'validAt', direction: 'DESC' }] });
     }
 
     static async getOrganizationPackagesMap(organizationId: string): Promise<Map<STPackageType, STPackageStatus>> {
-        const packages = await this.getForOrganizationIncludingExpired(organizationId)
+        const packages = await this.getForOrganizationIncludingExpired(organizationId);
 
-        const map = new Map<STPackageType, STPackageStatus>()
+        const map = new Map<STPackageType, STPackageStatus>();
         for (const pack of packages) {
-            const exist = map.get(pack.meta.type)
+            const exist = map.get(pack.meta.type);
             if (exist) {
-                exist.merge(pack.createStatus())
-            } else {
-                map.set(pack.meta.type, pack.createStatus())
+                exist.merge(pack.createStatus());
+            }
+            else {
+                map.set(pack.meta.type, pack.createStatus());
             }
         }
 
@@ -93,52 +94,53 @@ export class STPackage extends Model {
     }
 
     static async updateOrganizationPackages(organizationId: string) {
-        console.log("Updating packages for organization "+organizationId)
-        const map = await this.getOrganizationPackagesMap(organizationId)
+        console.log('Updating packages for organization ' + organizationId);
+        const map = await this.getOrganizationPackagesMap(organizationId);
 
-        const organization = await Organization.getByID(organizationId)
+        const organization = await Organization.getByID(organizationId);
         if (organization) {
-            const didUseMembers = organization.meta.packages.useMembers && organization.meta.packages.useActivities
-            organization.meta.packages.packages = map
-            await organization.save()
+            const didUseMembers = organization.meta.packages.useMembers && organization.meta.packages.useActivities;
+            organization.meta.packages.packages = map;
+            await organization.save();
 
             if (!didUseMembers && organization.meta.packages.useMembers && organization.meta.packages.useActivities) {
-                console.log("Building groups and categories for "+organization.id)
-                const builder = new GroupBuilder(organization)
-                await builder.build()
+                console.log('Building groups and categories for ' + organization.id);
+                const builder = new GroupBuilder(organization);
+                await builder.build();
             }
-        } else {
-            console.error("Couldn't find organization when updating packages "+organizationId)
+        }
+        else {
+            console.error("Couldn't find organization when updating packages " + organizationId);
         }
     }
 
     async activate() {
         if (this.validAt !== null) {
-            return
+            return;
         }
-        this.validAt = new Date()
-        await this.save()
+        this.validAt = new Date();
+        await this.save();
 
         if (this.meta.didRenewId) {
-            const pack = await STPackage.getByID(this.meta.didRenewId)
+            const pack = await STPackage.getByID(this.meta.didRenewId);
             if (pack && pack.organizationId === this.organizationId) {
-                await pack.didRenew(this)
+                await pack.didRenew(this);
             }
         }
     }
 
     async didRenew(renewed: STPackage) {
-        this.removeAt = renewed.meta.startDate ?? renewed.validAt ?? new Date()
-        this.meta.allowRenew = false
-        await this.save()
+        this.removeAt = renewed.meta.startDate ?? renewed.validAt ?? new Date();
+        this.meta.allowRenew = false;
+        await this.save();
     }
 
     async deactivate() {
         if (this.removeAt !== null && this.removeAt <= new Date()) {
-            return
+            return;
         }
-        this.removeAt = new Date()
-        await this.save()
+        this.removeAt = new Date();
+        await this.save();
     }
 
     /**
@@ -147,43 +149,43 @@ export class STPackage extends Model {
     createRenewed(): STPackage {
         if (!this.meta.allowRenew) {
             throw new SimpleError({
-                code: "not_allowed",
-                message: "Not allowed",
-                human: "Je kan dit pakket niet verlengen"
-            })
+                code: 'not_allowed',
+                message: 'Not allowed',
+                human: 'Je kan dit pakket niet verlengen',
+            });
         }
 
-        const pack = new STPackage()
-        pack.id = uuidv4()
-        pack.meta = this.meta
+        const pack = new STPackage();
+        pack.id = uuidv4();
+        pack.meta = this.meta;
 
         // Not yet valid / active (ignored until valid)
-        pack.validAt = null
-        pack.organizationId = this.organizationId
-
-        pack.meta.startDate = new Date(Math.max(new Date().getTime(), this.validUntil?.getTime() ?? 0))
-        pack.meta.paidAmount = 0
-        pack.meta.paidPrice = 0
-        pack.meta.firstFailedPayment = null
-        pack.meta.didRenewId = this.id
-        
+        pack.validAt = null;
+        pack.organizationId = this.organizationId;
+
+        pack.meta.startDate = new Date(Math.max(new Date().getTime(), this.validUntil?.getTime() ?? 0));
+        pack.meta.paidAmount = 0;
+        pack.meta.paidPrice = 0;
+        pack.meta.firstFailedPayment = null;
+        pack.meta.didRenewId = this.id;
+
         // Duration for renewals is always a year ATM
-        pack.validUntil = new Date(pack.meta.startDate)
-        pack.validUntil.setFullYear(pack.validUntil.getFullYear() + 1)
+        pack.validUntil = new Date(pack.meta.startDate);
+        pack.validUntil.setFullYear(pack.validUntil.getFullYear() + 1);
 
         // Remove (= not renewable) if not renewed after 3 months
-        pack.removeAt = new Date(pack.validUntil)
-        pack.removeAt.setMonth(pack.removeAt.getMonth() + 3)
+        pack.removeAt = new Date(pack.validUntil);
+        pack.removeAt.setMonth(pack.removeAt.getMonth() + 3);
 
         // Custom renewals for single webshop:
         if (this.meta.type === STPackageType.SingleWebshop) {
             // Disable functions after two months
-            pack.validUntil = new Date(pack.meta.startDate)
-            pack.validUntil.setMonth(pack.validUntil.getMonth() + 2)
-            pack.removeAt = new Date(pack.validUntil)
+            pack.validUntil = new Date(pack.meta.startDate);
+            pack.validUntil.setMonth(pack.validUntil.getMonth() + 2);
+            pack.removeAt = new Date(pack.validUntil);
         }
 
-        return pack
+        return pack;
     }
 
     createStatus(): STPackageStatus {
@@ -193,19 +195,19 @@ export class STPackage extends Model {
             startDate: this.meta.startDate,
             validUntil: this.validUntil,
             removeAt: this.removeAt,
-            firstFailedPayment: this.meta.firstFailedPayment
-        })
+            firstFailedPayment: this.meta.firstFailedPayment,
+        });
     }
 
     async sendExpiryEmail() {
         if (this.validAt === null) {
             // never activated
-            return
+            return;
         }
 
         if (this.removeAt && this.removeAt <= new Date()) {
-            this.emailCount += 1
-            await this.save()
+            this.emailCount += 1;
+            await this.save();
             return;
         }
 
@@ -215,91 +217,96 @@ export class STPackage extends Model {
         if (this.meta.type === STPackageType.Members) {
             type = EmailTemplateType.MembersExpirationReminder;
             allowDays = 32;
-        } else if (this.meta.type === STPackageType.Webshops) {
+        }
+        else if (this.meta.type === STPackageType.Webshops) {
             type = EmailTemplateType.WebshopsExpirationReminder;
             allowDays = 32;
-        } else if (this.meta.type === STPackageType.SingleWebshop) {
+        }
+        else if (this.meta.type === STPackageType.SingleWebshop) {
             type = EmailTemplateType.SingleWebshopExpirationReminder;
             allowDays = 7;
-        } else if (this.meta.type === STPackageType.TrialMembers) {
+        }
+        else if (this.meta.type === STPackageType.TrialMembers) {
             type = EmailTemplateType.TrialMembersExpirationReminder;
             allowDays = 3;
-        } else if (this.meta.type === STPackageType.TrialWebshops) {
+        }
+        else if (this.meta.type === STPackageType.TrialWebshops) {
             type = EmailTemplateType.TrialWebshopsExpirationReminder;
             allowDays = 3;
         }
 
-        const allowFrom = new Date(Date.now() + 1000 * 60 * 60 * 24 * allowDays)
+        const allowFrom = new Date(Date.now() + 1000 * 60 * 60 * 24 * allowDays);
         if (type && (this.validUntil === null || this.validUntil < new Date() || this.validUntil > allowFrom)) {
-            console.log('Skip sending expiration email for '+this.id)
+            console.log('Skip sending expiration email for ' + this.id);
             return;
         }
 
         if (type) {
-            console.log('Sending expiration email for '+this.id, type)
-            if (STAMHOOFD.environment === "production") {
+            console.log('Sending expiration email for ' + this.id, type);
+            if (STAMHOOFD.environment === 'production') {
                 await this.sendEmailTemplate({
-                    type
-                })
+                    type,
+                });
             }
-            this.lastEmailAt = new Date()
-        } else {
-            console.log('Skip sending expiration email for '+this.id+' (no type)')
+            this.lastEmailAt = new Date();
         }
-        
-        this.emailCount += 1
-        await this.save()
+        else {
+            console.log('Skip sending expiration email for ' + this.id + ' (no type)');
+        }
+
+        this.emailCount += 1;
+        await this.save();
     }
 
     async sendEmailTemplate(data: {
-        type: EmailTemplateType,
-        replyTo?: string
+        type: EmailTemplateType;
+        replyTo?: string;
     }) {
-        const organization = await Organization.getByID(this.organizationId)
+        const organization = await Organization.getByID(this.organizationId);
 
         if (!organization) {
-            console.error("Could not find package organization "+this.id)
-            return
+            console.error('Could not find package organization ' + this.id);
+            return;
         }
 
-        const admins = await organization.getFullAdmins()
+        const admins = await organization.getFullAdmins();
 
-        const recipients = admins.map(admin => 
+        const recipients = admins.map(admin =>
             Recipient.create({
                 firstName: admin.firstName,
                 lastName: admin.lastName,
                 email: admin.email,
                 replacements: [
                     Replacement.create({
-                        token: "organizationName",
-                        value: organization.name
+                        token: 'organizationName',
+                        value: organization.name,
                     }),
                     Replacement.create({
-                        token: "packageName",
-                        value: this.meta.name ?? ""
+                        token: 'packageName',
+                        value: this.meta.name ?? '',
                     }),
                     Replacement.create({
-                        token: "validUntil",
-                        value: this.validUntil ? Formatter.dateTime(this.validUntil) : "nooit"
+                        token: 'validUntil',
+                        value: this.validUntil ? Formatter.dateTime(this.validUntil) : 'nooit',
                     }),
                     Replacement.create({
-                        token: "validUntilDate",
-                        value: this.validUntil ? Formatter.date(this.validUntil) : "nooit"
+                        token: 'validUntilDate',
+                        value: this.validUntil ? Formatter.date(this.validUntil) : 'nooit',
                     }),
                     Replacement.create({
-                        token: "renewUrl",
-                        value: "https://"+(STAMHOOFD.domains.dashboard ?? "stamhoofd.app")+"/"+organization.i18n.locale+"/settings/packages"
+                        token: 'renewUrl',
+                        value: 'https://' + (STAMHOOFD.domains.dashboard ?? 'stamhoofd.app') + '/' + organization.i18n.locale + '/settings/packages',
                     }),
-                ]
-            })
+                ],
+            }),
         );
-        
+
         // Create e-mail builder
         await sendEmailTemplate(null, {
             template: {
-                type: data.type
+                type: data.type,
             },
-            recipients
-        })
+            recipients,
+        });
     }
 }

package/src/models/STPendingInvoice.ts

@@ -1,6 +1,6 @@
-import { column, ManyToOneRelation, Model } from "@simonbackx/simple-database";
+import { column, ManyToOneRelation, Model } from '@simonbackx/simple-database';
 import { STInvoiceMeta } from '@stamhoofd/structures';
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 
 import { Organization } from './';
 
@@ -8,56 +8,56 @@ import { Organization } from './';
  * Things that should get paid, but are not yet invoiced yet because:
  * - total price is too low
  * - auto renewals waiting for payment
- * 
+ *
  * When they are about to get paid, we create a new invoice model
  * and if that model is marked as paid, it will remove the corresponding
  * items in this pending invoice.
- * 
+ *
  * So please make sure you don't edit existing items, unless you change the id
  */
 export class STPendingInvoice extends Model {
-    static table = "stamhoofd_pending_invoices";
+    static table = 'stamhoofd_pending_invoices';
 
     // Columns
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ foreignKey: STPendingInvoice.organization, type: "string", nullable: true })
+    @column({ foreignKey: STPendingInvoice.organization, type: 'string', nullable: true })
     organizationId: string | null;
-    
-    @column({ type: "json", decoder: STInvoiceMeta })
-    meta: STInvoiceMeta
+
+    @column({ type: 'json', decoder: STInvoiceMeta })
+    meta: STInvoiceMeta;
 
     /// We can only have one invoice at a time for the pending invoice items
     /// So until this invoice is marked as 'failed', we don't create new invoices for this pending invoice
-    @column({ type: "string", nullable: true })
-    invoiceId: string | null = null
+    @column({ type: 'string', nullable: true })
+    invoiceId: string | 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;
 
-    static organization = new ManyToOneRelation(Organization, "organization");
+    static organization = new ManyToOneRelation(Organization, 'organization');
 }

package/src/models/StripeAccount.ts

@@ -1,60 +1,60 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { column, Model } from '@simonbackx/simple-database';
 import { Requirements, StripeBusinessProfile, StripeCompany, StripeMetaAccountSettings, StripeMetaData } from '@stamhoofd/structures';
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 
 /**
  * Keeps track of how much a member/user owes or needs to be reimbursed.
  */
 export class StripeAccount extends Model {
-    static table = "stripe_accounts"
+    static table = 'stripe_accounts';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
-    organizationId: string
+    @column({ type: 'string' })
+    organizationId: string;
 
-    @column({ type: "string" })
-    accountId: string
+    @column({ type: 'string' })
+    accountId: string;
 
-    @column({ type: "json", decoder: StripeMetaData })
-    meta = StripeMetaData.create({})
+    @column({ type: 'json', decoder: StripeMetaData })
+    meta = StripeMetaData.create({});
 
-    @column({ type: "string" })
-    status: 'active' | 'deleted' = 'active'
+    @column({ type: 'string' })
+    status: 'active' | 'deleted' = 'active';
 
     @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;
 
     setMetaFromStripeAccount(account: any) {
         this.meta = StripeMetaData.create({
             type: account.type ?? 'express',
             blob: account,
-            business_profile: StripeBusinessProfile.create(!account.business_profile?.name ? {...account.business_profile, name: ''} : account.business_profile),
+            business_profile: StripeBusinessProfile.create(!account.business_profile?.name ? { ...account.business_profile, name: '' } : account.business_profile),
             business_type: account.business_type ?? this.meta.business_type ?? null,
             company: account.company ? StripeCompany.create(account.company) : (this.meta.company ?? null),
             charges_enabled: account.charges_enabled,
@@ -64,8 +64,8 @@ export class StripeAccount extends Model {
             requirements: Requirements.create(account.requirements),
             future_requirements: Requirements.create(account.future_requirements),
             settings: StripeMetaAccountSettings.create(account.settings),
-            bank_account_last4: account.external_accounts?.data[0]?.last4 ?? this.meta.bank_account_last4 ?? "",
-            bank_account_bank_name: account.external_accounts?.data[0]?.bank_name ?? this.meta.bank_account_bank_name ?? "",
+            bank_account_last4: account.external_accounts?.data[0]?.last4 ?? this.meta.bank_account_last4 ?? '',
+            bank_account_bank_name: account.external_accounts?.data[0]?.bank_name ?? this.meta.bank_account_bank_name ?? '',
         });
     }
 }