@stamhoofd/backend 2.8.0 → 2.13.0

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

@@ -1,91 +1,160 @@
-import { AutoEncoder, Data, DateDecoder, Decoder, EnumDecoder, field, IntegerDecoder, StringDecoder } from "@simonbackx/simple-encoding";
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Organization, Payment } from "@stamhoofd/models";
-import { PaymentGeneral, PaymentMethod, PaymentProvider, PaymentStatus } from "@stamhoofd/structures";
-
-import { AuthenticatedStructures } from "../../../../helpers/AuthenticatedStructures";
-import { Context } from "../../../../helpers/Context";
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Payment } from '@stamhoofd/models';
+import { SQLJsonUnquote, SQL, SQLConcat, SQLFilterDefinitions, SQLOrderBy, SQLOrderByDirection, SQLScalar, SQLSortDefinitions, baseSQLFilterCompilers, compileToSQLFilter, compileToSQLSorter, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler, SQLCast } from "@stamhoofd/sql";
+import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
+import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
-type Body = undefined
-type ResponseBody = PaymentGeneral[]
-
-export class StringArrayDecoder<T> implements Decoder<T[]> {
-    decoder: Decoder<T>;
-
-    constructor(decoder: Decoder<T>) {
-        this.decoder = decoder;
-    }
-
-    decode(data: Data): T[] {
-        const strValue = data.string;
-
-        // Split on comma
-        const parts = strValue.split(",");
-        return parts
-            .map((v, index) => {
-                return data.clone({ 
-                    data: v, 
-                    context: data.context, 
-                    field: data.addToCurrentField(index) 
-                }).decode(this.decoder)
-            });
-    }
+type Query = LimitedFilteredRequest;
+type Body = undefined;
+type ResponseBody = PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>
+
+const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    "id": createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'id')),
+    "price": createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'price')),
+    
+    "balanceItem": createSQLFilterNamespace({
+        ...baseSQLFilterCompilers,
+        id: createSQLColumnFilterCompiler(SQL.column('balance_items', 'id')),
+        description: createSQLColumnFilterCompiler(SQL.column('balance_items', 'description')),
+    })
 }
 
-export class StringNullableDecoder<T> implements Decoder<T | null> {
-    decoder: Decoder<T>;
-
-    constructor(decoder: Decoder<T>) {
-        this.decoder = decoder;
-    }
+const filterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLColumnFilterCompiler('id'),
+    method: createSQLColumnFilterCompiler('method'),
+    status: createSQLColumnFilterCompiler('status'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    createdAt: createSQLColumnFilterCompiler('createdAt'),
+    paidAt: createSQLColumnFilterCompiler('paidAt', {nullable: true}),
+    price: createSQLColumnFilterCompiler('price'),
+    provider: createSQLColumnFilterCompiler('provider', {nullable: true}),
+    customer: createSQLFilterNamespace({
+        ...baseSQLFilterCompilers,
+        email: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('customer'), '$.value.email'),
+            {isJSONValue: true}
+        ),
+        firstName: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('customer'), '$.value.firstName'),
+            {isJSONValue: true}
+        ),
+        lastName: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('customer'), '$.value.lastName'),
+            {isJSONValue: true}
+        ),
+        name: createSQLExpressionFilterCompiler(
+            new SQLCast(
+                new SQLConcat(
+                    new SQLJsonUnquote(SQL.jsonValue(SQL.column('customer'), '$.value.firstName')),
+                    new SQLScalar(' '),
+                    new SQLJsonUnquote(SQL.jsonValue(SQL.column('customer'), '$.value.lastName')),
+                ),
+                'CHAR'
+            )
+        ),
+        company: createSQLFilterNamespace({
+            name: createSQLExpressionFilterCompiler(
+                SQL.jsonValue(SQL.column('customer'), '$.value.company.name'),
+                {isJSONValue: true}
+            ),
+            VATNumber: createSQLExpressionFilterCompiler(
+                SQL.jsonValue(SQL.column('customer'), '$.value.company.VATNumber'),
+                {isJSONValue: true}
+            ),
+            companyNumber: createSQLExpressionFilterCompiler(
+                SQL.jsonValue(SQL.column('customer'), '$.value.company.companyNumber'),
+                {isJSONValue: true}
+            ),
+            administrationEmail: createSQLExpressionFilterCompiler(
+                SQL.jsonValue(SQL.column('customer'), '$.value.company.administrationEmail'),
+                {isJSONValue: true}
+            ),
+        })
+    }),
+    balanceItemPayments: createSQLRelationFilterCompiler(
+        SQL.select()
+        .from(
+            SQL.table('balance_item_payments')
+        ).join(
+            SQL.join(
+                SQL.table('balance_items')
+            ).where(
+                SQL.column('balance_items', 'id'),
+                SQL.column('balance_item_payments', 'balanceItemId')
+            )
+        ).where(
+            SQL.column('paymentId'),
+            SQL.column('payments', 'id')
+        ),
+        balanceItemPaymentsCompilers
+    ),
+}
 
-    decode(data: Data): T | null {
-        if (data.value === 'null') {
-            return null;
+const sorters: SQLSortDefinitions<Payment> = {
+    'id': {
+        getValue(a) {
+            return a.id
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction
+            })
+        }
+    },
+    'createdAt': {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt, 'UTC')
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction
+            })
+        }
+    },
+    'paidAt': {
+        getValue(a) {
+            return a.paidAt !== null ? Formatter.dateTimeIso(a.paidAt, 'UTC') : null
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('paidAt'),
+                direction
+            })
+        }
+    },
+    'price': {
+        getValue(a) {
+            return a.price
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('price'),
+                direction
+            })
         }
-
-        return data.decode(this.decoder);
     }
 }
 
-
-class Query extends AutoEncoder {
-    /**
-     * Usage in combination with paidSince is special!
-     */
-    @field({ decoder: StringDecoder, optional: true })
-    afterId?: string
-
-    /**
-     * Return all payments that were paid after (and including) this date. 
-     * Only returns orders **equal** to this date if afterId is not provided or if the id of those payments is also higher.
-     */
-    @field({ decoder: DateDecoder, optional: true })
-    paidSince?: Date
-
-    @field({ decoder: DateDecoder, optional: true })
-    paidBefore?: Date
-
-    @field({ decoder: IntegerDecoder, optional: true })
-    limit?: number
-
-    @field({ decoder: new StringArrayDecoder(new EnumDecoder(PaymentMethod)), optional: true })
-    methods?: PaymentMethod[]
-
-    @field({ decoder: new StringArrayDecoder(new StringNullableDecoder(new EnumDecoder(PaymentProvider))), optional: true })
-    providers?: (PaymentProvider|null)[]
-}
-
 export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    protected queryDecoder = Query;
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method != "GET") {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/payments", {});
+        const params = Endpoint.parseParameters(request.url, "/payments", {});
 
         if (params) {
             return [true, params as Params];
@@ -93,115 +162,168 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
         return [false];
     }
 
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+    static async buildQuery(q: CountFilteredRequest|LimitedFilteredRequest) {
+        const organization = Context.organization
+        let scopeFilter: StamhoofdFilter|undefined = undefined;
+
+        if (!organization) {
+            throw Context.auth.error()
+        }
 
         if (!await Context.auth.canManagePayments(organization.id)) {
             throw Context.auth.error()
-        } 
+        }
 
-        return new Response(
-            (await this.getPayments(organization, request.query))
-        );
-    }
+        scopeFilter = {
+            organizationId: organization.id
+        };
+        
+        const query = SQL
+            .select()
+            .from(
+                SQL.table('payments')
+            );
+            
+        if (scopeFilter) {
+            query.where(compileToSQLFilter(scopeFilter, filterCompilers))
+        }
+
+        if (q.filter) {
+            query.where(compileToSQLFilter(q.filter, filterCompilers))
+        }
 
-    async getPayments(organization: Organization, query: Query) {
-        const paidSince = query.paidSince ?? new Date(Date.now() - (24 * 60 * 60 * 1000 * 7 ))
-        paidSince.setMilliseconds(0)
-        const payments: Payment[] = []
-
-        if (query.afterId) {
-            // First return all payments with id > afterId and paidAt == paidSince
-            payments.push(...await Payment.where({
-                organizationId: organization.id, 
-                paidAt: {
-                    sign: '=', 
-                    value: paidSince
-                },
-                id: {
-                    sign: '>',
-                    value: query.afterId ?? ""
-                },
-                method: {
-                    sign: 'IN', 
-                    value: query.methods ?? [PaymentMethod.Transfer]
-                },
-                provider: {
-                    sign: 'IN', 
-                    value: query.providers ?? [null]
+        if (q.search) {
+            // todo
+
+            let searchFilter: StamhoofdFilter|null = null
+            searchFilter = {
+                $or: [
+                    {
+                        customer: {
+                            name: {
+                                $contains: q.search
+                            }
+                        }
+                    },
+                    {
+                        customer: {
+                            company: {
+                                name: {
+                                    $contains: q.search
+                                }
+                            }
+                        }
+                    },
+                    {
+                        balanceItemPayments: {
+                            $elemMatch: {
+                                balanceItem: {
+                                    description: {
+                                        $contains: q.search
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            }
+
+            if (q.search.includes('@')) {
+                searchFilter = {
+                    $or: [
+                        {
+                            customer: {
+                                email: {
+                                    $contains: q.search
+                                }
+                            }
+                        },
+                        {
+                            customer: {
+                                company: {
+                                    administrationEmail: {
+                                        $contains: q.search
+                                    }
+                                }
+                            }
+                        },
+                    ]
                 }
-            }, {
-                limit: query.limit ?? undefined,
-                sort: [{
-                    column: "id",
-                    direction: "ASC"
-                }]
-            }));
+            } 
+
+            if (searchFilter) {
+                query.where(compileToSQLFilter(searchFilter, filterCompilers))
+            }
         }
 
-        payments.push(...await Payment.where({
-            organizationId: organization.id, 
-            paidAt: query.paidBefore ? [{
-                sign: query.afterId  ? '>' : '>=', 
-                value: paidSince
-            }, {
-                sign: '<=', 
-                value: query.paidBefore
-            }] : {
-                sign: query.afterId  ? '>' : '>=', 
-                value: paidSince
-            },
-            method: {
-                sign: 'IN', 
-                value: query.methods ?? [PaymentMethod.Transfer]
-            },
-            provider: {
-                sign: 'IN', 
-                value: query.providers ?? [null]
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
             }
-        }, {
-            limit: query.limit ? (query.limit - payments.length) : undefined,
-            sort: [{
-                column: "paidAt",
-                direction: "ASC"
-            }, 
-            {
-                column: "id",
-                direction: "ASC"
-            }]
-        }));
-
-
-        if (!query.paidSince && !query.methods && !query.providers) {
-            // Default behaviour is to return all not-paid transfer payments that are not yet paid
-
-            payments.push(...
-                await Payment.where({
-                    organizationId: organization.id, 
-                    paidAt: null,
-                    method: PaymentMethod.Transfer,
-                    status: {
-                        sign: '!=',
-                        value: PaymentStatus.Failed
-                    }
-                })
-            );
 
-            payments.push(...
-                await Payment.where({
-                    organizationId: organization.id, 
-                    paidAt: null,
-                    updatedAt: {
-                        sign: '>', 
-                        value: new Date(Date.now() - (24 * 60 * 60 * 1000 * 7 ))
-                    },
-                    method: PaymentMethod.Transfer,
-                    status: PaymentStatus.Failed
-                })
-            );
+            query.orderBy(compileToSQLSorter(q.sort, sorters))
+            query.limit(q.limit)
+        }
+       
+        return query
+    }
+
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const query = await this.buildQuery(requestQuery)
+        const data = await query.fetch()
+        
+        const payments = Payment.fromRows(data, 'payments')
+
+        let next: LimitedFilteredRequest|undefined;
+
+        if (payments.length >= requestQuery.limit) {
+            const lastObject = payments[payments.length - 1];
+            const nextFilter = getSortFilter(lastObject, sorters, requestQuery.sort);
+
+            next = new LimitedFilteredRequest({
+                filter: requestQuery.filter,
+                pageFilter: nextFilter,
+                sort: requestQuery.sort,
+                limit: requestQuery.limit,
+                search: requestQuery.search
+            })
+
+            if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
+                console.error('Found infinite loading loop for', requestQuery);
+                next = undefined;
+            }
         }
 
-        return await AuthenticatedStructures.paymentsGeneral(payments, true)
+        return new PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.paymentsGeneral(payments, false),
+            next
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope();
+        await Context.authenticate()
+
+        const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
+
+        if (request.query.limit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit
+            })
+        }
+
+        if (request.query.limit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1'
+            })
+        }
+        
+        return new Response(
+            await GetPaymentsEndpoint.buildData(request.query)
+        );
     }
 }

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

@@ -3,7 +3,7 @@ import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-
 import { SimpleError } from "@simonbackx/simple-errors";
 import { BalanceItem, Member, Order, Registration, User } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { BalanceItemStatus, MemberBalanceItem, PermissionLevel } from "@stamhoofd/structures";
+import { BalanceItemStatus, BalanceItemType, BalanceItemWithPayments, PermissionLevel } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { Context } from '../../../../helpers/Context';
@@ -11,11 +11,11 @@ import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = PatchableArrayAutoEncoder<MemberBalanceItem>
-type ResponseBody = MemberBalanceItem[]
+type Body = PatchableArrayAutoEncoder<BalanceItemWithPayments>
+type ResponseBody = BalanceItemWithPayments[]
 
 export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = new PatchableArrayDecoder(MemberBalanceItem as Decoder<MemberBalanceItem>, MemberBalanceItem.patchType() as Decoder<AutoEncoderPatchType<MemberBalanceItem>>, StringDecoder)
+    bodyDecoder = new PatchableArrayDecoder(BalanceItemWithPayments as Decoder<BalanceItemWithPayments>, BalanceItemWithPayments.patchType() as Decoder<AutoEncoderPatchType<BalanceItemWithPayments>>, StringDecoder)
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method != "PATCH") {
@@ -53,7 +53,10 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
                 // Create a new balance item
                 const model = new BalanceItem();
                 model.description = put.description;
-                model.price = put.price;
+                model.amount = put.amount;
+                model.type = BalanceItemType.Other
+                model.unitPrice = put.unitPrice;
+                model.amount = put.amount;
                 model.organizationId = organization.id;
                 model.createdAt = put.createdAt;
                 model.status = put.status === BalanceItemStatus.Hidden ? BalanceItemStatus.Hidden : BalanceItemStatus.Pending;
@@ -75,19 +78,6 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
                     })
                 }
 
-                if (put.registration) {
-                    const registration = await Registration.getByID(put.registration.id)
-                    if (!registration || registration.memberId !== model.memberId || registration.organizationId !== organization.id) {
-                        throw new SimpleError({
-                            code: 'invalid_field',
-                            message: 'Registration not found',
-                            field: 'registration'
-                        })
-                    }
-                    model.registrationId = registration.id
-                    registrationIds.push(registration.id)
-                }
-
                 await model.save();
                 returnedModels.push(model);
             }
@@ -101,6 +91,15 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
                         message: 'BalanceItem not found'
                     })
                 }
+
+                if (patch.unitPrice !== undefined) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'You cannot change the unit price of a balance item',
+                        human: 'Het is niet mogelijk om de eenheidsprijs van een openstaande schuld te wijzigen. Je kan de openstaande schuld verwijderen en opnieuw aanmaken indien noodzakelijk.'
+                    })
+                }
+
                 // Check permissions
                 if (model.memberId) {
                     // Update old
@@ -123,30 +122,16 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
                     model.createdAt = patch.createdAt
                 }
 
-                if (patch.registration) {
-                    const registration = await Registration.getByID(patch.registration.id)
-                    if (!registration || registration.memberId !== model.memberId || registration.organizationId !== organization.id) {
-                        throw new SimpleError({
-                            code: 'invalid_field',
-                            message: 'Registration not found',
-                            field: 'registration'
-                        })
-                    }
-                    model.registrationId = registration.id
-
-                    // Update new
-                    registrationIds.push(model.registrationId)
-                } else if (patch.registration === null) {
-                    model.registrationId = null
-                }
                 model.description = patch.description ?? model.description;
-                model.price = patch.price ?? model.price;
+                model.unitPrice = patch.unitPrice ?? model.unitPrice;
+                model.amount = patch.amount ?? model.amount;
 
                 if (model.orderId) {
                     // Not allowed to change this
                     const order = await Order.getByID(model.orderId)
                     if (order) {
-                        model.price = order.totalToPay
+                        model.unitPrice = order.totalToPay
+                        model.amount = 1
                     }
                 }
 
@@ -167,7 +152,7 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
         await Registration.updateOutstandingBalance(Formatter.uniqueArray(registrationIds), organization.id)
 
          return new Response(
-            await BalanceItem.getMemberStructure(returnedModels)
+            await BalanceItem.getStructureWithPayments(returnedModels)
         );
     }