@stamhoofd/backend 2.121.0 → 2.122.0

package/src/helpers/PaymentCustomerResolver.test.ts

@@ -0,0 +1,203 @@
+import { BalanceItem, Member, Order, Organization, Payment, User } from '@stamhoofd/models';
+import { Company, MemberDetails, OrderData, Parent, ParentType } from '@stamhoofd/structures';
+import { determinePaymentCustomer } from './PaymentCustomerResolver.js';
+
+describe('PaymentCustomerResolver', () => {
+    function createPayment(props: Partial<Pick<Payment, 'payingUserId' | 'payingOrganizationId'>> = {}): Payment {
+        const payment = new Payment();
+        payment.id = 'payment-1';
+        payment.payingUserId = props.payingUserId ?? null;
+        payment.payingOrganizationId = props.payingOrganizationId ?? null;
+        return payment;
+    }
+
+    function createBalanceItem(props: Partial<Pick<BalanceItem, 'id' | 'memberId' | 'userId' | 'orderId' | 'payingOrganizationId'>>): BalanceItem {
+        const balanceItem = new BalanceItem();
+        balanceItem.id = props.id ?? 'balance-item-1';
+        balanceItem.memberId = props.memberId ?? null;
+        balanceItem.userId = props.userId ?? null;
+        balanceItem.orderId = props.orderId ?? null;
+        balanceItem.payingOrganizationId = props.payingOrganizationId ?? null;
+        return balanceItem;
+    }
+
+    function createUser(props: { id: string; firstName?: string | null; lastName?: string | null; email: string }): User {
+        const user = new User();
+        user.id = props.id;
+        user.firstName = props.firstName ?? null;
+        user.lastName = props.lastName ?? null;
+        user.email = props.email;
+        return user;
+    }
+
+    function createMember(id: string, details: MemberDetails): Member {
+        const member = new Member();
+        member.id = id;
+        member.details = details;
+        return member;
+    }
+
+    const emptyRelations = {
+        balanceItems: [] as BalanceItem[],
+        members: [] as Member[],
+        users: [] as User[],
+        orders: [] as Order[],
+        payingOrganizations: [] as Organization[],
+    };
+
+    function createOrganization(id: string, companyName: string): Organization {
+        const organization = new Organization();
+        organization.id = id;
+        organization.name = companyName;
+        organization.meta = { companies: [Company.create({ name: companyName })] } as any;
+        return organization;
+    }
+
+    it('returns the company of the paying organization', () => {
+        const organization = createOrganization('org-1', 'My Organization');
+
+        const payment = createPayment({ payingOrganizationId: 'org-1' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            payingOrganizations: [organization],
+        });
+
+        expect(customer).not.toBeNull();
+        expect(customer!.company).not.toBeNull();
+        expect(customer!.company!.name).toBe('My Organization');
+    });
+
+    it('returns the paying user', () => {
+        const payment = createPayment({ payingUserId: 'user-1' });
+        const user = createUser({ id: 'user-1', firstName: 'John', lastName: 'Doe', email: 'john@example.com' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            users: [user],
+        });
+
+        expect(customer).not.toBeNull();
+        expect(customer!.firstName).toBe('John');
+        expect(customer!.lastName).toBe('Doe');
+        expect(customer!.email).toBe('john@example.com');
+    });
+
+    it('falls back to a member linked to a balance item', () => {
+        const payment = createPayment();
+        const details = MemberDetails.create({
+            firstName: 'Jane',
+            lastName: 'Smith',
+            email: 'jane@example.com',
+            birthDay: new Date(1990, 0, 1),
+        });
+        const member = createMember('member-1', details);
+        const balanceItem = createBalanceItem({ id: 'b1', memberId: 'member-1' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            balanceItems: [balanceItem],
+            members: [member],
+        });
+
+        expect(customer).not.toBeNull();
+        expect(customer!.firstName).toBe('Jane');
+        expect(customer!.lastName).toBe('Smith');
+        expect(customer!.email).toBe('jane@example.com');
+    });
+
+    it('uses the parent of a young member', () => {
+        const payment = createPayment();
+        const details = MemberDetails.create({
+            firstName: 'Kid',
+            lastName: 'Smith',
+            birthDay: new Date(2020, 0, 1),
+            parents: [
+                Parent.create({
+                    type: ParentType.Mother,
+                    firstName: 'Mom',
+                    lastName: 'Smith',
+                    email: 'mom@example.com',
+                }),
+            ],
+        });
+        const member = createMember('member-1', details);
+        const balanceItem = createBalanceItem({ id: 'b1', memberId: 'member-1' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            balanceItems: [balanceItem],
+            members: [member],
+        });
+
+        expect(customer).not.toBeNull();
+        expect(customer!.firstName).toBe('Mom');
+        expect(customer!.email).toBe('mom@example.com');
+    });
+
+    it('falls back to a user linked to a balance item', () => {
+        const payment = createPayment();
+        const user = createUser({ id: 'user-2', firstName: 'Linked', lastName: 'User', email: 'linked@example.com' });
+        const balanceItem = createBalanceItem({ id: 'b1', userId: 'user-2' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            balanceItems: [balanceItem],
+            users: [user],
+        });
+
+        expect(customer).not.toBeNull();
+        expect(customer!.email).toBe('linked@example.com');
+    });
+
+    it('falls back to the customer of a linked order', () => {
+        const payment = createPayment();
+        const order = new Order();
+        order.id = 'order-1';
+        order.data = OrderData.create({});
+        order.data.customer.firstName = 'Order';
+        order.data.customer.lastName = 'Customer';
+        order.data.customer.email = 'order@example.com';
+        const balanceItem = createBalanceItem({ id: 'b1', orderId: 'order-1' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            balanceItems: [balanceItem],
+            orders: [order],
+        });
+
+        expect(customer).not.toBeNull();
+        expect(customer!.email).toBe('order@example.com');
+    });
+
+    it('prefers the paying organization over a linked member', () => {
+        const organization = createOrganization('org-1', 'My Company');
+
+        const payment = createPayment({ payingOrganizationId: 'org-1' });
+        const details = MemberDetails.create({ firstName: 'Jane', lastName: 'Smith', email: 'jane@example.com', birthDay: new Date(1990, 0, 1) });
+        const member = createMember('member-1', details);
+        const balanceItem = createBalanceItem({ id: 'b1', memberId: 'member-1' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            balanceItems: [balanceItem],
+            members: [member],
+            payingOrganizations: [organization],
+        });
+
+        expect(customer).not.toBeNull();
+        expect(customer!.company!.name).toBe('My Company');
+    });
+
+    it('returns null when no information is available', () => {
+        const payment = createPayment();
+        const balanceItem = createBalanceItem({ id: 'b1' });
+
+        const customer = determinePaymentCustomer(payment, {
+            ...emptyRelations,
+            balanceItems: [balanceItem],
+        });
+
+        expect(customer).toBeNull();
+    });
+});

package/src/helpers/PaymentCustomerResolver.ts

@@ -0,0 +1,144 @@
+import { PaymentCustomer } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import type { BalanceItem, Member, Order, Organization, Payment, User } from '@stamhoofd/models';
+
+/**
+ * The related models that are needed to determine the customer of a payment on a best-effort basis.
+ */
+export type PaymentCustomerRelations = {
+    /**
+     * The balance items linked to the payment (via balance item payments).
+     */
+    balanceItems: BalanceItem[];
+    members: Member[];
+    users: User[];
+    orders: Order[];
+    payingOrganizations: Organization[];
+};
+
+/**
+ * Determines the customer that paid a payment on a best-effort basis.
+ *
+ * In our v1 code payments had no customer. To fill in the missing data we try to figure out who paid
+ * by inspecting the balance items linked to the payment and their related members, users and orders, in
+ * addition to the paying organization/user stored directly on the payment.
+ *
+ * Priority (most reliable source first):
+ * 1. The paying organization (payingOrganizationId) → company customer
+ * 2. The paying user (payingUserId)
+ * 3. A member linked to one of the balance items
+ * 4. A user linked to one of the balance items
+ * 5. The customer of an order linked to one of the balance items
+ *
+ * Returns null when we could not find any usable information.
+ */
+export function determinePaymentCustomer(payment: Payment, relations: PaymentCustomerRelations): PaymentCustomer | null {
+    const { balanceItems, members, users, orders, payingOrganizations } = relations;
+
+    // 1. Paid by an organization
+    if (payment.payingOrganizationId) {
+        const organization = payingOrganizations.find(o => o.id === payment.payingOrganizationId);
+        if (organization) {
+            return PaymentCustomer.create({
+                company: organization.defaultCompanies[0] ?? null,
+            });
+        }
+    }
+
+    // 2. Paid by a known user
+    if (payment.payingUserId) {
+        const user = users.find(u => u.id === payment.payingUserId);
+        const customer = user ? customerFromUser(user) : null;
+        if (customer) {
+            return customer;
+        }
+    }
+
+    // The balance items linked to this payment, used to find members/users/orders.
+    const linkedMemberIds = Formatter.uniqueArray(balanceItems.map(b => b.memberId).filter((id): id is string => id !== null));
+    const linkedUserIds = Formatter.uniqueArray(balanceItems.map(b => b.userId).filter((id): id is string => id !== null));
+    const linkedOrderIds = Formatter.uniqueArray(balanceItems.map(b => b.orderId).filter((id): id is string => id !== null));
+    const linkedPayingOrganizationIds = Formatter.uniqueArray(balanceItems.map(b => b.payingOrganizationId).filter((id): id is string => id !== null));
+
+    // 3. A member linked to the balance items
+    for (const memberId of linkedMemberIds) {
+        const member = members.find(m => m.id === memberId);
+        if (member) {
+            const customer = customerFromMember(member);
+            if (customer) {
+                return customer;
+            }
+        }
+    }
+
+    // 4. A user linked to the balance items
+    for (const userId of linkedUserIds) {
+        const user = users.find(u => u.id === userId);
+        if (user) {
+            const customer = customerFromUser(user);
+            if (customer) {
+                return customer;
+            }
+        }
+    }
+
+    // 5. The customer data of an order linked to the balance items
+    for (const orderId of linkedOrderIds) {
+        const order = orders.find(o => o.id === orderId);
+        if (order && (order.data.customer.email || order.data.customer.name)) {
+            return order.data.customer.toPaymentCustomer();
+        }
+    }
+
+    // 6. A paying organization referenced by a balance item (fallback)
+    for (const organizationId of linkedPayingOrganizationIds) {
+        const organization = payingOrganizations.find(o => o.id === organizationId);
+        if (organization) {
+            return PaymentCustomer.create({
+                company: organization.defaultCompanies[0] ?? null,
+            });
+        }
+    }
+
+    return null;
+}
+
+function customerFromUser(user: User): PaymentCustomer | null {
+    if (!user.firstName && !user.lastName && !user.email) {
+        return null;
+    }
+    return PaymentCustomer.create({
+        firstName: user.firstName,
+        lastName: user.lastName,
+        email: user.email,
+    });
+}
+
+function customerFromMember(member: Member): PaymentCustomer | null {
+    const details = member.details;
+
+    // For young members the parents are the ones who pay, mirroring the logic used elsewhere
+    // (e.g. ReceivableBalance customers).
+    const useParents = (details.calculatedParentsHaveAccess || details.getMemberEmails().length === 0) && details.parents.length > 0;
+
+    if (useParents) {
+        const parent = details.parents[0];
+        return PaymentCustomer.create({
+            firstName: parent.firstName ?? null,
+            lastName: parent.lastName ?? null,
+            email: parent.getEmails()[0] ?? null,
+            phone: parent.phone,
+        });
+    }
+
+    if (!details.firstName && !details.lastName && details.getMemberEmails().length === 0) {
+        return null;
+    }
+
+    return PaymentCustomer.create({
+        firstName: details.firstName ?? null,
+        lastName: details.lastName ?? null,
+        email: details.getMemberEmails()[0] ?? null,
+        phone: details.phone,
+    });
+}

package/src/helpers/PeriodHelper.ts

@@ -85,7 +85,7 @@ export class PeriodHelper {
         if (QueueHandler.isRunning(tag)) {
             throw new SimpleError({
                 code: 'move_period_pending',
-                message: 'Er is al een jaarovergang bezig. Wacht tot deze klaar is.',
+                message: $t('%1cP'),
             });
         }
 
@@ -93,8 +93,7 @@ export class PeriodHelper {
             for await (const organization of Organization.select().all()) {
                 try {
                     await this.moveOrganizationToPeriod(organization, period);
-                }
-                catch (error) {
+                } catch (error) {
                     console.error('Error moving organization to period', organization.id, error);
                 }
             }