@stamhoofd/backend 2.126.2 → 2.127.0

package/src/helpers/StripeInvoicer.ts

@@ -1,13 +1,11 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Email } from '@stamhoofd/email';
-import { BalanceItem, BalanceItemPayment, Invoice, Organization, Payment, StripeAccount, User } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, Organization, Payment, StripeAccount, User } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, getPaymentProviderName, InvoiceStruct, PaymentCustomer, PaymentMethod, PaymentProvider, PaymentStatus, PaymentType, TranslatedString } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, getPaymentProviderName, PaymentCustomer, PaymentMethod, PaymentProvider, PaymentStatus, PaymentType, TranslatedString } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import Stripe from 'stripe';
-import { InvoiceService } from '../services/InvoiceService.js';
 import { PaymentService } from '../services/PaymentService.js';
-import { AuthenticatedStructures } from './AuthenticatedStructures.js';
 import { VATService } from '../services/VATService.js';
 
 export class ApplicationFeeDetails {
@@ -120,12 +118,12 @@ export class StripeReportInvoicer {
     }
 
     async generateInvoices(sellingOrganization: Organization, reference: string) {
-        const invoices: Invoice[] = [];
+        const payments: Payment[] = [];
         for (const [account, details] of this.report.applicationFeesPerAccount) {
             try {
-                const invoice = await this.generateInvoice(sellingOrganization, reference, account, details);
-                if (invoice) {
-                    invoices.push(invoice);
+                const payment = await this.generateInvoice(sellingOrganization, reference, account, details);
+                if (payment) {
+                    payments.push(payment);
                 }
             } catch (e) {
                 console.error(e);
@@ -136,11 +134,11 @@ export class StripeReportInvoicer {
                 });
             }
         }
-        return invoices;
+        return payments;
     }
 
-    static async hasInvoice(sellingOrganization: Organization, reference: string) {
-        return !!await Invoice.select().where('organizationId', sellingOrganization.id).where('reference', reference).where('number', '!=', null).first(false);
+    static async hasPayment(sellingOrganization: Organization, reference: string) {
+        return !!await Payment.select().where('organizationId', sellingOrganization.id).where('reference', reference).where('status', PaymentStatus.Succeeded).first(false);
     }
 
     async generateInvoice(sellingOrganization: Organization, reference: string, accountId: string, applicationFee: ApplicationFeeDetails) {
@@ -174,46 +172,38 @@ export class StripeReportInvoicer {
             });
         }
 
-        const existingInvoices = await Invoice.select()
+        const existingPayments = await Payment.select()
             .where('organizationId', sellingOrganization.id)
             .where('payingOrganizationId', organization.id)
             .where('reference', reference)
-            .where('number', '!=', null)
+            .where('status', PaymentStatus.Succeeded)
             .fetch();
 
-        for (const i of existingInvoices) {
-            if (!i.stripeAccountId && i.totalWithVAT === applicationFee.amount) {
-                i.stripeAccountId = accountId;
-
-                console.log('Set stripe account id for invoice ' + i.number + ' to ' + accountId);
-                await i.save();
-            }
-
-            if (!i.stripeAccountId) {
+        for (const i of existingPayments) {
+            if (i.price !== applicationFee.amount) {
                 throw new SimpleError({
-                    code: 'invoice_already_exists_with_different_amount',
-                    message: 'Invoice without account id already exists with different amount ' + organization.id + ' expected ' + applicationFee.amount + ' got ' + i.totalWithVAT + ' in invoice ' + i.number,
+                    code: 'payment_already_exists_with_different_amount',
+                    message: 'Payment already exists with different amount ' + organization.id + ' expected ' + applicationFee.amount + ' got ' + i.price + ' in payment ' + i.id,
                 });
             }
+        }
 
-            if (i.stripeAccountId === accountId) {
-                if (i.totalWithVAT !== applicationFee.amount) {
-                    throw new SimpleError({
-                        code: 'invoice_already_exists_with_different_amount',
-                        message: 'Invoice already exists with different amount ' + organization.id + ' expected ' + applicationFee.amount + ' got ' + i.totalWithVAT + ' in invoice ' + i.number,
-                    });
-                }
-
-                // Already invoiced
-                console.warn('Tried to invoice an already invoiced.');
-                return;
-            }
+        if (existingPayments.length) {
+            console.warn('Tried to create an already created stripe invoice payment ' + existingPayments.map(p => p.id).join(', '));
+            return;
         }
 
         const customer = PaymentCustomer.create({
-            company: sellingOrganization.defaultCompanies[0],
+            company: organization.defaultCompanies[0],
         });
 
+        if (customer.company!.isSameEntity(seller)) {
+            throw new SimpleError({
+                code: 'same_customer',
+                message: 'Cannot invoice self',
+            });
+        }
+
         const balanceItems: BalanceItem[] = [];
 
         if (applicationFee.serviceFee !== 0) {
@@ -292,9 +282,10 @@ export class StripeReportInvoicer {
         payment.status = PaymentStatus.Pending;
         payment.price = applicationFee.amount;
         payment.roundingAmount = 0;
-        payment.method = PaymentMethod.Unknown;
+        payment.method = PaymentMethod.AccountDeductions;
         payment.type = PaymentType.Payment;
         payment.createMandate = null;
+        payment.reference = reference;
 
         payment.provider = PaymentProvider.Stripe;
         payment.stripeAccountId = stripeAccount.id;
@@ -310,23 +301,8 @@ export class StripeReportInvoicer {
             await balanceItemPayment.save();
         }
 
-        // Create invoice (before payment, to prevent auto-invoicing)
-        const generalStructs = await AuthenticatedStructures.paymentsGeneral([payment], false);
-
-        const invoiceStruct = InvoiceStruct.create({
-            seller,
-            customer: payment.customer,
-            payments: generalStructs,
-        });
-        invoiceStruct.buildFromPayments();
-
-        invoiceStruct.reference = reference;
-        invoiceStruct.stripeAccountId = accountId;
-
-        await PaymentService.handlePaymentStatusUpdate(payment, sellingOrganization, PaymentStatus.Succeeded, this.end);
-        const invoice = await InvoiceService.createFrom(sellingOrganization, invoiceStruct);
-
-        return invoice;
+        await PaymentService.handlePaymentStatusUpdate(payment, sellingOrganization, PaymentStatus.Succeeded, this.start);
+        return payment;
     }
 }
 
@@ -367,7 +343,7 @@ export class StripeInvoicer {
 
         try {
             await QueueHandler.schedule(reference, async () => {
-                if (!options?.force && await StripeReportInvoicer.hasInvoice(sellingOrganization, reference)) {
+                if (!options?.force && await StripeReportInvoicer.hasPayment(sellingOrganization, reference)) {
                     console.log('Already invoiced month', reference);
                     return;
                 }

package/src/services/BalanceItemService.ts

@@ -299,6 +299,23 @@ export class BalanceItemService {
         }
     }
 
+    /**
+     * Bump the updatedAt of the orders these balance items belong to. Clients keep a local copy
+     * of all orders (for offline support) and only pull in orders with a newer updatedAt, so this
+     * makes sure changes to the balance items of an order (or their payments) reach the clients.
+     */
+    static async markOrdersUpdated(items: BalanceItem[]) {
+        const orderIds = Formatter.uniqueArray(items.flatMap(item => item.orderId ? [item.orderId] : []));
+
+        for (const orderId of orderIds) {
+            const order = await Order.getByID(orderId);
+            if (order) {
+                order.markUpdated();
+                await order.save();
+            }
+        }
+    }
+
     static async undoPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
         // If order
         if (balanceItem.orderId) {
@@ -327,7 +344,7 @@ export class BalanceItemService {
 
     static async markFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
         // If order
-        if (balanceItem.orderId) {
+        if (balanceItem.orderId && payment.type === PaymentType.Payment) {
             const order = await Order.getByID(balanceItem.orderId);
             if (order) {
                 await order.onPaymentFailed(payment, organization);
@@ -343,7 +360,7 @@ export class BalanceItemService {
 
     static async undoFailed(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
         // If order
-        if (balanceItem.orderId) {
+        if (balanceItem.orderId && payment.type === PaymentType.Payment) {
             const order = await Order.getByID(balanceItem.orderId);
             if (order) {
                 await order.undoPaymentFailed(payment, organization);

package/src/services/InvoiceService.ts

@@ -61,6 +61,15 @@ export class InvoiceService {
             });
         }
 
+        if (struct.customer.company && struct.customer.company.isSameEntity(struct.seller)) {
+            throw new SimpleError({
+                code: 'invalid_customer',
+                message: 'Cannot self invoice',
+                human: $t('%ZaI'),
+                statusCode: 400,
+            });
+        }
+
         model.seller = struct.seller;
         model.organizationId = organization.id;
         model.payingOrganizationId = struct.payingOrganizationId;

package/src/services/MollieService.ts

@@ -1,5 +1,5 @@
 import type { Mandate, Payment as MolliePaymentType } from '@mollie/api-client';
-import { ApiMode, createMollieClient, MandateMethod, MandateStatus, PaymentMethod as molliePaymentMethod, PaymentStatus as molliePaymentStatus, OnboardingStatus, ProfileStatus, SequenceType } from '@mollie/api-client';
+import { ApiMode, createMollieClient, MandateMethod, MandateStatus, MollieApiError, PaymentMethod as molliePaymentMethod, PaymentStatus as molliePaymentStatus, OnboardingStatus, ProfileStatus, RefundStatus, SequenceType } from '@mollie/api-client';
 import { SimpleError } from '@simonbackx/simple-errors';
 import type { Payment, User } from '@stamhoofd/models';
 import type { Organization } from '@stamhoofd/models';
@@ -513,6 +513,83 @@ export class MollieService {
         };
     }
 
+    /**
+     * Create a refund at Mollie for a payment that was paid via Mollie.
+     * The amount is a (positive) price in the internal format (per ten thousand).
+     * Provider errors (e.g. amount higher than the refundable remainder, insufficient balance)
+     * are converted to SimpleErrors that can be shown to the user.
+     */
+    /**
+     * Map a Mollie refund status to a payment status. A refund only succeeds once Mollie
+     * reports it as refunded: before that it can still fail or be canceled.
+     */
+    static refundStatusToPaymentStatus(status: RefundStatus): PaymentStatus {
+        switch (status) {
+            case RefundStatus.refunded:
+                return PaymentStatus.Succeeded;
+            case RefundStatus.failed:
+            case RefundStatus.canceled:
+                return PaymentStatus.Failed;
+            default:
+                // queued, pending, processing
+                return PaymentStatus.Pending;
+        }
+    }
+
+    async createRefund({ payment, amount, description, metadata }: {
+        payment: Payment;
+        amount: number;
+        description: string;
+        metadata?: { [key: string]: string | undefined };
+    }): Promise<{ mollieRefundId: string; createdAt: Date; status: PaymentStatus }> {
+        const molliePayment = await MolliePayment.select().where('paymentId', payment.id).first(false);
+        if (!molliePayment) {
+            throw new SimpleError({
+                code: 'refund_not_supported',
+                message: 'Mollie payment not found for payment ' + payment.id,
+                human: $t('%Za1'),
+            });
+        }
+
+        const data: Parameters<typeof this.client.paymentRefunds.create>[0] = {
+            paymentId: molliePayment.mollieId,
+            amount: {
+                currency: 'EUR',
+                value: (Math.round(amount / 100) / 100).toFixed(2),
+            },
+            description,
+            metadata,
+            testmode: this.testMode,
+        };
+
+        console.log('Creating Mollie refund', data);
+
+        try {
+            const refund = await this.client.paymentRefunds.create(data);
+            console.log('Mollie refund response', refund);
+
+            return {
+                mollieRefundId: refund.id,
+                createdAt: new Date(refund.createdAt),
+                status: MollieService.refundStatusToPaymentStatus(refund.status),
+            };
+        } catch (e) {
+            console.error('Failed to create Mollie refund for payment ' + payment.id, e);
+
+            if (e instanceof MollieApiError) {
+                // E.g. the amount is higher than the remaining refundable amount, the payment
+                // was already (fully) refunded, or there is not enough balance available
+                throw new SimpleError({
+                    code: 'refund_failed',
+                    message: 'Mollie refused to create the refund: ' + e.message,
+                    human: $t('%ZZx', { message: e.message }),
+                    statusCode: 400,
+                });
+            }
+            throw e;
+        }
+    }
+
     async getStatus(payment: Payment, cancel = false) {
         const molliePayment = await MolliePayment.select().where('paymentId', payment.id).first(false);
         if (!molliePayment) {
@@ -527,4 +604,34 @@ export class MollieService {
 
         return this.getStatusFor(mollieData, payment, cancel);
     }
+
+    /**
+     * Get the status of a refund payment (type Refund). The linked MolliePayment row contains the
+     * Mollie refund id (re_...), while the source payment's row contains the Mollie payment id
+     * (tr_...) that is needed to address the refund in the Mollie API.
+     */
+    async getRefundStatus(refundPayment: Payment): Promise<{ status: PaymentStatus }> {
+        const mollieRefund = await MolliePayment.select().where('paymentId', refundPayment.id).first(false);
+        if (!mollieRefund) {
+            throw new Error('Mollie refund not found for payment ' + refundPayment.id);
+        }
+
+        if (!refundPayment.reversingPaymentId) {
+            throw new Error('Refund payment ' + refundPayment.id + ' is missing a reversing payment id');
+        }
+
+        const sourceMolliePayment = await MolliePayment.select().where('paymentId', refundPayment.reversingPaymentId).first(false);
+        if (!sourceMolliePayment) {
+            throw new Error('Mollie payment not found for source payment ' + refundPayment.reversingPaymentId);
+        }
+
+        const refund = await this.client.paymentRefunds.get(mollieRefund.mollieId, {
+            paymentId: sourceMolliePayment.mollieId,
+            testmode: this.testMode,
+        });
+
+        return {
+            status: MollieService.refundStatusToPaymentStatus(refund.status),
+        };
+    }
 }