@stamhoofd/backend 2.55.1 → 2.56.0

package/index.ts

@@ -13,6 +13,7 @@ import { sleep } from '@stamhoofd/utility';
 import { stopCrons, startCrons, waitForCrons } from '@stamhoofd/crons';
 import { resumeEmails } from './src/helpers/EmailResumer';
 import { ContextMiddleware } from './src/middleware/ContextMiddleware';
+import { Platform } from '@stamhoofd/models';
 
 process.on('unhandledRejection', (error: Error) => {
     console.error('unhandledRejection');
@@ -83,6 +84,9 @@ const start = async () => {
     // Add CORS headers
     routerServer.addResponseMiddleware(CORSMiddleware);
 
+    // Init platform shared struct: otherwise permissions won't work with missing responsibilities
+    await Platform.getSharedStruct();
+
     // Register Excel loaders
     await import('./src/excel-loaders/members');
     await import('./src/excel-loaders/payments');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.55.1",
+    "version": "2.56.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -31,19 +31,20 @@
         "sinon": "^18.0.0"
     },
     "dependencies": {
+        "@bwip-js/node": "^4.5.1",
         "@mollie/api-client": "3.7.0",
         "@simonbackx/simple-database": "1.25.0",
         "@simonbackx/simple-encoding": "2.16.6",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.55.1",
-        "@stamhoofd/backend-middleware": "2.55.1",
-        "@stamhoofd/email": "2.55.1",
-        "@stamhoofd/models": "2.55.1",
-        "@stamhoofd/queues": "2.55.1",
-        "@stamhoofd/sql": "2.55.1",
-        "@stamhoofd/structures": "2.55.1",
-        "@stamhoofd/utility": "2.55.1",
+        "@stamhoofd/backend-i18n": "2.56.0",
+        "@stamhoofd/backend-middleware": "2.56.0",
+        "@stamhoofd/email": "2.56.0",
+        "@stamhoofd/models": "2.56.0",
+        "@stamhoofd/queues": "2.56.0",
+        "@stamhoofd/sql": "2.56.0",
+        "@stamhoofd/structures": "2.56.0",
+        "@stamhoofd/utility": "2.56.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -63,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "83f014895a675bef94b85eb9457411949a488326"
+    "gitHead": "39e791f29d992c918b83871d9dc6cf72c418b2c4"
 }

package/src/crons.ts

@@ -13,6 +13,7 @@ import { endFunctionsOfUsersWithoutRegistration } from './crons/endFunctionsOfUs
 import { ExchangePaymentEndpoint } from './endpoints/organization/shared/ExchangePaymentEndpoint';
 import { checkSettlements } from './helpers/CheckSettlements';
 import { ForwardHandler } from './helpers/ForwardHandler';
+import { PaymentService } from './services/PaymentService';
 
 // Importing postmark returns undefined (this is a bug, so we need to use require)
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -469,7 +470,7 @@ async function checkPayments() {
             if (payment.organizationId) {
                 const organization = await Organization.getByID(payment.organizationId);
                 if (organization) {
-                    await ExchangePaymentEndpoint.pollStatus(payment.id, organization);
+                    await PaymentService.pollStatus(payment.id, organization);
                     continue;
                 }
             }
@@ -478,7 +479,7 @@ async function checkPayments() {
             }
 
             // Check expired
-            if (ExchangePaymentEndpoint.isManualExpired(payment.status, payment)) {
+            if (PaymentService.isManualExpired(payment.status, payment)) {
                 console.error('[DELAYED PAYMENTS] Could not resolve handler for expired payment, marking as failed', payment.id);
                 payment.status = PaymentStatus.Failed;
                 await payment.save();
@@ -542,7 +543,7 @@ async function checkFailedBuckarooPayments() {
             if (payment.organizationId) {
                 const organization = await Organization.getByID(payment.organizationId);
                 if (organization) {
-                    await ExchangePaymentEndpoint.pollStatus(payment.id, organization);
+                    await PaymentService.pollStatus(payment.id, organization);
                     continue;
                 }
             }

package/src/endpoints/global/audit-logs/GetAuditLogsEndpoint.ts

@@ -0,0 +1,150 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { AuditLog } from '@stamhoofd/models';
+import { SQL, SQLFilterDefinitions, SQLSortDefinitions, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
+import { AuditLog as AuditLogStruct, CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
+
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
+import { Context } from '../../../helpers/Context';
+import { auditLogFilterCompilers } from '../../../sql-filters/audit-logs';
+import { auditLogSorters } from '../../../sql-sorters/audit-logs';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = undefined;
+type ResponseBody = PaginatedResponse<AuditLogStruct[], LimitedFilteredRequest>;
+
+const filterCompilers: SQLFilterDefinitions = auditLogFilterCompilers;
+const sorters: SQLSortDefinitions<AuditLog> = auditLogSorters;
+
+export class GetAuditLogsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/audit-logs', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization;
+        let scopeFilter: StamhoofdFilter | undefined = undefined;
+
+        if (organization) {
+            if (!await Context.auth.hasFullAccess(organization.id)) {
+                throw Context.auth.error();
+            }
+            scopeFilter = {
+                organizationId: organization.id,
+            };
+        }
+        else {
+            if (!Context.auth.hasPlatformFullAccess()) {
+                throw Context.auth.error();
+            }
+        }
+
+        const query = SQL
+            .select(
+                SQL.wildcard(AuditLog.table),
+            )
+            .from(
+                SQL.table(AuditLog.table),
+            );
+
+        if (scopeFilter) {
+            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
+        }
+
+        if (q.filter) {
+            query.where(compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            throw new SimpleError({
+                code: 'not_supported',
+                message: 'Search is not possible in audit logs',
+                human: 'Zoeken is niet mogelijk in audit logs',
+            });
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+            }
+
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            query.orderBy(compileToSQLSorter(q.sort, sorters));
+            query.limit(q.limit);
+        }
+
+        return query;
+    }
+
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const query = await GetAuditLogsEndpoint.buildQuery(requestQuery);
+        const data = await query.fetch();
+
+        const logs = AuditLog.fromRows(data, AuditLog.table);
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (logs.length >= requestQuery.limit) {
+            const lastObject = logs[logs.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 new PaginatedResponse<AuditLogStruct[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.auditLogs(logs),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOptionalOrganizationScope();
+        await Context.authenticate();
+
+        const maxLimit = 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 GetAuditLogsEndpoint.buildData(request.query),
+        );
+    }
+}

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -3,7 +3,7 @@ import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, Patch
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, mergeTwoMembers, Organization, Platform, RateLimiter, Registration, SetupStepUpdater, User } from '@stamhoofd/models';
-import { GroupType, MembersBlob, MemberWithRegistrationsBlob, PermissionLevel } from '@stamhoofd/structures';
+import { AuditLogType, GroupType, MembersBlob, MemberWithRegistrationsBlob, PermissionLevel } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { Email } from '@stamhoofd/email';
@@ -13,6 +13,7 @@ import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructure
 import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
+import { AuditLogService } from '../../../services/AuditLogService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -142,6 +143,13 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
             // Auto link users based on data
             await MemberUserSyncer.onChangeMember(member);
+
+            if (!duplicate) {
+                await AuditLogService.log({
+                    type: AuditLogType.MemberAdded,
+                    member: member,
+                });
+            }
         }
 
         let shouldUpdateSetupSteps = false;
@@ -161,6 +169,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             }
 
             patch = await Context.auth.filterMemberPatch(member, patch);
+            const originalDetails = member.details.clone();
 
             if (patch.details) {
                 if (patch.details.isPut()) {
@@ -196,6 +205,15 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
             await member.save();
 
+            if (patch.details) {
+                await AuditLogService.log({
+                    type: AuditLogType.MemberEdited,
+                    member: member,
+                    oldMemberDetails: originalDetails,
+                    memberDetailsPatch: patch.details,
+                });
+            }
+
             // Update documents
             await Document.updateForMember(member.id);
 
@@ -450,14 +468,14 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                             SQL.where('startDate', SQLWhereSign.LessEqual, put.startDate)
                                 .and('endDate', SQLWhereSign.GreaterEqual, put.startDate),
                         )
-                        .or(
-                            SQL.where('startDate', SQLWhereSign.LessEqual, put.endDate)
-                                .and('endDate', SQLWhereSign.GreaterEqual, put.endDate),
-                        )
-                        .or(
-                            SQL.where('startDate', SQLWhereSign.GreaterEqual, put.startDate)
-                                .and('endDate', SQLWhereSign.LessEqual, put.endDate),
-                        )
+                            .or(
+                                SQL.where('startDate', SQLWhereSign.LessEqual, put.endDate)
+                                    .and('endDate', SQLWhereSign.GreaterEqual, put.endDate),
+                            )
+                            .or(
+                                SQL.where('startDate', SQLWhereSign.GreaterEqual, put.startDate)
+                                    .and('endDate', SQLWhereSign.LessEqual, put.endDate),
+                            ),
                     )
                     .first(false);
 

package/src/endpoints/global/payments/StripeWebhookEndpoint.ts

@@ -6,6 +6,7 @@ import { isDebouncedError, QueueHandler } from '@stamhoofd/queues';
 
 import { StripeHelper } from '../../../helpers/StripeHelper';
 import { ExchangePaymentEndpoint } from '../../organization/shared/ExchangePaymentEndpoint';
+import { PaymentService } from '../../../services/PaymentService';
 
 type Params = Record<string, never>;
 class Body extends AutoEncoder {
@@ -159,7 +160,7 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
             await QueueHandler.debounce('stripe-webhook/payment-' + paymentId, async () => {
                 const organization = await Organization.getByID(organizationId);
                 if (organization) {
-                    await ExchangePaymentEndpoint.pollStatus(paymentId, organization);
+                    await PaymentService.pollStatus(paymentId, organization);
                 }
                 else {
                     console.warn('Could not find organization with id', organizationId);

package/src/endpoints/global/platform/PatchPlatformEnpoint.ts

@@ -1,7 +1,7 @@
 import { AutoEncoderPatchType, Decoder, isPatchableArray, patchObject } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Organization, Platform, RegistrationPeriod, SetupStepUpdater } from '@stamhoofd/models';
-import { MemberResponsibility, PlatformConfig, PlatformPremiseType, Platform as PlatformStruct } from '@stamhoofd/structures';
+import { AuditLogType, MemberResponsibility, PlatformConfig, PlatformPremiseType, Platform as PlatformStruct } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
@@ -10,6 +10,7 @@ import { MembershipCharger } from '../../../helpers/MembershipCharger';
 import { MembershipHelper } from '../../../helpers/MembershipHelper';
 import { PeriodHelper } from '../../../helpers/PeriodHelper';
 import { TagHelper } from '../../../helpers/TagHelper';
+import { AuditLogService } from '../../../services/AuditLogService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -90,9 +91,9 @@ export class PatchPlatformEndpoint extends Endpoint<
 
             // Update config
             if (newConfig) {
+                const oldConfig: PlatformConfig = platform.config.clone();
                 const shouldCheckSteps = newConfig.premiseTypes || newConfig.responsibilities;
                 if (shouldCheckSteps) {
-                    const oldConfig: PlatformConfig = platform.config.clone();
                     platform.config = patchObject(platform.config, newConfig);
                     const currentConfig: PlatformConfig = platform.config;
 
@@ -107,6 +108,12 @@ export class PatchPlatformEndpoint extends Endpoint<
                 else {
                     platform.config = patchObject(platform.config, newConfig);
                 }
+
+                await AuditLogService.log({
+                    type: AuditLogType.PlatformSettingChanged,
+                    oldConfig,
+                    patch: newConfig,
+                });
             }
 
             if (newConfig.tags && isPatchableArray(newConfig.tags) && newConfig.tags.changes.length > 0) {

package/src/endpoints/global/registration/PatchUserMembersEndpoint.ts

@@ -2,12 +2,13 @@ import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArra
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Document, Member, RateLimiter } from '@stamhoofd/models';
-import { MemberDetails, MembersBlob, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+import { AuditLogType, MemberDetails, MembersBlob, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer';
 import { PatchOrganizationMembersEndpoint } from '../../global/members/PatchOrganizationMembersEndpoint';
+import { AuditLogService } from '../../../services/AuditLogService';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = PatchableArrayAutoEncoder<MemberWithRegistrationsBlob>;
@@ -68,6 +69,11 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
 
             await member.save();
             addedMembers.push(member);
+
+            await AuditLogService.log({
+                type: AuditLogType.MemberAdded,
+                member: member,
+            });
         }
 
         // Modify members
@@ -84,6 +90,7 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             }
             const securityCode = struct.details?.securityCode; // will get cleared after the filter
             struct = await Context.auth.filterMemberPatch(member, struct);
+            const originalDetails = member.details.clone();
 
             if (struct.details) {
                 if (struct.details.isPut()) {
@@ -122,6 +129,15 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             await member.save();
             await MemberUserSyncer.onChangeMember(member);
 
+            if (struct.details) {
+                await AuditLogService.log({
+                    type: AuditLogType.MemberEdited,
+                    member: member,
+                    oldMemberDetails: originalDetails,
+                    memberDetailsPatch: struct.details,
+                });
+            }
+
             // Update documents
             await Document.updateForMember(member.id);
         }

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -12,6 +12,8 @@ import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructure
 import { BuckarooHelper } from '../../../helpers/BuckarooHelper';
 import { Context } from '../../../helpers/Context';
 import { StripeHelper } from '../../../helpers/StripeHelper';
+import { BalanceItemService } from '../../../services/BalanceItemService';
+import { RegistrationService } from '../../../services/RegistrationService';
 type Params = Record<string, never>;
 type Query = undefined;
 type Body = IDRegisterCheckout;
@@ -354,16 +356,17 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             await BalanceItem.deleteForDeletedRegistration(existingRegistration.id);
 
             // Clear the registration
-            await existingRegistration.deactivate();
-            deactivatedRegistrationGroupIds.push(existingRegistration.groupId);
-
-            const group = groups.find(g => g.id === existingRegistration.groupId);
+            let group = groups.find(g => g.id === existingRegistration.groupId);
             if (!group) {
-                const g = await Group.getByID(existingRegistration.groupId);
-                if (g) {
-                    groups.push(g);
+                group = await Group.getByID(existingRegistration.groupId);
+                if (group) {
+                    groups.push(group);
                 }
             }
+            const member = members.find(m => m.id === existingRegistration.memberId);
+
+            await RegistrationService.deactivate(existingRegistration, group, member);
+            deactivatedRegistrationGroupIds.push(existingRegistration.groupId);
         }
 
         async function createBalanceItem({ registration, amount, unitPrice, description, type, relations }: { amount?: number; registration: RegistrationWithMemberAndGroup; unitPrice: number; description: string; relations: Map<BalanceItemRelationType, BalanceItemRelation>; type: BalanceItemType }) {
@@ -584,8 +587,8 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         async function markValidIfNeeded() {
             if (shouldMarkValid) {
                 for (const balanceItem of [...createdBalanceItems, ...unrelatedCreatedBalanceItems]) {
-                    // Mark vlaid
-                    await balanceItem.markPaid(payment, organization);
+                    // Mark valid
+                    await BalanceItemService.markPaid(balanceItem, payment, organization);
                 }
             }
         }

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

@@ -8,6 +8,8 @@ import { Payment as PaymentStruct, PaymentGeneral, PaymentMethod, PaymentStatus,
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 import { ExchangePaymentEndpoint } from '../../shared/ExchangePaymentEndpoint';
+import { PaymentService } from '../../../../services/PaymentService';
+import { BalanceItemService } from '../../../../services/BalanceItemService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -143,7 +145,7 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
 
             // Mark paid or failed
             if (put.status !== PaymentStatus.Created && put.status !== PaymentStatus.Pending) {
-                await ExchangePaymentEndpoint.handlePaymentStatusUpdate(payment, organization, put.status);
+                await PaymentService.handlePaymentStatusUpdate(payment, organization, put.status);
 
                 if (put.status === PaymentStatus.Succeeded) {
                     payment.paidAt = put.paidAt;
@@ -152,7 +154,7 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
             }
             else {
                 for (const balanceItem of balanceItems) {
-                    await balanceItem.markUpdated(payment, organization);
+                    await BalanceItemService.markUpdated(balanceItem, payment, organization);
                 }
 
                 await BalanceItem.updateOutstanding(balanceItems);
@@ -222,7 +224,7 @@ export class PatchPaymentsEndpoint extends Endpoint<Params, Query, Body, Respons
                 await payment.save();
 
                 if (patch.status) {
-                    await ExchangePaymentEndpoint.handlePaymentStatusUpdate(payment, organization, patch.status);
+                    await PaymentService.handlePaymentStatusUpdate(payment, organization, patch.status);
                 }
 
                 changedPayments.push(