@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/OrganizationRegistrationPeriod.ts

@@ -1,126 +1,126 @@
 import { column, Model } from '@simonbackx/simple-database';
 import { Group as GroupStruct, OrganizationRegistrationPeriodSettings, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, SetupSteps } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 import { Group, RegistrationPeriod } from '.';
 
 export class OrganizationRegistrationPeriod extends Model {
-    static table = "organization_registration_periods";
+    static table = 'organization_registration_periods';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     organizationId: string;
 
-    @column({ type: "string" })
-    periodId: string
+    @column({ type: 'string' })
+    periodId: string;
 
-    @column({ type: "json", decoder: OrganizationRegistrationPeriodSettings })
-    settings = OrganizationRegistrationPeriodSettings.create({})
+    @column({ type: 'json', decoder: OrganizationRegistrationPeriodSettings })
+    settings = OrganizationRegistrationPeriodSettings.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;
 
-    @column({ type: "json", decoder: SetupSteps })
-    setupSteps = SetupSteps.create({})
+    @column({ type: 'json', decoder: SetupSteps })
+    setupSteps = SetupSteps.create({});
 
     getStructure(this: OrganizationRegistrationPeriod, period: RegistrationPeriod, groups: Group[]) {
         return OrganizationRegistrationPeriodStruct.create({
             ...this,
             period: period.getStructure(),
-            groups: groups.map(g => g.getStructure()).sort(GroupStruct.defaultSort)
-        })
+            groups: groups.map(g => g.getStructure()).sort(GroupStruct.defaultSort),
+        });
     }
 
     getPrivateStructure(this: OrganizationRegistrationPeriod, period: RegistrationPeriod, groups: Group[]) {
         return OrganizationRegistrationPeriodStruct.create({
             ...this,
             period: period.getStructure(),
-            groups: groups.map(g => g.getPrivateStructure()).sort(GroupStruct.defaultSort)
-        })
+            groups: groups.map(g => g.getPrivateStructure()).sort(GroupStruct.defaultSort),
+        });
     }
 
-    async cleanCategories(groups: {id: string}[]) {
-        const reachable = new Map<string, boolean>()
-        const queue = [this.settings.rootCategoryId]
-        reachable.set(this.settings.rootCategoryId, true)
+    async cleanCategories(groups: { id: string }[]) {
+        const reachable = new Map<string, boolean>();
+        const queue = [this.settings.rootCategoryId];
+        reachable.set(this.settings.rootCategoryId, true);
         let shouldSave = false;
 
-        const usedGroupIds = new Set<string>()
+        const usedGroupIds = new Set<string>();
 
         while (queue.length > 0) {
-            const id = queue.shift()
+            const id = queue.shift();
             if (!id) {
-                break
+                break;
             }
 
-            const category = this.settings.categories.find(c => c.id === id)
+            const category = this.settings.categories.find(c => c.id === id);
             if (!category) {
-                continue
+                continue;
             }
 
             for (const i of category.categoryIds) {
                 if (!reachable.get(i)) {
-                    reachable.set(i, true)
-                    queue.push(i)
+                    reachable.set(i, true);
+                    queue.push(i);
                 }
             }
 
             // Remove groupIds that no longer exist or are in a different category already
-            let filtered = category.groupIds.filter(id => !!groups.find(g => g.id === id) && !usedGroupIds.has(id))
+            let filtered = category.groupIds.filter(id => !!groups.find(g => g.id === id) && !usedGroupIds.has(id));
 
             // Remove duplicate groups
-            filtered = Formatter.uniqueArray(filtered)
+            filtered = Formatter.uniqueArray(filtered);
 
             if (filtered.length !== category.groupIds.length) {
                 shouldSave = true;
-                console.log("Deleted "+ (category.groupIds.length - filtered.length) +" group ids from category " + category.id + ", in organization period "+this.id)
-                category.groupIds = filtered
+                console.log('Deleted ' + (category.groupIds.length - filtered.length) + ' group ids from category ' + category.id + ', in organization period ' + this.id);
+                category.groupIds = filtered;
             }
 
             for (const groupId of category.groupIds) {
-                usedGroupIds.add(groupId)
+                usedGroupIds.add(groupId);
             }
         }
 
-        const reachableCategoryIds = [...reachable.keys()]
+        const reachableCategoryIds = [...reachable.keys()];
 
         // Delete all categories that are not reachable anymore
         const beforeCount = this.settings.categories.length;
-        this.settings.categories = this.settings.categories.filter(c => reachableCategoryIds.includes(c.id))
+        this.settings.categories = this.settings.categories.filter(c => reachableCategoryIds.includes(c.id));
 
         if (this.settings.categories.length !== beforeCount) {
-            console.log("Deleted "+ (beforeCount - this.settings.categories.length) +" categories from organizaton period "+this.id)
-            await this.save()
-        } else {
+            console.log('Deleted ' + (beforeCount - this.settings.categories.length) + ' categories from organizaton period ' + this.id);
+            await this.save();
+        }
+        else {
             if (shouldSave) {
-                await this.save()
+                await this.save();
             }
         }
     }
-
 }

package/src/models/PasswordToken.ts

@@ -1,12 +1,11 @@
+import { column, Database, ManyToOneRelation, Model } from '@simonbackx/simple-database';
+import { I18n } from '@stamhoofd/backend-i18n';
+import basex from 'base-x';
+import crypto from 'crypto';
 
-import { column, Database, ManyToOneRelation, Model } from "@simonbackx/simple-database";
-import { I18n } from "@stamhoofd/backend-i18n";
-import basex from "base-x";
-import crypto from "crypto";
-
-import { Organization, User } from "./";
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-const bs58 = basex(ALPHABET)
+import { Organization, User } from './';
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const bs58 = basex(ALPHABET);
 
 export type PasswordTokenWithUser = PasswordToken & { user: User };
 
@@ -23,47 +22,47 @@ async function randomBytes(size: number): Promise<Buffer> {
 }
 
 export class PasswordToken extends Model {
-    static table = "password_tokens";
-   
+    static table = 'password_tokens';
+
     // Columns
-    @column({ primary: true, type: "string" })
+    @column({ primary: true, type: 'string' })
     token: string;
 
-    @column({ type: "datetime" })
+    @column({ type: 'datetime' })
     validUntil: Date;
 
     @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: "string", foreignKey: PasswordToken.user })
+    @column({ type: 'string', foreignKey: PasswordToken.user })
     userId: string;
 
-    static user = new ManyToOneRelation(User, "user");
+    static user = new ManyToOneRelation(User, 'user');
 
     isExpired(): boolean {
-        return this.validUntil < new Date()
+        return this.validUntil < new Date();
     }
-    
+
     /**
      * Get a token
-     * @param token 
+     * @param token
      * @param ignoreExpireDate: do not return if it is expired
      */
     static async getToken(token: string, ignoreExpireDate = false): Promise<PasswordTokenWithUser | undefined> {
         const [rows] = await Database.select(
-            `SELECT ${this.getDefaultSelect()}, ${User.getDefaultSelect("user")}  FROM ${
+            `SELECT ${this.getDefaultSelect()}, ${User.getDefaultSelect('user')}  FROM ${
                 this.table
-            } ${PasswordToken.user.joinQuery(this.table, "user")} WHERE ${this.primary.name} = ? LIMIT 1 `,
-            [token]
+            } ${PasswordToken.user.joinQuery(this.table, 'user')} WHERE ${this.primary.name} = ? LIMIT 1 `,
+            [token],
         );
 
         if (rows.length == 0) {
@@ -78,13 +77,13 @@ export class PasswordToken extends Model {
 
         if (!ignoreExpireDate && passwordToken.isExpired()) {
             // If the refresh token is invalid, do not return it
-            return undefined
+            return undefined;
         }
 
-        const user = User.fromRow(rows[0]["user"]) || null;
+        const user = User.fromRow(rows[0]['user']) || null;
 
         if (!user) {
-            console.error("Password token without a valid user!");
+            console.error('Password token without a valid user!');
             return undefined;
         }
 
@@ -98,8 +97,9 @@ export class PasswordToken extends Model {
         const token = new PasswordToken().setRelation(PasswordToken.user, user);
 
         if (validUntil) {
-            token.validUntil = new Date(validUntil)
-        } else {
+            token.validUntil = new Date(validUntil);
+        }
+        else {
             token.validUntil = new Date();
             token.validUntil.setTime(token.validUntil.getTime() + 3 * 3600 * 1000);
         }
@@ -109,31 +109,31 @@ export class PasswordToken extends Model {
         return token;
     }
 
-    static async getPasswordRecoveryUrl(user: User, organization: Organization|null, i18n: I18n, validUntil?: Date) {
+    static async getPasswordRecoveryUrl(user: User, organization: Organization | null, i18n: I18n, validUntil?: Date) {
         if (user.organizationId !== null && ((user.organizationId ?? null) !== (organization?.id ?? null))) {
-            throw new Error('Unexpected mismatch in organization id for PasswordToken')
+            throw new Error('Unexpected mismatch in organization id for PasswordToken');
         }
         // Send an e-mail to say you already have an account + follow password forgot flow
-        const token = await PasswordToken.createToken(user, validUntil)
+        const token = await PasswordToken.createToken(user, validUntil);
 
         let host: string;
-        if (user.permissions || !organization || STAMHOOFD.userMode === "platform") {
-            host = "https://"+(STAMHOOFD.domains.dashboard)+"/"+i18n.locale
-            return host+"/reset-password"+((user.organizationId || organization) ? ("/"+encodeURIComponent(user.organizationId ?? organization!.id)) : "")+"?token="+encodeURIComponent(token.token);
+        if (user.permissions || !organization || STAMHOOFD.userMode === 'platform') {
+            host = 'https://' + (STAMHOOFD.domains.dashboard) + '/' + i18n.locale;
+            return host + '/reset-password' + ((user.organizationId || organization) ? ('/' + encodeURIComponent(user.organizationId ?? organization!.id)) : '') + '?token=' + encodeURIComponent(token.token);
         }
 
-        host = "https://"+organization.getHost(i18n)
-        return host+"/reset-password?token="+encodeURIComponent(token.token);
+        host = 'https://' + organization.getHost(i18n);
+        return host + '/reset-password?token=' + encodeURIComponent(token.token);
     }
 
     static async getMagicSignInUrl(user: User, organization: Organization) {
         // For now we don't add a token yet for security. We might add some sort of email validation thing later on
-        const host = "https://"+organization.getHost()
-        return Promise.resolve(host+"/login"+"?email="+encodeURIComponent(user.email)+"&hasAccount="+(user.hasAccount() ? 1 : 0));
+        const host = 'https://' + organization.getHost();
+        return Promise.resolve(host + '/login' + '?email=' + encodeURIComponent(user.email) + '&hasAccount=' + (user.hasAccount() ? 1 : 0));
     }
 
     static async clearFor(userId: string) {
         const query = `DELETE from ${this.table} where userId = ?`;
-        await Database.delete(query, [userId])
+        await Database.delete(query, [userId]);
     }
 }

package/src/models/PayconiqPayment.ts

@@ -1,127 +1,128 @@
-import { column, Model } from "@simonbackx/simple-database";
+import { column, Model } from '@simonbackx/simple-database';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { PayconiqAccount, PaymentStatus, Version } from '@stamhoofd/structures';
 import { IncomingMessage } from 'http';
-import https from "https";
-import { v4 as uuidv4 } from "uuid";
+import https from 'https';
+import { v4 as uuidv4 } from 'uuid';
 
 import { Organization, Payment } from './';
 
 export class PayconiqPayment extends Model {
-    static table = "payconiq_payments";
+    static table = 'payconiq_payments';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     paymentId: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     payconiqId: string;
 
     async getStatus(organization: Organization): Promise<PaymentStatus> {
-        const apiKey = organization.privateMeta.payconiqApiKey
+        const apiKey = organization.privateMeta.payconiqApiKey;
         if (!apiKey) {
             throw new SimpleError({
-                code: "",
-                message: "Payconiq API key missing to check the status of the payment"
-            })
+                code: '',
+                message: 'Payconiq API key missing to check the status of the payment',
+            });
         }
 
-        const response = await PayconiqPayment.request("GET", "/v3/payments/"+this.payconiqId, {}, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
+        const response = await PayconiqPayment.request('GET', '/v3/payments/' + this.payconiqId, {}, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
         if (response.status) {
             switch (response.status) {
-                case "AUTHORIZED": return PaymentStatus.Pending;
-                case "PENDING": return PaymentStatus.Created;
+                case 'AUTHORIZED': return PaymentStatus.Pending;
+                case 'PENDING': return PaymentStatus.Created;
 
-                case "IDENTIFIED": return PaymentStatus.Pending; // Code has been scanned!
+                case 'IDENTIFIED': return PaymentStatus.Pending; // Code has been scanned!
 
-                case "AUTHORIZATION_FAILED": return PaymentStatus.Failed;
-                case "EXPIRED": return PaymentStatus.Failed;
-                case "FAILED": return PaymentStatus.Failed;
-                case "CANCELLED": return PaymentStatus.Failed;
+                case 'AUTHORIZATION_FAILED': return PaymentStatus.Failed;
+                case 'EXPIRED': return PaymentStatus.Failed;
+                case 'FAILED': return PaymentStatus.Failed;
+                case 'CANCELLED': return PaymentStatus.Failed;
 
-                case "SUCCEEDED": return PaymentStatus.Succeeded;
+                case 'SUCCEEDED': return PaymentStatus.Succeeded;
             }
-            return PaymentStatus.Pending // default to pending
+            return PaymentStatus.Pending; // default to pending
         }
         throw new SimpleError({
-            code: "",
-            message: "Status missing in response"
-        })
+            code: '',
+            message: 'Status missing in response',
+        });
     }
 
     async cancel(organization: Organization): Promise<boolean> {
-        const apiKey = organization.privateMeta.payconiqApiKey
+        const apiKey = organization.privateMeta.payconiqApiKey;
         if (!apiKey) {
             throw new SimpleError({
-                code: "",
-                message: "Payconiq API key missing to check the status of the payment"
-            })
+                code: '',
+                message: 'Payconiq API key missing to check the status of the payment',
+            });
         }
 
         // Throws on failure
         try {
-            await PayconiqPayment.request("DELETE", "/v3/payments/"+this.payconiqId, {}, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
+            await PayconiqPayment.request('DELETE', '/v3/payments/' + this.payconiqId, {}, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
             return true;
-        } catch (e) {
-            console.error('Failed to cancel Payconiq payment', this.id, this.payconiqId, e)
+        }
+        catch (e) {
+            console.error('Failed to cancel Payconiq payment', this.id, this.payconiqId, e);
             return false;
         }
     }
 
-    static async createTest(organization: Organization, payconiqAccount: PayconiqAccount): Promise<undefined|object> {
-        const apiKey = payconiqAccount.apiKey
+    static async createTest(organization: Organization, payconiqAccount: PayconiqAccount): Promise<undefined | object> {
+        const apiKey = payconiqAccount.apiKey;
         if (!apiKey) {
-            return
+            return;
         }
 
         try {
-            const response = await this.request("POST", "/v3/payments", {
-                reference: "test-"+(new Date().getTime()), // 36 chars, max length is 35...
+            const response = await this.request('POST', '/v3/payments', {
+                reference: 'test-' + (new Date().getTime()), // 36 chars, max length is 35...
                 amount: 1,
-                currency: "EUR",
-                callbackUrl: 'https://'+organization.getApiHost(),
-                description: "Key validation test",
+                currency: 'EUR',
+                callbackUrl: 'https://' + organization.getApiHost(),
+                description: 'Key validation test',
 
-            }, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
+            }, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
             return response;
-        } catch (e) {
+        }
+        catch (e) {
             return;
         }
     }
 
-
     static async createPayment(payment: Payment, organization: Organization, description: string, returnUrl?: string, callbackUrl?: string) {
-        const apiKey = organization.privateMeta.payconiqApiKey
+        const apiKey = organization.privateMeta.payconiqApiKey;
         if (!apiKey) {
             throw new SimpleError({
-                code: "",
-                message: "Betaling via Payconiq is tijdelijk onbeschikbaar"
-            })
+                code: '',
+                message: 'Betaling via Payconiq is tijdelijk onbeschikbaar',
+            });
         }
 
-        const response = await this.request("POST", "/v3/payments", {
-            reference: payment.id.replace("-", ""), // 36 chars, max length is 35...
+        const response = await this.request('POST', '/v3/payments', {
+            reference: payment.id.replace('-', ''), // 36 chars, max length is 35...
             amount: payment.price,
-            currency: "EUR",
-            callbackUrl: callbackUrl ?? 'https://'+organization.getApiHost()+"/v"+Version+"/payments/"+encodeURIComponent(payment.id)+"?exchange=true",
+            currency: 'EUR',
+            callbackUrl: callbackUrl ?? 'https://' + organization.getApiHost() + '/v' + Version + '/payments/' + encodeURIComponent(payment.id) + '?exchange=true',
             returnUrl,
-            description
-        }, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
+            description,
+        }, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
 
-        const payconiqPayment = new PayconiqPayment()
-        payconiqPayment.paymentId = payment.id
-        payconiqPayment.payconiqId = response.paymentId
+        const payconiqPayment = new PayconiqPayment();
+        payconiqPayment.paymentId = payment.id;
+        payconiqPayment.payconiqId = response.paymentId;
 
         // Read link (currently we use checkout!)
         let link = response._links.checkout.href as string;
 
-        if (organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production') {
+        if (organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production') {
             // For checkout only!
             // We get the wrong link in development mode
             link = link.replace('https://payconiq.com/', 'https://ext.payconiq.com/');
@@ -138,20 +139,20 @@ export class PayconiqPayment extends Model {
     private static request(method: string, path: string, data = {}, auth: string | null = null, testMode: boolean): Promise<any> {
         return new Promise((resolve, reject) => {
             const jsonData = JSON.stringify(data);
-            const hostname = !testMode ? "api.payconiq.com" : "api.ext.payconiq.com"
-            const base = "https://"+hostname
+            const hostname = !testMode ? 'api.payconiq.com' : 'api.ext.payconiq.com';
+            const base = 'https://' + hostname;
 
             // Log all communication
-            console.log(method+" "+base+path+"\n"+jsonData);
+            console.log(method + ' ' + base + path + '\n' + jsonData);
             console.log(jsonData);
 
             const headers = {
-                "Content-Type": "application/json; charset=utf-8",
-                "Content-Length": Buffer.byteLength(jsonData),
+                'Content-Type': 'application/json; charset=utf-8',
+                'Content-Length': Buffer.byteLength(jsonData),
             };
 
             if (auth) {
-                headers["Authorization"] = "Bearer "+auth
+                headers['Authorization'] = 'Bearer ' + auth;
             }
 
             const req = https.request(
@@ -168,14 +169,14 @@ export class PayconiqPayment extends Model {
 
                     const chunks: any[] = [];
 
-                    response.on("data", (chunk) => {
+                    response.on('data', (chunk) => {
                         chunks.push(chunk);
                     });
 
-                    response.on("end", () => {
+                    response.on('end', () => {
                         try {
                             if (!response.statusCode) {
-                                reject(new Error("Unexpected order of events"));
+                                reject(new Error('Unexpected order of events'));
                                 return;
                             }
                             const body = Buffer.concat(chunks).toString();
@@ -189,20 +190,22 @@ export class PayconiqPayment extends Model {
                             let json: any;
                             try {
                                 json = JSON.parse(body);
-                            } catch (error) {
+                            }
+                            catch (error) {
                                 console.error(error);
-                                
+
                                 // invalid json
                                 if (response.statusCode < 200 || response.statusCode >= 300) {
                                     if (body.length == 0) {
                                         console.error(response.statusCode);
-                                        reject(new Error("Status " + response.statusCode));
+                                        reject(new Error('Status ' + response.statusCode));
                                         return;
                                     }
-                                    console.error(response.statusCode + " " + body);
+                                    console.error(response.statusCode + ' ' + body);
                                     reject(new Error(body));
                                     return;
-                                } else {
+                                }
+                                else {
                                     // something wrong: throw parse error
                                     reject(error);
                                     return;
@@ -211,25 +214,26 @@ export class PayconiqPayment extends Model {
 
                             if (response.statusCode < 200 || response.statusCode >= 300) {
                                 console.error(body);
-                                reject(new Error(response.statusCode + " " + response.statusMessage));
+                                reject(new Error(response.statusCode + ' ' + response.statusMessage));
                                 return;
                             }
 
                             resolve(json);
-                        } catch (error) {
+                        }
+                        catch (error) {
                             console.error(error);
                             reject(error);
                         }
                     });
-                }
+                },
             );
 
             // use its "timeout" event to abort the request
-            req.on("timeout", () => {
+            req.on('timeout', () => {
                 req.abort();
             });
 
-            req.on("error", (error) => {
+            req.on('error', (error) => {
                 console.error(error);
                 reject(error);
             });