@stamhoofd/backend 2.121.0 → 2.122.0

package/src/helpers/BalanceItemRelationsBackfiller.test.ts

@@ -0,0 +1,174 @@
+import type { Organization, RegistrationPeriod, Webshop } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemFactory, GroupFactory, MemberFactory, OrganizationFactory, OrganizationRegistrationPeriodFactory, Order, RegistrationFactory, RegistrationPeriodFactory, WebshopFactory } from '@stamhoofd/models';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType, OrderData, ReduceablePrice, TranslatedString } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { v4 as uuidv4 } from 'uuid';
+import { backfillBalanceItemRelations } from './BalanceItemRelationsBackfiller.js';
+
+describe('helper.BalanceItemRelationsBackfiller', () => {
+    let period: RegistrationPeriod;
+
+    beforeAll(async () => {
+        period = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1),
+            endDate: new Date(2030, 11, 31),
+        }).create();
+    });
+
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    async function createOrder(organization: Organization, webshop: Webshop) {
+        const order = new Order();
+        order.organizationId = organization.id;
+        order.webshopId = webshop.id;
+        order.data = OrderData.create({});
+        await order.save();
+        return order;
+    }
+
+    it('fills member, group and group price relations for registration balance items', async () => {
+        const organization = await new OrganizationFactory({ period }).create();
+        await new OrganizationRegistrationPeriodFactory({ organization, period }).create();
+
+        const member = await new MemberFactory({ organization, firstName: 'John', lastName: 'Doe' }).create();
+        const group = await new GroupFactory({ organization, period }).create();
+        const registration = await new RegistrationFactory({ member, group }).create();
+
+        const balanceItem = await new BalanceItemFactory({
+            organizationId: organization.id,
+            memberId: member.id,
+            registrationId: registration.id,
+            type: BalanceItemType.Registration,
+            amount: 1,
+            unitPrice: 25_00,
+        }).create();
+
+        expect(balanceItem.relations.size).toBe(0);
+
+        await backfillBalanceItemRelations();
+
+        const updated = await BalanceItem.getByID(balanceItem.id);
+        expect(updated?.relations.get(BalanceItemRelationType.Member)).toMatchObject({ id: member.id });
+        expect(updated?.relations.get(BalanceItemRelationType.Member)?.name.toString()).toBe('John Doe');
+        expect(updated?.relations.get(BalanceItemRelationType.Group)).toMatchObject({ id: group.id });
+        // Only one price configured, so no group price relation
+        expect(updated?.relations.has(BalanceItemRelationType.GroupPrice)).toBe(false);
+    });
+
+    it('fills the group price relation when the group has multiple prices', async () => {
+        const organization = await new OrganizationFactory({ period }).create();
+        await new OrganizationRegistrationPeriodFactory({ organization, period }).create();
+
+        const member = await new MemberFactory({ organization }).create();
+        const group = await new GroupFactory({ organization, period }).create();
+
+        // Add a second price so the relation should be filled
+        group.settings.prices.push(group.settings.prices[0].clone());
+        group.settings.prices[1].id = uuidv4();
+        group.settings.prices[1].name = new TranslatedString('Late price');
+        group.settings.prices[1].price = ReduceablePrice.create({ price: 30_00 });
+        await group.save();
+
+        const registration = await new RegistrationFactory({ member, group, groupPrice: group.settings.prices[1] }).create();
+
+        const balanceItem = await new BalanceItemFactory({
+            organizationId: organization.id,
+            memberId: member.id,
+            registrationId: registration.id,
+            type: BalanceItemType.Registration,
+            amount: 1,
+            unitPrice: 30_00,
+        }).create();
+
+        await backfillBalanceItemRelations();
+
+        const updated = await BalanceItem.getByID(balanceItem.id);
+        expect(updated?.relations.get(BalanceItemRelationType.GroupPrice)).toMatchObject({ id: group.settings.prices[1].id });
+    });
+
+    it('copies the registration period dates onto the balance item', async () => {
+        const organization = await new OrganizationFactory({ period }).create();
+        await new OrganizationRegistrationPeriodFactory({ organization, period }).create();
+
+        const member = await new MemberFactory({ organization }).create();
+        const group = await new GroupFactory({ organization, period }).create();
+        const registration = await new RegistrationFactory({ member, group }).create();
+
+        const startDate = new Date(2024, 7, 1);
+        const endDate = new Date(2025, 6, 31);
+        registration.startDate = startDate;
+        registration.endDate = endDate;
+        await registration.save();
+
+        const balanceItem = await new BalanceItemFactory({
+            organizationId: organization.id,
+            memberId: member.id,
+            registrationId: registration.id,
+            type: BalanceItemType.Registration,
+            amount: 1,
+            unitPrice: 25_00,
+        }).create();
+
+        await backfillBalanceItemRelations();
+
+        const updated = await BalanceItem.getByID(balanceItem.id);
+        expect(updated?.startDate?.getTime()).toBe(startDate.getTime());
+        expect(updated?.endDate?.getTime()).toBe(endDate.getTime());
+    });
+
+    it('fills the webshop relation for order balance items', async () => {
+        const organization = await new OrganizationFactory({ period }).create();
+        const webshop = await new WebshopFactory({ organizationId: organization.id, name: 'My webshop' }).create();
+        const order = await createOrder(organization, webshop);
+
+        const balanceItem = await new BalanceItemFactory({
+            organizationId: organization.id,
+            orderId: order.id,
+            type: BalanceItemType.Order,
+            amount: 1,
+            unitPrice: 12_00,
+        }).create();
+
+        expect(balanceItem.relations.size).toBe(0);
+
+        await backfillBalanceItemRelations();
+
+        const updated = await BalanceItem.getByID(balanceItem.id);
+        expect(updated?.relations.get(BalanceItemRelationType.Webshop)).toMatchObject({ id: webshop.id });
+        expect(updated?.relations.get(BalanceItemRelationType.Webshop)?.name.toString()).toBe('My webshop');
+    });
+
+    it('does not overwrite existing relations', async () => {
+        const organization = await new OrganizationFactory({ period }).create();
+        await new OrganizationRegistrationPeriodFactory({ organization, period }).create();
+
+        const member = await new MemberFactory({ organization }).create();
+        const group = await new GroupFactory({ organization, period }).create();
+        const registration = await new RegistrationFactory({ member, group }).create();
+
+        const existingRelations = new Map([
+            [
+                BalanceItemRelationType.Member,
+                BalanceItemRelation.create({ id: member.id, name: new TranslatedString('Custom name') }),
+            ],
+        ]);
+
+        const balanceItem = await new BalanceItemFactory({
+            organizationId: organization.id,
+            memberId: member.id,
+            registrationId: registration.id,
+            type: BalanceItemType.Registration,
+            amount: 1,
+            unitPrice: 25_00,
+            relations: existingRelations,
+        }).create();
+
+        await backfillBalanceItemRelations();
+
+        const updated = await BalanceItem.getByID(balanceItem.id);
+        expect(updated?.relations.size).toBe(1);
+        expect(updated?.relations.get(BalanceItemRelationType.Member)?.name.toString()).toBe('Custom name');
+    });
+});

package/src/helpers/BalanceItemRelationsBackfiller.ts

@@ -0,0 +1,163 @@
+import { BalanceItem, Group, Member, Order, Registration, Webshop } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType, TranslatedString } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { SeedTools } from './SeedTools.js';
+
+/**
+ * Backfills the `relations` (and registration `startDate`/`endDate`) of legacy v1 balance items.
+ *
+ * V1 balance items were created without relations, so the frontend cannot show the member name, the
+ * registration group, the working year or the webshop name (it falls back to "Onbekende
+ * inschrijvingsgroep" / "Onbekende webshop"). We reconstruct that data from the linked registration or
+ * order.
+ *
+ * Only balance items that still have empty relations are touched, so the migration is idempotent and
+ * never overwrites relations that were already set by the current flows.
+ */
+
+/**
+ * Build the relations for a registration balance item, mirroring RegisterMembersEndpoint.
+ * Returns null when the linked registration/group/member can no longer be resolved.
+ */
+function buildRegistrationRelations(registration: Registration, group: Group, member: Member | undefined): Map<BalanceItemRelationType, BalanceItemRelation> {
+    const relations = new Map<BalanceItemRelationType, BalanceItemRelation>();
+
+    if (member) {
+        relations.set(BalanceItemRelationType.Member, BalanceItemRelation.create({
+            id: member.id,
+            name: new TranslatedString(member.details.name),
+        }));
+    }
+
+    relations.set(BalanceItemRelationType.Group, BalanceItemRelation.create({
+        id: group.id,
+        name: group.settings.name,
+    }));
+
+    // Mirror RegisterMembersEndpoint: only add the group price relation when there are multiple prices.
+    if (group.settings.prices.length > 1 && registration.groupPrice) {
+        relations.set(BalanceItemRelationType.GroupPrice, BalanceItemRelation.create({
+            id: registration.groupPrice.id,
+            name: registration.groupPrice.name,
+        }));
+    }
+
+    return relations;
+}
+
+async function backfillRegistrationBalanceItems(): Promise<number> {
+    let updated = 0;
+
+    await SeedTools.loopBatched({
+        batchSize: 100,
+        query: BalanceItem.select()
+            .whereNot('registrationId', null)
+            .where(SQL.jsonLength(SQL.column('relations'), '$.value'), 0),
+        batchAction: async (items: BalanceItem[]) => {
+            const registrationIds = Formatter.uniqueArray(items.map(i => i.registrationId!).filter(id => !!id));
+            const registrations = await Registration.getByIDs(...registrationIds);
+            const registrationMap = new Map(registrations.map(r => [r.id, r]));
+
+            const groups = await Group.getByIDs(...Formatter.uniqueArray(registrations.map(r => r.groupId)));
+            const groupMap = new Map(groups.map(g => [g.id, g]));
+
+            const members = await Member.getByIDs(...Formatter.uniqueArray(registrations.map(r => r.memberId)));
+            const memberMap = new Map(members.map(m => [m.id, m]));
+
+            for (const item of items) {
+                // A second safety check: never overwrite existing relations.
+                if (item.relations.size > 0) {
+                    continue;
+                }
+
+                const registration = registrationMap.get(item.registrationId!);
+                if (!registration) {
+                    continue;
+                }
+
+                const group = groupMap.get(registration.groupId);
+                if (!group) {
+                    continue;
+                }
+
+                const member = memberMap.get(registration.memberId);
+
+                item.relations = buildRegistrationRelations(registration, group, member);
+
+                // Reconstruct the period (working year) so the frontend can show it.
+                if (item.startDate === null && registration.startDate) {
+                    item.startDate = registration.startDate;
+                }
+                if (item.endDate === null && registration.endDate) {
+                    item.endDate = registration.endDate;
+                }
+
+                await item.save();
+                updated += 1;
+            }
+        },
+    });
+
+    return updated;
+}
+
+async function backfillOrderBalanceItems(): Promise<number> {
+    let updated = 0;
+
+    await SeedTools.loopBatched({
+        batchSize: 100,
+        query: BalanceItem.select()
+            .where('type', BalanceItemType.Order)
+            .whereNot('orderId', null)
+            .where(SQL.jsonLength(SQL.column('relations'), '$.value'), 0),
+        batchAction: async (items: BalanceItem[]) => {
+            const orderIds = Formatter.uniqueArray(items.map(i => i.orderId!).filter(id => !!id));
+            const orders = await Order.getByIDs(...orderIds);
+            const orderMap = new Map(orders.map(o => [o.id, o]));
+
+            const webshops = await Webshop.getByIDs(...Formatter.uniqueArray(orders.map(o => o.webshopId)));
+            const webshopMap = new Map(webshops.map(w => [w.id, w]));
+
+            for (const item of items) {
+                if (item.relations.size > 0) {
+                    continue;
+                }
+
+                const order = orderMap.get(item.orderId!);
+                if (!order) {
+                    continue;
+                }
+
+                const webshop = webshopMap.get(order.webshopId);
+                if (!webshop) {
+                    continue;
+                }
+
+                item.relations = new Map([
+                    [
+                        BalanceItemRelationType.Webshop,
+                        BalanceItemRelation.create({
+                            id: webshop.id,
+                            name: new TranslatedString(webshop.meta.name),
+                        }),
+                    ],
+                ]);
+
+                await item.save();
+                updated += 1;
+            }
+        },
+    });
+
+    return updated;
+}
+
+export async function backfillBalanceItemRelations(): Promise<{ registrations: number; orders: number }> {
+    const registrations = await backfillRegistrationBalanceItems();
+    const orders = await backfillOrderBalanceItems();
+
+    console.log(`[BalanceItemRelationsBackfiller] Updated ${registrations} registration balance items and ${orders} order balance items`);
+
+    return { registrations, orders };
+}

package/src/helpers/BuckarooHelper.ts

@@ -115,8 +115,7 @@ export class BuckarooHelper {
             const status = this.getStatusFromResponse(response);
 
             return status === PaymentStatus.Pending || status === PaymentStatus.Created || status === PaymentStatus.Succeeded;
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
         return false;
@@ -205,8 +204,7 @@ export class BuckarooHelper {
             await dbPayment.save();
 
             return response['RequiredAction']?.['RedirectURL'] ?? null;
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
             throw new SimpleError({
                 code: 'buckaroo_error',

package/src/helpers/CheckSettlements.ts

@@ -39,8 +39,7 @@ export async function checkAllStripePayouts(checkAll = false) {
                 stripeAccount: account.accountId,
             });
             await checker.checkSettlements(checkAll);
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
     }
@@ -63,8 +62,7 @@ export async function checkSettlements(checkAll = false) {
     const token = STAMHOOFD.MOLLIE_ORGANIZATION_TOKEN;
     if (!token) {
         console.error('Missing mollie organization token');
-    }
-    else {
+    } else {
         await checkMollieSettlementsFor(token, checkAll);
     }
 
@@ -77,19 +75,16 @@ export async function checkSettlements(checkAll = false) {
         for (const token of mollieTokens) {
             if (token.createdAt < new Date(2021, 8 /* september! */, 8)) {
                 console.log('Skipped mollie token that is too old');
-            }
-            else {
+            } else {
                 try {
                     await token.refreshIfNeeded();
                     await checkMollieSettlementsFor(token.accessToken, checkAll);
-                }
-                catch (e) {
+                } catch (e) {
                     console.error(e);
                 }
             }
         }
-    }
-    catch (e) {
+    } catch (e) {
         console.error(e);
     }
 }
@@ -135,22 +130,18 @@ export async function checkMollieSettlementsFor(token: string, checkAll = false)
                             await updateSettlement(token, settlement);
                         }
                     }
-                }
-                else {
+                } else {
                     console.error('Unreadable settlements');
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 console.error(request.data);
                 throw e;
             }
-        }
-        else {
+        } else {
             console.error('Failed to fetch settlements');
             console.error(request.data);
         }
-    }
-    catch (e) {
+    } catch (e) {
         console.error(e);
     }
 }
@@ -199,12 +190,10 @@ async function updateSettlement(token: string, settlement: MollieSettlement, fro
                         console.log('Updated settlement of payment ' + payment.id);
                         console.log(payment.settlement);
                     }
-                }
-                else {
+                } else {
                     console.log('Missing payment ' + mp.paymentId);
                 }
-            }
-            else {
+            } else {
                 // Probably a payment in a different system/platform
                 // console.log("No mollie payment found for id "+mollie.id)
             }
@@ -214,8 +203,7 @@ async function updateSettlement(token: string, settlement: MollieSettlement, fro
         if (request.data._links.next) {
             await updateSettlement(token, settlement, molliePayments[molliePayments.length - 1].id);
         }
-    }
-    else {
+    } else {
         console.error(request.data);
     }
 }

package/src/helpers/Context.ts

@@ -5,7 +5,7 @@ import type { User } from '@stamhoofd/models';
 import { Organization, Platform, RateLimiter, Token } from '@stamhoofd/models';
 import { AsyncLocalStorage } from 'async_hooks';
 
-import type { Decoder} from '@simonbackx/simple-encoding';
+import type { Decoder } from '@simonbackx/simple-encoding';
 import { AutoEncoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { ApiUserRateLimits } from '@stamhoofd/structures';
 import { AdminPermissionChecker } from './AdminPermissionChecker.js';
@@ -156,8 +156,7 @@ export class ContextInstance {
     async setOptionalOrganizationScope(options?: { willAuthenticate?: boolean }) {
         try {
             return await this.setOrganizationScope(options);
-        }
-        catch (e) {
+        } catch (e) {
             if (isSimpleError(e) && e.hasCode('invalid_host')) {
                 return null;
             }
@@ -199,11 +198,16 @@ export class ContextInstance {
         return organization;
     }
 
+    async setManualOrganizationScope(organization: Organization) {
+        this.organization = organization;
+        this.i18n.switchToLocale({ country: organization.address.country });
+        return organization;
+    }
+
     async optionalAuthenticate({ allowWithoutAccount = false }: { allowWithoutAccount?: boolean } = {}): Promise<{ user?: User }> {
         try {
             return await this.authenticate({ allowWithoutAccount });
-        }
-        catch (e) {
+        } catch (e) {
             if (e.code === 'not_authenticated') {
                 // Do not allow to optional authenticate to inactive organizations
                 if (this.organization && !this.organization.active) {
@@ -226,8 +230,7 @@ export class ContextInstance {
             try {
                 const decoded = await DecodedRequest.fromRequest(this.request, undefined, undefined, AuthorizationPostBody as Decoder<AuthorizationPostBody>);
                 header = decoded.body.header_authorization;
-            }
-            catch (e) {
+            } catch (e) {
                 // Ignore: failed to read from body
             }
         }
@@ -307,8 +310,12 @@ export class ContextInstance {
         );
 
         // Load member of user
-        // todo
+        await this.insecurelyAuthenticateAs(user);
+
+        return { user, token };
+    }
 
+    async insecurelyAuthenticateAs(user: User) {
         this.#auth = new AdminPermissionChecker(user, await Platform.getSharedPrivateStruct(), this.organization);
 
         if (this.organization && !this.organization.active) {
@@ -322,8 +329,6 @@ export class ContextInstance {
                 });
             }
         }
-
-        return { user, token };
     }
 }
 

package/src/helpers/CookieHelper.ts

@@ -38,8 +38,7 @@ export class CookieHelper {
             response.headers['set-cookie'] = [
                 cookies,
             ];
-        }
-        else {
+        } else {
             if (!Array.isArray(currentCookies)) {
                 currentCookies = [currentCookies.toString()];
                 response.headers['set-cookie'] = currentCookies;

package/src/helpers/EmailResumer.ts

@@ -30,8 +30,7 @@ export async function resumeEmails() {
             await ContextInstance.startForUser(user, organization, async () => {
                 await email.resumeSending();
             });
-        }
-        catch (e) {
+        } catch (e) {
             console.error('Error resuming email', email.id, e);
         }
     }

package/src/helpers/FileCache.ts

@@ -111,7 +111,7 @@ export class FileCache {
             throw new SimpleError({
                 code: 'invalid_file',
                 message: 'Invalid file',
-                human: $t(`%Fn`),
+                human: $t(`%Fm`),
                 statusCode: 400,
             });
         }
@@ -136,8 +136,7 @@ export class FileCache {
         let stat: fs.Stats;
         try {
             stat = await fs.promises.stat(filePath);
-        }
-        catch (e) {
+        } catch (e) {
             if (e.code == 'ENOENT') {
                 throw new SimpleError({
                     code: 'file_expired',

package/src/helpers/FinancialSupportHelper.ts

@@ -3,9 +3,9 @@ import type { FinancialSupportSettings, Organization as OrganizationStruct, Plat
 
 /**
  * Get the financial support settings from the platform if userMode is platform, or from the organization otherwise.
- * @param platform 
+ * @param platform
  * @param getOrganization callback to prevent fetching the organization if not needed
- * @returns 
+ * @returns
  */
 export async function getFinancialSupportSettingsAsync(platform: Platform | PlatformStruct, getOrganization: () => Promise<Organization | OrganizationStruct | null>): Promise<FinancialSupportSettings | null> {
     if (STAMHOOFD.userMode === 'platform') {

package/src/helpers/FlagMomentCleanup.ts

@@ -82,8 +82,7 @@ export class FlagMomentCleanup {
                     ),
                 )
                 .fetch();
-        }
-        else {
+        } else {
             return await MemberResponsibilityRecord.select()
                 .join(SQL.innerJoin(
                     SQL.table(Organization.table))

package/src/helpers/ForwardHandler.ts

@@ -43,8 +43,7 @@ export class ForwardHandler {
                     }
                     model.unsubscribedAll = true;
                     await model.save();
-                }
-                else {
+                } else {
                     console.error('[Unsubscribe] Received an unsubscribe request for unknown ID ' + id + ' from ' + from);
 
                     // Forward
@@ -98,17 +97,14 @@ export class ForwardHandler {
             if (!organizationEmails) {
                 if (STAMHOOFD.environment === 'test') {
                     // ignore
-                }
-                else {
+                } else {
                     console.error('Missing reply emails for organization ' + organization.id);
                 }
                 return doBounce();
-            }
-            else {
+            } else {
                 defaultEmail = organizationEmails;
             }
-        }
-        else {
+        } else {
             return doBounce();
         }
 
@@ -123,8 +119,7 @@ export class ForwardHandler {
             if (body !== -1) {
                 const endTag = parsed.html.indexOf('>', body);
                 html = parsed.html.substring(0, endTag + 1) + '<p><i>' + Formatter.escapeHtml(extraDescription) + '<br><br></i></p>' + parsed.html.substring(endTag + 1);
-            }
-            else {
+            } else {
                 html = '<p><i>' + Formatter.escapeHtml(extraDescription) + '<br><br></i></p>' + parsed.html;
             }
         }

package/src/helpers/GlobalHelper.ts

@@ -9,13 +9,13 @@ export class GlobalHelper {
         await I18n.load();
         this.loadGlobalTranslateFunction();
         await FileSignService.load();
-        
+
         MemberRecordStore.init();
-        
+
         BalanceItemService.listen();
     }
 
-    private static loadGlobalTranslateFunction() {
+    static loadGlobalTranslateFunction() {
         function getI18n() {
             return ContextInstance.optional?.i18n ?? new I18n(I18n.defaultLanguage, STAMHOOFD.fixedCountry ?? I18n.defaultCountry);
         }