@stamhoofd/backend 2.39.1 → 2.40.1

package/src/helpers/CheckSettlements.ts

@@ -1,7 +1,5 @@
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import { MolliePayment, MollieToken, Order, Organization, PayconiqPayment, Payment, StripeAccount } from '@stamhoofd/models';
-import { Settlement } from '@stamhoofd/structures'
+import { Settlement } from '@stamhoofd/structures';
 import axios from 'axios';
 
 import { StripePayoutChecker } from './StripePayoutChecker';
@@ -11,108 +9,112 @@ type MollieSettlement = {
     reference: string;
     createdAt: string;
     settledAt: string;
-    status: "open" | "pending" | "paidout" | "failed";
+    status: 'open' | 'pending' | 'paidout' | 'failed';
     amount: {
         currenty: string;
         value: string;
-    }
-}
+    };
+};
 
 type MolliePaymentJSON = {
     id: string;
-}
+};
 
-let lastSettlementCheck: Date | null = null
+let lastSettlementCheck: Date | null = null;
 
 export async function checkAllStripePayouts(checkAll = false) {
-    if (STAMHOOFD.environment !== "production") {
-        console.log("Skip settlement check")
-        return
+    if (STAMHOOFD.environment !== 'production') {
+        console.log('Skip settlement check');
+        return;
     }
-    
+
     // Stripe payouts
-    const stripeAccounts = await StripeAccount.where({ status: 'active' })
+    const stripeAccounts = await StripeAccount.where({ status: 'active' });
     for (const account of stripeAccounts) {
         try {
-            console.log("Checking settlements for ", account.accountId)
+            console.log('Checking settlements for ', account.accountId);
 
             const checker = new StripePayoutChecker({
                 secretKey: STAMHOOFD.STRIPE_SECRET_KEY,
-                stripeAccount: account.accountId
-            })
-            await checker.checkSettlements(checkAll)
-        } catch (e) {
-            console.error(e)
+                stripeAccount: account.accountId,
+            });
+            await checker.checkSettlements(checkAll);
+        }
+        catch (e) {
+            console.error(e);
         }
     }
 }
 
 export async function checkSettlements(checkAll = false) {
-    if (STAMHOOFD.environment !== "production") {
-        return
+    if (STAMHOOFD.environment !== 'production') {
+        return;
     }
 
     if (!checkAll && lastSettlementCheck && (lastSettlementCheck > new Date(new Date().getTime() - 24 * 60 * 60 * 1000))) {
-        console.log("Skip settlement check")
-        return
+        console.log('Skip settlement check');
+        return;
     }
 
-    console.log("Checking settlements...")
-    lastSettlementCheck = new Date()
+    console.log('Checking settlements...');
+    lastSettlementCheck = new Date();
 
     // Mollie payment is required
-    const token = STAMHOOFD.MOLLIE_ORGANIZATION_TOKEN
+    const token = STAMHOOFD.MOLLIE_ORGANIZATION_TOKEN;
     if (!token) {
-        console.error("Missing mollie organization token")
-    } else {
-        await checkMollieSettlementsFor(token, checkAll)
+        console.error('Missing mollie organization token');
+    }
+    else {
+        await checkMollieSettlementsFor(token, checkAll);
     }
 
     // Loop all mollie tokens created after given date (when settlement permission was added)
     try {
         // Stripe payouts
-        await checkAllStripePayouts(checkAll)
+        await checkAllStripePayouts(checkAll);
 
-        const mollieTokens = await MollieToken.all()
+        const mollieTokens = await MollieToken.all();
         for (const token of mollieTokens) {
             if (token.createdAt < new Date(2021, 8 /* september! */, 8)) {
-                console.log("Skipped mollie token that is too old")
-            } else {
+                console.log('Skipped mollie token that is too old');
+            }
+            else {
                 try {
-                    await token.refreshIfNeeded()
-                    await checkMollieSettlementsFor(token.accessToken, checkAll)
-                } catch (e) {
-                    console.error(e)
+                    await token.refreshIfNeeded();
+                    await checkMollieSettlementsFor(token.accessToken, checkAll);
+                }
+                catch (e) {
+                    console.error(e);
                 }
             }
         }
-    } catch (e) {
-        console.error(e)
+    }
+    catch (e) {
+        console.error(e);
     }
 }
 
 // Check settlements once a week on tuesday morning/night
 export async function checkMollieSettlementsFor(token: string, checkAll = false) {
     // Check last 2 weeks + 3 day margin, unless we check them all
-    const d = new Date()
-    d.setDate(d.getDate() - 17)
+    const d = new Date();
+    d.setDate(d.getDate() - 17);
 
-    console.log("Checking settlements for given token...")
+    console.log('Checking settlements for given token...');
 
     // Loop all organizations with online paymetns the last week
     try {
-        const request = await axios.get("https://api.mollie.com/v2/settlements?limit="+(checkAll ? 250 : 14), {
+        const request = await axios.get('https://api.mollie.com/v2/settlements?limit=' + (checkAll ? 250 : 14), {
             headers: {
-                "Authorization": "Bearer "+token
-            }
-        })
+                Authorization: 'Bearer ' + token,
+            },
+        });
         if (request.status === 200) {
             // get data
             try {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                const data = request.data
+                const data = request.data;
                 // Read the data
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+
                 if (data._embedded?.settlements) {
                     const settlements = data._embedded.settlements as MollieSettlement[];
 
@@ -122,66 +124,68 @@ export async function checkMollieSettlementsFor(token: string, checkAll = false)
                             continue;
                         }
 
-                        const settledAt = new Date(settlement.settledAt)
-                        
+                        const settledAt = new Date(settlement.settledAt);
+
                         if (isNaN(settledAt.getTime())) {
                             console.error('Received an invalid settledAt from Mollie', settlement, 'for token', token);
                             continue;
                         }
 
                         if (checkAll || settledAt > d) {
-                            await updateSettlement(token, settlement)
+                            await updateSettlement(token, settlement);
                         }
                     }
-                } else {
-                    console.error("Unreadable settlements")
                 }
-            } catch (e) {
-                console.error(request.data)
+                else {
+                    console.error('Unreadable settlements');
+                }
+            }
+            catch (e) {
+                console.error(request.data);
                 throw e;
             }
-            
-        } else {
-            console.error("Failed to fetch settlements")
-            console.error(request.data)
         }
-        
-    } catch (e) {
-        console.error(e)
+        else {
+            console.error('Failed to fetch settlements');
+            console.error(request.data);
+        }
+    }
+    catch (e) {
+        console.error(e);
     }
 }
 
 async function updateSettlement(token: string, settlement: MollieSettlement, fromPaymentId?: string) {
-    const limit = 250
+    const limit = 250;
 
     // Loop all payments of this settlement
-    const request = await axios.get("https://api.mollie.com/v2/settlements/"+settlement.id+"/payments?limit="+limit+(fromPaymentId ? ("&from="+encodeURIComponent(fromPaymentId)) : ""), {
+    const request = await axios.get('https://api.mollie.com/v2/settlements/' + settlement.id + '/payments?limit=' + limit + (fromPaymentId ? ('&from=' + encodeURIComponent(fromPaymentId)) : ''), {
         headers: {
-            "Authorization": "Bearer "+token
-        }
-    })
+            Authorization: 'Bearer ' + token,
+        },
+    });
 
     if (request.status === 200) {
-        const molliePayments = request.data._embedded.payments as MolliePaymentJSON[]
+        const molliePayments = request.data._embedded.payments as MolliePaymentJSON[];
 
         for (const mollie of molliePayments) {
             // Search payment
-            const mps = await MolliePayment.where({ mollieId: mollie.id })
+            const mps = await MolliePayment.where({ mollieId: mollie.id });
             if (mps.length == 1) {
-                const mp = mps[0]
-                const payment = await Payment.getByID(mp.paymentId)
+                const mp = mps[0];
+                const payment = await Payment.getByID(mp.paymentId);
                 if (payment) {
                     payment.settlement = Settlement.create({
                         id: settlement.id,
                         reference: settlement.reference,
                         settledAt: new Date(settlement.settledAt),
-                        amount: Math.round(parseFloat(settlement.amount.value)*100)
-                    })
-                    const saved = await payment.save()
+                        amount: Math.round(parseFloat(settlement.amount.value) * 100),
+                    });
+                    const saved = await payment.save();
 
                     if (saved) {
                         // Mark order as 'updated', or the frontend won't pull in the updates
-                        const order = await Order.getForPayment(null, payment.id)
+                        const order = await Order.getForPayment(null, payment.id);
                         if (order) {
                             order.updatedAt = new Date();
                             order.forceSaveProperty('updatedAt');
@@ -190,26 +194,28 @@ async function updateSettlement(token: string, settlement: MollieSettlement, fro
 
                         // TODO: Mark registrations as 'saved'
                     }
-                    
 
-                    if (STAMHOOFD.environment === "development") {
-                        console.log("Updated settlement of payment "+payment.id)
-                        console.log(payment.settlement)
+                    if (STAMHOOFD.environment === 'development') {
+                        console.log('Updated settlement of payment ' + payment.id);
+                        console.log(payment.settlement);
                     }
-                } else {
-                    console.log("Missing payment "+mp.paymentId)
                 }
-            } else {
+                else {
+                    console.log('Missing payment ' + mp.paymentId);
+                }
+            }
+            else {
                 // Probably a payment in a different system/platform
-                //console.log("No mollie payment found for id "+mollie.id)
+                // console.log("No mollie payment found for id "+mollie.id)
             }
         }
 
         // Check next page
         if (request.data._links.next) {
-            await updateSettlement(token, settlement, molliePayments[molliePayments.length - 1].id)
+            await updateSettlement(token, settlement, molliePayments[molliePayments.length - 1].id);
         }
-    } else {
-        console.error(request.data)
     }
-}
+    else {
+        console.error(request.data);
+    }
+}

package/src/helpers/Context.ts

@@ -1,44 +1,44 @@
-import { Request } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
-import { I18n } from "@stamhoofd/backend-i18n";
-import { Organization, Platform, RateLimiter, Token, User } from "@stamhoofd/models";
-import { AsyncLocalStorage } from "async_hooks";
+import { Request } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { I18n } from '@stamhoofd/backend-i18n';
+import { Organization, Platform, RateLimiter, Token, User } from '@stamhoofd/models';
+import { AsyncLocalStorage } from 'async_hooks';
 
-import { AdminPermissionChecker } from "./AdminPermissionChecker";
+import { AdminPermissionChecker } from './AdminPermissionChecker';
 
 export const apiUserRateLimiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Block heavy bursts (5req/s for 5s)
             limit: 25,
-            duration: 5 * 1000
+            duration: 5 * 1000,
         },
-        {   
+        {
             // max 1req/s during 150s
             limit: 150,
-            duration: 150 * 1000
+            duration: 150 * 1000,
         },
-        {   
+        {
             // 1000 requests per hour
             limit: 1000,
-            duration: 60 * 1000 * 60
+            duration: 60 * 1000 * 60,
         },
-        {   
+        {
             // 2000 requests per day
             limit: 2000,
-            duration: 24 * 60 * 1000 * 60
-        }
-    ]
+            duration: 24 * 60 * 1000 * 60,
+        },
+    ],
 });
 
 export class ContextInstance {
-    request: Request
+    request: Request;
 
-    user?: User
-    organization?: Organization
+    user?: User;
+    organization?: Organization;
 
-    #i18n: I18n|null = null
-    #auth: AdminPermissionChecker|null = null
+    #i18n: I18n | null = null;
+    #auth: AdminPermissionChecker | null = null;
 
     constructor(request: Request) {
         this.request = request;
@@ -53,31 +53,31 @@ export class ContextInstance {
             throw new SimpleError({
                 code: 'no_context',
                 message: 'No context found',
-                statusCode: 500
-            })
+                statusCode: 500,
+            });
         }
 
         return c;
     }
 
-    static async startForUser<T>(user: User, organization: Organization|null, handler: () => Promise<T>): Promise<T> {
+    static async startForUser<T>(user: User, organization: Organization | null, handler: () => Promise<T>): Promise<T> {
         const request = new Request({
             method: 'GET',
             url: '/',
-            host: ''
-        })
+            host: '',
+        });
         const context = new ContextInstance(request);
 
         if (organization) {
-            context.organization = organization
-            context.i18n.switchToLocale({ country: organization.address.country })
+            context.organization = organization;
+            context.i18n.switchToLocale({ country: organization.address.country });
         }
 
-        context.user = user
+        context.user = user;
         context.#auth = new AdminPermissionChecker(user, await Platform.getSharedPrivateStruct(), context.organization);
 
         return await this.asyncLocalStorage.run(context, async () => {
-            return await handler()
+            return await handler();
         });
     }
 
@@ -85,19 +85,19 @@ export class ContextInstance {
         const context = new ContextInstance(request);
 
         return await this.asyncLocalStorage.run(context, async () => {
-            return await handler()
+            return await handler();
         });
     }
 
     get version() {
-        return this.request.getVersion()
+        return this.request.getVersion();
     }
 
     get i18n() {
         if (!this.#i18n) {
-            this.#i18n = I18n.fromRequest(this.request)
+            this.#i18n = I18n.fromRequest(this.request);
         }
-        return this.#i18n
+        return this.#i18n;
     }
 
     get auth() {
@@ -105,21 +105,22 @@ export class ContextInstance {
             throw new SimpleError({
                 code: 'internal_error',
                 statusCode: 500,
-                message: 'AdminPermissionChecker not set in RequestContext: make sure the request is authenticated before using the permissionChecker'
-            })
+                message: 'AdminPermissionChecker not set in RequestContext: make sure the request is authenticated before using the permissionChecker',
+            });
         }
-        return this.#auth
+        return this.#auth;
     }
 
     get optionalAuth() {
-        return this.#auth
+        return this.#auth;
     }
 
     async setOptionalOrganizationScope() {
         try {
-            return await this.setOrganizationScope()
-        } catch (e) {
-            return null
+            return await this.setOrganizationScope();
+        }
+        catch (e) {
+            return null;
         }
     }
 
@@ -130,89 +131,89 @@ export class ContextInstance {
         if (STAMHOOFD.userMode === 'platform') {
             return null;
         }
-        return await this.setOrganizationScope()
+        return await this.setOrganizationScope();
     }
 
-    async setOrganizationScope(options?: {allowInactive?: boolean}) {
+    async setOrganizationScope(options?: { allowInactive?: boolean }) {
         const organization = await Organization.fromApiHost(this.request.host, options);
 
-        this.organization = organization
-        this.i18n.switchToLocale({ country: organization.address.country })
+        this.organization = organization;
+        this.i18n.switchToLocale({ country: organization.address.country });
 
-        return organization
+        return organization;
     }
 
-    async optionalAuthenticate({allowWithoutAccount = false}: {allowWithoutAccount?: boolean} = {}): Promise<{user?: User}> {
-        const header = this.request.headers.authorization
+    async optionalAuthenticate({ allowWithoutAccount = false }: { allowWithoutAccount?: boolean } = {}): Promise<{ user?: User }> {
+        const header = this.request.headers.authorization;
         if (!header) {
-            return {}
+            return {};
         }
-        return this.authenticate({allowWithoutAccount})
+        return this.authenticate({ allowWithoutAccount });
     }
 
-    async authenticate({allowWithoutAccount = false}: {allowWithoutAccount?: boolean} = {}): Promise<{user: User, token: Token}> {
-        const header = this.request.headers.authorization
+    async authenticate({ allowWithoutAccount = false }: { allowWithoutAccount?: boolean } = {}): Promise<{ user: User; token: Token }> {
+        const header = this.request.headers.authorization;
         if (!header) {
             throw new SimpleError({
-                code: "not_authenticated",
-                message: "Missing required authorization header",
-                statusCode: 401
-            })
+                code: 'not_authenticated',
+                message: 'Missing required authorization header',
+                statusCode: 401,
+            });
         }
 
-        if (!header.startsWith("Bearer ")) {
+        if (!header.startsWith('Bearer ')) {
             throw new SimpleError({
-                code: "not_supported_authentication",
-                message: "Authentication method not supported. Please authenticate with OAuth2",
-                statusCode: 401
-            })
+                code: 'not_supported_authentication',
+                message: 'Authentication method not supported. Please authenticate with OAuth2',
+                statusCode: 401,
+            });
         }
 
-        const accessToken = header.substring("Bearer ".length);
+        const accessToken = header.substring('Bearer '.length);
+
+        const token = await Token.getByAccessToken(accessToken, true);
 
-        const token = await Token.getByAccessToken(accessToken, true)
-        
         if (!token || (this.organization && token.user.organizationId !== null && token.user.organizationId !== this.organization.id) || (!this.organization && token.user.organizationId)) {
             throw new SimpleError({
-                code: "invalid_access_token",
-                message: "The access token is invalid",
-                human: "Je bent automatisch uitgelogd, log opnieuw in om verder te gaan",
-                statusCode: 401
-            })
+                code: 'invalid_access_token',
+                message: 'The access token is invalid',
+                human: 'Je bent automatisch uitgelogd, log opnieuw in om verder te gaan',
+                statusCode: 401,
+            });
         }
-        
+
         if (token.isAccessTokenExpired()) {
             throw new SimpleError({
-                code: "expired_access_token",
-                message: "The access token is expired",
-                human: "Je bent automatisch uitgelogd, log opnieuw in om verder te gaan",
-                statusCode: 401
-            })
+                code: 'expired_access_token',
+                message: 'The access token is expired',
+                human: 'Je bent automatisch uitgelogd, log opnieuw in om verder te gaan',
+                statusCode: 401,
+            });
         }
 
         if (!token.user.hasAccount() && !allowWithoutAccount) {
             throw new SimpleError({
-                code: "not_activated",
-                message: "This user is not yet activated",
-                human: "Maak een account aan op dit e-mailadres om een wachtwoord in te stellen voor je inlogt.",
-                statusCode: 401
-            })
+                code: 'not_activated',
+                message: 'This user is not yet activated',
+                human: 'Maak een account aan op dit e-mailadres om een wachtwoord in te stellen voor je inlogt.',
+                statusCode: 401,
+            });
         }
 
         // Rate limits for api users
         if (token.user.isApiUser) {
-            apiUserRateLimiter.track(this.organization?.id ?? token.user.id)
+            apiUserRateLimiter.track(this.organization?.id ?? token.user.id);
         }
 
-        const user = token.user
-        this.user = user
+        const user = token.user;
+        this.user = user;
 
         // Load member of user
         // todo
 
         this.#auth = new AdminPermissionChecker(user, await Platform.getSharedPrivateStruct(), this.organization);
 
-        return {user, token};
+        return { user, token };
     }
 }
 
@@ -220,8 +221,8 @@ export const Context = new Proxy(ContextInstance, {
     get(target, prop, receiver) {
         const c = target.current[prop];
         if (c && typeof c == 'function') {
-            return c.bind(target.current)
+            return c.bind(target.current);
         }
         return c;
-    }
+    },
 }) as unknown as ContextInstance;