@stamhoofd/backend 2.18.0 → 2.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.18.0",
+    "version": "2.19.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -39,10 +39,10 @@
         "@stamhoofd/backend-i18n": "^2.17.0",
         "@stamhoofd/backend-middleware": "^2.17.0",
         "@stamhoofd/email": "^2.17.0",
-        "@stamhoofd/models": "^2.18.0",
+        "@stamhoofd/models": "^2.19.0",
         "@stamhoofd/queues": "^2.17.3",
         "@stamhoofd/sql": "^2.18.0",
-        "@stamhoofd/structures": "^2.18.0",
+        "@stamhoofd/structures": "^2.19.0",
         "@stamhoofd/utility": "^2.17.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
@@ -60,5 +60,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "a47aa5bb6ad71d1e6a2f88bc203caa5acf4f497f"
+    "gitHead": "876e7b976122e1c2f67d4cceebe92ec2af2bc35a"
 }

package/src/endpoints/admin/memberships/ChargeMembershipsEndpoint.ts

@@ -0,0 +1,49 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { QueueHandler } from '@stamhoofd/queues';
+import { sleep } from '@stamhoofd/utility';
+import { Context } from '../../../helpers/Context';
+import { MembershipCharger } from '../../../helpers/MembershipCharger';
+import { SimpleError } from '@simonbackx/simple-errors';
+
+
+type Params = Record<string, never>;
+type Query = Record<string, never>;
+type Body = undefined;
+type ResponseBody = undefined;
+
+export class ChargeMembershipsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "POST") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/admin/charge-memberships", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate()
+
+        if (!Context.auth.hasPlatformFullAccess()) {
+            throw Context.auth.error()
+        }
+
+        if (QueueHandler.isRunning('charge-memberships')) {
+            throw new SimpleError({
+                code: 'charge_pending',
+                message: 'Charge already pending',
+                human: 'Er is al een aanrekening bezig, even geduld.'
+            })
+        }
+
+        QueueHandler.schedule('charge-memberships', async () => {
+            await MembershipCharger.charge()
+        }).catch(console.error);
+       
+        return new Response(undefined);
+    }
+}

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -2,6 +2,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SQL, SQLAlias, SQLCount, SQLDistinct, SQLSelectAs, SQLSum } from '@stamhoofd/sql';
 import { ChargeMembershipsSummary, ChargeMembershipsTypeSummary } from '@stamhoofd/structures';
 import { Context } from '../../../helpers/Context';
+import { QueueHandler } from '@stamhoofd/queues';
 
 
 type Params = Record<string, never>;
@@ -29,6 +30,14 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
         if (!Context.auth.hasPlatformFullAccess()) {
             throw Context.auth.error()
         }
+
+        if (QueueHandler.isRunning('charge-memberships')) {
+            return new Response(
+                ChargeMembershipsSummary.create({
+                    running: true
+                })
+            );
+        }
         
         const query = SQL
             .select(
@@ -74,6 +83,7 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
 
         return new Response(
             ChargeMembershipsSummary.create({
+                running: false,
                 memberships: memberships ?? 0,
                 members: members ?? 0,
                 price: price ?? 0,

package/src/endpoints/organization/dashboard/billing/GetDetailedBillingStatusEndpoint.ts

@@ -1,5 +1,5 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { OrganizationDetailedBillingStatus, OrganizationDetailedBillingStatusItem, PaymentMethod } from "@stamhoofd/structures";
+import { OrganizationDetailedBillingStatus, OrganizationDetailedBillingStatusItem, PaymentMethod, PaymentStatus } from "@stamhoofd/structures";
 
 import { BalanceItem, Organization, Payment } from "@stamhoofd/models";
 import { SQL } from "@stamhoofd/sql";
@@ -41,8 +41,7 @@ export class GetDetailedBillingStatusEndpoint extends Endpoint<Params, Query, Bo
         const paymentModels = await Payment.select()
             .where('payingOrganizationId', organization.id)
             .andWhere(
-                SQL.whereNot('paidAt', null)
-                    .or('method', [PaymentMethod.Transfer, PaymentMethod.DirectDebit, PaymentMethod.PointOfSale, PaymentMethod.Unknown])
+                SQL.whereNot('status', PaymentStatus.Failed)
             )
             .fetch()
 

package/src/helpers/MembershipCharger.ts

@@ -0,0 +1,126 @@
+import { SimpleError } from "@simonbackx/simple-errors";
+import { BalanceItem, Member, MemberPlatformMembership, Platform } from "@stamhoofd/models";
+import { SQL, SQLOrderBy, SQLWhereSign } from "@stamhoofd/sql";
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemType } from "@stamhoofd/structures";
+import { Formatter } from "@stamhoofd/utility";
+
+export const MembershipCharger = {
+    async charge() {
+        console.log('Charging memberships...')
+        
+        // Loop all
+        let lastId = "";
+        const platform = await Platform.getShared()
+        const chargeVia = platform.membershipOrganizationId
+
+        if (!chargeVia) {
+            throw new SimpleError({
+                code: 'missing_membership_organization',
+                message: 'Missing membershipOrganizationId',
+                human: 'Er is geen lokale groep verantwoordelijk voor de aanrekening van aansluitingen geconfigureerd'
+            })
+        }
+
+        function getType(id: string) {
+            return platform.config.membershipTypes.find(t => t.id === id)
+        }
+
+        let createdCount = 0;
+        let createdPrice = 0;
+
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const memberships = await MemberPlatformMembership.select()
+                .where('id', SQLWhereSign.Greater, lastId)
+                .where('balanceItemId', null)
+                .limit(100)
+                .orderBy(
+                    new SQLOrderBy({
+                        column: SQL.column('id'),
+                        direction: 'ASC'
+                    })
+                )
+                .fetch();
+        
+            if (memberships.length === 0) {
+                break;
+            }
+
+            const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId))
+            const members = await Member.getByIDs(...memberIds)
+            const createdBalanceItems: BalanceItem[] = []
+
+            for (const membership of memberships) {
+                // charge
+                if (membership.balanceItemId) {
+                    continue;
+                }
+                const type = getType(membership.membershipTypeId);
+                if (!type) {
+                    console.error('Unknown membership type id ', membership.membershipTypeId)
+                    continue;
+                }
+
+                if (membership.organizationId === chargeVia) {
+                    continue;
+                }
+
+                const member = members.find(m => m.id === membership.memberId)
+
+                if (!member) {
+                    console.error('Unexpected missing member id ', membership.memberId, 'for membership', membership.id)
+                    continue;
+                }
+
+                const balanceItem = new BalanceItem();
+                balanceItem.unitPrice = membership.price
+                balanceItem.amount = 1
+                balanceItem.description = Formatter.dateNumber(membership.startDate, true) + " tot " + Formatter.dateNumber(membership.expireDate ?? membership.endDate, true)
+                balanceItem.relations = new Map([
+                    [
+                        BalanceItemRelationType.Member, 
+                        BalanceItemRelation.create({
+                            id: member.id,
+                            name: member.details.name
+                        })
+                    ],
+                    [
+                        BalanceItemRelationType.MembershipType, 
+                        BalanceItemRelation.create({
+                            id: type.id,
+                            name: type.name
+                        })
+                    ]
+                ])
+
+                balanceItem.type = BalanceItemType.PlatformMembership
+                balanceItem.organizationId = chargeVia
+                balanceItem.payingOrganizationId = membership.organizationId
+
+                await balanceItem.save();
+                membership.balanceItemId = balanceItem.id;
+                await membership.save()
+
+                createdBalanceItems.push(balanceItem)
+
+                createdCount += 1;
+                createdPrice += membership.price
+            }
+
+            await BalanceItem.updateOutstanding(createdBalanceItems)
+
+            if (memberships.length < 100) {
+                break;
+            }
+            
+            const z = lastId;
+            lastId = memberships[memberships.length - 1].id;
+
+            if (lastId === z) {
+                throw new Error('Unexpected infinite loop found in MembershipCharger')
+            }
+        }
+
+        console.log('Charged ' + Formatter.integer(createdCount) +'  memberships, for a total value of ' + Formatter.price(createdPrice))
+    }
+};