@stamhoofd/backend 2.120.6 → 2.122.0

package/src/services/SSOService.ts

@@ -1,10 +1,9 @@
-import type { DecodedRequest} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest } from '@simonbackx/simple-endpoints';
 import { Response } from '@simonbackx/simple-endpoints';
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
-import type { Organization} from '@stamhoofd/models';
-import { Platform, Token, User, Webshop } from '@stamhoofd/models';
-import type { LoginMethod, StartOpenIDFlowStruct} from '@stamhoofd/structures';
-import { LoginProviderType, OpenIDClientConfiguration, Token as TokenStruct } from '@stamhoofd/structures';
+import { Organization, Platform, Token, User, Webshop } from '@stamhoofd/models';
+import type { LoginMethod, StartOpenIDFlowStruct } from '@stamhoofd/structures';
+import { getAppHost, LoginProviderType, OpenIDClientConfiguration, Token as TokenStruct } from '@stamhoofd/structures';
 import crypto from 'crypto';
 import { generators, Issuer } from 'openid-client';
 import { Context } from '../helpers/Context.js';
@@ -32,6 +31,7 @@ type SSOSessionContext = {
     redirectUri: string;
     spaState: string;
     providerType: LoginProviderType;
+    organizationId?: string | null;
 
     /**
      * Link this method to this existing user and don't create a new token
@@ -127,17 +127,19 @@ export class SSOService {
         let redirectUri = 'https://' + STAMHOOFD.domains.dashboard;
 
         if (this.organization) {
-            redirectUri = 'https://' + this.organization.getHost();
+            redirectUri = 'https://' + getAppHost('registration', this.organization, true);
         }
         return redirectUri;
     }
 
-    static async fromContext(provider: LoginProviderType) {
+    static async fromContext(provider: LoginProviderType, options: { validate?: boolean } = {}) {
         const organization = Context.organization;
         const platform = await Platform.getForEditing();
 
         const service = new SSOService({ provider, platform, organization });
-        service.validateConfiguration();
+        if (options.validate ?? false) {
+            service.validateConfiguration();
+        }
 
         return service;
     }
@@ -148,17 +150,14 @@ export class SSOService {
         if (this.provider === LoginProviderType.SSO) {
             if (this.organization) {
                 configuration = this.organization.serverMeta.ssoConfiguration ?? OpenIDClientConfiguration.create({});
-            }
-            else {
+            } else {
                 configuration = this.platform.serverConfig.ssoConfiguration ?? OpenIDClientConfiguration.create({});
             }
-        }
-        else if (this.provider === LoginProviderType.Google) {
+        } else if (this.provider === LoginProviderType.Google) {
             if (this.organization) {
                 // Not supported yet
                 configuration = null;
-            }
-            else {
+            } else {
                 configuration = this.platform.serverConfig.googleConfiguration ?? OpenIDClientConfiguration.create({});
             }
         }
@@ -174,15 +173,11 @@ export class SSOService {
     }
 
     get loginConfiguration() {
-        if (this.organization) {
-            throw new SimpleError({
-                code: 'invalid_client',
-                message: 'Login configuration not yet supported for organization users',
-                statusCode: 400,
-            });
-        }
+        const loginMethods = this.organization
+            ? this.organization.meta.loginMethods
+            : this.platform.config.loginMethods;
 
-        const loginConfiguration = this.platform.config.loginMethods.get(this.provider as unknown as LoginMethod);
+        const loginConfiguration = loginMethods.get(this.provider as unknown as LoginMethod);
         if (!loginConfiguration) {
             throw new SimpleError({
                 code: 'invalid_client',
@@ -195,9 +190,9 @@ export class SSOService {
     }
 
     validateConfiguration() {
-        // Validate configuration exists
-        const _ = this.configuration;
-        const __ = this.loginConfiguration;
+        // Trigger getters to validate both server and login method configuration.
+        void this.configuration;
+        void this.loginConfiguration;
     }
 
     validateEmail(email: string) {
@@ -218,21 +213,19 @@ export class SSOService {
         if (this.provider === LoginProviderType.SSO) {
             if (this.organization) {
                 this.organization.serverMeta.ssoConfiguration = configuration;
-                await this.getClient();
+                await this.validateClientConfiguration();
                 await this.organization.save();
                 return;
-            }
-            else {
+            } else {
                 this.platform.serverConfig.ssoConfiguration = configuration;
-                await this.getClient();
+                await this.validateClientConfiguration();
                 await this.platform.save();
                 return;
             }
-        }
-        else if (this.provider === LoginProviderType.Google) {
+        } else if (this.provider === LoginProviderType.Google) {
             if (!this.organization) {
                 this.platform.serverConfig.googleConfiguration = configuration;
-                await this.getClient();
+                await this.validateClientConfiguration();
                 await this.platform.save();
                 return;
             }
@@ -245,6 +238,20 @@ export class SSOService {
         });
     }
 
+    async validateClientConfiguration() {
+        try {
+            await this.getClient();
+        } catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            throw new SimpleError({
+                code: 'invalid_sso_configuration',
+                message: 'Failed to validate SSO configuration: ' + message,
+                human: $t('%1Xe', { message }),
+                statusCode: 400,
+            });
+        }
+    }
+
     async getClient() {
         const issuer = await Issuer.discover(this.configuration.issuer);
         const client = new issuer.Client({
@@ -331,8 +338,7 @@ export class SSOService {
 
                 if (allowedHost.host === givenUrl.host && givenUrl.protocol === 'https:') {
                     redirectUri = givenUrl.href;
-                }
-                else {
+                } else {
                     throw new SimpleError({
                         code: 'redirect_uri_not_allowed',
                         message: 'Redirect uri not allowed',
@@ -340,8 +346,7 @@ export class SSOService {
                         statusCode: 400,
                     });
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 throw new SimpleError({
                     code: 'invalid_redirect_uri',
                     message: 'Invalid redirect uri',
@@ -385,8 +390,7 @@ export class SSOService {
         let parsed: URL;
         try {
             parsed = new URL(uri);
-        }
-        catch (e) {
+        } catch (e) {
             throw new SimpleError({
                 code: 'invalid_redirect_uri',
                 message: 'Invalid redirect uri',
@@ -429,6 +433,7 @@ export class SSOService {
             redirectUri,
             spaState, // this is the state frontend <-> backend (not backend <-> SSO provider)
             providerType: this.provider,
+            organizationId: this.organization?.id ?? null,
             userId: user?.id ?? null,
         };
 
@@ -465,8 +470,7 @@ export class SSOService {
             response.status = 302;
 
             return response;
-        }
-        catch (e) {
+        } catch (e) {
             const message = (isSimpleError(e) || isSimpleErrors(e) ? e.getHuman() : $t(`%G0`));
             console.error('Error in openID callback', e);
             return SSOServiceWithSession.getErrorRedirectResponse(session, message);
@@ -492,7 +496,14 @@ export class SSOServiceWithSession {
             throw new Error('Missing session');
         }
 
-        const service = await SSOService.fromContext(session.providerType);
+        const platform = await Platform.getForEditing();
+        const organization = session.organizationId ? await Organization.getByID(session.organizationId) : null;
+        if (session.organizationId && !organization) {
+            throw new Error('Missing organization');
+        }
+
+        const service = new SSOService({ provider: session.providerType, platform, organization });
+        service.validateConfiguration();
 
         return new SSOServiceWithSession(session, service, request);
     }
@@ -548,8 +559,7 @@ export class SSOServiceWithSession {
 
             if (tokenSet.refresh_token) {
                 console.log('OK. Refresh token received!');
-            }
-            else {
+            } else {
                 console.log('No refresh token');
             }
 
@@ -600,8 +610,7 @@ export class SSOServiceWithSession {
                         statusCode: 500,
                     });
                 }
-            }
-            else {
+            } else {
                 if (this.session.userId && user.id !== this.session.userId) {
                     throw new SimpleError({
                         code: 'invalid_user',
@@ -640,8 +649,7 @@ export class SSOServiceWithSession {
                 const st = new TokenStruct(token);
                 redirectUri.searchParams.set('oid_rt', st.refreshToken);
                 redirectUri.searchParams.set('s', session.spaState);
-            }
-            else {
+            } else {
                 redirectUri.searchParams.set('s', session.spaState);
                 redirectUri.searchParams.set('msg', 'Je account is succesvol gekoppeld');
             }
@@ -650,8 +658,7 @@ export class SSOServiceWithSession {
             response.status = 302;
 
             return response;
-        }
-        catch (e) {
+        } catch (e) {
             const message = (isSimpleError(e) || isSimpleErrors(e) ? e.getHuman() : $t(`%G0`));
             console.error('Error in openID callback', e);
             return SSOServiceWithSession.getErrorRedirectResponse(session, message);

package/src/services/STPackageService.ts

@@ -1,11 +1,9 @@
-import { SimpleError } from '@simonbackx/simple-errors';
 import { BalanceItem, Organization, Platform, STPackage } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
-import type { PaymentCustomer, STPackageStatus, STPackageType } from '@stamhoofd/structures';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, STPricingType, TranslatedString, VATExcemptReason } from '@stamhoofd/structures';
-import { Country } from '@stamhoofd/types/Country';
-import { Formatter } from '@stamhoofd/utility';
-import { GroupBuilder } from '../helpers/GroupBuilder.js';
+import type { Company } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, getPricingTypeName, STPackageStatus, STPackageType, STPackageTypeHelper, STPricingType, TranslatedString } from '@stamhoofd/structures';
+import { Formatter, STMath } from '@stamhoofd/utility';
+import { VATService } from './VATService.js';
 
 export class STPackageService {
     static async getActivePackages(organizationId: string) {
@@ -35,18 +33,13 @@ export class STPackageService {
     static async getChargeableQuantity(pack: STPackage) {
         // If type is
         let amount = 1;
-        let membersCount: number | null = null;
-
-        if (membersCount === null && pack.meta.pricingType === STPricingType.PerMember) {
-            membersCount = await Organization.getActiveMembers(pack.organizationId);
-        }
 
         if (pack.meta.pricingType === STPricingType.PerMember) {
-            amount = membersCount ?? 1;
+            amount = await Organization.getActiveMembers(pack.organizationId);
         }
 
-        if (amount < pack.meta.minimumAmount) {
-            amount = pack.meta.minimumAmount;
+        if (amount < (pack.meta.minimumAmount || 1)) {
+            amount = (pack.meta.minimumAmount || 1);
         }
 
         return amount;
@@ -74,6 +67,17 @@ export class STPackageService {
             }
         }
 
+        // Stop trials
+        const trialType = STPackageTypeHelper.getTrial(pack.meta.type);
+        if (trialType) {
+            const activePackages = await this.getActivePackages(pack.organizationId);
+            for (const p of activePackages) {
+                if (p.meta.type === trialType) {
+                    await this.deactivatePackage(p);
+                }
+            }
+        }
+
         await this.updateOrganizationPackages(pack.organizationId);
     }
 
@@ -83,6 +87,14 @@ export class STPackageService {
         await old.save();
     }
 
+    static async deactivatePackage(pack: STPackage) {
+        console.log('Deactivating package', pack.meta.type, 'with id', pack.id);
+        // Deactivate
+        pack.removeAt = new Date();
+        pack.removeAt.setTime(pack.removeAt.getTime() - 5_000);
+        await pack.save();
+    }
+
     static async getPaidOrPendingQuantity(pack: STPackage) {
         if (!pack.existsInDatabase || pack.createdAt.getTime() > Date.now() - 1_000) {
             return 0;
@@ -91,7 +103,7 @@ export class STPackageService {
         return await BalanceItem.select()
             .where('packageId', pack.id)
             .where('status', BalanceItemStatus.Due)
-            .count(SQL.column('amount'));
+            .sum(SQL.column('amount'));
     }
 
     /**
@@ -99,42 +111,33 @@ export class STPackageService {
      *
      * Convertable into STInvoiceItem (or the diffence if amount is increased)
      * Use this to calculate prices or create an invoice
-     * This will calculate the price to expand the package to the given amount.
+     * This will calculate the price to expand the package to the given amount
      * If you want to renew a package, you need to create a new package first
      */
-    static async chargePackage(pack: STPackage, date?: Date, customer?: PaymentCustomer): Promise<BalanceItem | null> {
+    static async chargePackage(pack: STPackage, sellingOrganization: Organization, company: Company | null | undefined, date?: Date): Promise<BalanceItem | null> {
         let unitPrice = Math.round(pack.meta.unitPrice);
 
         let amount = await this.getChargeableQuantity(pack);
-
-        if (amount < pack.meta.minimumAmount) {
-            // Minimum should get applied first, because we might already have paid for the minimum (paid amount)
-            amount = pack.meta.minimumAmount;
-        }
-
         const paid = await this.getPaidOrPendingQuantity(pack);
         amount -= paid;
 
         if (amount <= 0) {
-            amount = 0;
-        }
-
-        if (amount <= 0) {
+            console.log('Not charging package', pack.id, 'amount is', amount);
             return null;
         }
 
         /// When pricing type is memebrs, the price is calculated per year.
         /// If a shorter period is remaining, we give a discount in order
         /// to no need to handle it more complicated
-        let now = date ?? new Date();
+        let now = date ?? Formatter.luxon().startOf('day').toJSDate();
         if (now < pack.meta.startDate) {
             // When creating a new package, we sometimes buy it for the future, so use that date instead of now
             now = pack.meta.startDate;
         }
 
-        if (pack.validUntil && pack.meta.pricingType !== STPricingType.Fixed) {
-            const totalDays = Math.round((pack.validUntil.getTime() - pack.meta.startDate.getTime()) / (1000 * 60 * 60 * 24));
-            let remainingDays = Math.round((pack.validUntil.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+        if (pack.endDate && pack.meta.pricingType !== STPricingType.Fixed) {
+            const totalDays = Math.round((pack.endDate.getTime() - pack.meta.startDate.getTime()) / (1000 * 60 * 60 * 24));
+            let remainingDays = Math.round((pack.endDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
 
             /// First 3 months are full price
             const paidDays = 30 * 3;
@@ -150,8 +153,7 @@ export class STPackageService {
 
             if (pack.meta.pricingType === STPricingType.PerMember) {
                 unitPrice = Math.round(Math.min(unitPrice, unitPrice * remainingDays / (Math.max(365, totalDays) - paidDays)));
-            }
-            else {
+            } else {
                 unitPrice = Math.round(unitPrice);
             }
         }
@@ -159,46 +161,40 @@ export class STPackageService {
         const item = new BalanceItem();
         item.type = BalanceItemType.STPackage;
         item.description = pack.meta.name + ' ' + (
-            pack.validUntil
-                ? $t('%1LM', { startDate: Formatter.date(now, true), endDate: Formatter.date(pack.validUntil, true) })
-                : $t('%1LN', { startDate: Formatter.date(pack.meta.startDate, true) })
+            pack.endDate
+                ? $t('%1LM', { startDate: Formatter.startDate(now, false, true), endDate: Formatter.endDate(pack.endDate, false, true) })
+                : $t('%1LN', { startDate: Formatter.startDate(pack.meta.startDate, false, true) })
         );
         item.relations.set(BalanceItemRelationType.STPackage, BalanceItemRelation.create({
             id: pack.id,
             name: TranslatedString.create(pack.meta.name),
         }));
+        item.relations.set(BalanceItemRelationType.STPricingType, BalanceItemRelation.create({
+            id: pack.meta.pricingType,
+            name: TranslatedString.create(getPricingTypeName(pack.meta.pricingType)),
+        }));
+
         item.packageId = pack.id;
         item.startDate = now;
 
-        if (pack.validUntil) {
-            item.endDate = pack.validUntil;
+        if (pack.endDate) {
+            item.endDate = pack.endDate;
         }
 
         item.payingOrganizationId = pack.organizationId;
-        const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
-        if (!membershipOrganizationId) {
-            throw new SimpleError({
-                code: 'unavailable',
-                message: 'No membership organization id set on the platform',
-                human: 'Package purchases are currently unavailable',
-            });
-        }
-        item.organizationId = membershipOrganizationId;
+        item.organizationId = sellingOrganization.id;
         item.VATPercentage = 21;
         item.VATIncluded = false;
-        item.VATExcempt = null;
+        item.VATExcempt = VATService.getVATExcempt({
+            company,
+            sellingOrganization,
+            type: 'services',
+        });
         item.quantity = amount;
-        item.unitPrice = unitPrice;
-        item.createdAt = now;
+        item.unitPrice = STMath.round(unitPrice / 100) * 100;
+        item.createdAt = new Date();
         item.status = BalanceItemStatus.Hidden;
 
-        if (customer && customer.company && customer.company.address) {
-            // Reverse charged vat applicable?
-            if (customer.company.address.country !== Country.Belgium) {
-                item.VATExcempt = VATExcemptReason.IntraCommunity;
-            }
-        }
-
         return item;
     }
 
@@ -213,15 +209,26 @@ export class STPackageService {
     }
 
     private static async getOrganizationPackagesMap(organizationId: string): Promise<Map<STPackageType, STPackageStatus>> {
+        const map = new Map<STPackageType, STPackageStatus>();
+
+        if (STAMHOOFD.userMode === 'platform' || organizationId === ((await Platform.getShared()).membershipOrganizationId)) {
+            map.set(STPackageType.Webshops, STPackageStatus.create({
+                startDate: new Date(0),
+            }));
+
+            map.set(STPackageType.Members, STPackageStatus.create({
+                startDate: new Date(0),
+            }));
+            return map;
+        }
+
         const packages = await this.getForOrganizationIncludingExpired(organizationId);
 
-        const map = new Map<STPackageType, STPackageStatus>();
         for (const pack of packages) {
             const exist = map.get(pack.meta.type);
             if (exist) {
                 exist.merge(pack.createStatus());
-            }
-            else {
+            } else {
                 map.set(pack.meta.type, pack.createStatus());
             }
         }
@@ -235,18 +242,40 @@ export class STPackageService {
 
         const organization = await Organization.getByID(organizationId);
         if (organization) {
-            const didUseMembers = organization.meta.packages.useMembers && organization.meta.packages.useActivities;
             organization.meta.packages.packages = map;
             await organization.save();
+        } else {
+            console.error("Couldn't find organization when updating packages " + organizationId);
+        }
+    }
 
-            if (!didUseMembers && organization.meta.packages.useMembers && organization.meta.packages.useActivities) {
-                console.log('Building groups and categories for ' + organization.id);
-                const builder = new GroupBuilder(organization);
-                await builder.build();
-            }
+    static async markFailedPayment(organizationId: string) {
+        console.log('Marking packages with failed payment for ' + organizationId);
+
+        // Mark all active packages as failed
+        const activePackages = await this.getActivePackages(organizationId);
+        for (const pack of activePackages) {
+            console.log('Marking package with failed payment ' + pack.id);
+            pack.meta.firstFailedPayment = pack.meta.firstFailedPayment ?? new Date();
+            pack.meta.paymentFailedCount++;
+            await pack.save();
         }
-        else {
-            console.error("Couldn't find organization when updating packages " + organizationId);
+        await this.updateOrganizationPackages(organizationId);
+    }
+
+    static async markBalanceRestored(organizationId: string) {
+        console.log('Marking packages as restored for ' + organizationId);
+
+        // Mark all active packages as failed
+        const activePackages = await this.getActivePackages(organizationId);
+        for (const pack of activePackages) {
+            if (pack.meta.firstFailedPayment || pack.meta.paymentFailedCount) {
+                console.log('Marking package restored ' + pack.id);
+                pack.meta.paymentFailedCount = 0;
+                pack.meta.firstFailedPayment = null;
+                await pack.save();
+            }
         }
+        await this.updateOrganizationPackages(organizationId);
     }
 }

package/src/services/UniqueMemberNumberService.ts

@@ -0,0 +1,69 @@
+import { Database } from '@simonbackx/simple-database';
+import { logger, StyledText } from '@simonbackx/simple-logging';
+import chalk from 'chalk';
+
+const UNIQUE_KEY_PLATFORM = 'memberNumber';
+const UNIQUE_KEY_ORGANIZATION = 'memberNumber_organizationId';
+
+/**
+ * This service is responsible for creating MySQL unique constraints on boot depending on the environment configuration.
+ * If STAMHOOFD.userMode = 'platform' then we'll create a unique constraint on the memberNumber column of the member table.
+ * If 'organization' we will not create a unique constraint on memberNumber and organizationId (we did in the past)
+ *  */
+export class UniqueMemberNumberService {
+    static async check() {
+        await logger.setContext({
+            prefixes: [
+                new StyledText(`[UniqueMemberNumberService] `).addClass('unique-member-number-service', 'tag'),
+            ],
+            tags: ['unique-member-number-service'],
+        }, async () => {
+            if (STAMHOOFD.userMode === 'platform') {
+                if (await this.hasUniqueConstraint(UNIQUE_KEY_ORGANIZATION)) {
+                    console.warn('Unique constraint for userMode organization exists but should be removed. Deleting it now...');
+                    await this.dropConstraint(UNIQUE_KEY_ORGANIZATION);
+                }
+
+                if (!(await this.hasUniqueConstraint(UNIQUE_KEY_PLATFORM))) {
+                    console.warn('Unique constraint for userMode platform is missing. Creating it now...');
+                    await this.createConstraintForPlatform();
+                }
+            } else {
+                if (await this.hasUniqueConstraint(UNIQUE_KEY_PLATFORM)) {
+                    console.warn('Unique constraint for userMode platform exists but should be removed. Deleting it now...');
+                    await this.dropConstraint(UNIQUE_KEY_PLATFORM);
+                }
+
+                if (await this.hasUniqueConstraint(UNIQUE_KEY_ORGANIZATION)) {
+                    console.warn('Unique constraint for userMode organization exists but should be removed. Deleting it now...');
+                    await this.dropConstraint(UNIQUE_KEY_ORGANIZATION);
+                }
+            }
+        });
+    }
+
+    private static async hasUniqueConstraint(key: string) {
+        const [results] = await Database.select('SHOW INDEX FROM `members` WHERE Key_name = ?', [key]);
+        return results.length > 0;
+    }
+
+    private static async dropConstraint(key: string) {
+        try {
+            await Database.statement('ALTER TABLE `members` DROP INDEX `' + key + '`;');
+            console.log('Unique constraint dropped.');
+        } catch (e) {
+            console.error(chalk.red(`Failed to drop unique constraint "${key}" of members table:`));
+            console.error(e);
+        }
+    }
+
+    private static async createConstraintForPlatform() {
+        try {
+            await Database.statement('ALTER TABLE `members` ADD UNIQUE INDEX `' + UNIQUE_KEY_PLATFORM + '` (`memberNumber`) USING BTREE;');
+            console.log('Unique constraint created.');
+        } catch (e) {
+            console.error(chalk.red('Failed to create unique constraint on memberNumber column of members table:'));
+            console.error(e);
+        }
+    }
+}

package/src/services/UniqueUserService.ts

@@ -27,8 +27,7 @@ export class UniqueUserService {
                     console.warn('Unique constraint is missing. Creating it now...');
                     await this.createConstraint();
                 }
-            }
-            else {
+            } else {
                 if (await this.hasUniqueConstraint()) {
                     console.warn('Unique constraint exists but should be removed. Deleting it now...');
                     await this.dropConstraint();
@@ -41,8 +40,7 @@ export class UniqueUserService {
         try {
             await Database.statement('ALTER TABLE `users` ADD UNIQUE INDEX `' + UNIQUE_KEY_NAME + '` (`email`) USING BTREE;');
             console.log('Unique constraint created.');
-        }
-        catch (e) {
+        } catch (e) {
             console.error(chalk.red('Failed to create unique constraint on email column of users table:'));
             console.error(e);
         }
@@ -52,8 +50,7 @@ export class UniqueUserService {
         try {
             await Database.statement('ALTER TABLE `users` DROP INDEX `' + UNIQUE_KEY_NAME + '`;');
             console.log('Unique constraint dropped.');
-        }
-        catch (e) {
+        } catch (e) {
             console.error(chalk.red('Failed to drop unique constraint on email column of users table:'));
             console.error(e);
         }