@stamhoofd/models 2.120.5 → 2.121.0

package/src/models/MollieToken.ts

@@ -1,8 +1,7 @@
 import { column } from '@simonbackx/simple-database';
-import type { PartialWithoutMethods, PlainObject } from '@simonbackx/simple-encoding';
+import type { PlainObject } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { QueryableModel } from '@stamhoofd/sql';
-import { MollieOnboarding, MollieProfile, MollieStatus } from '@stamhoofd/structures';
 import type { IncomingMessage } from 'http';
 import https from 'https';
 
@@ -12,9 +11,17 @@ function sleep(ms: number) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+export class MollieError extends Error {
+    body: PlainObject
+}
+
 export class MollieToken extends QueryableModel {
     static table = 'mollie_tokens';
 
+    get id() {
+        return this.organizationId
+    }
+
     @column({ primary: true, type: 'string' })
     organizationId!: string;
 
@@ -184,7 +191,9 @@ export class MollieToken extends QueryableModel {
 
                             if (response.statusCode < 200 || response.statusCode >= 300) {
                                 console.error(body);
-                                reject(new Error(response.statusCode + ' ' + response.statusMessage));
+                                const e = new MollieError(response.statusCode + ' ' + response.statusMessage);
+                                e.body = json;
+                                reject(e);
                                 return;
                             }
 
@@ -223,23 +232,38 @@ export class MollieToken extends QueryableModel {
     * 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');
+        try {
+            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;
+            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' });
+        } catch (e) {
+            if (e instanceof MollieError) {
+                if (e.body && typeof e.body === 'object' && 'error' in e.body && e.body.error === 'invalid_grant') {
+                    // Refresh token not valid.
+                    console.error('Deleting Mollie Token because invalid refresh token')
+                    await this.delete()
+
+                    // Still throw
+                    throw e;
+                }
+            }
+            throw e;
         }
-        throw new SimpleError({ code: '', message: 'Something went wrong in the response' });
+        
     }
 
     /**
@@ -279,97 +303,13 @@ export class MollieToken extends QueryableModel {
 
             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: $t(`%x1`),
-                    categoryCode: 8398,
-                },
-            });
-        }
-    }
 }

package/src/models/Organization.ts

@@ -7,7 +7,7 @@ import type { EmailInterfaceRecipient } from '@stamhoofd/email';
 import { QueueHandler } from '@stamhoofd/queues';
 import { QueryableModel, SQL } from '@stamhoofd/sql';
 import type { OrganizationEmail, PrivatePaymentConfiguration } from '@stamhoofd/structures';
-import { Address, appToUri, DNSRecordStatus, EmailTemplateType, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, Recipient, Replacement, STPackageType, TransferSettings } from '@stamhoofd/structures';
+import { Address, appToUri, Company, DNSRecordStatus, EmailTemplateType, GroupType, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, Recipient, Replacement, STPackageType, TransferSettings } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 import { validateDNSRecords } from '../helpers/DNSValidator.js';
@@ -17,6 +17,8 @@ import { OrganizationRegistrationPeriod } from './OrganizationRegistrationPeriod
 import { StripeAccount } from './StripeAccount.js';
 import { Country } from '@stamhoofd/types/Country';
 import { Language } from '@stamhoofd/types/Language';
+import { Registration } from './Registration.js';
+import type { PaymentMandate } from '@stamhoofd/structures/PaymentMandate.js';
 
 export class Organization extends QueryableModel {
     static table = 'organizations';
@@ -238,6 +240,10 @@ export class Organization extends QueryableModel {
         return this.uri + '.' + defaultDomain;
     }
 
+    getDashboardHost(i18n?: { language: Language; locale: string }): string {
+        return STAMHOOFD.domains.dashboard + '/' + (i18n?.locale ?? this.i18n.locale) + '/' + appToUri('dashboard') + '/' + this.uri;
+    }
+
     get registerUrl() {
         return 'https://' + this.getRegistrationHost();
     }
@@ -913,10 +919,17 @@ export class Organization extends QueryableModel {
         };
     }
 
-    async getPaymentProviderFor(method: PaymentMethod, config: PrivatePaymentConfiguration): Promise<{
+    async getPaymentProviderFor(method: PaymentMethod, mandate: PaymentMandate | null, config: PrivatePaymentConfiguration): Promise<{
         provider: PaymentProvider | null;
         stripeAccount: StripeAccount | null;
     }> {
+        if (mandate) {
+            return {
+                provider: mandate.provider,
+                stripeAccount: null
+            }
+        }
+        
         let stripeAccount = (config.stripeAccountId ? (await StripeAccount.getByID(config.stripeAccountId)) : null) ?? null;
         if (stripeAccount && stripeAccount.organizationId !== this.id) {
             console.warn('Stripe account ' + stripeAccount.id + ' is not linked to organization ' + this.id);
@@ -984,7 +997,7 @@ export class Organization extends QueryableModel {
             return 0;
         }
 
-        return await this.select()
+        return await Registration.select()
             .join(
                 SQL.join(Group.table)
                     .where(SQL.column('id'), SQL.parentColumn('groupId')),
@@ -993,8 +1006,23 @@ export class Organization extends QueryableModel {
             .where('deactivatedAt', null)
             .where('registeredAt', '!=', null)
             .where(SQL.column(Group.table, 'deletedAt'), null)
+            .where(SQL.column(Group.table, 'type'), '!=', GroupType.WaitingList)
             .count(
                 SQL.distinct(SQL.column('memberId')),
             );
     }
+
+    /**
+     * Assures at least one company at all times
+     */
+    get defaultCompanies() {
+        return this.meta.companies.length
+            ? this.meta.companies
+            : [
+                    Company.create({
+                        name: this.name,
+                        address: this.address,
+                    }),
+                ];
+    }
 }

package/src/models/Payment.ts

@@ -1,10 +1,11 @@
 import { column } from '@simonbackx/simple-database';
-import type { PaymentMethod, PaymentStatus} from '@stamhoofd/structures';
+import type { PaymentMethod, PaymentStatus } from '@stamhoofd/structures';
 import { BalanceItemDetailed, BalanceItemPaymentDetailed, BaseOrganization, PaymentCustomer, PaymentGeneral, PaymentProvider, PaymentType, Settlement, TransferSettings } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 
 import { QueryableModel } from '@stamhoofd/sql';
+import { CreateMandateSettings } from '@stamhoofd/structures/checkout/CreateMandateSettings.js';
 import type { BalanceItem } from './BalanceItem.js';
 import type { BalanceItemPayment } from './BalanceItemPayment.js';
 import { Organization } from './Organization.js';
@@ -52,6 +53,19 @@ export class Payment extends QueryableModel {
     @column({ type: 'string', nullable: true })
     payingUserId: string | null = null;
 
+    /**
+     * External ID of the mandate used for this payment
+     */
+    @column({ type: 'string', nullable: true })
+    mandateId: string | null = null;
+
+    /**
+     * Link to related payment that was reversed.
+     * Used for refunds and chargebacks
+     */
+    @column({ type: 'string', nullable: true })
+    reversingPaymentId: string | null = null;
+
     /**
      * @deprecated
      */
@@ -75,6 +89,9 @@ export class Payment extends QueryableModel {
     @column({ type: 'string', nullable: true })
     stripeAccountId: string | null = null;
 
+    @column({ type: 'json', decoder: CreateMandateSettings, nullable: true })
+    createMandate: CreateMandateSettings | null = null;
+
     /**
      * Total price
      */
@@ -84,10 +101,12 @@ export class Payment extends QueryableModel {
     /**
      * The difference between the sum of the balance item payments price and the price of the payment, caused by rounding to 1 cent.
      * This cannot be >= 100 (= 0,01 euro) or <= -100 (=-0,01 euro)
+     * 
+     * For understanding the sign of the value, regard it as an extra balance item to the payment.
      *
      * Just like all prices, this price is stored per ten thousand (1 = 0,0001 ). Storing smaller units is not possible because even in balance items, the price to pay cannot be smaller than 0,0001 euro
      *
-     * E.g. total price to pay is 0,242 because of VAT, then we round this to 0,24. The roundingAmount will be -0,002 in this case.
+     * E.g. total price to pay is 0,242 because of VAT, then we round this to 0,24. The roundingAmount will be -0,002 in this case, because all the items (0,242) - 0,002 = 0,24.
      */
     @column({ type: 'integer' })
     roundingAmount = 0;

package/src/models/Registration.ts

@@ -1,12 +1,12 @@
 import type { ManyToOneRelation } from '@simonbackx/simple-database';
 import { column } from '@simonbackx/simple-database';
-import type { RecordAnswer} from '@stamhoofd/structures';
+import type { RecordAnswer } from '@stamhoofd/structures';
 import { AppliedRegistrationDiscount, GroupPrice, RecordAnswerDecoder, RegisterItemOption, Registration as RegistrationStructure, StockReservation } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 
 import { ArrayDecoder, MapDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { QueryableModel } from '@stamhoofd/sql';
-import type {Group} from './Group.js';
+import type { Group } from './Group.js';
 
 export class Registration extends QueryableModel {
     static table = 'registrations';
@@ -117,6 +117,7 @@ export class Registration extends QueryableModel {
     waitingList = false;
 
     /**
+     * @deprecated - use RegistrationInvitation instead
      * When a registration is on the waiting list or is invite only, set this to true to allow the user to
      * register normally.
      */

package/src/models/RegistrationInvitation.ts

@@ -0,0 +1,40 @@
+import { column } from '@simonbackx/simple-database';
+import { v4 as uuidv4 } from 'uuid';
+
+import { QueryableModel } from '@stamhoofd/sql';
+
+/**
+ * Invitation to register for a group. If an invitation exists the member can always register even if he does not meet the requirements of the group.
+ * Used for allowing members who are on a waiting list to register for a group.
+ */
+export class RegistrationInvitation extends QueryableModel {
+    static table = 'registration_invitations';
+
+    @column({
+        primary: true, type: 'string', beforeSave(value) {
+            return value ?? uuidv4();
+        },
+    })
+    id: string;
+
+    @column({ type: 'string' })
+    groupId: string;
+
+    @column({ type: 'string' })
+    memberId: string;
+
+    @column({ type: 'string' })
+    organizationId: string;
+
+    @column({
+        type: 'datetime', beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
+    })
+    createdAt: Date;
+}

package/src/models/User.ts

@@ -141,20 +141,19 @@ export class User extends QueryableModel {
         return global;
     }
 
-    static async getAdmins(organizationId: string, options?: { verified?: boolean }) {
+    static async getAdmins(organizationId: string | string[], options?: { verified?: boolean }) {
         if (STAMHOOFD.userMode === 'platform') {
             // Custom implementation
             const q = User.select()
                 .where('organizationId', null)
                 .where('permissions', '!=', null)
                 .where(
-                    SQL.jsonExtract(
-                        SQL.jsonExtract(SQL.column('permissions'), '$.value.organizationPermissions'),
-                        '$."' + organizationId + '"',
-                        true,
+                    SQL.jsonOverlaps(
+                        SQL.jsonKeys(SQL.jsonExtract(SQL.column('permissions'), '$.value.organizationPermissions')),
+                        SQL.cast(SQL.scalar(JSON.stringify(Array.isArray(organizationId) ? organizationId : [organizationId])), 'JSON'),
                     ),
-                    '!=',
-                    null,
+                    '=',
+                    1,
                 )
             ;
 

package/src/models/index.ts

@@ -61,5 +61,6 @@ export * from './UitpasClientCredential.js';
 
 export * from './Invoice.js';
 export * from './InvoicedBalanceItem.js';
+export * from './RegistrationInvitation.js';
 
 import './_relations.js';