@stamhoofd/models 2.1.1

package/src/models/OrganizationRegistrationPeriod.ts

@@ -0,0 +1,54 @@
+import { column, Model } from '@simonbackx/simple-database';
+import { Group as GroupStruct, OrganizationRegistrationPeriodSettings, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct } from '@stamhoofd/structures';
+import { v4 as uuidv4 } from "uuid";
+import { Group, RegistrationPeriod } from '.';
+
+export class OrganizationRegistrationPeriod extends Model {
+    static table = "organization_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: "string" })
+    periodId: string
+
+    @column({ type: "json", decoder: OrganizationRegistrationPeriodSettings })
+    settings = OrganizationRegistrationPeriodSettings.create({})
+
+    @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(this: OrganizationRegistrationPeriod, period: RegistrationPeriod, groups: Group[]) {
+        return OrganizationRegistrationPeriodStruct.create({
+            ...this,
+            period: period.getStructure(),
+            groups: groups.map(g => g.getStructure()).sort(GroupStruct.defaultSort)
+        })
+    }
+}

package/src/models/PasswordToken.ts

@@ -0,0 +1,139 @@
+
+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)
+
+export type PasswordTokenWithUser = PasswordToken & { user: User };
+
+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 PasswordToken extends Model {
+    static table = "password_tokens";
+   
+    // Columns
+    @column({ primary: true, type: "string" })
+    token: string;
+
+    @column({ type: "datetime" })
+    validUntil: Date;
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    @column({ type: "string", foreignKey: PasswordToken.user })
+    userId: string;
+
+    static user = new ManyToOneRelation(User, "user");
+
+    isExpired(): boolean {
+        return this.validUntil < new Date()
+    }
+    
+    /**
+     * Get a 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 ${
+                this.table
+            } ${PasswordToken.user.joinQuery(this.table, "user")} WHERE ${this.primary.name} = ? LIMIT 1 `,
+            [token]
+        );
+
+        if (rows.length == 0) {
+            return undefined;
+        }
+
+        const passwordToken = this.fromRow(rows[0][this.table]);
+
+        if (!passwordToken) {
+            return undefined;
+        }
+
+        if (!ignoreExpireDate && passwordToken.isExpired()) {
+            // If the refresh token is invalid, do not return it
+            return undefined
+        }
+
+        const user = User.fromRow(rows[0]["user"]) || null;
+
+        if (!user) {
+            console.error("Password token without a valid user!");
+            return undefined;
+        }
+
+        return passwordToken.setRelation(PasswordToken.user, user);
+    }
+
+    /***
+     * Create a token without saving it
+     */
+    static async createToken<U extends User>(user: U, validUntil?: Date): Promise<PasswordTokenWithUser> {
+        const token = new PasswordToken().setRelation(PasswordToken.user, user);
+
+        if (validUntil) {
+            token.validUntil = new Date(validUntil)
+        } else {
+            token.validUntil = new Date();
+            token.validUntil.setTime(token.validUntil.getTime() + 3 * 3600 * 1000);
+        }
+        token.validUntil.setMilliseconds(0);
+        token.token = bs58.encode(await randomBytes(100)).toLowerCase();
+        await token.save();
+        return token;
+    }
+
+    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')
+        }
+        // Send an e-mail to say you already have an account + follow password forgot flow
+        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);
+        }
+
+        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));
+    }
+
+    static async clearFor(userId: string) {
+        const query = `DELETE from ${this.table} where userId = ?`;
+        await Database.delete(query, [userId])
+    }
+}

package/src/models/PayconiqPayment.ts

@@ -0,0 +1,241 @@
+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 { Organization, Payment } from './';
+
+export class PayconiqPayment extends Model {
+    static table = "payconiq_payments";
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    paymentId: string;
+
+    @column({ type: "string" })
+    payconiqId: string;
+
+    async getStatus(organization: Organization): Promise<PaymentStatus> {
+        const apiKey = organization.privateMeta.payconiqApiKey
+        if (!apiKey) {
+            throw new SimpleError({
+                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')
+        if (response.status) {
+            switch (response.status) {
+                case "AUTHORIZED": return PaymentStatus.Pending;
+                case "PENDING": return PaymentStatus.Created;
+
+                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 "SUCCEEDED": return PaymentStatus.Succeeded;
+            }
+            return PaymentStatus.Pending // default to pending
+        }
+        throw new SimpleError({
+            code: "",
+            message: "Status missing in response"
+        })
+    }
+
+    async cancel(organization: Organization): Promise<boolean> {
+        const apiKey = organization.privateMeta.payconiqApiKey
+        if (!apiKey) {
+            throw new SimpleError({
+                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')
+            return true;
+        } 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
+        if (!apiKey) {
+            return
+        }
+
+        try {
+            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",
+
+            }, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
+            return response;
+        } catch (e) {
+            return;
+        }
+    }
+
+
+    static async createPayment(payment: Payment, organization: Organization, description: string, returnUrl?: string, callbackUrl?: string) {
+        const apiKey = organization.privateMeta.payconiqApiKey
+        if (!apiKey) {
+            throw new SimpleError({
+                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...
+            amount: payment.price,
+            currency: "EUR",
+            callbackUrl: callbackUrl ?? 'https://'+organization.getApiHost()+"/v"+Version+"/payments/"+encodeURIComponent(payment.id)+"?exchange=true",
+            returnUrl,
+            description
+        }, apiKey, organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production')
+
+        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') {
+            // For checkout only!
+            // We get the wrong link in development mode
+            link = link.replace('https://payconiq.com/', 'https://ext.payconiq.com/');
+        }
+
+        await payconiqPayment.save();
+
+        return link;
+    }
+
+    /**
+     * Do a post request on the API.
+     */
+    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
+
+            // Log all communication
+            console.log(method+" "+base+path+"\n"+jsonData);
+            console.log(jsonData);
+
+            const headers = {
+                "Content-Type": "application/json; charset=utf-8",
+                "Content-Length": Buffer.byteLength(jsonData),
+            };
+
+            if (auth) {
+                headers["Authorization"] = "Bearer "+auth
+            }
+
+            const req = https.request(
+                {
+                    hostname: hostname,
+                    path: path,
+                    method: method,
+                    headers: headers,
+                    timeout: 10000,
+                },
+                (response: IncomingMessage) => {
+                    console.log(`statusCode: ${response.statusCode ?? '/'}`);
+                    console.log(`HEADERS: ${JSON.stringify(response.headers)}`);
+
+                    const chunks: any[] = [];
+
+                    response.on("data", (chunk) => {
+                        chunks.push(chunk);
+                    });
+
+                    response.on("end", () => {
+                        try {
+                            if (!response.statusCode) {
+                                reject(new Error("Unexpected order of events"));
+                                return;
+                            }
+                            const body = Buffer.concat(chunks).toString();
+                            console.log(body);
+
+                            if (response.statusCode == 204) {
+                                resolve(undefined);
+                                return;
+                            }
+
+                            let json: any;
+                            try {
+                                json = JSON.parse(body);
+                            } 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));
+                                        return;
+                                    }
+                                    console.error(response.statusCode + " " + body);
+                                    reject(new Error(body));
+                                    return;
+                                } else {
+                                    // something wrong: throw parse error
+                                    reject(error);
+                                    return;
+                                }
+                            }
+
+                            if (response.statusCode < 200 || response.statusCode >= 300) {
+                                console.error(body);
+                                reject(new Error(response.statusCode + " " + response.statusMessage));
+                                return;
+                            }
+
+                            resolve(json);
+                        } catch (error) {
+                            console.error(error);
+                            reject(error);
+                        }
+                    });
+                }
+            );
+
+            // use its "timeout" event to abort the request
+            req.on("timeout", () => {
+                req.abort();
+            });
+
+            req.on("error", (error) => {
+                console.error(error);
+                reject(error);
+            });
+
+            req.write(jsonData);
+            req.end();
+        });
+    }
+}

package/src/models/Payment.ts

@@ -0,0 +1,216 @@
+import { column, ManyToOneRelation, Model } from '@simonbackx/simple-database';
+import { BalanceItemDetailed, BalanceItemPaymentDetailed, Member as MemberStruct, Order as OrderStruct, PaymentGeneral, PaymentMethod, PaymentProvider, PaymentStatus, Settlement, TransferSettings } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from "uuid";
+
+import { Organization, Registration } from './';
+
+export class Payment extends Model {
+    static table = "payments"
+
+    @column({
+        primary: true, type: "string", beforeSave(value) {
+            return value ?? uuidv4();
+        }
+    })
+    id!: string;
+
+    @column({ type: "string" })
+    method: PaymentMethod;
+
+    @column({ type: "string", nullable: true })
+    provider: PaymentProvider | null = null;
+
+    @column({ type: "string" })
+    status: PaymentStatus;
+
+    @column({ type: "string", nullable: true })
+    organizationId: string| null = null
+
+    // Link a user for debugging
+    @column({ type: "string", nullable: true })
+    userId: string | null = null;
+
+    // Link a user for debugging
+    @column({ type: "string", nullable: true })
+    stripeAccountId: string | null = null;
+
+    /**
+     * Total price
+     */
+    @column({ type: "integer" })
+    price: number;
+
+    /**
+     * Fee paid to the payment provider (if available, otherwise set to 0)
+     */
+    @column({ type: "integer" })
+    transferFee = 0
+
+    /**
+     * Included in the total price
+     */
+    @column({ type: "integer", nullable: true })
+    freeContribution: number | null = null;
+
+    @column({ type: "string", nullable: true })
+    transferDescription: string | null = null;
+
+    @column({ type: "json", nullable: true, decoder: TransferSettings })
+    transferSettings: TransferSettings | null = null;
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    _forceUpdatedAt: Date | null = null
+
+    @column({
+        type: "datetime", beforeSave() {
+            if (this._forceUpdatedAt) {
+                return this._forceUpdatedAt
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        },
+        skipUpdate: true
+    })
+    updatedAt: Date
+
+    @column({ type: "datetime", nullable: true })
+    paidAt: Date | null = null
+
+    /// Settlement meta data
+    @column({ type: "json", decoder: Settlement, nullable: true })
+    settlement: Settlement | null = null;
+
+    @column({ type: "string", nullable: true })
+    iban: string | null = null;
+
+    @column({ type: "string", nullable: true })
+    ibanName: string | null = null;
+
+    generateDescription(organization: Organization, reference: string, replacements: { [key: string]: string } = {}) {
+        const settings = this.transferSettings ?? organization.meta.transferSettings
+        this.transferDescription = settings.generateDescription(reference, organization.address.country, replacements)
+    }
+
+    static async getGeneralStructure(payments: Payment[], includeSettlements = false): Promise<PaymentGeneral[]> {
+        if (payments.length === 0) {
+            return []
+        }
+
+        const {balanceItemPayments, balanceItems} = await Payment.loadBalanceItems(payments)
+        const {registrations, orders, members, groups} = await Payment.loadBalanceItemRelations(balanceItems);
+        
+        return this.getGeneralStructureFromRelations({
+            payments,
+            registrations,
+            orders,
+            members,
+            balanceItemPayments,
+            balanceItems,
+            groups
+        }, includeSettlements)
+    }
+
+    static getGeneralStructureFromRelations({payments, registrations, orders, members, balanceItemPayments, balanceItems, groups}: {
+        payments: Payment[];
+        registrations: import("./Registration").Registration[];
+        orders: import("./Order").Order[];
+        members: import("./Member").Member[];
+        balanceItemPayments: import("./BalanceItemPayment").BalanceItemPayment[];
+        balanceItems: import("./BalanceItem").BalanceItem[];
+        groups: import("./Group").Group[];
+    }, includeSettlements = false): PaymentGeneral[] {
+        if (payments.length === 0) {
+            return []
+        }
+
+        return payments.map(payment => {
+            return PaymentGeneral.create({
+                ...payment,
+                balanceItemPayments: balanceItemPayments.filter(item => item.paymentId === payment.id).map((item) => {
+                    const balanceItem = balanceItems.find(b => b.id === item.balanceItemId)
+                    const registration = balanceItem?.registrationId && registrations.find(r => r.id === balanceItem.registrationId)
+                    const member = balanceItem?.memberId ? members.find(r => r.id === balanceItem.memberId) : undefined
+                    const order = balanceItem?.orderId && orders.find(r => r.id === balanceItem.orderId)
+                    const group = registration && groups.find(g => g.id === registration.groupId)
+
+                    if (!group) {
+                        throw new Error("Group not found")
+                    }
+
+                    return BalanceItemPaymentDetailed.create({
+                        ...item,
+                        balanceItem: BalanceItemDetailed.create({
+                            ...balanceItem,
+                            registration: registration ? registration.setRelation(Registration.group, group).getStructure() : null,
+                            member: member ? MemberStruct.create(member) : null,
+                            order: order ? OrderStruct.create({...order, payment: null}) : null
+                        })
+                    })
+                }),
+                ...(!includeSettlements) ? {settlement: null, transferFee: 0, stripeAccountId: null} : {}
+            })
+        })
+    }
+
+    /**
+     * 
+     * @param checkPermissions Only set to undefined when not returned in the API + not for public use
+     * @returns 
+     */
+    async getGeneralStructure(): Promise<PaymentGeneral> {
+        return (await Payment.getGeneralStructure([this], false))[0]
+    }
+
+    static async loadBalanceItems(payments: Payment[]) {
+        if (payments.length === 0) {
+            return {balanceItemPayments: [], balanceItems: []}
+        }
+        const {BalanceItemPayment} = await import("./BalanceItemPayment");
+        const {BalanceItem} = await import("./BalanceItem");
+
+        // Load all the related models from the database so we can build the structures
+        const balanceItemPayments = await BalanceItemPayment.where({
+            paymentId: {
+                sign: 'IN',
+                value: payments.map(p => p.id)
+            }
+        })
+        const ids = Formatter.uniqueArray(balanceItemPayments.flatMap(p => p.balanceItemId));
+        const balanceItems = await BalanceItem.getByIDs(...ids);
+
+        return {balanceItemPayments, balanceItems}
+    }
+
+    static async loadBalanceItemRelations(balanceItems: import("./BalanceItem").BalanceItem[]) {
+        const {Registration} = await import("./Registration");
+        const {Order} = await import("./Order");
+        const {Member} = await import("./Member");
+
+        // Load members and orders
+        const registrationIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.registrationId ? [b.registrationId] : []))
+        const orderIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.orderId ? [b.orderId] : []))
+        const memberIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.memberId ? [b.memberId] : []))
+
+        const registrations = await Registration.getByIDs(...registrationIds)
+        const orders = await Order.getByIDs(...orderIds)
+        const members = await Member.getByIDs(...memberIds)
+
+        const groupIds = Formatter.uniqueArray(registrations.map(r => r.groupId))
+        const groups = await (await import("./Group")).Group.getByIDs(...groupIds)
+
+        return {registrations, orders, members, groups}
+    }
+}