@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/EmailVerificationCode.ts

@@ -1,15 +1,15 @@
-import { column, Model } from "@simonbackx/simple-database";
-import { SimpleError } from "@simonbackx/simple-errors";
-import { I18n } from "@stamhoofd/backend-i18n";
-import { EmailTemplateType, Recipient, Replacement } from "@stamhoofd/structures";
-import basex from "base-x";
-import crypto from "crypto";
-import { v4 as uuidv4 } from "uuid";
-import { sendEmailTemplate } from "../helpers/EmailBuilder";
-import { Platform } from "./Platform";
-
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-const bs58 = basex(ALPHABET)
+import { column, Model } from '@simonbackx/simple-database';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { I18n } from '@stamhoofd/backend-i18n';
+import { EmailTemplateType, Recipient, Replacement } from '@stamhoofd/structures';
+import basex from 'base-x';
+import crypto from 'crypto';
+import { v4 as uuidv4 } from 'uuid';
+import { sendEmailTemplate } from '../helpers/EmailBuilder';
+import { Platform } from './Platform';
+
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const bs58 = basex(ALPHABET);
 
 async function randomBytes(size: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -30,79 +30,78 @@ async function randomInt(max: number): Promise<number> {
                 reject(err);
                 return;
             }
-            resolve(n)
-        })
-    })
+            resolve(n);
+        });
+    });
 }
 
-
 /**
  * Holds the verificationCodes for a given email (not a user, since a user can switch email addresses and might avoid verification that way)
  */
 export class EmailVerificationCode extends Model {
-    static table = "email_verification_codes";
+    static table = 'email_verification_codes';
 
-     @column({
-        primary: true, type: "string", beforeSave(value) {
+    @column({
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string", nullable: true })
-    organizationId: string|null = null;
+    @column({ type: 'string', nullable: true })
+    organizationId: string | null = null;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     userId: string;
 
     /**
      * The e-mail that will get verified. If on verification, the user e-mail differs from this one,
      * we'll set the user email to this email address
      */
-    @column({ type: "string" })
+    @column({ type: 'string' })
     email: string;
 
     /**
      * This one is send to the sender. Allows for polling + extra length + sender authentication
      */
-    @column({ type: "string" })
-    token = "";
+    @column({ type: 'string' })
+    token = '';
 
-    @column({ type: "string" })
-    code = "";
+    @column({ type: 'string' })
+    code = '';
 
     /**
      * The amount of times this code has been generated for the same e-mail address
      */
-    @column({ type: "integer" })
+    @column({ type: 'integer' })
     generatedCount = 0;
 
     /**
      * The amount of times this unique code has been tried.
      */
-    @column({ type: "integer" })
+    @column({ type: 'integer' })
     tries = 0;
 
-    @column({ type: "datetime" })
+    @column({ type: 'datetime' })
     expiresAt: Date;
 
     /**
      * createdAt behaves more like createdAt for verificationCode. Since every save is considered to have a new verificationCode
      */
     @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;
+        },
     })
-    createdAt: Date
+    createdAt: Date;
 
-    static CODE_LENGTH = 6
-    static MAX_TRIES = 9 // minus 0..MAX_TRIES_VARY
+    static CODE_LENGTH = 6;
+    static MAX_TRIES = 9; // minus 0..MAX_TRIES_VARY
 
     async generateCode() {
-        this.code = ((await randomInt(Math.pow(10, EmailVerificationCode.CODE_LENGTH)))+"").padStart(EmailVerificationCode.CODE_LENGTH, "0")
+        this.code = ((await randomInt(Math.pow(10, EmailVerificationCode.CODE_LENGTH))) + '').padStart(EmailVerificationCode.CODE_LENGTH, '0');
         this.token = bs58.encode(await randomBytes(100)).toLowerCase();
 
         // Increase generatedCount if we changed the code
@@ -112,64 +111,65 @@ export class EmailVerificationCode extends Model {
         }
 
         // Reset the real tries
-        this.tries = 0
+        this.tries = 0;
 
         // Expire in 12 hours
-        this.expiresAt = new Date(new Date().getTime() + 1000 * 60 * 60 * 12)
+        this.expiresAt = new Date(new Date().getTime() + 1000 * 60 * 60 * 12);
     }
 
-    getEmailVerificationUrl(user: import('./User').User, organization: import('./Organization').Organization|null, i18n: I18n) {
+    getEmailVerificationUrl(user: import('./User').User, organization: import('./Organization').Organization | null, i18n: I18n) {
         let host: string;
         if (user.permissions || !organization || STAMHOOFD.userMode === 'platform') {
-            host = "https://"+(STAMHOOFD.domains.dashboard ?? "stamhoofd.app")+"/"+i18n.locale
-        } else {
+            host = 'https://' + (STAMHOOFD.domains.dashboard ?? 'stamhoofd.app') + '/' + i18n.locale;
+        }
+        else {
             // Add language if different than default
-            host = "https://"+organization.getHost()
+            host = 'https://' + organization.getHost();
 
-            if (i18n.language != organization.i18n.language) {
-                host += "/"+i18n.language
+            if (i18n.language !== organization.i18n.language) {
+                host += '/' + i18n.language;
             }
         }
 
-        return host+"/verify-email"+(user.organizationPermissions && this.organizationId ? "/"+encodeURIComponent(this.organizationId) : "")+"?code="+encodeURIComponent(this.code)+"&token="+encodeURIComponent(this.token);
+        return host + '/verify-email' + (user.organizationPermissions && this.organizationId ? '/' + encodeURIComponent(this.organizationId) : '') + '?code=' + encodeURIComponent(this.code) + '&token=' + encodeURIComponent(this.token);
     }
 
     /**
      * Return true if this token is still valid (used for automatic polling in code view)
      */
-    static async poll(organizationId: string|null, token: string): Promise<boolean> {
-        const verificationCodes = await this.where({ 
-            token, 
+    static async poll(organizationId: string | null, token: string): Promise<boolean> {
+        const verificationCodes = await this.where({
+            token,
             organizationId: {
                 sign: 'IN',
-                value: [organizationId, null]
-            } 
-        }, { limit: 1 })
+                value: [organizationId, null],
+            },
+        }, { limit: 1 });
 
         if (verificationCodes.length == 0) {
-            return false // = expired or invalid
+            return false; // = expired or invalid
         }
 
-        const verificationCode = verificationCodes[0]
+        const verificationCode = verificationCodes[0];
 
         if (verificationCode.token !== token) {
             // Safety check, is not possible
-            console.error("Security check failed for verify: check MySQL optimization")
+            console.error('Security check failed for verify: check MySQL optimization');
             return false;
         }
 
         if (verificationCode.expiresAt < new Date()) {
-            // Expired. 
+            // Expired.
             // Can't expose this because that would expose a user enumeration attack
             // -> we'll include this expiry date in e-mails
-            return false
+            return false;
         }
 
         if (verificationCode.tries >= EmailVerificationCode.MAX_TRIES) {
-            return false
+            return false;
         }
 
-        return true
+        return true;
     }
 
     /**
@@ -177,73 +177,73 @@ export class EmailVerificationCode extends Model {
      * We just expose if it is valid or not, nothing else
      * False = expired or invalid
      * Error => token okay, but too many attempts checking the code
-     * 
+     *
      */
-    static async verify(organizationId: string|null, token: string, code: string): Promise<EmailVerificationCode | undefined> {
-        if (code.length != EmailVerificationCode.CODE_LENGTH) {
-            return
+    static async verify(organizationId: string | null, token: string, code: string): Promise<EmailVerificationCode | undefined> {
+        if (code.length !== EmailVerificationCode.CODE_LENGTH) {
+            return;
         }
-        
-        const verificationCodes = await this.where({ 
-            token, 
+
+        const verificationCodes = await this.where({
+            token,
             organizationId: {
                 sign: 'IN',
-                value: [organizationId, null]
-            }
-        }, { limit: 1 })
+                value: [organizationId, null],
+            },
+        }, { limit: 1 });
 
         if (verificationCodes.length == 0) {
-            return // = expired or invalid
+            return; // = expired or invalid
         }
 
-        const verificationCode = verificationCodes[0]
+        const verificationCode = verificationCodes[0];
 
         if (verificationCode.token !== token) {
             // Safety check, is not possible
-            console.error("Security check failed for verify: check MySQL optimization")
+            console.error('Security check failed for verify: check MySQL optimization');
             return;
         }
 
         if (verificationCode.expiresAt < new Date()) {
-            // Expired. 
+            // Expired.
             // Can't expose this because that would expose a user enumeration attack
             // -> we'll include this expiry date in e-mails
-            return
+            return;
         }
 
         if (verificationCode.tries >= EmailVerificationCode.MAX_TRIES) {
             // We can saferly inform the user, because he is authenticated with the token
             throw new SimpleError({
-                code: "too_many_attempts",
-                message: "Too many attempts",
-                human: "Je hebt de code te veel foutief ingegeven. Verstuur eerst een nieuwe code voor je opnieuw probeert.",
-                statusCode: 429
-            })
+                code: 'too_many_attempts',
+                message: 'Too many attempts',
+                human: 'Je hebt de code te veel foutief ingegeven. Verstuur eerst een nieuwe code voor je opnieuw probeert.',
+                statusCode: 429,
+            });
         }
 
-        if (verificationCode.code === code || (code === "111111" && STAMHOOFD.environment === "development")) {
+        if (verificationCode.code === code || (code === '111111' && STAMHOOFD.environment === 'development')) {
             // Delete all remaining information!
             // To avoid leaving information about the existince of this user (tries)
-            await verificationCode.delete()
+            await verificationCode.delete();
 
-            return verificationCode
+            return verificationCode;
         }
 
-        verificationCode.tries++
-        await verificationCode.save()
+        verificationCode.tries++;
+        await verificationCode.save();
 
         if (verificationCode.tries >= EmailVerificationCode.MAX_TRIES) {
             // We can saferly inform the user, because he is authenticated with the token
             throw new SimpleError({
-                code: "too_many_attempts",
-                message: "Too many attempts",
-                human: "Je hebt de code te veel foutief ingegeven. Verstuur eerst een nieuwe code voor je opnieuw probeert.",
-                statusCode: 429
-            })
+                code: 'too_many_attempts',
+                message: 'Too many attempts',
+                human: 'Je hebt de code te veel foutief ingegeven. Verstuur eerst een nieuwe code voor je opnieuw probeert.',
+                statusCode: 429,
+            });
         }
     }
 
-    async send(user: import('./User').User, organization: import('./Organization').Organization|null, i18n: I18n, withCode = true) {
+    async send(user: import('./User').User, organization: import('./Organization').Organization | null, i18n: I18n, withCode = true) {
         const url = this.getEmailVerificationUrl(user, organization, i18n);
 
         const name = organization?.name ?? (await Platform.getSharedPrivateStruct()).config.name;
@@ -251,16 +251,16 @@ export class EmailVerificationCode extends Model {
         const replacements: Replacement[] = [
             Replacement.create({
                 token: 'organizationName',
-                value: name
+                value: name,
             }),
             Replacement.create({
                 token: 'confirmEmailUrl',
-                value: url
-            })
-        ]
+                value: url,
+            }),
+        ];
 
         if (withCode) {
-            const formattedCode = this.code.substr(0, 3)+" "+this.code.substr(3)
+            const formattedCode = this.code.substr(0, 3) + ' ' + this.code.substr(3);
 
             await sendEmailTemplate(organization, {
                 recipients: [
@@ -270,66 +270,69 @@ export class EmailVerificationCode extends Model {
                             ...replacements,
                             Replacement.create({
                                 token: 'confirmEmailCode',
-                                value: formattedCode
-                            })
-                        ]
-                    })
+                                value: formattedCode,
+                            }),
+                        ],
+                    }),
                 ],
                 template: {
                     type: EmailTemplateType.VerifyEmail,
                 },
-                type: 'transactional'
-            })
-        } else {
+                type: 'transactional',
+            });
+        }
+        else {
             await sendEmailTemplate(organization, {
                 recipients: [
                     Recipient.create({
                         email: this.email,
-                        replacements
-                    })
+                        replacements,
+                    }),
                 ],
                 template: {
                     type: EmailTemplateType.VerifyEmailWithoutCode,
                 },
-                type: 'transactional'
-            })
+                type: 'transactional',
+            });
         }
     }
 
-    static async resend(organization: import('./Organization').Organization|null, token: string, i18n: I18n) {
-        const verificationCodes = await this.where({ 
-            token, 
-            organizationId: organization ? {
-                sign: 'IN',
-                value: [organization.id, null]
-            } : null
-        }, { limit: 1 })
+    static async resend(organization: import('./Organization').Organization | null, token: string, i18n: I18n) {
+        const verificationCodes = await this.where({
+            token,
+            organizationId: organization
+                ? {
+                        sign: 'IN',
+                        value: [organization.id, null],
+                    }
+                : null,
+        }, { limit: 1 });
 
         if (verificationCodes.length == 0) {
-            console.log("Can't resend code, no coded found for token", token)
+            console.log("Can't resend code, no coded found for token", token);
             // TODO: maybe send a note via email
-            return
+            return;
         }
 
-        const verificationCode = verificationCodes[0]
+        const verificationCode = verificationCodes[0];
 
         if (verificationCode.expiresAt < new Date()) {
             // Don't report error, could be brute forced
-            console.log("Can't resend code, token is expired", token)
-            return 
+            console.log("Can't resend code, token is expired", token);
+            return;
         }
 
-        const {User} = await import('./User')
-        const user = await User.getByID(verificationCode.userId)
+        const { User } = await import('./User');
+        const user = await User.getByID(verificationCode.userId);
         if (!user) {
-            return
+            return;
         }
-        await verificationCode.send(user, organization, i18n)
+        await verificationCode.send(user, organization, i18n);
     }
 
     /**
      * Create or reuse a verification code for a given email address
-     * If needed, it will update the code. 
+     * If needed, it will update the code.
      * Use this method for sending only, not for verification!
      */
     static async createFor(user: import('./User').User, email: string): Promise<EmailVerificationCode> {
@@ -340,32 +343,33 @@ export class EmailVerificationCode extends Model {
         // Since, when changing email, we don't throw an error if it is use (user enumeration)
         // So multiple users should be able to request changing to a password, but only on validation should they fail
         // (or this should be noted in the verification email and accounts could be merged)
-        const verificationCodes = await this.where({ userId: user.id }, { limit: 1 })
+        const verificationCodes = await this.where({ userId: user.id }, { limit: 1 });
 
-        let verificationCode: EmailVerificationCode
+        let verificationCode: EmailVerificationCode;
         if (verificationCodes.length == 0) {
-            verificationCode = new EmailVerificationCode()
-            verificationCode.organizationId = user.organizationId
-            await verificationCode.generateCode()
+            verificationCode = new EmailVerificationCode();
+            verificationCode.organizationId = user.organizationId;
+            await verificationCode.generateCode();
 
             // Reset the real tries
-            verificationCode.tries = 0
+            verificationCode.tries = 0;
 
             // Expire in 3 hours
-            verificationCode.expiresAt = new Date(new Date().getTime() + 1000 * 60 * 60 * 3)
-        } else {
-            verificationCode = verificationCodes[0]
+            verificationCode.expiresAt = new Date(new Date().getTime() + 1000 * 60 * 60 * 3);
+        }
+        else {
+            verificationCode = verificationCodes[0];
 
             if (verificationCode.expiresAt < new Date(new Date().getTime() - 15 * 60 * 1000) || verificationCode.tries >= EmailVerificationCode.MAX_TRIES) {
                 // Expired: also update the token
-                await verificationCode.generateCode()
+                await verificationCode.generateCode();
             }
         }
-        
-        verificationCode.email = email
-        verificationCode.userId = user.id
 
-        await verificationCode.save()
-        return verificationCode
+        verificationCode.email = email;
+        verificationCode.userId = user.id;
+
+        await verificationCode.save();
+        return verificationCode;
     }
 }

package/src/models/Event.ts

@@ -1,116 +1,116 @@
-
-import { column, Model } from "@simonbackx/simple-database";
+import { column, Model } from '@simonbackx/simple-database';
 import { EventMeta, Event as EventStruct, GroupType } from '@stamhoofd/structures';
-import { v4 as uuidv4 } from "uuid";
-import { Group } from "./Group";
+import { v4 as uuidv4 } from 'uuid';
+import { Group } from './Group';
 
 export class Event extends Model {
-    static table = "events";
+    static table = 'events';
 
-    @column({ primary: true, type: "string", beforeSave(value) {
+    @column({ primary: true, type: 'string', beforeSave(value) {
         return value ?? uuidv4();
     } })
     id!: string;
 
-    @column({ type: "string" })
-    name: string
+    @column({ type: 'string' })
+    name: string;
 
-    @column({ type: "string" })
-    typeId: string
+    @column({ type: 'string' })
+    typeId: string;
 
-    @column({ type: "string", nullable: true })
-    organizationId: string|null = null
+    @column({ type: 'string', nullable: true })
+    organizationId: string | null = null;
 
-    @column({ type: "string", nullable: true })
-    groupId: string|null = null
+    @column({ type: 'string', nullable: true })
+    groupId: string | null = null;
 
-    @column({ type: "datetime" })
-    startDate: Date
+    @column({ type: 'datetime' })
+    startDate: Date;
 
-    @column({ type: "datetime" })
-    endDate: Date
+    @column({ type: 'datetime' })
+    endDate: Date;
 
-    @column({ type: "json", decoder: EventMeta })
-    meta = EventMeta.create({})
+    @column({ type: 'json', decoder: EventMeta })
+    meta = EventMeta.create({});
 
     @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;
 
     /**
      * @deprecated
      */
-    getStructure(group?: Group|null) {
+    getStructure(group?: Group | null) {
         return EventStruct.create({
             ...this,
-            group: group ? group.getStructure() : null
-        })
+            group: group ? group.getStructure() : null,
+        });
     }
 
     /**
      * @deprecated
      */
-    getPrivateStructure(group?: Group|null) {
+    getPrivateStructure(group?: Group | null) {
         return EventStruct.create({
             ...this,
-            group: group ? group.getPrivateStructure() : null
-        })
+            group: group ? group.getPrivateStructure() : null,
+        });
     }
 
-    async syncGroupRequirements(group: Group|null) {
+    async syncGroupRequirements(group: Group | null) {
         if (!group) {
             return;
         }
 
-        group.settings.requireDefaultAgeGroupIds = this.meta.defaultAgeGroupIds ?? []
-        group.settings.requireGroupIds = this.meta.groups?.map(g => g.id) ?? []
+        group.settings.requireDefaultAgeGroupIds = this.meta.defaultAgeGroupIds ?? [];
+        group.settings.requireGroupIds = this.meta.groups?.map(g => g.id) ?? [];
 
         if (group.type === GroupType.EventRegistration) {
             // Don't change the name of the waiting list
-            group.settings.name = this.name
+            group.settings.name = this.name;
         }
 
         if (this.organizationId) {
             // This is a not-national event, so require the organization
-            group.settings.requireOrganizationIds = [this.organizationId]
-            group.settings.requireOrganizationTags = []
-            group.settings.requirePlatformMembershipOn = null
-        } else {
-            group.settings.requireOrganizationTags = this.meta.organizationTagIds ?? []
+            group.settings.requireOrganizationIds = [this.organizationId];
+            group.settings.requireOrganizationTags = [];
+            group.settings.requirePlatformMembershipOn = null;
+        }
+        else {
+            group.settings.requireOrganizationTags = this.meta.organizationTagIds ?? [];
 
             // Everyone can register
-            group.settings.requireOrganizationIds = []
+            group.settings.requireOrganizationIds = [];
 
             // But they need a valid platform membership
-            group.settings.requirePlatformMembershipOn = this.endDate
+            group.settings.requirePlatformMembershipOn = this.endDate;
         }
-        await group.save()
+        await group.save();
 
         if (group.waitingListId) {
-            const waitingList = await Group.getByID(group.waitingListId)
+            const waitingList = await Group.getByID(group.waitingListId);
             if (waitingList) {
                 if (group.settings.allowRegistrationsByOrganization) {
-                    waitingList.settings.allowRegistrationsByOrganization = true
+                    waitingList.settings.allowRegistrationsByOrganization = true;
                 }
-                await this.syncGroupRequirements(waitingList)
+                await this.syncGroupRequirements(waitingList);
             }
         }
     }