@stamhoofd/backend 2.55.1 → 2.56.0

package/src/services/BalanceItemPaymentService.ts

@@ -0,0 +1,45 @@
+import { ManyToOneRelation } from '@simonbackx/simple-database';
+import { BalanceItemPayment, Organization } from '@stamhoofd/models';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+import { BalanceItemService } from './BalanceItemService';
+
+type Loaded<T> = (T) extends ManyToOneRelation<infer Key, infer Model> ? Record<Key, Model> : never;
+
+export const BalanceItemPaymentService = {
+    async markPaid(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Update cached amountPaid of the balance item (balanceItemPayment will get overwritten later, but we need it to calculate the status)
+        balanceItemPayment.balanceItem.pricePaid += balanceItemPayment.price;
+
+        // Update status
+        const old = balanceItemPayment.balanceItem.status;
+        balanceItemPayment.balanceItem.updateStatus();
+        await balanceItemPayment.balanceItem.save();
+
+        // Do logic of balance item
+        if (balanceItemPayment.balanceItem.status === BalanceItemStatus.Paid && old !== BalanceItemStatus.Paid) {
+            // Only call markPaid once (if it wasn't (partially) paid before)
+            await BalanceItemService.markPaid(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+        }
+        else {
+            await BalanceItemService.markUpdated(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+        }
+    },
+
+    /**
+     * Call balanceItemPayment once a earlier succeeded payment is no longer succeeded
+     */
+    async undoPaid(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        await BalanceItemService.undoPaid(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+    },
+
+    async markFailed(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Do logic of balance item
+        await BalanceItemService.markFailed(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+    },
+
+    async undoFailed(balanceItemPayment: BalanceItemPayment & Loaded<typeof BalanceItemPayment.balanceItem> & Loaded<typeof BalanceItemPayment.payment>, organization: Organization) {
+        // Reactivate deleted items
+        await BalanceItemService.undoFailed(balanceItemPayment.balanceItem, balanceItemPayment.payment, organization);
+    },
+
+};

package/src/services/BalanceItemService.ts

@@ -0,0 +1,88 @@
+import { BalanceItem, Order, Organization, Payment, Webshop } from '@stamhoofd/models';
+import { BalanceItemStatus, OrderStatus } from '@stamhoofd/structures';
+import { RegistrationService } from './RegistrationService';
+
+export const BalanceItemService = {
+    async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+        if (balanceItem.status === BalanceItemStatus.Hidden) {
+            await BalanceItem.reactivateItems([balanceItem]);
+        }
+
+        // status and pricePaid changes are handled inside balanceitempayment
+        if (balanceItem.dependingBalanceItemId) {
+            const depending = await BalanceItem.getByID(balanceItem.dependingBalanceItemId);
+            if (depending && depending.status === BalanceItemStatus.Hidden) {
+                await BalanceItem.reactivateItems([depending]);
+            }
+        }
+
+        // If registration
+        if (balanceItem.registrationId) {
+            await RegistrationService.markValid(balanceItem.registrationId);
+        }
+
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.markPaid(payment, organization);
+
+                // Save number in balance description
+                if (order.number !== null) {
+                    const webshop = await Webshop.getByID(order.webshopId);
+
+                    if (webshop) {
+                        balanceItem.description = order.generateBalanceDescription(webshop);
+                        await balanceItem.save();
+                    }
+                }
+            }
+        }
+    },
+
+    async markUpdated(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+        // For orders: mark order as changed (so they are refetched in front ends)
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.paymentChanged(payment, organization);
+            }
+        }
+    },
+
+    async undoPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.undoPaid(payment, organization);
+            }
+        }
+    },
+
+    async markFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.onPaymentFailed(payment, organization);
+
+                if (order.status === OrderStatus.Deleted) {
+                    balanceItem.status = BalanceItemStatus.Hidden;
+                    await balanceItem.save();
+                }
+            }
+        }
+    },
+
+    async undoFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
+        // If order
+        if (balanceItem.orderId) {
+            const order = await Order.getByID(balanceItem.orderId);
+            if (order) {
+                await order.undoPaymentFailed(payment, organization);
+            }
+        }
+    },
+
+};

package/src/services/GroupService.ts

@@ -0,0 +1,13 @@
+import { Group } from '@stamhoofd/models';
+
+export const GroupService = {
+    async updateOccupancy(groupId: string) {
+        const group = await Group.getByID(groupId);
+        if (group) {
+            // todo: implementation should move to the service
+            await group.updateOccupancy();
+            await group.save();
+        }
+        return group;
+    },
+};

package/src/services/PaymentService.ts

@@ -0,0 +1,308 @@
+import createMollieClient, { PaymentStatus as MolliePaymentStatus } from '@mollie/api-client';
+import { BalanceItem, BalanceItemPayment, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
+import { BuckarooHelper } from '../helpers/BuckarooHelper';
+import { StripeHelper } from '../helpers/StripeHelper';
+import { BalanceItemPaymentService } from './BalanceItemPaymentService';
+
+export const PaymentService = {
+    async handlePaymentStatusUpdate(payment: Payment, organization: Organization, status: PaymentStatus) {
+        if (payment.status === status) {
+            return;
+        }
+
+        if (status === PaymentStatus.Succeeded) {
+            payment.status = PaymentStatus.Succeeded;
+            payment.paidAt = new Date();
+            await payment.save();
+
+            // Prevent concurrency issues
+            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                const unloaded = (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment));
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    unloaded,
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await BalanceItemPaymentService.markPaid(balanceItemPayment, organization);
+                }
+
+                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+            });
+            return;
+        }
+
+        const oldStatus = payment.status;
+
+        // Save before updating balance items
+        payment.status = status;
+        payment.paidAt = null;
+        await payment.save();
+
+        // If OLD status was succeeded, we need to revert the actions
+        if (oldStatus === PaymentStatus.Succeeded) {
+            // No longer succeeded
+            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await BalanceItemPaymentService.undoPaid(balanceItemPayment, organization);
+                }
+
+                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+            });
+        }
+
+        // Moved to failed
+        if (status == PaymentStatus.Failed) {
+            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await BalanceItemPaymentService.markFailed(balanceItemPayment, organization);
+                }
+
+                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+            });
+        }
+
+        // If OLD status was FAILED, we need to revert the actions
+        if (oldStatus === PaymentStatus.Failed) { // OLD FAILED!! -> NOW PENDING
+            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                    (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
+                );
+
+                for (const balanceItemPayment of balanceItemPayments) {
+                    await BalanceItemPaymentService.undoFailed(balanceItemPayment, organization);
+                }
+
+                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+            });
+        }
+    },
+
+    /**
+     * ID of payment is needed because of race conditions (need to fetch payment in a race condition save queue)
+     */
+    async pollStatus(paymentId: string, org: Organization | null, cancel = false): Promise<Payment | undefined> {
+        // Prevent polling the same payment multiple times at the same time: create a queue to prevent races
+        return await QueueHandler.schedule('payments/' + paymentId, async () => {
+            // Get a new copy of the payment (is required to prevent concurreny bugs)
+            const payment = await Payment.getByID(paymentId);
+            if (!payment) {
+                return;
+            }
+
+            if (!payment.organizationId) {
+                console.error('Payment without organization not supported', payment.id);
+                return;
+            }
+
+            const organization = org ?? await Organization.getByID(payment.organizationId);
+            if (!organization) {
+                console.error('Organization not found for payment', payment.id);
+                return;
+            }
+
+            const testMode = organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production';
+
+            if (payment.status === PaymentStatus.Pending || payment.status === PaymentStatus.Created || (payment.provider === PaymentProvider.Buckaroo && payment.status === PaymentStatus.Failed)) {
+                if (payment.provider === PaymentProvider.Stripe) {
+                    try {
+                        let status = await StripeHelper.getStatus(payment, cancel || this.shouldTryToCancel(payment.status, payment), testMode);
+
+                        if (this.isManualExpired(status, payment)) {
+                            console.error('Manually marking Stripe payment as expired', payment.id);
+                            status = PaymentStatus.Failed;
+                        }
+
+                        await this.handlePaymentStatusUpdate(payment, organization, status);
+                    }
+                    catch (e) {
+                        console.error('Payment check failed Stripe', payment.id, e);
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking Stripe payment as expired', payment.id);
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                        }
+                    }
+                }
+                else if (payment.provider === PaymentProvider.Mollie) {
+                    // check status via mollie
+                    const molliePayments = await MolliePayment.where({ paymentId: payment.id }, { limit: 1 });
+                    if (molliePayments.length == 1) {
+                        const molliePayment = molliePayments[0];
+                        // check status
+                        const token = await MollieToken.getTokenFor(organization.id);
+
+                        if (token) {
+                            try {
+                                const mollieClient = createMollieClient({ accessToken: await token.getAccessToken() });
+                                const mollieData = await mollieClient.payments.get(molliePayment.mollieId, {
+                                    testmode: organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production',
+                                });
+
+                                console.log(mollieData); // log to log files to check issues
+
+                                const details = mollieData.details as any;
+                                if (details?.consumerName) {
+                                    payment.ibanName = details.consumerName;
+                                }
+                                if (details?.consumerAccount) {
+                                    payment.iban = details.consumerAccount;
+                                }
+                                if (details?.cardHolder) {
+                                    payment.ibanName = details.cardHolder;
+                                }
+                                if (details?.cardNumber) {
+                                    payment.iban = 'xxxx xxxx xxxx ' + details.cardNumber;
+                                }
+
+                                if (mollieData.status === MolliePaymentStatus.paid) {
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Succeeded);
+                                }
+                                else if (mollieData.status === MolliePaymentStatus.failed || mollieData.status === MolliePaymentStatus.expired || mollieData.status === MolliePaymentStatus.canceled) {
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                                }
+                                else if (this.isManualExpired(payment.status, payment)) {
+                                    // Mollie still returning pending after 1 day: mark as failed
+                                    console.error('Manually marking Mollie payment as expired', payment.id);
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                                }
+                            }
+                            catch (e) {
+                                console.error('Payment check failed Mollie', payment.id, e);
+                                if (this.isManualExpired(payment.status, payment)) {
+                                    console.error('Manually marking Mollie payment as expired', payment.id);
+                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                                }
+                            }
+                        }
+                        else {
+                            console.warn('Mollie payment is missing for organization ' + organization.id + ' while checking payment status...');
+
+                            if (this.isManualExpired(payment.status, payment)) {
+                                console.error('Manually marking payment without mollie token as expired', payment.id);
+                                await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                            }
+                        }
+                    }
+                    else {
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking payment without mollie payments as expired', payment.id);
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                        }
+                    }
+                }
+                else if (payment.provider == PaymentProvider.Buckaroo) {
+                    const helper = new BuckarooHelper(organization.privateMeta.buckarooSettings?.key ?? '', organization.privateMeta.buckarooSettings?.secret ?? '', organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
+                    try {
+                        let status = await helper.getStatus(payment);
+
+                        if (this.isManualExpired(status, payment)) {
+                            console.error('Manually marking Buckaroo payment as expired', payment.id);
+                            status = PaymentStatus.Failed;
+                        }
+
+                        await this.handlePaymentStatusUpdate(payment, organization, status);
+                    }
+                    catch (e) {
+                        console.error('Payment check failed Buckaroo', payment.id, e);
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking Buckaroo payment as expired', payment.id);
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                        }
+                    }
+                }
+                else if (payment.provider == PaymentProvider.Payconiq) {
+                    // Check status
+
+                    const payconiqPayments = await PayconiqPayment.where({ paymentId: payment.id }, { limit: 1 });
+                    if (payconiqPayments.length == 1) {
+                        const payconiqPayment = payconiqPayments[0];
+
+                        if (cancel) {
+                            console.error('Cancelling Payconiq payment on request', payment.id);
+                            await payconiqPayment.cancel(organization);
+                        }
+
+                        let status = await payconiqPayment.getStatus(organization);
+
+                        if (!cancel && this.shouldTryToCancel(status, payment)) {
+                            console.error('Manually cancelling Payconiq payment', payment.id);
+                            if (await payconiqPayment.cancel(organization)) {
+                                status = PaymentStatus.Failed;
+                            }
+                        }
+
+                        if (this.isManualExpired(status, payment)) {
+                            console.error('Manually marking Payconiq payment as expired', payment.id);
+                            status = PaymentStatus.Failed;
+                        }
+
+                        await this.handlePaymentStatusUpdate(payment, organization, status);
+                    }
+                    else {
+                        console.warn('Payconiq payment is missing for organization ' + organization.id + ' while checking payment status...');
+
+                        if (this.isManualExpired(payment.status, payment)) {
+                            console.error('Manually marking Payconiq payment as expired because not found', payment.id);
+                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                        }
+                    }
+                }
+                else {
+                    console.error('Invalid payment provider', payment.provider, 'for payment', payment.id);
+                    if (this.isManualExpired(payment.status, payment)) {
+                        console.error('Manually marking unknown payment as expired', payment.id);
+                        await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                    }
+                }
+            }
+            else {
+                // Do a manual update if needed
+                if (payment.status === PaymentStatus.Succeeded) {
+                    if (payment.provider === PaymentProvider.Stripe) {
+                        // Update the status
+                        await StripeHelper.getStatus(payment, false, testMode);
+                    }
+                }
+            }
+            return payment;
+        });
+    },
+
+    isManualExpired(status: PaymentStatus, payment: Payment) {
+        if ((status == PaymentStatus.Pending || status === PaymentStatus.Created) && payment.method !== PaymentMethod.DirectDebit) {
+            // If payment is not succeeded after one day, mark as failed
+            if (payment.createdAt < new Date(new Date().getTime() - 60 * 1000 * 60 * 24)) {
+                return true;
+            }
+        }
+        return false;
+    },
+
+    /**
+     * Try to cancel a payment that is still pending
+     */
+    shouldTryToCancel(status: PaymentStatus, payment: Payment): boolean {
+        if ((status == PaymentStatus.Pending || status === PaymentStatus.Created) && payment.method !== PaymentMethod.DirectDebit) {
+            let timeout = STAMHOOFD.environment === 'development' ? 60 * 1000 * 2 : 60 * 1000 * 30;
+
+            // If payconiq and not yet 'identified' (scanned), cancel after 5 minutes
+            if (payment.provider === PaymentProvider.Payconiq && status === PaymentStatus.Created) {
+                timeout = STAMHOOFD.environment === 'development' ? 60 * 1000 * 1 : 60 * 1000 * 5;
+            }
+
+            if (payment.createdAt < new Date(new Date().getTime() - timeout)) {
+                return true;
+            }
+        }
+        return false;
+    },
+};

package/src/services/RegistrationService.ts

@@ -0,0 +1,78 @@
+import { ManyToOneRelation } from '@simonbackx/simple-database';
+import { Document, Group, Member, Registration } from '@stamhoofd/models';
+import { AuditLogType, EmailTemplateType } from '@stamhoofd/structures';
+import { GroupService } from './GroupService';
+import { AuditLogService } from './AuditLogService';
+
+export const RegistrationService = {
+    async markValid(registrationId: string) {
+        const registration = await Registration.getByID(registrationId);
+        if (!registration) {
+            throw new Error('Registration not found');
+        }
+
+        if (registration.registeredAt !== null && registration.deactivatedAt === null) {
+            return false;
+        }
+
+        registration.reservedUntil = null;
+        registration.registeredAt = registration.registeredAt ?? new Date();
+        registration.deactivatedAt = null;
+        registration.canRegister = false;
+        await registration.save();
+        registration.scheduleStockUpdate();
+
+        await Member.updateMembershipsForId(registration.memberId);
+
+        await registration.sendEmailTemplate({
+            type: EmailTemplateType.RegistrationConfirmation,
+        });
+
+        const member = await Member.getByID(registration.memberId);
+        if (member) {
+            const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
+            registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
+            await Document.updateForRegistration(registration.setRelation(registrationMemberRelation, member));
+        }
+
+        // Update group occupancy
+        const group = await GroupService.updateOccupancy(registration.groupId);
+
+        // Create a log
+        if (member && group) {
+            await AuditLogService.log({
+                type: AuditLogType.MemberRegistered,
+                member,
+                group,
+                registration,
+            });
+        }
+
+        return true;
+    },
+
+    async deactivate(registration: Registration, group?: Group, member?: Member) {
+        if (registration.deactivatedAt !== null) {
+            return;
+        }
+
+        // Clear the registration
+        registration.deactivatedAt = new Date();
+        await registration.save();
+        registration.scheduleStockUpdate();
+
+        await Member.updateMembershipsForId(registration.memberId);
+
+        const fetchedMember = member ?? await Member.getByID(registration.memberId);
+        const fetchedGroup = group ?? await Group.getByID(registration.groupId);
+
+        if (fetchedMember && fetchedGroup) {
+            await AuditLogService.log({
+                type: AuditLogType.MemberUnregistered,
+                member: fetchedMember,
+                group: fetchedGroup,
+                registration,
+            });
+        }
+    },
+};

package/src/sql-filters/audit-logs.ts

@@ -0,0 +1,10 @@
+import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQLFilterDefinitions } from '@stamhoofd/sql';
+
+export const auditLogFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLColumnFilterCompiler('id'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    type: createSQLColumnFilterCompiler('type'),
+    objectId: createSQLColumnFilterCompiler('objectId'),
+    createdAt: createSQLColumnFilterCompiler('createdAt'),
+};

package/src/sql-sorters/audit-logs.ts

@@ -0,0 +1,35 @@
+import { AuditLog } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+
+export const auditLogSorters: SQLSortDefinitions<AuditLog> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields.
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
+    id: {
+        getValue(a) {
+            return a.id;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return a.createdAt;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
+};