@stamhoofd/backend 2.83.5 → 2.84.0

package/tests/helpers/PayconiqMocker.ts

@@ -0,0 +1,55 @@
+import { PayconiqAccount } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import nock from 'nock';
+import { v4 as uuidv4 } from 'uuid';
+
+export class PayconiqMocker {
+    static infect() {
+        if (STAMHOOFD.environment !== 'test') {
+            throw new Error('PayconiqMocker can only be used in test environment');
+        }
+
+        TestUtils.addBeforeAll(async () => {
+            this.setup();
+        });
+
+        TestUtils.addAfterEach(() => {
+            this.reset();
+        });
+    }
+
+    static generateTestAccount() {
+        // Todo: store the api key somewhere so we can validate it in the API calls
+        return PayconiqAccount.create({
+            id: uuidv4(),
+            apiKey: 'testKey',
+            merchantId: 'test',
+            profileId: 'test',
+            name: 'test',
+            iban: 'BE56587127952688', // = random IBAN
+            callbackUrl: 'https://www.example.com',
+        });
+    }
+
+    static setup() {
+        nock('https://api.ext.payconiq.com')
+            .persist()
+            .post('/v3/payments')
+            .reply((uri, body) => {
+                // todo: do something smarter with the body
+
+                return [200, {
+                    paymentId: uuidv4(),
+                    _links: {
+                        checkout: {
+                            href: 'https://payconiq.com/pay/2/5bdb1685b93d1c000bde96f2?token=530ea8a4ec8ded7d87620c8637354022cd965b143f257f8f8cb118e7f4a22d8f&returnUrl=https%3A%2F%2Fummy.webshop%2Fcheckout%2Fsuccess',
+                        },
+                    },
+                }];
+            });
+    }
+
+    static reset() {
+        // todo: clean up any state if needed
+    }
+}

package/tests/init/index.ts

@@ -0,0 +1,5 @@
+export * from './initAdmin';
+export * from './initPlatformAdmin';
+export * from './initPayconiq';
+export * from './initBundleDiscount';
+export * from './initStripe';

package/tests/init/initAdmin.ts

@@ -0,0 +1,14 @@
+import { Organization, Token, UserFactory } from '@stamhoofd/models';
+import { PermissionLevel, Permissions } from '@stamhoofd/structures';
+
+export async function initAdmin({ organization }: { organization: Organization }) {
+    const admin = await new UserFactory({
+        organization,
+        permissions: Permissions.create({
+            level: PermissionLevel.Full,
+        }),
+    }).create();
+
+    const adminToken = await Token.createToken(admin);
+    return { admin, adminToken };
+}

package/tests/init/initBundleDiscount.ts

@@ -0,0 +1,47 @@
+import { Group, OrganizationRegistrationPeriod } from '@stamhoofd/models';
+import { GroupPriceDiscountType, BundleDiscount, TranslatedString, GroupPriceDiscount, ReduceablePrice, GroupPrice, BundleDiscountGroupPriceSettings } from '@stamhoofd/structures';
+
+function createBundleDiscount({
+    name = 'Bundle discount',
+    countWholeFamily = true,
+    countPerGroup = false,
+    discounts = [
+        { value: 10_00, type: GroupPriceDiscountType.Fixed },
+        { value: 15_00, type: GroupPriceDiscountType.Fixed },
+    ],
+}: {
+    name?: string;
+    countWholeFamily?: boolean;
+    countPerGroup?: boolean;
+    discounts?: Array<{ value: number; type: GroupPriceDiscountType; reducedValue?: number }>;
+} = {}) {
+    return BundleDiscount.create({
+        name: new TranslatedString(name),
+        countWholeFamily,
+        countPerGroup,
+        discounts: discounts.map(d => GroupPriceDiscount.create({
+            value: ReduceablePrice.create({
+                price: d.value,
+                reducedPrice: d.reducedValue ?? null,
+            }),
+            type: d.type,
+        })),
+    });
+}
+
+export async function enableDiscount({ group, groupPrice, bundleDiscount }: { group: Group; groupPrice: GroupPrice; bundleDiscount: BundleDiscount }) {
+    groupPrice.bundleDiscounts.set(bundleDiscount.id, BundleDiscountGroupPriceSettings.create({
+        name: bundleDiscount.name,
+    }));
+    await group.save();
+}
+
+/**
+ * Create a bundle discount
+ */
+export async function initBundleDiscount({ organizationRegistrationPeriod, discount }: { organizationRegistrationPeriod: OrganizationRegistrationPeriod; discount: Parameters<typeof createBundleDiscount>[0] }) {
+    const bundleDiscount = createBundleDiscount(discount);
+    organizationRegistrationPeriod.settings.bundleDiscounts.push(bundleDiscount);
+    await organizationRegistrationPeriod.save();
+    return bundleDiscount;
+}

package/tests/init/initPayconiq.ts

@@ -0,0 +1,9 @@
+import { PaymentMethod } from '@stamhoofd/structures';
+import { PayconiqMocker } from '../helpers/PayconiqMocker';
+import { Organization } from '@stamhoofd/models';
+
+export async function initPayconiq({ organization }: { organization: Organization }) {
+    organization.meta.registrationPaymentConfiguration.paymentMethods.push(PaymentMethod.Payconiq);
+    organization.privateMeta.payconiqAccounts = [PayconiqMocker.generateTestAccount()];
+    await organization.save();
+}

package/tests/init/initPlatformAdmin.ts

@@ -0,0 +1,13 @@
+import { Token, UserFactory } from '@stamhoofd/models';
+import { PermissionLevel, Permissions } from '@stamhoofd/structures';
+
+export async function initPlatformAdmin() {
+    const admin = await new UserFactory({
+        globalPermissions: Permissions.create({
+            level: PermissionLevel.Full,
+        }),
+    }).create();
+
+    const adminToken = await Token.createToken(admin);
+    return { admin, adminToken };
+}

package/tests/init/initStripe.ts

@@ -0,0 +1,21 @@
+import { Organization } from '@stamhoofd/models';
+import { StripeMocker } from '../helpers/StripeMocker';
+import { PaymentMethod } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+
+export async function initStripe({ organization }: { organization: Organization }) {
+    const stripeMocker = new StripeMocker();
+    const stripeAccount = await stripeMocker.createStripeAccount(organization.id);
+
+    stripeMocker.start();
+
+    TestUtils.scheduleAfterThisTest(() => {
+        stripeMocker.stop();
+    });
+
+    organization.meta.registrationPaymentConfiguration.paymentMethods.push(PaymentMethod.Bancontact, PaymentMethod.CreditCard, PaymentMethod.iDEAL);
+    organization.privateMeta.registrationPaymentConfiguration.stripeAccountId = stripeAccount.id;
+    await organization.save();
+
+    return { stripeMocker, stripeAccount };
+}

package/tests/jest.setup.ts

@@ -11,6 +11,10 @@ import { GlobalHelper } from '../src/helpers/GlobalHelper';
 import * as jose from 'jose';
 import { TestUtils } from '@stamhoofd/test-utils';
 import './toMatchMap';
+import { PayconiqMocker } from './helpers/PayconiqMocker';
+import { BalanceItemService } from '../src/services/BalanceItemService';
+import { QueueHandler } from '@stamhoofd/queues';
+import { SimpleError } from '@simonbackx/simple-errors';
 
 // Set version of saved structures
 Column.setJSONVersion(Version);
@@ -75,6 +79,26 @@ beforeAll(async () => {
 });
 
 afterAll(async () => {
+    // Call twice to also wait on items that are scheduled withing scheduled tasks
+    await BalanceItemService.flushAll();
+    await BalanceItemService.flushAll();
+    QueueHandler.abortAll(
+        new SimpleError({
+            code: 'SHUTDOWN',
+            message: 'Shutting down',
+            statusCode: 503,
+        }),
+    );
+    await QueueHandler.awaitAll();
+    QueueHandler.abortAll(
+        new SimpleError({
+            code: 'SHUTDOWN',
+            message: 'Shutting down',
+            statusCode: 503,
+        }),
+    );
+    await QueueHandler.awaitAll();
+
     // Wait for email queue etc
     while (Email.currentQueue.length > 0) {
         console.info('Emails still in queue. Waiting...');
@@ -83,5 +107,10 @@ afterAll(async () => {
     await Database.end();
 });
 
+afterEach(async () => {
+    await QueueHandler.awaitAll();
+});
+
 TestUtils.setup();
 EmailMocker.infect();
+PayconiqMocker.infect();

package/src/seeds-temporary/1736266448-recall-balance-item-price-paid.ts

@@ -1,70 +0,0 @@
-import { Migration } from '@simonbackx/simple-database';
-import { logger } from '@simonbackx/simple-logging';
-import { BalanceItem, BalanceItemPayment, Organization, Payment } from '@stamhoofd/models';
-import { QueueHandler } from '@stamhoofd/queues';
-import { AuditLogSource, PaymentStatus } from '@stamhoofd/structures';
-import { AuditLogService } from '../services/AuditLogService';
-import { BalanceItemPaymentService } from '../services/BalanceItemPaymentService';
-
-export default new Migration(async () => {
-    if (STAMHOOFD.environment == 'test') {
-        console.log('skipped in tests');
-        return;
-    }
-
-    process.stdout.write('\n');
-    let c = 0;
-
-    await logger.setContext({ tags: ['silent-seed', 'seed'] }, async () => {
-        const q = Payment.select()
-            .where('status', PaymentStatus.Succeeded)
-            .where('createdAt', '>=', new Date('2024-12-12'))
-            .limit(100);
-        for await (const payment of q.all()) {
-            await fix(payment);
-
-            c += 1;
-
-            if (c % 1000 === 0) {
-                process.stdout.write('.');
-            }
-        }
-    });
-
-    console.log('Updated ' + c + ' payments');
-
-    // Do something here
-    return Promise.resolve();
-});
-
-async function fix(payment: Payment) {
-    if (payment.status !== PaymentStatus.Succeeded) {
-        return;
-    }
-
-    if (!payment.organizationId) {
-        return;
-    }
-
-    const organization = await Organization.getByID(payment.organizationId);
-
-    if (!organization) {
-        return;
-    }
-
-    await AuditLogService.setContext({ fallbackUserId: payment.payingUserId, source: AuditLogSource.Payment, fallbackOrganizationId: payment.organizationId }, async () => {
-        // Prevent concurrency issues
-        await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
-            const unloaded = (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment));
-            const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
-                unloaded,
-            );
-
-            for (const balanceItemPayment of balanceItemPayments) {
-                await BalanceItemPaymentService.markPaidRepeated(balanceItemPayment, organization);
-            }
-
-            await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-        });
-    });
-}