@stamhoofd/backend 2.72.0 → 2.73.1

package/src/endpoints/organization/dashboard/documents/GetDocumentsEndpoint.ts

@@ -38,7 +38,7 @@ export class GetDocumentsEndpoint extends Endpoint<Params, Query, Body, Response
         return [false];
     }
 
-    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
         const organization = Context.organization!;
 
         const documentTable: string = Document.table;
@@ -46,25 +46,25 @@ export class GetDocumentsEndpoint extends Endpoint<Params, Query, Body, Response
         const query = SQL
             .select(SQL.wildcard(documentTable))
             .from(SQL.table(documentTable))
-            .where(compileToSQLFilter({
+            .where(await compileToSQLFilter({
                 organizationId: organization.id,
             }, filterCompilers));
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
             const searchFilter: StamhoofdFilter | null = getDocumentSearchFilter(q.search);
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);
@@ -76,7 +76,7 @@ export class GetDocumentsEndpoint extends Endpoint<Params, Query, Body, Response
     }
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = this.buildQuery(requestQuery);
+        const query = await this.buildQuery(requestQuery);
         const data = await query.fetch();
 
         const documents: Document[] = Document.fromRows(data, Document.table);

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -8,9 +8,9 @@ import { Formatter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { BuckarooHelper } from '../../../../helpers/BuckarooHelper';
 import { Context } from '../../../../helpers/Context';
+import { SetupStepUpdater } from '../../../../helpers/SetupStepUpdater';
 import { TagHelper } from '../../../../helpers/TagHelper';
 import { ViesHelper } from '../../../../helpers/ViesHelper';
-import { SetupStepUpdater } from '../../../../helpers/SetupStepUpdater';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -126,6 +126,7 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 organization.privateMeta.privateKey = request.body.privateMeta.privateKey ?? organization.privateMeta.privateKey;
                 organization.privateMeta.featureFlags = patchObject(organization.privateMeta.featureFlags, request.body.privateMeta.featureFlags);
                 organization.privateMeta.balanceNotificationSettings = patchObject(organization.privateMeta.balanceNotificationSettings, request.body.privateMeta.balanceNotificationSettings);
+                organization.privateMeta.recordAnswers = request.body.privateMeta.recordAnswers.applyTo(organization.privateMeta.recordAnswers);
 
                 if (request.body.privateMeta.mollieProfile !== undefined) {
                     organization.privateMeta.mollieProfile = patchObject(organization.privateMeta.mollieProfile, request.body.privateMeta.mollieProfile);

package/src/endpoints/organization/dashboard/payments/GetPaymentsEndpoint.ts

@@ -5,11 +5,11 @@ import { Payment } from '@stamhoofd/models';
 import { SQL, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
 import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, TransferSettings, assertSort, getSortFilter } from '@stamhoofd/structures';
 
+import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 import { paymentFilterCompilers } from '../../../../sql-filters/payments';
 import { paymentSorters } from '../../../../sql-sorters/payments';
-import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
@@ -59,11 +59,11 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             );
 
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
@@ -142,13 +142,13 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             }
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalancesEndpoint.ts

@@ -3,7 +3,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SimpleError } from '@simonbackx/simple-errors';
 import { CachedBalance } from '@stamhoofd/models';
 import { compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
-import { ReceivableBalance as ReceivableBalanceStruct, CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter, ReceivableBalanceType } from '@stamhoofd/structures';
+import { assertSort, CountFilteredRequest, DetailedReceivableBalance, getSortFilter, LimitedFilteredRequest, PaginatedResponse, ReceivableBalance as ReceivableBalanceStruct, StamhoofdFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
@@ -54,23 +54,49 @@ export class GetReceivableBalancesEndpoint extends Endpoint<Params, Query, Body,
             .select();
 
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
+            query.where(await compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
-            throw new SimpleError({
-                code: 'not_implemented',
-                message: 'Zoeken in openstaande bedragen is voorlopig nog niet mogelijk',
-            });
+            let searchFilter: StamhoofdFilter | null = null;
+
+            searchFilter = {
+                $or: [
+                    {
+                        organizations: {
+                            $elemMatch: {
+                                $or: [
+                                    { name: { $contains: q.search } },
+                                    { uri: q.search },
+                                ],
+                            },
+                        },
+                    },
+                    {
+                        members: {
+                            $elemMatch: { name: { $contains: q.search } },
+                        },
+                    },
+                    {
+                        users: {
+                            $elemMatch: { name: { $contains: q.search } },
+                        },
+                    },
+                ],
+            };
+
+            if (searchFilter) {
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
+            }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);
@@ -81,7 +107,7 @@ export class GetReceivableBalancesEndpoint extends Endpoint<Params, Query, Body,
         return query;
     }
 
-    static async buildData(requestQuery: LimitedFilteredRequest) {
+    static async buildDataHelper(requestQuery: LimitedFilteredRequest) {
         const query = await GetReceivableBalancesEndpoint.buildQuery(requestQuery);
         const data = await query.fetch();
 
@@ -107,12 +133,28 @@ export class GetReceivableBalancesEndpoint extends Endpoint<Params, Query, Body,
             }
         }
 
+        return { data, next };
+    }
+
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const { data, next } = await GetReceivableBalancesEndpoint.buildDataHelper(requestQuery);
+
         return new PaginatedResponse<ReceivableBalanceStruct[], LimitedFilteredRequest>({
             results: await AuthenticatedStructures.receivableBalances(data),
             next,
         });
     }
 
+    static async buildDetailedData(requestQuery: LimitedFilteredRequest) {
+        const organization = Context.organization ?? await Context.setOrganizationScope();
+        const { data, next } = await GetReceivableBalancesEndpoint.buildDataHelper(requestQuery);
+
+        return new PaginatedResponse<DetailedReceivableBalance[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.detailedReceivableBalances(organization.id, data),
+            next,
+        });
+    }
+
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.setOrganizationScope();
         await Context.authenticate();

package/src/endpoints/organization/dashboard/webshops/GetWebshopOrdersCountEndpoint.ts

@@ -35,7 +35,7 @@ export class GetWebshopOrdersCountEndpoint extends Endpoint<Params, Query, Body,
             throw Context.auth.error();
         }
 
-        const query = GetWebshopOrdersEndpoint.buildQuery(request.query);
+        const query = await GetWebshopOrdersEndpoint.buildQuery(request.query);
 
         const count = await query
             .count();

package/src/endpoints/organization/dashboard/webshops/GetWebshopOrdersEndpoint.ts

@@ -35,7 +35,7 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
         // todo: filter userId???
         const organization = Context.organization!;
 
@@ -44,7 +44,7 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
         const query = SQL
             .select(SQL.wildcard(ordersTable))
             .from(SQL.table(ordersTable))
-            .where(compileToSQLFilter({
+            .where(await compileToSQLFilter({
                 organizationId: organization.id,
                 number: {
                     $neq: null,
@@ -52,20 +52,20 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
             }, filterCompilers));
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
             const searchFilter: StamhoofdFilter | null = getOrderSearchFilter(q.search, parsePhoneNumber);
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+                query.where(await compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);
@@ -77,7 +77,7 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
     }
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = this.buildQuery(requestQuery);
+        const query = await this.buildQuery(requestQuery);
         const data = await query.fetch();
 
         const orders: Order[] = Order.fromRows(data, Order.table);

package/src/endpoints/organization/dashboard/webshops/GetWebshopTicketsEndpoint.ts

@@ -34,7 +34,7 @@ export class GetWebshopTicketsEndpoint extends Endpoint<Params, Query, Body, Res
         return [false];
     }
 
-    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
         const organization = Context.organization!;
 
         const ticketsTable: string = Ticket.table;
@@ -42,12 +42,12 @@ export class GetWebshopTicketsEndpoint extends Endpoint<Params, Query, Body, Res
         const query = SQL
             .select(SQL.wildcard(ticketsTable))
             .from(SQL.table(ticketsTable))
-            .where(compileToSQLFilter({
+            .where(await Promise.resolve(compileToSQLFilter({
                 organizationId: organization.id,
-            }, filterCompilers));
+            }, filterCompilers)));
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers));
+            query.where(await Promise.resolve(compileToSQLFilter(q.filter, filterCompilers)));
         }
 
         // currently no search supported, probably not needed?
@@ -56,7 +56,7 @@ export class GetWebshopTicketsEndpoint extends Endpoint<Params, Query, Body, Res
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+                query.where(await Promise.resolve(compileToSQLFilter(q.pageFilter, filterCompilers)));
             }
 
             q.sort = assertSort(q.sort, [{ key: 'id' }]);
@@ -68,7 +68,7 @@ export class GetWebshopTicketsEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = this.buildQuery(requestQuery);
+        const query = await this.buildQuery(requestQuery);
         const data = await query.fetch();
 
         const tickets: Ticket[] = Ticket.fromRows(data, Ticket.table);

package/src/excel-loaders/members.ts

@@ -204,6 +204,14 @@ const sheet: XlsxTransformerSheet<PlatformMember, PlatformMember> = {
                 };
             },
         },
+        {
+            id: 'nationalRegisterNumber',
+            name: 'Rijksregisternummer',
+            width: 30,
+            getValue: ({ patchedMember: object }: PlatformMember) => ({
+                value: object.details.nationalRegisterNumber?.toString() ?? '',
+            }),
+        },
 
         ...XlsxTransformerColumnHelper.creatColumnsForParents(),
 

package/src/excel-loaders/receivable-balances.ts

@@ -0,0 +1,294 @@
+import { XlsxBuiltInNumberFormat, XlsxTransformerColumn, XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
+import { BalanceItemRelationType, BalanceItemWithPayments, DetailedReceivableBalance, ExcelExportType, getBalanceItemRelationTypeName, getBalanceItemStatusName, getBalanceItemTypeName, getReceivableBalanceTypeNameNotTranslated, PaginatedResponse, ReceivableBalance } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint';
+import { GetReceivableBalancesEndpoint } from '../endpoints/organization/dashboard/receivable-balances/GetReceivableBalancesEndpoint';
+
+type ReceivableBalanceWithItem = {
+    receivableBalance: DetailedReceivableBalance;
+    balanceItem: BalanceItemWithPayments;
+};
+
+ExportToExcelEndpoint.loaders.set(ExcelExportType.ReceivableBalances, {
+    fetch: async (requestQuery) => {
+        const data = await GetReceivableBalancesEndpoint.buildDetailedData(requestQuery);
+
+        return new PaginatedResponse({
+            ...data,
+        });
+    },
+    sheets: [
+        {
+            id: 'receivableBalances',
+            name: 'Te ontvangen bedragen',
+            columns: getGeneralColumns(),
+        },
+        {
+            id: 'balanceItems',
+            name: 'Lijnen',
+            transform: (data: DetailedReceivableBalance): ReceivableBalanceWithItem[] => data.balanceItems.map(balanceItem => ({
+                receivableBalance: data,
+                balanceItem,
+            })),
+            columns: [
+                ...getBalanceItemColumns(),
+
+                // Repeating columns need to de-transform again
+                ...getGeneralColumns()
+                    .map((c) => {
+                        return {
+                            ...c,
+                            id: `receivableBalance.${c.id}`,
+                            getValue: (object: ReceivableBalanceWithItem) => {
+                                return c.getValue(object.receivableBalance);
+                            },
+                        };
+                    }),
+            ],
+        },
+    ],
+});
+
+function getBalanceItemColumns(): XlsxTransformerColumn<ReceivableBalanceWithItem>[] {
+    return [
+        {
+            id: 'id',
+            name: 'ID',
+            width: 40,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.id,
+                style: {
+                    font: {
+                        bold: true,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'type',
+            name: 'Type',
+            width: 30,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: getBalanceItemTypeName(object.balanceItem.type),
+            }),
+        },
+        {
+            id: 'category',
+            name: 'Categorie',
+            width: 30,
+            getValue: (object: ReceivableBalanceWithItem) => {
+                return {
+                    value: Formatter.capitalizeFirstLetter(object.balanceItem.category),
+                };
+            },
+        },
+        {
+            id: 'description',
+            name: 'Beschrijving',
+            width: 40,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.description,
+            }),
+        },
+        {
+            id: 'amount',
+            name: 'Aantal',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.amount,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Number,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'unitPrice',
+            name: 'Eenheidsprijs',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.unitPrice / 100,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'price',
+            name: 'Prijs',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.price / 100,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'pricePaid',
+            name: 'Betaald bedrag',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.pricePaid / 100,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'pricePending',
+            name: 'In verwerking',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.pricePending / 100,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'priceOpen',
+            name: 'Openstaand bedrag',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.priceOpen / 100,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'createdAt',
+            name: 'Aangemaakt op',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.createdAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'dueAt',
+            name: 'Verschuldigd vanaf',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: object.balanceItem.dueAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateSlash,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'status',
+            name: 'Status',
+            width: 20,
+            getValue: (object: ReceivableBalanceWithItem) => ({
+                value: getBalanceItemStatusName(object.balanceItem.status),
+            }),
+        },
+
+        {
+            match: (id) => {
+                if (id.startsWith('relations.')) {
+                    const type = id.split('.')[1] as BalanceItemRelationType;
+                    if (Object.values(BalanceItemRelationType).includes(type)) {
+                        return [
+                            {
+                                id: `relations.${type}`,
+                                name: getBalanceItemRelationTypeName(type),
+                                width: 35,
+                                getValue: (object: ReceivableBalanceWithItem) => ({
+                                    value: object.balanceItem.relations.get(type)?.name || '',
+                                }),
+                            },
+                        ];
+                    }
+                }
+            },
+        },
+    ];
+}
+
+function getGeneralColumns(): XlsxTransformerConcreteColumn<ReceivableBalance>[] {
+    return [
+        {
+            id: 'id',
+            name: 'ID schuldenaar',
+            width: 40,
+            getValue: (object: ReceivableBalance) => ({
+                value: object.id,
+                style: {
+                    font: {
+                        bold: true,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'name',
+            name: 'Schuldenaar',
+            width: 40,
+            getValue: (object: ReceivableBalance) => ({
+                value: object.object.name,
+            }),
+        },
+        {
+            id: 'uri',
+            name: 'Groepsnummer',
+            width: 16,
+            getValue: (object: ReceivableBalance) => ({
+                value: object.object.uri,
+            }),
+        },
+        {
+            id: 'amountOpen',
+            name: 'Openstaand bedrag',
+            width: 10,
+            getValue: (object: ReceivableBalance) => ({
+                value: object.amountOpen / 100,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'amountPending',
+            name: 'In verwerking',
+            width: 18,
+            getValue: (object: ReceivableBalance) => ({
+                value: object.amountPending / 100,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.Currency2DecimalWithRed,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'objectType',
+            name: 'type',
+            width: 10,
+            getValue: (object: ReceivableBalance) => ({
+                value: getReceivableBalanceTypeNameNotTranslated(object.objectType),
+            }),
+        },
+    ];
+}