@stamhoofd/models 2.120.6 → 2.122.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/Order.ts

@@ -286,8 +286,7 @@ export class Order extends QueryableModel {
             if (webshop) {
                 await this.setRelation(Order.webshop, webshop).updateTickets();
             }
-        }
-        else {
+        } else {
             this.markUpdated();
             await this.save();
         }
@@ -427,8 +426,7 @@ export class Order extends QueryableModel {
                 // Remove any reserved stock
                 const updated = Order.updateTimeSlotStock(timeSlot, this.data, false);
                 changed = changed || updated;
-            }
-            else {
+            } else {
                 this.data.reservedOrder = false;
                 this.data.reservedPersons = 0;
                 changed = true;
@@ -442,8 +440,7 @@ export class Order extends QueryableModel {
             if (timeSlot) {
                 const updated = Order.updateTimeSlotStock(timeSlot, this.data, add);
                 changed = changed || updated;
-            }
-            else {
+            } else {
                 console.error('Missing timeslot ' + s.id + ' in webshop ' + this.webshopId);
             }
         }
@@ -456,6 +453,7 @@ export class Order extends QueryableModel {
                     if (previousData !== null) {
                         // Already removed
                         item.reservedSeats = [];
+                        // eslint-disable-next-line no-useless-assignment
                         changed = true;
                     }
 
@@ -491,8 +489,7 @@ export class Order extends QueryableModel {
                 code.reserved = false;
                 discountCodeUsageMap.set(code.id, (discountCodeUsageMap.get(code.id) ?? 0) - 1);
                 changed = true;
-            }
-            else if (!code.reserved && add) {
+            } else if (!code.reserved && add) {
                 code.reserved = true;
                 discountCodeUsageMap.set(code.id, (discountCodeUsageMap.get(code.id) ?? 0) + 1);
                 changed = true;
@@ -599,8 +596,7 @@ export class Order extends QueryableModel {
                     ticketMap.set(item.product.id, offset + item.amount);
                 }
             }
-        }
-        else {
+        } else {
             // Create a shared ticket for the whole order
             const ticket = new Ticket();
             ticket.orderId = this.id;
@@ -752,8 +748,7 @@ export class Order extends QueryableModel {
         // Needs to happen before validation, because we can include the tickets in the validation that way
         if (this.validAt === null) {
             await this.setRelation(Order.webshop, webshop).markValid(payment, tickets);
-        }
-        else {
+        } else {
             this.markUpdated();
             await this.save();
 
@@ -764,8 +759,7 @@ export class Order extends QueryableModel {
             if (this.data.customer.email.length > 0) {
                 if (didCreateTickets) {
                     await this.setRelation(Order.webshop, webshop).sendTickets();
-                }
-                else {
+                } else {
                     if (payment && payment.method === PaymentMethod.Transfer) {
                         await this.setRelation(Order.webshop, webshop).sendPaidMail();
                     }
@@ -976,40 +970,34 @@ export class Order extends QueryableModel {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.TicketsConfirmationPOS,
                     });
-                }
-                else {
+                } else {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.TicketsConfirmation,
                     });
                 }
-            }
-            else {
+            } else {
                 if (this.webshop.meta.ticketType === WebshopTicketType.None) {
                     if (payment && payment.method === PaymentMethod.Transfer) {
                         // Also send a copy
                         await this.sendEmailTemplate({
                             type: EmailTemplateType.OrderConfirmationTransfer,
                         });
-                    }
-                    else if (payment && payment.method === PaymentMethod.PointOfSale) {
+                    } else if (payment && payment.method === PaymentMethod.PointOfSale) {
                         await this.sendEmailTemplate({
                             type: EmailTemplateType.OrderConfirmationPOS,
                         });
-                    }
-                    else {
+                    } else {
                         // Also send a copy
                         await this.sendEmailTemplate({
                             type: EmailTemplateType.OrderConfirmationOnline,
                         });
                     }
-                }
-                else {
+                } else {
                     if (payment && payment.method === PaymentMethod.Transfer) {
                         await this.sendEmailTemplate({
                             type: EmailTemplateType.TicketsConfirmationTransfer,
                         });
-                    }
-                    else {
+                    } else {
                         console.error('Unexpected missing tickets for order where tickets are expected');
                     }
                 }

package/src/models/Organization.ts

@@ -6,17 +6,21 @@ import { I18n } from '@stamhoofd/backend-i18n/I18n';
 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 { Formatter } from '@stamhoofd/utility';
+import type { AppType, OrganizationEmail, PrivatePaymentConfiguration } from '@stamhoofd/structures';
+import { AccessRight, Address, appToUri, Company, DNSRecordStatus, EmailTemplateType, getAppHost, GroupType, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, Recipient, Replacement, STPackageType, TransferSettings } from '@stamhoofd/structures';
+import type { PaymentMandate } from '@stamhoofd/structures/PaymentMandate.js';
+import { Country } from '@stamhoofd/types/Country';
+import { Language } from '@stamhoofd/types/Language';
+import { Formatter, Sorter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 import { validateDNSRecords } from '../helpers/DNSValidator.js';
 import { OrganizationServerMetaData } from '../structures/OrganizationServerMetaData.js';
 import { Group } from './Group.js';
 import { OrganizationRegistrationPeriod } from './OrganizationRegistrationPeriod.js';
+import { Registration } from './Registration.js';
 import { StripeAccount } from './StripeAccount.js';
-import { Country } from '@stamhoofd/types/Country';
-import { Language } from '@stamhoofd/types/Language';
+import { Token } from './Token.js';
+import type { User } from './User.js';
 
 export class Organization extends QueryableModel {
     static table = 'organizations';
@@ -209,53 +213,12 @@ export class Organization extends QueryableModel {
         return organization;
     }
 
-    /**
-     * Potentially includes a path
-     */
-    getRegistrationHost(i18n?: { language: Language; locale: string }): string {
-        if (this.registerDomain) {
-            let d = this.registerDomain;
-
-            if (i18n && i18n.language !== this.i18n.language) {
-                d += '/' + i18n.language;
-            }
-
-            return d;
-        }
-        return this.getDefaultRegistrationHost(i18n);
+    getDashboardHost(i18n?: { language: Language; locale: string }): string {
+        return getAppHost('dashboard', this, true, i18n);
     }
 
-    getDefaultRegistrationHost(i18n?: { language: Language; locale: string }): string {
-        if (!STAMHOOFD.domains.registration) {
-            return STAMHOOFD.domains.dashboard + '/' + (i18n?.locale ?? this.i18n.locale) + '/' + appToUri('registration') + '/' + this.uri;
-        }
-        let defaultDomain = STAMHOOFD.domains.registration[this.address.country] ?? STAMHOOFD.domains.registration[''];
-
-        if (i18n && i18n.language !== this.i18n.language) {
-            defaultDomain += '/' + i18n.language;
-        }
-
-        return this.uri + '.' + defaultDomain;
-    }
-
-    get registerUrl() {
-        return 'https://' + this.getRegistrationHost();
-    }
-
-    /**
-     * @deprecated
-     * use getRegistrationHost
-     */
-    getHost(i18n?: I18n): string {
-        return this.getRegistrationHost(i18n);
-    }
-
-    /**
-     * @deprecated
-     * Use getDefaultRegistrationHost
-     */
-    getDefaultHost(i18n?: I18n): string {
-        return this.getDefaultRegistrationHost(i18n);
+    get registerUrl(): string {
+        return 'https://' + getAppHost('registration', this, false);
     }
 
     get marketingDomain(): string {
@@ -297,8 +260,7 @@ export class Organization extends QueryableModel {
                 await created.save();
                 return created;
             });
-        }
-        else {
+        } else {
             oPeriod = oPeriods[0];
         }
 
@@ -361,8 +323,7 @@ export class Organization extends QueryableModel {
 
                     console.log('Did set register domain for ' + this.id + ' to ' + organization.registerDomain);
                 }
-            }
-            else {
+            } else {
                 // Clear register domain
                 if (organization.registerDomain) {
                     // We need to clear it, to prevent sending e-mails with invalid links
@@ -400,8 +361,7 @@ export class Organization extends QueryableModel {
                     type: EmailTemplateType.OrganizationStableDNS,
                     bcc: true,
                 });
-            }
-            else if (!wasActive && this.privateMeta.mailDomainActive && (!didSendDomainSetupMail || didSendWarning) && !organization.serverMeta.isDNSUnstable) {
+            } else if (!wasActive && this.privateMeta.mailDomainActive && (!didSendDomainSetupMail || didSendWarning) && !organization.serverMeta.isDNSUnstable) {
                 organization.serverMeta.didSendDomainSetupMail = true;
                 await organization.save();
 
@@ -409,15 +369,13 @@ export class Organization extends QueryableModel {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationDNSSetupComplete,
                     });
-                }
-                else {
+                } else {
                     await this.sendEmailTemplate({
                         type: EmailTemplateType.OrganizationValidDNS,
                     });
                 }
             }
-        }
-        else {
+        } else {
             // DNS settings gone broken
             if (organization.privateMeta.mailDomain) {
                 organization.privateMeta.pendingMailDomain = organization.privateMeta.pendingMailDomain ?? organization.privateMeta.mailDomain;
@@ -442,8 +400,7 @@ export class Organization extends QueryableModel {
                     type: EmailTemplateType.OrganizationUnstableDNS,
                     bcc: true,
                 });
-            }
-            else if (!organization.serverMeta.isDNSUnstable && organization.serverMeta.didSendDomainSetupMail && organization.serverMeta.DNSRecordWarningCount == 0) {
+            } else if (!organization.serverMeta.isDNSUnstable && organization.serverMeta.didSendDomainSetupMail && organization.serverMeta.DNSRecordWarningCount == 0) {
                 organization.serverMeta.DNSRecordWarningCount += 1;
                 await organization.save();
 
@@ -494,6 +451,10 @@ export class Organization extends QueryableModel {
                     token: 'mailDomain',
                     value: this.privateMeta.mailDomain ?? this.privateMeta.pendingMailDomain ?? '',
                 }),
+                Replacement.create({
+                    token: 'organizationName',
+                    value: this.name,
+                }),
             ],
             unsubscribeType: 'marketing',
             fromStamhoofd: true,
@@ -541,8 +502,7 @@ export class Organization extends QueryableModel {
 
             await client.send(deleteCmd);
             console.log('Deleted AWS mail idenitiy @' + this.id + ' for ' + this.privateMeta.mailDomain);
-        }
-        catch (e) {
+        } catch (e) {
             console.error('Could not delete AWS email identitiy @' + this.id + ' for ' + this.privateMeta.mailDomain);
             console.error(e);
         }
@@ -609,8 +569,7 @@ export class Organization extends QueryableModel {
                 // Recreate it immediately
                 exists = false;
             }
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
 
@@ -854,6 +813,17 @@ export class Organization extends QueryableModel {
         return admins.filter(a => a.permissions && a.permissions.forOrganization(this)?.hasFullAccess());
     }
 
+    /**
+     * These email addresess are private
+     */
+    async getFinanceAdmins() {
+        const admins = await this.getAdmins();
+        const filtered = admins.filter(a => a.permissions && (a.permissions.forOrganization(this)?.hasFullAccess() || a.permissions.forOrganization(this)?.hasAccessRight(AccessRight.OrganizationFinanceDirector)));
+
+        // Only full access
+        return filtered;
+    }
+
     /**
      * These email addresess are private
      */
@@ -873,32 +843,90 @@ export class Organization extends QueryableModel {
         return filtered.flatMap(f => f.getEmailTo());
     }
 
+    adminsToRecipients(admins: User[]) {
+        return admins.flatMap((f) => {
+            return Recipient.create({
+                firstName: f.firstName,
+                lastName: f.lastName,
+                email: f.email,
+                replacements: [],
+            });
+        });
+    }
+
     /**
      * These email addresess are private
      */
     async getAdminRecipients(): Promise<Recipient[]> {
-        let filtered = await this.getFullAdmins();
+        const filtered = await this.getFullAdmins();
+        return this.adminsToRecipients(filtered);
+    }
 
-        if (STAMHOOFD.environment === 'production') {
-            if (filtered.length > 1) {
-                // remove stamhoofd email addresses
-                filtered = filtered.filter(e => !e.email.endsWith('@stamhoofd.be') && !e.email.endsWith('@stamhoofd.nl'));
-            }
+    /**
+     * These email addresess are private
+     */
+    async getFinanceAdminRecipients(): Promise<Recipient[]> {
+        const filtered = await this.getFullAdmins();
+        return this.adminsToRecipients(filtered);
+    }
+
+    /**
+     * These email addresess are private
+     */
+    async getInvoicingToEmails() {
+        // Circular reference fix
+        const filtered = await this.getFinanceAdmins();
+
+        if (filtered.length > 0) {
+            return filtered.flatMap(f => f.getEmailTo()).map((recipient) => {
+                if (!recipient.name) {
+                    return recipient.email;
+                }
+                const cleanedName = Formatter.emailSenderName(recipient.name);
+                if (cleanedName.length < 2) {
+                    return recipient.email;
+                }
+                return '"' + cleanedName + '" <' + recipient.email + '>';
+            }).join(', ');
         }
 
-        return filtered.flatMap((f) => {
-            return Recipient.create({
-                firstName: f.firstName,
-                lastName: f.lastName,
-                email: f.email,
-                replacements: [
-                    Replacement.create({
-                        token: 'organizationName',
-                        value: this.name,
-                    }),
-                ],
-            });
+        return undefined;
+    }
+
+    /**
+     * Returns one email for invoices. since in ubl we can only add one address.
+     * We choose the oldest user that was active in the last 3 months (otherwise the oldest user if noone was active)
+     */
+    async getInvoicingToEmail(): Promise<string | undefined> {
+        // Circular reference fix
+        const admins = await this.getAdmins();
+
+        const tokens = await Token.select().where('userId', admins.map(a => a.id)).fetch();
+
+        // Sort by admins that were active in the last 3 months, then creation date
+        const cutoffDate = new Date(Date.now() - 1000 * 60 * 60 * 24 * 31 * 3);
+        admins.sort((a, b) => {
+            const aTokens = tokens.filter(t => t.userId === a.id);
+            const bTokens = tokens.filter(t => t.userId === b.id);
+            const aActive = !!aTokens.find(t => t.updatedAt > cutoffDate);
+            const bActive = !!bTokens.find(t => t.updatedAt > cutoffDate);
+            return Sorter.stack(
+                Sorter.byBooleanValue(aActive, bActive),
+                Sorter.byDateValue(b.createdAt, a.createdAt),
+            );
         });
+
+        const filtered = admins.filter(a => a.verified && a.permissions && !a.email.endsWith('@stamhoofd.be') && (a.permissions.forOrganization(this)?.hasFullAccess() || a.permissions.forOrganization(this)?.hasAccessRight(AccessRight.OrganizationFinanceDirector)));
+
+        if (filtered.length > 0) {
+            return filtered.map(f => f.email)[0];
+        }
+        const filtered2 = admins.filter(a => a.verified && a.permissions && (a.permissions.forOrganization(this)?.hasFullAccess() || a.permissions.forOrganization(this)?.hasAccessRight(AccessRight.OrganizationFinanceDirector)));
+
+        if (filtered2.length > 0) {
+            return filtered2.map(f => f.email)[0];
+        }
+        return undefined;
     }
 
     /**
@@ -913,10 +941,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 +1019,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 +1028,30 @@ 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() {
+        const b = this.meta.companies.length
+            ? this.meta.companies
+            : [
+                    Company.create({
+                        name: this.name,
+                        address: this.address,
+                    }),
+                ];
+
+        // Missing address -> use organization address
+        if (!b[0].address) {
+            b[0].address = this.address;
+        }
+
+        return b;
+    }
 }