@stamhoofd/models 2.1.1

package/src/models/MollieToken.ts

@@ -0,0 +1,369 @@
+import { column,Model } from '@simonbackx/simple-database';
+import { PartialWithoutMethods, PlainObject } from '@simonbackx/simple-encoding';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { MollieOnboarding,MollieProfile, MollieStatus } from '@stamhoofd/structures';
+import { IncomingMessage } from "http";
+import https from "https";
+
+import { Organization } from './Organization';
+
+function sleep(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export class MollieToken extends Model {
+    static table = "mollie_tokens"
+
+    @column({ primary: true, type: "string" })
+    organizationId!: string;
+
+    @column({ type: "string" })
+    accessToken: string;
+
+    @column({ type: "string" })
+    refreshToken: string;
+
+    @column({ type: "datetime" })
+    expiresOn: Date;
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    static verbose = true
+
+    static knownTokens: Map<string, MollieToken> = new Map()
+
+    static async getTokenFor(organizationId: string) {
+        const existing = this.knownTokens.get(organizationId)
+        if (existing) {
+            return existing
+        }
+        const tokens = await MollieToken.where({ organizationId })
+        if (tokens.length == 0) {
+            return undefined
+        }
+        this.knownTokens.set(organizationId, tokens[0])
+        return tokens[0]
+    }
+
+    async delete() {
+        await super.delete()
+        MollieToken.knownTokens.delete(this.organizationId)
+    }
+
+    private static objectToQueryString(obj: Record<string, string>) {
+        const str: string[] = [];
+        // eslint-disable-next-line no-prototype-builtins
+        for (const p in obj)
+            // eslint-disable-next-line no-prototype-builtins
+            if (obj.hasOwnProperty(p)) {
+                str.push(encodeURIComponent(p) + "=" + encodeURIComponent(obj[p]));
+            }
+        return str.join("&");
+    }
+
+    async getAccessToken() {
+        if (this.expiresOn < new Date()) {
+            await this.refresh()
+            await sleep(200)
+        }
+        return this.accessToken
+    }
+
+    async refreshIfNeeded() {
+        if (this.expiresOn < new Date()) {
+            await this.refresh()
+            await sleep(200)
+        }
+    }
+
+    async authRequest(method: string, path: string, data: PlainObject = {}) {
+        if (this.expiresOn < new Date()) {
+            await this.refresh()
+            await sleep(200)
+        }
+
+        return await MollieToken.request(method, path, data, "json", this.accessToken);
+    }
+
+    /**
+     * Do a post request on the API.
+     */
+    private static request(method: string, path: string, data: PlainObject = {}, type = "json", auth: string | null = null): Promise<any> {
+        return new Promise((resolve, reject) => {
+            let jsonData: string;
+            if (type == "json") {
+                jsonData = JSON.stringify(data);
+            } else {
+                jsonData = this.objectToQueryString(data as Record<string, string>);
+            }
+
+            if (this.verbose) {
+                console.log(method+" https://api.mollie.com"+path+"\n"+jsonData);
+            }
+            const req = https.request(
+                {
+                    hostname: "api.mollie.com",
+                    path: path,
+                    method: method,
+                    headers: method === 'GET' ? 
+                    {
+                        "Authorization": auth ? "Bearer "+auth : "Basic "+Buffer.from((STAMHOOFD.MOLLIE_CLIENT_ID ?? "")+":"+(STAMHOOFD.MOLLIE_SECRET ?? ""), "ascii").toString("base64")
+                    } : {
+                        "Content-Type": type == "json" ? "application/json" : "application/x-www-form-urlencoded",
+                        "Content-Length": Buffer.byteLength(jsonData),
+                        "Authorization": auth ? "Bearer "+auth : "Basic "+Buffer.from((STAMHOOFD.MOLLIE_CLIENT_ID ?? "")+":"+(STAMHOOFD.MOLLIE_SECRET ?? ""), "ascii").toString("base64")
+                    },
+                    timeout: 10000,
+                },
+                (response: IncomingMessage) => {
+                    if (this.verbose) {
+                        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();
+
+                            if (this.verbose) {
+                                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) {
+                            if (this.verbose) {
+                                console.error(error);
+                            }
+                            reject(error);
+                        }
+                    });
+                }
+            );
+
+            // use its "timeout" event to abort the request
+            req.on("timeout", () => {
+                req.abort();
+            });
+
+            req.on("error", (error) => {
+                if (this.verbose) {
+                    console.error(error);
+                }
+                reject(error);
+            });
+
+            if (method !== 'GET') {
+                req.write(jsonData);
+            }
+            req.end();
+        });
+    }
+
+    /**
+    * Refresh the token itself, without generating a new token. Everyone who had the token has a new token now
+    */
+    async refresh(): Promise<void> {
+        const data = await MollieToken.request("POST", "/oauth2/tokens", {
+            grant_type: "refresh_token",
+            refresh_token: this.refreshToken,
+        }, "urlencoded")
+
+        if (data && data.access_token && data.refresh_token) {
+            // Delete token if exisitng
+            this.refreshToken = data.refresh_token
+            this.accessToken = data.access_token
+            this.expiresOn = new Date(new Date().getTime() + 3600 * 1000 - 60*1000)
+            await this.save()
+
+            // Update shared tokens if this object was fetched directly
+            MollieToken.knownTokens.set(this.organizationId, this)
+            return
+        }
+        throw new SimpleError({ code: "", message: "Something went wrong in the response"})
+
+    }
+
+    /**
+    * Refresh the token itself, without generating a new token. Everyone who had the token has a new token now
+    */
+    async revoke(): Promise<void> {
+        try {
+            await MollieToken.request("DELETE", "/oauth2/tokens", {
+                token_type_hint: "refresh_token",
+                token: this.refreshToken,
+            }, "urlencoded")
+        } catch (e) {
+            console.error("Failed to revoke token", this.organizationId, e)
+        }
+        await this.delete()
+    }
+
+    /**
+    * Refresh the token itself, without generating a new token. Everyone who had the token has a new token now
+    */
+    static async create(organization: Organization, code: string): Promise<MollieToken> {
+        const data = await MollieToken.request("POST", "/oauth2/tokens", {
+            grant_type: "authorization_code",
+            code: code
+        }, "urlencoded")
+
+        if (data && data.access_token && data.refresh_token) {
+            // Delete token if exisitng
+            const existing = await MollieToken.where({ organizationId: organization.id })
+            const token = existing[0] ?? new MollieToken()
+            token.organizationId = organization.id
+            token.refreshToken = data.refresh_token
+            token.accessToken = data.access_token
+            token.expiresOn = new Date(new Date().getTime() + 3600 * 1000 - 60*1000)
+            await token.save()
+
+            this.knownTokens.set(organization.id, token)
+
+            organization.privateMeta.mollieOnboarding = await token.getOnboardingStatus()
+            await token.setup(organization)
+
+            await organization.save()
+            return token
+        }
+        throw new SimpleError({ code: "", message: "Something went wrong in the response"})
+
+    }
+
+    async getOnboardingStatus() {
+        try {
+            const response = await this.authRequest("GET", "/v2/onboarding/me")
+            return MollieOnboarding.create({
+                canReceivePayments: !!response.canReceivePayments,
+                canReceiveSettlements: !!response.canReceiveSettlements,
+                status: response.status === "needs-data" ? MollieStatus.NeedsData : (response.status === "in-review" ? MollieStatus.InReview : (MollieStatus.Completed))
+            });
+        } catch (e) {
+            console.error("Error when requesting Mollie onboarding status:")
+            console.error(e)
+            return null;
+        }
+    }
+
+    async getProfiles(): Promise<MollieProfile[]> {
+        try {
+            const response = await this.authRequest("GET", "/v2/profiles?limit=250")
+            const profiles = response._embedded.profiles as PartialWithoutMethods<MollieProfile>[];
+            return profiles.map(p => MollieProfile.create(p))
+        } catch(e) {
+            console.error('Failed to parse mollie profiles', e)
+            return [];
+        }
+    }
+
+    async getProfileId(website?: string): Promise<string | null> {
+        const response = await this.authRequest("GET", "/v2/profiles?limit=250")
+        const profiles = response._embedded.profiles;
+
+        // Search profile with Stamhoofd as name
+        if (website) {
+            for (const profile of profiles) {
+                if (profile.website.toLowerCase().includes(website)) {
+                    return profile.id
+                }
+            }
+        }
+
+        // Search profile with Stamhoofd as name
+        for (const profile of profiles) {
+            if (profile.name.toLowerCase().includes("stamhoofd")) {
+                return profile.id
+            }
+        }
+
+        return response._embedded.profiles[0]?.id ?? null
+
+    }
+
+    async getOnboardingLink() {
+        const response = await this.authRequest("GET", "/v2/onboarding/me")
+        return response._links.dashboard.href ?? ""
+    }
+
+    /**
+     * Set initial onboarding values + enable bancontact
+     */
+    async setup(organization: Organization) {
+        // Submit onboarding data
+
+        if (organization.privateMeta.mollieOnboarding && organization.privateMeta.mollieOnboarding.status == MollieStatus.NeedsData) {
+            await this.authRequest("POST", "/v2/onboarding/me", {
+                organization: {
+                    name: organization.name,
+                    address: {
+                        streetAndNumber: organization.address.street + " "+organization.address.number,
+                        postalCode: organization.address.postalCode,
+                        city: organization.address.city,
+                        country: organization.address.country,
+                    },
+                   
+                    vatRegulation: "shifted"
+                },
+                profile: {
+                    name: organization.name+" - Stamhoofd",
+                    //url: "https://"+organization.getHost(),
+                    description: "Betalen van inschrijvingsgelden of webshops voor een vereniging via Stamhoofd (partner).",
+                    categoryCode: 8398
+                }
+            })
+        }
+    }
+}

package/src/models/OneTimeToken.ts

@@ -0,0 +1,131 @@
+
+import { column, Model } from "@simonbackx/simple-database";
+import { AnyDecoder } from "@simonbackx/simple-encoding";
+import basex from "base-x";
+import crypto from "crypto";
+
+import { Organization } from "./Organization";
+
+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);
+        });
+    });
+}
+
+enum OneTimeTokenType {
+    WebshopNotificationEmailVerification = "WebshopNotificationEmailVerification",
+    WebshopNotificationEmailUnsubscribe = "WebshopNotificationEmailUnsubscribe"
+}
+
+/**
+ * Token that saves some information and can execute an action if you have access to the token (e.g. in an email)
+ */
+export class OneTimeToken extends Model {
+    static table = "one_time_tokens";
+   
+    // Columns
+    @column({ primary: true, type: "string" })
+    token: string;
+
+    @column({ type: "string" })
+    organizationId: string;
+
+    @column({ type: "datetime", nullable: true })
+    validUntil: Date | null = null;
+
+    @column({
+        type: "datetime", beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date()
+            date.setMilliseconds(0)
+            return date
+        }
+    })
+    createdAt: Date
+
+    // Columns
+    @column({ type: "string" })
+    type: OneTimeTokenType
+
+    // Columns
+    @column({ type: "json", decoder: AnyDecoder })
+    data: any = {};
+
+    isExpired(): boolean {
+        return !!this.validUntil && this.validUntil < new Date()
+    }
+    
+    /**
+     * Get a token
+     * @param token 
+     * @param ignoreExpireDate: do not return if it is expired
+     */
+    static async getToken(token: string, organizationId: string, ignoreExpireDate = false): Promise<OneTimeToken | undefined> {
+        const [oneTimeToken] = await this.where({token, organizationId}, {limit: 1})
+
+        if (!oneTimeToken) {
+            return undefined;
+        }
+
+        if (!ignoreExpireDate && oneTimeToken.isExpired()) {
+            // If the refresh token is invalid, do not return it
+            return undefined
+        }
+
+        return oneTimeToken;
+    }
+
+    /***
+     * Create a token without saving it
+     */
+    static async createToken(organizationId: string, type: OneTimeTokenType, data: any, options?: {validUntil?: Date, expireIn?: number}): Promise<OneTimeToken> {
+        const token = new OneTimeToken();
+        token.type = type;
+        token.data = data;
+        token.organizationId = organizationId
+
+        if (options?.validUntil) {
+            token.validUntil = new Date(options?.validUntil)
+            token.validUntil.setMilliseconds(0);
+        } else if (options?.expireIn) {
+            token.validUntil = new Date();
+            token.validUntil.setTime(token.validUntil.getTime() + options?.expireIn);
+            token.validUntil.setMilliseconds(0);
+        }
+        token.token = bs58.encode(await randomBytes(100)).toLowerCase();
+        await token.save();
+        return token;
+    }
+
+    /**
+     * Pass in an organization if you want to use the registration page instead of the dashboard
+     */
+    getUrl(organization: Organization, dashboard = false) {
+        // Send an e-mail to say you already have an account + follow password forgot flow
+        const i18n = organization.i18n;
+
+        let host: string;
+        if (dashboard) {
+            host = "https://"+(STAMHOOFD.domains.dashboard ?? "stamhoofd.app")+"/"+i18n.locale
+        } else {
+            host = "https://"+organization.getHost()
+
+            if (i18n.language != organization.i18n.language) {
+                host += "/"+i18n.language
+            }
+        }
+
+        return host+"/ott"+(dashboard ? "/"+encodeURIComponent(organization.id) : "")+"?token="+encodeURIComponent(this.token);
+    }
+}