@stamhoofd/backend 2.39.0 → 2.40.0

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

@@ -1,9 +1,8 @@
-/* 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 { SQL, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
+import { SQL, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
 import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
@@ -14,20 +13,20 @@ import { paymentSorters } from '../../../../sql-sorters/payments';
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>
+type ResponseBody = PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>;
 
-const filterCompilers = paymentFilterCompilers
-const sorters = paymentSorters
+const filterCompilers = paymentFilterCompilers;
+const sorters = paymentSorters;
 
 export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/payments", {});
+        const params = Endpoint.parseParameters(request.url, '/payments', {});
 
         if (params) {
             return [true, params as Params];
@@ -35,71 +34,71 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
         return [false];
     }
 
-    static async buildQuery(q: CountFilteredRequest|LimitedFilteredRequest) {
-        const organization = Context.organization
-        let scopeFilter: StamhoofdFilter|undefined = undefined;
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization;
+        let scopeFilter: StamhoofdFilter | undefined = undefined;
 
         if (!organization) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         if (!await Context.auth.canManagePayments(organization.id)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         scopeFilter = {
-            organizationId: organization.id
+            organizationId: organization.id,
         };
-        
+
         const query = SQL
             .select()
             .from(
-                SQL.table('payments')
+                SQL.table('payments'),
             );
-            
+
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers))
+            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers))
+            query.where(compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
             // todo
 
-            let searchFilter: StamhoofdFilter|null = null
+            let searchFilter: StamhoofdFilter | null = null;
             searchFilter = {
                 $or: [
                     {
                         customer: {
                             name: {
-                                $contains: q.search
-                            }
-                        }
+                                $contains: q.search,
+                            },
+                        },
                     },
                     {
                         customer: {
                             company: {
                                 name: {
-                                    $contains: q.search
-                                }
-                            }
-                        }
+                                    $contains: q.search,
+                                },
+                            },
+                        },
                     },
                     {
                         balanceItemPayments: {
                             $elemMatch: {
                                 balanceItem: {
                                     description: {
-                                        $contains: q.search
-                                    }
-                                }
-                            }
-                        }
-                    }
-                ]
-            }
+                                        $contains: q.search,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                ],
+            };
 
             if (q.search.includes('@')) {
                 searchFilter = {
@@ -107,48 +106,48 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                         {
                             customer: {
                                 email: {
-                                    $contains: q.search
-                                }
-                            }
+                                    $contains: q.search,
+                                },
+                            },
                         },
                         {
                             customer: {
                                 company: {
                                     administrationEmail: {
-                                        $contains: q.search
-                                    }
-                                }
-                            }
+                                        $contains: q.search,
+                                    },
+                                },
+                            },
                         },
-                    ]
-                }
-            } 
+                    ],
+                };
+            }
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers))
+                query.where(compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
-            q.sort = assertSort(q.sort, [{key: 'id'}])
-            query.orderBy(compileToSQLSorter(q.sort, sorters))
-            query.limit(q.limit)
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            query.orderBy(compileToSQLSorter(q.sort, sorters));
+            query.limit(q.limit);
         }
-       
-        return query
+
+        return query;
     }
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = await this.buildQuery(requestQuery)
-        const data = await query.fetch()
-        
-        const payments = Payment.fromRows(data, 'payments')
+        const query = await this.buildQuery(requestQuery);
+        const data = await query.fetch();
 
-        let next: LimitedFilteredRequest|undefined;
+        const payments = Payment.fromRows(data, 'payments');
+
+        let next: LimitedFilteredRequest | undefined;
 
         if (payments.length >= requestQuery.limit) {
             const lastObject = payments[payments.length - 1];
@@ -159,8 +158,8 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 pageFilter: nextFilter,
                 sort: requestQuery.sort,
                 limit: requestQuery.limit,
-                search: requestQuery.search
-            })
+                search: requestQuery.search,
+            });
 
             if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
                 console.error('Found infinite loading loop for', requestQuery);
@@ -170,13 +169,13 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
 
         return new PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>({
             results: await AuthenticatedStructures.paymentsGeneral(payments, true),
-            next
+            next,
         });
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
 
@@ -184,20 +183,20 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
-                message: 'Limit can not be more than ' + maxLimit
-            })
+                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'
-            })
+                message: 'Limit can not be less than 1',
+            });
         }
-        
+
         return new Response(
-            await GetPaymentsEndpoint.buildData(request.query)
+            await GetPaymentsEndpoint.buildData(request.query),
         );
     }
 }

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

@@ -1,27 +1,26 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { BalanceItem, Member, Order, User } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { BalanceItemStatus, BalanceItemType, BalanceItemWithPayments, PermissionLevel } from "@stamhoofd/structures";
+import { BalanceItemStatus, BalanceItemType, BalanceItemWithPayments, PermissionLevel } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
 
-
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = PatchableArrayAutoEncoder<BalanceItemWithPayments>
-type ResponseBody = BalanceItemWithPayments[]
+type Body = PatchableArrayAutoEncoder<BalanceItemWithPayments>;
+type ResponseBody = BalanceItemWithPayments[];
 
 export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = new PatchableArrayDecoder(BalanceItemWithPayments as Decoder<BalanceItemWithPayments>, BalanceItemWithPayments.patchType() as Decoder<AutoEncoderPatchType<BalanceItemWithPayments>>, 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") {
+        if (request.method !== 'PATCH') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization/balance", {});
+        const params = Endpoint.parseParameters(request.url, '/organization/balance', {});
 
         if (params) {
             return [true, params as Params];
@@ -31,30 +30,30 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!await Context.auth.hasSomeAccess(organization.id)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         if (request.body.changes.length == 0) {
             return new Response([]);
         }
 
-        const returnedModels: BalanceItem[] = []
-        const updateOutstandingBalance: BalanceItem[] = []
+        const returnedModels: BalanceItem[] = [];
+        const updateOutstandingBalance: BalanceItem[] = [];
 
         // Keep track of updates
-        const memberIds: string[] = []
-        const registrationIds: string[] = []
+        const memberIds: string[] = [];
+        const registrationIds: string[] = [];
 
-        await QueueHandler.schedule("balance-item-update/"+organization.id, async () => {
-            for (const {put} of request.body.getPuts()) {
+        await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+            for (const { put } of request.body.getPuts()) {
                 // Create a new balance item
                 const model = new BalanceItem();
                 model.description = put.description;
                 model.amount = put.amount;
-                model.type = BalanceItemType.Other
+                model.type = BalanceItemType.Other;
                 model.unitPrice = put.unitPrice;
                 model.amount = put.amount;
                 model.organizationId = organization.id;
@@ -67,61 +66,61 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
 
                 if (put.memberId) {
                     model.memberId = (await this.validateMemberId(put.memberId)).id;
-                    memberIds.push(model.memberId)
+                    memberIds.push(model.memberId);
                 }
 
                 if (!model.userId && !model.memberId) {
                     throw new SimpleError({
                         code: 'invalid_field',
                         message: 'No user or member provided',
-                        field: 'userId'
-                    })
+                        field: 'userId',
+                    });
                 }
 
                 await model.save();
                 returnedModels.push(model);
 
-                updateOutstandingBalance.push(model)
+                updateOutstandingBalance.push(model);
             }
 
             for (const patch of request.body.getPatches()) {
                 // Create a new balance item
-                const model = await BalanceItem.getByID(patch.id)
+                const model = await BalanceItem.getByID(patch.id);
                 if (!model || !(await Context.auth.canAccessBalanceItems([model], PermissionLevel.Write))) {
                     throw new SimpleError({
                         code: 'invalid_field',
-                        message: 'BalanceItem not found'
-                    })
+                        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.'
-                    })
+                        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
-                    memberIds.push(model.memberId)
+                    memberIds.push(model.memberId);
                 }
 
                 if (patch.memberId) {
                     model.memberId = (await this.validateMemberId(patch.memberId)).id;
 
                     // Update new
-                    memberIds.push(model.memberId)
+                    memberIds.push(model.memberId);
                 }
 
                 if (model.registrationId) {
                     // Update old
-                    registrationIds.push(model.registrationId)
+                    registrationIds.push(model.registrationId);
                 }
-                
+
                 if (patch.createdAt) {
-                    model.createdAt = patch.createdAt
+                    model.createdAt = patch.createdAt;
                 }
 
                 model.description = patch.description ?? model.description;
@@ -130,47 +129,48 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
 
                 if (model.orderId) {
                     // Not allowed to change this
-                    const order = await Order.getByID(model.orderId)
+                    const order = await Order.getByID(model.orderId);
                     if (order) {
-                        model.unitPrice = order.totalToPay
-                        model.amount = 1
+                        model.unitPrice = order.totalToPay;
+                        model.amount = 1;
                     }
                 }
 
                 if (patch.status && patch.status === BalanceItemStatus.Hidden) {
                     if (model.pricePaid === 0) {
-                        model.status = BalanceItemStatus.Hidden
+                        model.status = BalanceItemStatus.Hidden;
                     }
-                } else if (patch.status) {
+                }
+                else if (patch.status) {
                     model.status = model.pricePaid >= model.price ? BalanceItemStatus.Paid : BalanceItemStatus.Pending;
                 }
 
                 await model.save();
                 returnedModels.push(model);
-                
+
                 if (patch.unitPrice || patch.amount || patch.status) {
-                    updateOutstandingBalance.push(model)
+                    updateOutstandingBalance.push(model);
                 }
             }
         });
 
-        await BalanceItem.updateOutstanding(updateOutstandingBalance)
+        await BalanceItem.updateOutstanding(updateOutstandingBalance);
 
-         return new Response(
-            await BalanceItem.getStructureWithPayments(returnedModels)
+        return new Response(
+            await BalanceItem.getStructureWithPayments(returnedModels),
         );
     }
 
     async validateMemberId(memberId: string) {
-        const member = (await Member.getWithRegistrations(memberId))
+        const member = (await Member.getWithRegistrations(memberId));
 
         if (!member || !(await Context.auth.canLinkBalanceItemToMember(member))) {
             throw new SimpleError({
                 code: 'permission_denied',
                 message: 'No permission to link balanace items to this member',
                 human: 'Je hebt geen toegang om aanrekeningen te maken verbonden met dit lid',
-                field: 'memberId'
-            })
+                field: 'memberId',
+            });
         }
 
         return member;
@@ -183,8 +183,8 @@ export class PatchBalanceItemsEndpoint extends Endpoint<Params, Query, Body, Res
                 code: 'permission_denied',
                 message: 'No permission to link balanace items to this user',
                 human: 'Je hebt geen toegang om aanrekeningen te maken verbonden met deze gebruiker',
-                field: 'userId'
-            })
+                field: 'userId',
+            });
         }
 
         return user;