@stamhoofd/backend 2.79.8 → 2.80.0

package/src/endpoints/admin/members/ChargeMembersEndpoint.ts

@@ -0,0 +1,105 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { ChargeMembersRequest, LimitedFilteredRequest, PermissionLevel } from '@stamhoofd/structures';
+
+import { QueueHandler } from '@stamhoofd/queues';
+import { Context } from '../../../helpers/Context';
+import { fetchToAsyncIterator } from '../../../helpers/fetchToAsyncIterator';
+import { MemberCharger } from '../../../helpers/MemberCharger';
+import { GetMembersEndpoint } from '../../global/members/GetMembersEndpoint';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = ChargeMembersRequest;
+type ResponseBody = undefined;
+
+export class ChargeMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+    bodyDecoder = ChargeMembersRequest as Decoder<ChargeMembersRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'POST') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/admin/charge-members', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    private static throwIfInvalidBody(body: Body) {
+        if (!body.description?.trim()?.length) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid description',
+                human: 'Beschrijving is verplicht',
+                field: 'description',
+            });
+        }
+
+        if (!body.price) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid price',
+                human: 'Bedrag kan niet 0 zijn',
+                field: 'price',
+            });
+        }
+
+        if (body.amount === 0) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid amount',
+                human: 'Aantal kan niet 0 zijn',
+                field: 'amount',
+            });
+        }
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        const body = request.body;
+
+        await Context.authenticate();
+
+        if (!await Context.auth.canManagePayments(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        ChargeMembersEndpoint.throwIfInvalidBody(body);
+
+        const queueId = 'charge-members';
+
+        if (QueueHandler.isRunning(queueId)) {
+            throw new SimpleError({
+                code: 'charge_pending',
+                message: 'Charge members already pending',
+                human: 'Er is al een aanrekening bezig, even geduld.',
+            });
+        }
+
+        await QueueHandler.schedule(queueId, async () => {
+            const dataGenerator = fetchToAsyncIterator(request.query, {
+                fetch: request => GetMembersEndpoint.buildData(request, PermissionLevel.Write),
+            });
+
+            for await (const data of dataGenerator) {
+                await MemberCharger.chargeMany({
+                    chargingOrganizationId: organization.id,
+                    membersToCharge: data.members,
+                    price: body.price,
+                    amount: body.amount ?? 1,
+                    description: body.description,
+                    dueAt: body.dueAt,
+                    createdAt: body.createdAt,
+                });
+            }
+        });
+
+        return new Response(undefined);
+    }
+}

package/src/endpoints/admin/organizations/ChargeOrganizationsEndpoint.ts

@@ -1,7 +1,7 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { ChargeOrganizationsRequest, LimitedFilteredRequest, Organization as OrganizationStruct } from '@stamhoofd/structures';
+import { ChargeOrganizationsRequest, LimitedFilteredRequest } from '@stamhoofd/structures';
 
 import { QueueHandler } from '@stamhoofd/queues';
 import { Context } from '../../../helpers/Context';
@@ -59,7 +59,7 @@ export class ChargeOrganizationsEndpoint extends Endpoint<Params, Query, Body, R
             });
         }
 
-        if (body.organizationId === undefined) {
+        if (!body.organizationId) {
             throw new SimpleError({
                 code: 'invalid_field',
                 message: 'Invalid organization id',
@@ -94,19 +94,15 @@ export class ChargeOrganizationsEndpoint extends Endpoint<Params, Query, Body, R
                 fetch: GetOrganizationsEndpoint.buildData,
             });
 
-            const organizationId = body.organizationId;
-            const chargeOrganizations = organizationId === null
-                ? OrganizationCharger.chargeFromPlatform
-                : (args: { organizationsToCharge: OrganizationStruct[]; price: number; amount?: number; description: string }) => OrganizationCharger.chargeMany({
-                        chargingOrganizationId: organizationId,
-                        ...args });
-
             for await (const data of dataGenerator) {
-                await chargeOrganizations({
+                await OrganizationCharger.chargeMany({
+                    chargingOrganizationId: body.organizationId,
                     organizationsToCharge: data,
                     price: body.price,
                     amount: body.amount ?? 1,
                     description: body.description,
+                    dueAt: body.dueAt,
+                    createdAt: body.createdAt,
                 });
             }
         });