@stamhoofd/models 2.1.1

package/src/models/Platform.ts

@@ -0,0 +1,76 @@
+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";
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "json", decoder: PlatformConfig })
+    config: PlatformConfig = PlatformConfig.create({})
+
+    @column({ type: "string" })
+    periodId: string
+
+    @column({ type: "json", decoder: PlatformPrivateConfig })
+    privateConfig: PlatformPrivateConfig = PlatformPrivateConfig.create({})
+
+    static sharedStruct: PlatformStruct | null = null;
+
+    static async getSharedStruct(): Promise<PlatformStruct> {
+        const struct = await this.getSharedPrivateStruct();
+        const clone = struct.clone();
+        clone.privateConfig = null;
+        clone.setShared();
+
+        return clone;
+    }
+
+    static async getSharedPrivateStruct(): Promise<PlatformStruct> {
+        if (this.sharedStruct && this.sharedStruct.privateConfig) {
+            return this.sharedStruct;
+        }
+
+        return await QueueHandler.schedule('Platform.getSharedStruct', async () => {
+            const model = await this.getShared();
+            const period = await RegistrationPeriod.getByID(model.periodId);
+            const struct = PlatformStruct.create({
+                ...model,
+                period: period?.getStructure() ?? undefined
+            });
+            this.sharedStruct = struct;
+
+            return struct;
+        });
+    }
+
+    static async getShared(): Promise<Platform> {
+        return QueueHandler.schedule('Platform.getShared', async () => {
+            // Build a new one
+            let model = await this.getByID('1');
+            if (!model) {
+                // Create a new platform
+                model = new Platform();
+                model.id = '1';
+                model.periodId = (await RegistrationPeriod.all())[0].id;
+                await model.save();
+            }
+
+            return model;
+        });
+    }
+
+    async save() {
+        Platform.sharedStruct = null
+        return await super.save()
+    }
+}

package/src/models/RegisterCode.ts

@@ -0,0 +1,164 @@
+import { column, Model } from "@simonbackx/simple-database";
+import { SimpleError } from "@simonbackx/simple-errors";
+import { EmailInterfaceBase } from "@stamhoofd/email";
+import basex from "base-x";
+import crypto from "crypto";
+
+import { Organization } from "./Organization";
+import { STCredit } from "./STCredit";
+import { UsedRegisterCode } from "./UsedRegisterCode";
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+const bs58 = basex(ALPHABET)
+
+async function randomBytes(size: number): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+        crypto.randomBytes(size, (err: Error | null, buf: Buffer) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(buf);
+        });
+    });
+}
+
+export class RegisterCode extends Model {
+    static table = "register_codes";
+
+    @column({ type: "string", primary: true })
+    code: string;
+
+    @column({ type: "string" })
+    description: string;
+
+    @column({ type: "string", nullable: true })
+    customMessage: string|null = null;
+
+    @column({ type: "string", nullable: true })
+    organizationId: string | null;
+
+    @column({ type: "integer" })
+    value: number;
+
+    /**
+     * Invoice usages to the owning organization
+     */
+    @column({ type: "integer", nullable: true })
+    invoiceValue: number|null = null
+
+    @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 generateCode() {
+        this.code = bs58.encode(await randomBytes(8)).toUpperCase();
+    }
+
+    /**
+     * Prepares a register code for usage.
+     * Returns the models to save and the emails to send when succesful
+     */
+    static async applyRegisterCode(organization: Organization, codeString: string): Promise<{models: Model[], emails: EmailInterfaceBase[]}> {
+        const alreadyUsed = await UsedRegisterCode.getFor(organization.id)
+        if (alreadyUsed) {
+            throw new SimpleError({
+                code: "invalid_field",
+                message: "Invalid register code",
+                human: "Je hebt al een doorverwijzingscode gebruikt",
+                field: "registerCode",
+            });
+        }
+
+        const code = await RegisterCode.getByID(codeString)
+        if (!code) {
+            throw new SimpleError({
+                code: "invalid_field",
+                message: "Invalid register code",
+                human: "De doorverwijzingscode die je hebt opgegeven is niet langer geldig",
+                field: "registerCode",
+            });
+        }
+
+        const otherOrganization = code.organizationId ? await Organization.getByID(code.organizationId) : undefined
+        
+        const delayEmails: EmailInterfaceBase[] = []
+        let credit: STCredit | undefined = undefined
+        let usedCode: UsedRegisterCode | undefined = undefined
+
+        if (code.value > 0) {
+            // Create initial credit
+            credit = new STCredit()
+            credit.organizationId = organization.id
+            credit.change = code.value
+            credit.description = otherOrganization ? ("Tegoed gekregen van "+otherOrganization.name) : code.description
+
+            // Expire in one year (will get extended for every purchase or activation)
+            credit.expireAt = new Date()
+            credit.expireAt.setFullYear(credit.expireAt.getFullYear() + 1)
+            credit.expireAt.setMilliseconds(0)
+
+            // Save later
+        }
+
+        if (otherOrganization) {
+            const admins = await otherOrganization.getAdminToEmails()
+            if (admins) {
+                if (code.invoiceValue) {
+                    // Delay email until everything is validated and saved
+                    delayEmails.push({
+                        to: admins,
+                        bcc: "simon@stamhoofd.be",
+                        subject: organization.name+" heeft jullie doorverwijzingslink gebruikt 🥳",
+                        type: "transactional",
+                        text: "Dag "+otherOrganization.name+",\n\nGoed nieuws! "+organization.name+" heeft jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren.\n\n— Stamhoofd"
+                    })
+                } else {
+                    // Delay email until everything is validated and saved
+                    delayEmails.push({
+                        to: admins,
+                        bcc: "simon@stamhoofd.be",
+                        subject: organization.name+" heeft jullie doorverwijzingslink gebruikt 🥳",
+                        type: "transactional",
+                        text: "Dag "+otherOrganization.name+",\n\nGoed nieuws! "+organization.name+" heeft jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren. Als zij minstens 1 euro op Stamhoofd uitgeven ontvangen jullie een tegoed dat kan oplopen tot 100 euro per vereniging (zie daarvoor Stamhoofd > Instellingen). Lees zeker onze tips na om nog een groter bedrag te verzamelen 😉\n\n— Stamhoofd"
+                    })
+                }
+            }
+        } else {
+            delayEmails.push({
+                to: 'hallo@stamhoofd.be',
+                subject: organization.name+" heeft jullie doorverwijzingslink gebruikt 🥳",
+                type: "transactional",
+                text: "Dag Stamhoofd,\n\nGoed nieuws! "+organization.name+" heeft jullie doorverwijzingslink "+code.code+" gebruikt om zich op Stamhoofd te registreren. \n\n— Stamhoofd"
+            })
+        }
+
+        // Save that we used this code (so we can reward the other organization)
+        usedCode = new UsedRegisterCode()
+        usedCode.organizationId = organization.id
+        usedCode.code = code.code
+        
+        // Save later
+        return {
+            models: credit ? [credit, usedCode] : [usedCode],
+            emails: delayEmails
+        }
+    }
+}

package/src/models/Registration.ts

@@ -0,0 +1,405 @@
+import { column, Database, ManyToOneRelation, Model } from '@simonbackx/simple-database';
+import { Email } from '@stamhoofd/email';
+import { EmailTemplateType, PaymentMethod, PaymentMethodHelper, Recipient, Registration as RegistrationStructure, Replacement } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from "uuid";
+
+import { getEmailBuilder } from '../helpers/EmailBuilder';
+import { Document, EmailTemplate, Organization, User } from './';
+
+export class Registration extends Model {
+    static table = "registrations"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    memberId: string;
+
+    @column({ type: "string" })
+    organizationId: string
+
+    @column({ type: "string" })
+    periodId: string;
+
+    @column({ type: "string", foreignKey: Registration.group})
+    groupId: string;
+
+    /**
+     * @deprecated
+     */
+    @column({ type: "string", nullable: true })
+    paymentId: string | null = null
+
+    @column({ type: "integer" })
+    cycle: number;
+
+    @column({ type: "integer", nullable: true })
+    price: number | null = null;
+
+    @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
+
+    @column({ type: "datetime", nullable: true })
+    registeredAt: Date | null = null
+
+    @column({ type: "datetime", nullable: true })
+    reservedUntil: Date | null = null
+
+    @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: "datetime", nullable: true})
+    deactivatedAt: Date | null = null
+
+    /**
+     * Part of price that is paid
+     */
+    @column({ type: "integer" })
+    pricePaid = 0
+
+    static group: ManyToOneRelation<"group", import('./Group').Group>
+
+    getStructure(this: Registration & {group: import('./Group').Group}) {
+        return RegistrationStructure.create({
+            ...this,
+            group: this.group.getStructure(),
+            price: this.price ?? 0
+        })
+    }
+
+    /**
+     * Update the outstanding balance of multiple members in one go (or all members)
+     */
+    static async updateOutstandingBalance(registrationIds: string[] | 'all', organizationId: string) {
+        if (registrationIds !== 'all' && registrationIds.length == 0) {
+            return
+        }
+
+        const params: any[] = []
+        let firstWhere = ''
+        let secondWhere = ''
+
+        if (registrationIds !== 'all') {
+            firstWhere = ` AND registrationId IN (?)`
+            params.push(registrationIds)
+
+            secondWhere = `WHERE registrations.id IN (?)`
+            params.push(registrationIds)
+        }
+        
+        const query = `UPDATE
+            registrations
+            LEFT JOIN (
+                SELECT
+                    registrationId,
+                    sum(price) AS price,
+                    sum(pricePaid) AS pricePaid
+                FROM
+                    balance_items
+                WHERE status != 'Hidden'${firstWhere}
+                GROUP BY
+                    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)
+
+        if (registrationIds !== 'all') {
+            await Document.updateForRegistrations(registrationIds, organizationId)
+        }
+    }
+
+    /**
+     * Get the number of active members that are currently registered
+     * This is used for billing
+     */
+    static async getActiveMembers(organizationId: string): Promise<number> {
+        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 \`groups\`.status != 'Archived' AND \`${Registration.table}\`.registeredAt is not null AND \`${Registration.table}\`.waitingList = 0`
+        
+        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")
+        }
+    }
+
+    async markValid(this: Registration) {
+        if (this.registeredAt !== null) {
+            await this.save();
+            return false;
+        }
+        this.reservedUntil = null
+        this.registeredAt = new Date()
+        await this.save();
+
+        await this.sendEmailTemplate({
+            type: EmailTemplateType.RegistrationConfirmation
+        });
+
+        const {Member} = await import('./Member');
+        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))
+        }
+
+        return true;
+    }
+
+    async getRecipients(organization: Organization, group: import('./').Group) {
+        const {Member} = await import('./Member');
+
+        const member = await Member.getWithRegistrations(this.memberId);
+
+        if (!member) {
+            return [];
+        }
+
+        return member.users.map(user => Recipient.create({
+            firstName: user.firstName,
+            lastName: user.lastName,
+            email: user.email,
+            userId: user.id,
+            replacements: [
+                Replacement.create({
+                    token: "firstName",
+                    value: member.details.firstName,
+                }),
+                Replacement.create({
+                    token: "lastName",
+                    value: member.details.lastName,
+                }),
+                Replacement.create({
+                    token: "email",
+                    value: user.email
+                }),
+                Replacement.create({
+                    token: "registerUrl",
+                    value: "https://" + organization.getHost()
+                }),
+                Replacement.create({
+                    token: "organizationName",
+                    value: organization.name
+                }),
+                Replacement.create({
+                    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>`
+                }),
+            ]
+        }));
+    }
+
+    async sendEmailTemplate(data: {
+        type: EmailTemplateType
+    }) {
+        const Group = (await import('./')).Group
+        const group = await Group.getByID(this.groupId);
+
+        if (!group) {
+            return
+        }
+
+        // Most specific template: for specific group
+        let templates = (await EmailTemplate.where({ type: data.type, groupId: this.groupId, organizationId: group.organizationId }))
+
+        // Then for organization
+        if (templates.length == 0) {
+            templates = (await EmailTemplate.where({ type: data.type, organizationId: group.organizationId, groupId: null }))
+        }
+
+        // Then default
+        if (templates.length == 0) {
+            templates = (await EmailTemplate.where({ type: data.type, organizationId: null, groupId: null }))
+        }
+
+        if (templates.length == 0) {
+            console.error("Could not find email template for type "+data.type)
+            return
+        }
+
+        const template = templates[0]
+
+        const organization = await Organization.getByID(group.organizationId);
+        if (!organization) {
+            return
+        }
+
+        const recipients = await this.getRecipients(organization, group)
+
+        const {from, replyTo} = organization.getGroupEmail(group)
+
+        // Create e-mail builder
+        const builder = await getEmailBuilder(organization, {
+            recipients,
+            subject: template.subject,
+            html: template.html,
+            from,
+            type: "transactional",
+            replyTo
+        })
+
+        Email.schedule(builder)
+    }
+
+    static async sendTransferEmail(user: User, organization: Organization, payment: import('./').Payment) {
+        const data = {
+            type: EmailTemplateType.RegistrationTransferDetails
+        };
+
+        // First fetch template
+        let templates = (await EmailTemplate.where({ type: data.type, organizationId: organization.id, groupId: null }))
+
+        if (templates.length == 0) {
+            templates = (await EmailTemplate.where({ type: data.type, organizationId: null, groupId: null }))
+        }
+
+        if (templates.length == 0) {
+            console.error("Could not find email template for type "+data.type)
+            return
+        }
+
+        const template = templates[0]
+
+        const paymentGeneral = await payment.getGeneralStructure();
+        const registrations = paymentGeneral.registrations
+        let groupIds = registrations.map(r => r.groupId);
+        
+        // Remove duplicate groupIds
+        groupIds = groupIds.filter((v, i, a) => a.indexOf(v) === i);
+
+        const recipients = [
+            Recipient.create({
+                firstName: user.firstName,
+                lastName: user.lastName,
+                email: user.email,
+                userId: user.id,
+                replacements: [
+                    Replacement.create({
+                        token: "priceToPay",
+                        value: Formatter.price(payment.price)
+                    }),
+                    Replacement.create({
+                        token: "paymentMethod",
+                        value: PaymentMethodHelper.getName(payment.method ?? PaymentMethod.Unknown)
+                    }),
+                    Replacement.create({
+                        token: "transferDescription",
+                        value: (payment.transferDescription ?? "")
+                    }),
+                    Replacement.create({
+                        token: "transferBankAccount",
+                        value: payment.transferSettings?.iban ?? ""
+                    }),
+                    Replacement.create({
+                        token: "transferBankCreditor",
+                        value: payment.transferSettings?.creditor ?? organization.name
+                    }),
+                    Replacement.create({
+                        token: "overviewTable",
+                        value: "",
+                        html: paymentGeneral.getDetailsHTMLTable()
+                    }),
+                    Replacement.create({
+                        token: "overviewContext",
+                        value: "Inschrijving van " + paymentGeneral.memberFirstNames
+                    }),
+                    Replacement.create({
+                        token: "memberNames",
+                        value: paymentGeneral.memberNames
+                    }),
+                    Replacement.create({
+                        token: "overviewTable",
+                        value: "",
+                        html: paymentGeneral.getDetailsHTMLTable()
+                    }),
+                    Replacement.create({
+                        token: "paymentTable",
+                        value: "",
+                        html: paymentGeneral.getHTMLTable()
+                    }),
+                    Replacement.create({
+                        token: "registerUrl",
+                        value: "https://" + organization.getHost()
+                    }),
+                    Replacement.create({
+                        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>`
+                    })
+                ]
+            })
+        ];
+
+        let {from, replyTo} = organization.getDefaultEmail()
+
+        if (groupIds.length == 1) {
+            const Group = (await import('./')).Group
+            const group = await Group.getByID(groupIds[0]);
+            if (group) {
+                const groupEmail = organization.getGroupEmail(group)
+                from = groupEmail.from
+                replyTo = groupEmail.replyTo
+            }
+        }
+
+        // Create e-mail builder
+        const builder = await getEmailBuilder(organization, {
+            recipients,
+            subject: template.subject,
+            html: template.html,
+            from,
+            replyTo
+        })
+
+        Email.schedule(builder)
+    }
+}

package/src/models/RegistrationPeriod.ts

@@ -0,0 +1,55 @@
+import { column, Model } from '@simonbackx/simple-database';
+import { RegistrationPeriodSettings, RegistrationPeriod as RegistrationPeriodStruct } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+
+export class RegistrationPeriod extends Model {
+    static table = "registration_periods";
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string", nullable: true })
+    organizationId: string | null = null;
+
+    @column({ type: "datetime" })
+    startDate: Date
+
+    @column({ type: "datetime" })
+    endDate: Date
+  
+    @column({ type: "json", decoder: RegistrationPeriodSettings })
+    settings: RegistrationPeriodSettings;
+
+    @column({ type: "boolean" })
+    locked = false
+
+    @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
+
+    getStructure() {
+        return RegistrationPeriodStruct.create(this)
+    }
+}