@stamhoofd/backend 2.138.2 → 2.139.0

package/src/sql-filters/payments.ts

@@ -1,41 +1,39 @@
 import { Payment } from '@stamhoofd/models';
 import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, createJoinedRelationFilter, SQL, SQLCast, SQLConcat, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
+import type { StamhoofdFilter } from '@stamhoofd/structures';
+import { TransferSettings } from '@stamhoofd/structures';
 import { balanceItemPaymentsCompilers } from './balance-item-payments.js';
 import { organizationFilterCompilers } from './organizations.js';
+import { paymentSettlementFilterCompilers } from './payment-settlement.js';
 
 /**
  * Defines how to filter payments in the database from StamhoofdFilter objects
+ *
+ * All expressions are qualified with the payments table so they keep working when payments is joined
+ * into another query instead of being selected from (see balance-item-payments-root.ts).
  */
 export const paymentFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
+    // method, provider, status and settlement
+    ...paymentSettlementFilterCompilers,
     id: createColumnFilter({
-        expression: SQL.column('id'),
-        type: SQLValueType.String,
-        nullable: false,
-    }),
-    method: createColumnFilter({
-        expression: SQL.column(Payment.table, 'method'),
+        expression: SQL.column(Payment.table, 'id'),
         type: SQLValueType.String,
         nullable: false,
     }),
     type: createColumnFilter({
-        expression: SQL.column('type'),
-        type: SQLValueType.String,
-        nullable: false,
-    }),
-    status: createColumnFilter({
-        expression: SQL.column(Payment.table, 'status'),
+        expression: SQL.column(Payment.table, 'type'),
         type: SQLValueType.String,
         nullable: false,
     }),
     organizationId: createColumnFilter({
-        expression: SQL.column('organizationId'),
+        expression: SQL.column(Payment.table, 'organizationId'),
         type: SQLValueType.String,
         nullable: true,
     }),
     payingOrganizationId: createColumnFilter({
-        expression: SQL.column('payingOrganizationId'),
+        expression: SQL.column(Payment.table, 'payingOrganizationId'),
         type: SQLValueType.String,
         nullable: true,
     }),
@@ -44,22 +42,22 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         organizationFilterCompilers,
     ),
     invoiceId: createColumnFilter({
-        expression: SQL.column('invoiceId'),
+        expression: SQL.column(Payment.table, 'invoiceId'),
         type: SQLValueType.String,
         nullable: true,
     }),
     createdAt: createColumnFilter({
-        expression: SQL.column('createdAt'),
+        expression: SQL.column(Payment.table, 'createdAt'),
         type: SQLValueType.Datetime,
         nullable: false,
     }),
     updatedAt: createColumnFilter({
-        expression: SQL.column('updatedAt'),
+        expression: SQL.column(Payment.table, 'updatedAt'),
         type: SQLValueType.Datetime,
         nullable: false,
     }),
     paidAt: createColumnFilter({
-        expression: SQL.column('paidAt'),
+        expression: SQL.column(Payment.table, 'paidAt'),
         type: SQLValueType.Datetime,
         nullable: true,
     }),
@@ -68,44 +66,73 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Number,
         nullable: false,
     }),
-    provider: createColumnFilter({
-        expression: SQL.column('provider'),
+
+    stripeAccountId: createColumnFilter({
+        expression: SQL.column(Payment.table, 'stripeAccountId'),
         type: SQLValueType.String,
         nullable: true,
     }),
+
+    /**
+     * What a payment rounded away, which belongs to the payment as a whole instead of to one of the
+     * things it paid for (see PaymentBreakdownBuilder.addRounding).
+     */
+    roundingAmount: createColumnFilter({
+        expression: SQL.column(Payment.table, 'roundingAmount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    /**
+     * The account a transfer was made to. Used to narrow a breakdown down to the money that arrived on
+     * one account (see PaymentBreakdown).
+     */
+    transferSettings: {
+        ...baseSQLFilterCompilers,
+        iban: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column(Payment.table, 'transferSettings'), '$.value.iban'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        creditor: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column(Payment.table, 'transferSettings'), '$.value.creditor'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+    },
     transferDescription: createColumnFilter({
         expression: SQL.column(Payment.table, 'transferDescription'),
         type: SQLValueType.String,
         nullable: true,
     }),
     hasInvoice: createColumnFilter({
-        expression: SQL.isNull(SQL.column('invoiceId')),
+        expression: SQL.isNull(SQL.column(Payment.table, 'invoiceId')),
         type: SQLValueType.Boolean,
         nullable: false,
     }),
     customer: {
         ...baseSQLFilterCompilers,
         email: createColumnFilter({
-            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.email'),
+            expression: SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.email'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         firstName: createColumnFilter({
-            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.firstName'),
+            expression: SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.firstName'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         lastName: createColumnFilter({
-            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.lastName'),
+            expression: SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.lastName'),
             type: SQLValueType.JSONString,
             nullable: true,
         }),
         name: createColumnFilter({
             expression: new SQLCast(
                 new SQLConcat(
-                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.firstName')),
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.firstName')),
                     new SQLScalar(' '),
-                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.lastName')),
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.lastName')),
                 ),
                 'CHAR',
             ),
@@ -115,22 +142,22 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         company: {
             ...baseSQLFilterCompilers,
             name: createColumnFilter({
-                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.name'),
+                expression: SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.company.name'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
             VATNumber: createColumnFilter({
-                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.VATNumber'),
+                expression: SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.company.VATNumber'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
             companyNumber: createColumnFilter({
-                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.companyNumber'),
+                expression: SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.company.companyNumber'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
             administrationEmail: createColumnFilter({
-                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.administrationEmail'),
+                expression: SQL.jsonExtract(SQL.column(Payment.table, 'customer'), '$.value.company.administrationEmail'),
                 type: SQLValueType.JSONString,
                 nullable: true,
             }),
@@ -148,9 +175,44 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
                     SQL.column('balance_item_payments', 'balanceItemId'),
                 ),
             ).where(
-                SQL.column('paymentId'),
+                SQL.column('balance_item_payments', 'paymentId'),
                 SQL.column('payments', 'id'),
             ),
         balanceItemPaymentsCompilers,
     ),
 };
+
+/**
+ * What a search term typed in a list of payments selects, as a filter on the payments table.
+ *
+ * Shared by everything that lists or exports payments, so a search always selects the same payments no
+ * matter which of those it went through.
+ */
+export function getPaymentSearchFilter(search: string): StamhoofdFilter {
+    const transferDescription = search.replaceAll('+', '').replaceAll('/', '');
+
+    if (transferDescription.length === '562100153542'.length && !isNaN(parseInt(transferDescription))) {
+        // A structured transfer reference is only ever meant to find that one payment
+        return {
+            transferDescription: TransferSettings.structureOGM(transferDescription),
+        };
+    }
+
+    if (search.includes('@')) {
+        return {
+            $or: [
+                { customer: { email: { $contains: search } } },
+                { customer: { company: { administrationEmail: { $contains: search } } } },
+            ],
+        };
+    }
+
+    return {
+        $or: [
+            { customer: { name: { $contains: search } } },
+            { customer: { company: { name: { $contains: search } } } },
+            { balanceItemPayments: { $elemMatch: { balanceItem: { description: { $contains: search } } } } },
+            { transferDescription: { $contains: search } },
+        ],
+    };
+}

package/src/sql-sorters/balance-item-payments.ts

@@ -0,0 +1,32 @@
+import type { BalanceItemPayment } from '@stamhoofd/models';
+import type { SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { SQL, SQLOrderBy } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+
+export const balanceItemPaymentSorters: SQLSortDefinitions<BalanceItemPayment> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY! See balanceItemSorters for why sorting on anything that is
+    // not 1:1 with a column breaks pagination.
+
+    id: {
+        getValue(a) {
+            return a.id;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('balance_item_payments', 'id'),
+                direction,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('balance_item_payments', 'createdAt'),
+                direction,
+            });
+        },
+    },
+};

package/tests/helpers/ExportSlice.ts

@@ -0,0 +1,71 @@
+import { Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { Organization, User } from '@stamhoofd/models';
+import { Token } from '@stamhoofd/models';
+import type { StamhoofdFilter } from '@stamhoofd/structures';
+import { ExcelExportType, LimitedFilteredRequest, SortItemDirection } from '@stamhoofd/structures';
+import { ExportToExcelEndpoint } from '../../src/endpoints/global/files/ExportToExcelEndpoint.js';
+import { Context } from '../../src/helpers/Context.js';
+import { testServer } from './TestServer.js';
+
+// Registers the balance item payment export, which is what a row that holds a part of its objects is
+// written out with
+import '../../src/excel-loaders/balance-item-payments.js';
+
+/**
+ * Reads what the balance item payment export of a filter comes down to, from inside a request so it
+ * runs in the same scope an export runs in.
+ */
+class ExportSliceEndpoint extends Endpoint<Record<string, never>, undefined, undefined, undefined> {
+    result = { count: 0, price: 0 };
+
+    constructor(private readonly sliceFilter: StamhoofdFilter, private readonly search: string | null) {
+        super();
+    }
+
+    protected doesMatch(): [true, Record<string, never>] {
+        return [true, {}];
+    }
+
+    async handle() {
+        await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        const loader = ExportToExcelEndpoint.loaders.get(ExcelExportType.BalanceItemPayments)!;
+        const data = await loader.fetch(new LimitedFilteredRequest({
+            filter: this.sliceFilter,
+            search: this.search,
+            limit: 100,
+            sort: [{ key: 'id', order: SortItemDirection.ASC }],
+        }));
+
+        // Only the first page is added up, so a fixture that outgrows it would silently assert too little
+        expect(data.next).toBeUndefined();
+
+        const rows = data.results as { balanceItemPayment: { price: number } }[];
+
+        this.result = {
+            count: rows.length,
+            price: rows.reduce((total, row) => total + row.balanceItemPayment.price, 0),
+        };
+
+        return new Response(undefined);
+    }
+}
+
+/**
+ * How many balance item payments a filter selects, and what they are worth together.
+ */
+export async function exportSlice({ organization, user, filter, search = null }: { organization: Organization; user: User; filter: StamhoofdFilter; search?: string | null }) {
+    const token = await Token.createToken(user);
+
+    const request = Request.get({
+        path: '/exports/balance-item-payments',
+        host: organization.getApiHost(),
+        headers: { authorization: 'Bearer ' + token.accessToken },
+    });
+
+    const endpoint = new ExportSliceEndpoint(filter, search);
+    await testServer.test(endpoint, request);
+
+    return endpoint.result;
+}