@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/Registration.ts

@@ -1,7 +1,7 @@
 import { column, Database, ManyToOneRelation, Model } from '@simonbackx/simple-database';
 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";
+import { v4 as uuidv4 } from 'uuid';
 
 import { ArrayDecoder } from '@simonbackx/simple-encoding';
 import { QueueHandler } from '@stamhoofd/queues';
@@ -9,112 +9,112 @@ import { sendEmailTemplate } from '../helpers/EmailBuilder';
 import { Document, Group, Organization, User } from './';
 
 export class Registration extends Model {
-    static table = "registrations"
+    static table = 'registrations';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     memberId: string;
 
-    @column({ type: "string" })
-    organizationId: string
+    @column({ type: 'string' })
+    organizationId: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     periodId: string;
 
-    @column({ type: "string", foreignKey: Registration.group})
+    @column({ type: 'string', foreignKey: Registration.group })
     groupId: string;
-    
-    @column({ type: "json", decoder: GroupPrice})
+
+    @column({ type: 'json', decoder: GroupPrice })
     groupPrice: GroupPrice;
 
-    @column({ type: "json", decoder: new ArrayDecoder(RegisterItemOption) })
+    @column({ type: 'json', decoder: new ArrayDecoder(RegisterItemOption) })
     options: RegisterItemOption[] = [];
 
     /**
      * @deprecated
      */
-    @column({ type: "string", nullable: true })
-    paymentId: string | null = null
+    @column({ type: 'string', nullable: true })
+    paymentId: string | null = null;
 
     /**
      * @deprecated
      */
-    @column({ type: "integer" })
+    @column({ type: 'integer' })
     cycle: number = 0;
 
-    @column({ type: "integer", nullable: true })
+    @column({ type: 'integer', nullable: true })
     price: 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;
 
-    @column({ type: "datetime", nullable: true })
-    registeredAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    registeredAt: Date | null = null;
 
-    @column({ type: "datetime", nullable: true })
-    reservedUntil: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    reservedUntil: Date | null = null;
 
     /**
      * @deprecated - replaced by group type
      */
-    @column({ type: "boolean" })
-    waitingList = false
+    @column({ type: 'boolean' })
+    waitingList = false;
 
     /**
      * When a registration is on the waiting list or is invite only, set this to true to allow the user to
      * register normally.
      */
-    @column({ type: "boolean" })
-    canRegister = false
+    @column({ type: 'boolean' })
+    canRegister = false;
 
-    @column({ type: "datetime", nullable: true})
-    deactivatedAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    deactivatedAt: Date | null = null;
 
     /**
      * Part of price that is paid
      */
-    @column({ type: "integer" })
-    pricePaid = 0
+    @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[] = []
+    @column({ type: 'json', decoder: new ArrayDecoder(StockReservation), nullable: true })
+    stockReservations: StockReservation[] = [];
 
-    static group: ManyToOneRelation<"group", import('./Group').Group>
+    static group: ManyToOneRelation<'group', import('./Group').Group>;
 
-    getStructure(this: Registration & {group: import('./Group').Group}) {
+    getStructure(this: Registration & { group: import('./Group').Group }) {
         return RegistrationStructure.create({
             ...this,
             group: this.group.getStructure(),
-            price: this.price ?? 0
-        })
+            price: this.price ?? 0,
+        });
     }
 
     /**
@@ -122,21 +122,21 @@ export class Registration extends Model {
      */
     static async updateOutstandingBalance(registrationIds: string[] | 'all', organizationId?: string) {
         if (registrationIds !== 'all' && registrationIds.length == 0) {
-            return
+            return;
         }
 
-        const params: any[] = []
-        let firstWhere = ''
-        let secondWhere = ''
+        const params: any[] = [];
+        let firstWhere = '';
+        let secondWhere = '';
 
         if (registrationIds !== 'all') {
-            firstWhere = ` AND registrationId IN (?)`
-            params.push(registrationIds)
+            firstWhere = ` AND registrationId IN (?)`;
+            params.push(registrationIds);
 
-            secondWhere = `WHERE registrations.id IN (?)`
-            params.push(registrationIds)
+            secondWhere = `WHERE registrations.id IN (?)`;
+            params.push(registrationIds);
         }
-        
+
         const query = `UPDATE
             registrations
             LEFT JOIN (
@@ -151,12 +151,12 @@ export class Registration extends Model {
                     registrationId
             ) i ON i.registrationId = registrations.id 
         SET registrations.price = coalesce(i.price, 0), registrations.pricePaid = coalesce(i.pricePaid, 0)
-        ${secondWhere}`
-        
-        await Database.update(query, params)
+        ${secondWhere}`;
+
+        await Database.update(query, params);
 
         if (registrationIds !== 'all' && organizationId) {
-            await Document.updateForRegistrations(registrationIds, organizationId)
+            await Document.updateForRegistrations(registrationIds, organizationId);
         }
     }
 
@@ -168,67 +168,68 @@ 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 \`${Registration.table}\`.registeredAt is not null AND \`${Registration.table}\`.deactivatedAt is null`
-        
-        const [results] = await Database.select(query, [organizationId])
+        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'];
 
         if (Number.isInteger(count)) {
-           return count as number
-        } else {
-            console.error("Unexpected result for occupancy", results)
-            throw new Error("Query failed")
+            return count as number;
+        }
+        else {
+            console.error('Unexpected result for occupancy', results);
+            throw new Error('Query failed');
         }
     }
 
     async deactivate() {
         if (this.deactivatedAt !== null) {
-            return
+            return;
         }
 
         // Clear the registration
-        this.deactivatedAt = new Date()
-        await this.save()
-        this.scheduleStockUpdate()
-        
-        const {Member} = await import('./Member');
-        await Member.updateMembershipsForId(this.memberId)
+        this.deactivatedAt = new Date();
+        await this.save();
+        this.scheduleStockUpdate();
+
+        const { Member } = await import('./Member');
+        await Member.updateMembershipsForId(this.memberId);
     }
 
-    async markValid(this: Registration, options?: {skipEmail?: boolean}) {
+    async markValid(this: Registration, options?: { skipEmail?: boolean }) {
         if (this.registeredAt !== null && this.deactivatedAt === null) {
             await this.save();
             return false;
         }
 
-        this.reservedUntil = null
-        this.registeredAt =  this.registeredAt ?? new Date()
-        this.deactivatedAt = null
-        this.canRegister = false
+        this.reservedUntil = null;
+        this.registeredAt = this.registeredAt ?? new Date();
+        this.deactivatedAt = null;
+        this.canRegister = false;
         await this.save();
-        this.scheduleStockUpdate()
+        this.scheduleStockUpdate();
 
-        const {Member} = await import('./Member');
-        await Member.updateMembershipsForId(this.memberId)
+        const { Member } = await import('./Member');
+        await Member.updateMembershipsForId(this.memberId);
 
         if (options?.skipEmail !== true) {
             await this.sendEmailTemplate({
-                type: EmailTemplateType.RegistrationConfirmation
+                type: EmailTemplateType.RegistrationConfirmation,
             });
         }
 
         const member = await Member.getByID(this.memberId);
         if (member) {
-            const registrationMemberRelation = new ManyToOneRelation(Member, "member")
-            registrationMemberRelation.foreignKey = Member.registrations.foreignKey
-            await Document.updateForRegistration(this.setRelation(registrationMemberRelation, member))
+            const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
+            registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
+            await Document.updateForRegistration(this.setRelation(registrationMemberRelation, member));
         }
 
         return true;
     }
 
     async getRecipients(organization: Organization, group: import('./').Group) {
-        const {Member} = await import('./Member');
+        const { Member } = await import('./Member');
 
         const member = await Member.getWithRegistrations(this.memberId);
 
@@ -243,72 +244,72 @@ export class Registration extends Model {
             userId: user.id,
             replacements: [
                 Replacement.create({
-                    token: "firstName",
+                    token: 'firstName',
                     value: member.details.firstName,
                 }),
                 Replacement.create({
-                    token: "lastName",
+                    token: 'lastName',
                     value: member.details.lastName,
                 }),
                 Replacement.create({
-                    token: "firstNameMember",
+                    token: 'firstNameMember',
                     value: member.details.firstName,
                 }),
                 Replacement.create({
-                    token: "lastNameMember",
+                    token: 'lastNameMember',
                     value: member.details.lastName,
                 }),
                 Replacement.create({
-                    token: "email",
-                    value: user.email
+                    token: 'email',
+                    value: user.email,
                 }),
                 Replacement.create({
-                    token: "registerUrl",
-                    value: "https://" + organization.getHost()
+                    token: 'registerUrl',
+                    value: 'https://' + organization.getHost(),
                 }),
                 Replacement.create({
-                    token: "organizationName",
-                    value: organization.name
+                    token: 'organizationName',
+                    value: organization.name,
                 }),
                 Replacement.create({
-                    token: "groupName",
-                    value: group.settings.name
+                    token: 'groupName',
+                    value: group.settings.name,
                 }),
                 Replacement.create({
-                    token: "loginDetails",
-                    value: "",
-                    html: user.hasAccount() ? `<p class="description"><em>Je kan op het ledenportaal inloggen met <strong>${Formatter.escapeHtml(user.email)}</strong></em></p>` : `<p class="description"><em>Je kan op het ledenportaal een nieuw account aanmaken met het e-mailadres <strong>${Formatter.escapeHtml(user.email)}</strong>, dan krijg je automatisch toegang tot alle bestaande gegevens.</em></p>`
+                    token: 'loginDetails',
+                    value: '',
+                    html: user.hasAccount() ? `<p class="description"><em>Je kan op het ledenportaal inloggen met <strong>${Formatter.escapeHtml(user.email)}</strong></em></p>` : `<p class="description"><em>Je kan op het ledenportaal een nieuw account aanmaken met het e-mailadres <strong>${Formatter.escapeHtml(user.email)}</strong>, dan krijg je automatisch toegang tot alle bestaande gegevens.</em></p>`,
                 }),
-            ]
+            ],
         }));
     }
 
     async sendEmailTemplate(data: {
-        type: EmailTemplateType
+        type: EmailTemplateType;
     }) {
-        const Group = (await import('./')).Group
+        const Group = (await import('./')).Group;
         const group = await Group.getByID(this.groupId);
 
         if (!group) {
-            return
+            return;
         }
 
         const organization = await Organization.getByID(group.organizationId);
         if (!organization) {
-            return
+            return;
         }
 
-        const recipients = await this.getRecipients(organization, group)
+        const recipients = await this.getRecipients(organization, group);
 
         // Create e-mail builder
         await sendEmailTemplate(organization, {
             template: {
-                type: data.type, 
-                group
+                type: data.type,
+                group,
             },
             recipients,
-            type: "transactional",
-        })
+            type: 'transactional',
+        });
     }
 
     static async sendTransferEmail(user: User, organization: Organization, payment: import('./').Payment) {
@@ -323,69 +324,69 @@ export class Registration extends Model {
                 userId: user.id,
                 replacements: [
                     Replacement.create({
-                        token: "priceToPay",
-                        value: Formatter.price(payment.price)
+                        token: 'priceToPay',
+                        value: Formatter.price(payment.price),
                     }),
                     Replacement.create({
-                        token: "paymentMethod",
-                        value: PaymentMethodHelper.getName(payment.method ?? PaymentMethod.Unknown)
+                        token: 'paymentMethod',
+                        value: PaymentMethodHelper.getName(payment.method ?? PaymentMethod.Unknown),
                     }),
                     Replacement.create({
-                        token: "transferDescription",
-                        value: (payment.transferDescription ?? "")
+                        token: 'transferDescription',
+                        value: (payment.transferDescription ?? ''),
                     }),
                     Replacement.create({
-                        token: "transferBankAccount",
-                        value: payment.transferSettings?.iban ?? ""
+                        token: 'transferBankAccount',
+                        value: payment.transferSettings?.iban ?? '',
                     }),
                     Replacement.create({
-                        token: "transferBankCreditor",
-                        value: payment.transferSettings?.creditor ?? organization.name
+                        token: 'transferBankCreditor',
+                        value: payment.transferSettings?.creditor ?? organization.name,
                     }),
                     Replacement.create({
-                        token: "overviewTable",
-                        value: "",
-                        html: paymentGeneral.getDetailsHTMLTable()
+                        token: 'overviewTable',
+                        value: '',
+                        html: paymentGeneral.getDetailsHTMLTable(),
                     }),
                     Replacement.create({
-                        token: "overviewContext",
-                        value: "Inschrijving van " + paymentGeneral.memberNames
+                        token: 'overviewContext',
+                        value: 'Inschrijving van ' + paymentGeneral.memberNames,
                     }),
                     Replacement.create({
-                        token: "memberNames",
-                        value: paymentGeneral.memberNames
+                        token: 'memberNames',
+                        value: paymentGeneral.memberNames,
                     }),
                     Replacement.create({
-                        token: "overviewTable",
-                        value: "",
-                        html: paymentGeneral.getDetailsHTMLTable()
+                        token: 'overviewTable',
+                        value: '',
+                        html: paymentGeneral.getDetailsHTMLTable(),
                     }),
                     Replacement.create({
-                        token: "paymentTable",
-                        value: "",
-                        html: paymentGeneral.getHTMLTable()
+                        token: 'paymentTable',
+                        value: '',
+                        html: paymentGeneral.getHTMLTable(),
                     }),
                     Replacement.create({
-                        token: "registerUrl",
-                        value: "https://" + organization.getHost()
+                        token: 'registerUrl',
+                        value: 'https://' + organization.getHost(),
                     }),
                     Replacement.create({
-                        token: "organizationName",
-                        value: organization.name
+                        token: 'organizationName',
+                        value: organization.name,
                     }),
                     Replacement.create({
-                        token: "loginDetails",
-                        value: "",
-                        html: user.hasAccount() ? `<p class="description"><em>Je kan op het ledenportaal inloggen met <strong>${Formatter.escapeHtml(user.email)}</strong></em></p>` : `<p class="description"><em>Je kan op het ledenportaal een nieuw account aanmaken met het e-mailadres <strong>${Formatter.escapeHtml(user.email)}</strong>, dan krijg je automatisch toegang tot alle bestaande gegevens.</em></p>`
-                    })
-                ]
-            })
+                        token: 'loginDetails',
+                        value: '',
+                        html: user.hasAccount() ? `<p class="description"><em>Je kan op het ledenportaal inloggen met <strong>${Formatter.escapeHtml(user.email)}</strong></em></p>` : `<p class="description"><em>Je kan op het ledenportaal een nieuw account aanmaken met het e-mailadres <strong>${Formatter.escapeHtml(user.email)}</strong>, dan krijg je automatisch toegang tot alle bestaande gegevens.</em></p>`,
+                    }),
+                ],
+            }),
         ];
 
-        let group: Group|undefined|null = null;
+        let group: Group | undefined | null = null;
 
         if (groupIds.length == 1) {
-            const Group = (await import('./')).Group
+            const Group = (await import('./')).Group;
             group = await Group.getByID(groupIds[0]);
         }
 
@@ -393,19 +394,17 @@ export class Registration extends Model {
         await sendEmailTemplate(organization, {
             template: {
                 type: EmailTemplateType.RegistrationTransferDetails,
-                group
+                group,
             },
-            type: "transactional",
-            recipients
-        })
+            type: 'transactional',
+            recipients,
+        });
     }
 
     shouldIncludeStock() {
-        return (this.registeredAt !== null && this.deactivatedAt === null) || this.canRegister || (this.reservedUntil && this.reservedUntil > new Date())
+        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
@@ -415,20 +414,20 @@ export class Registration extends Model {
     scheduleStockUpdate() {
         const id = this.id;
 
-        QueueHandler.cancel('registration-stock-update-'+id);
-        QueueHandler.schedule('registration-stock-update-'+id, async function(this: undefined) {
+        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);
                 }
@@ -440,16 +439,16 @@ export class Registration extends Model {
                     StockReservation.create({
                         objectId: updated.groupPrice.id,
                         objectType: 'GroupPrice',
-                        amount: 1
+                        amount: 1,
                     }),
-                    ...updated.options.map(o => {
+                    ...updated.options.map((o) => {
                         return StockReservation.create({
                             objectId: o.option.id,
                             objectType: 'GroupOption',
-                            amount: o.amount
-                        })
-                    })
-                ]
+                            amount: o.amount,
+                        });
+                    }),
+                ];
 
                 await Group.applyStockReservations(updated.groupId, groupStockReservations);
 
@@ -459,17 +458,17 @@ export class Registration extends Model {
                         objectId: updated.groupId,
                         objectType: 'Group',
                         amount: 1,
-                        children: groupStockReservations
-                    })
+                        children: groupStockReservations,
+                    }),
                 ];
                 await updated.save();
-            } else {
+            }
+            else {
                 if (updated.stockReservations.length) {
                     updated.stockReservations = [];
                     await updated.save();
                 }
             }
-
-        }).catch(console.error)
+        }).catch(console.error);
     }
 }