@stamhoofd/backend 2.120.6 → 2.122.0

package/src/services/InvoiceService.ts

@@ -1,79 +1,17 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { BalanceItem, BalanceItemPayment, Invoice, InvoicedBalanceItem, Organization, Payment } from '@stamhoofd/models';
-import { InvoicedBalanceItem as InvoicedBalanceItemStruct, Invoice as InvoiceStruct } from '@stamhoofd/structures';
+import { Email } from '@stamhoofd/email';
+import { BalanceItem, Invoice, InvoicedBalanceItem, Organization, Payment, sendEmailTemplate } from '@stamhoofd/models';
+import { InvoiceCounter } from '@stamhoofd/models/helpers/InvoiceCounter.js';
+import type { Invoice as InvoiceStruct } from '@stamhoofd/structures';
+import { EmailTemplateType, PaymentStatus, Recipient, Replacement } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { ViesHelper } from '../helpers/ViesHelper.js';
+import { BalanceItemService } from './BalanceItemService.js';
+import { InvoicePdfService } from './InvoicePdfService.js';
+import { InvoiceXMlService } from './InvoiceXMLService.js';
 
 export class InvoiceService {
-    static async invoicePayment(payment: Payment) {
-        if (!payment.customer) {
-            throw new SimpleError({
-                code: 'missing_customer',
-                message: 'Missing customer',
-                field: 'customer',
-                human: $t('%1Iw'),
-            });
-        }
-
-        if (payment.price % 100 !== 0) {
-            throw new SimpleError({
-                code: 'invalid_price_decimals',
-                message: 'Cannot invoice a payment with a price having more than two decimals',
-            });
-        }
-
-        const organization = payment.organizationId ? await Organization.getByID(payment.organizationId) : null;
-        if (!organization) {
-            throw new SimpleError({
-                code: 'missing_organization',
-                message: 'Cannot invoice a payment without corresponding organization',
-                statusCode: 500,
-            });
-        }
-
-        // Find default company
-        const seller = organization.meta.companies[0];
-
-        if (!seller) {
-            throw new SimpleError({
-                code: 'missing_company',
-                message: 'Missing invoice settings (companies)',
-                human: $t('%1Ix', {
-                    'organization-name': organization.name,
-                }),
-            });
-        }
-
-        const items: InvoicedBalanceItemStruct[] = [];
-        const balanceItemPayments = await BalanceItemPayment.select().where('paymentId', payment.id).fetch();
-        const balanceItems = await BalanceItem.getByIDs(...Formatter.uniqueArray(balanceItemPayments.map(d => d.balanceItemId)));
-
-        for (const balanceItemPayment of balanceItemPayments) {
-            const balanceItem = balanceItems.find(b => b.id === balanceItemPayment.balanceItemId);
-            if (!balanceItem) {
-                throw new SimpleError({
-                    code: 'missing_balance_item',
-                    message: 'Balance item missing for balanceItemPayment ' + balanceItemPayment.id,
-                    statusCode: 500,
-                });
-            }
-
-            const item = InvoicedBalanceItemStruct.createFor(balanceItem.getStructure(), balanceItemPayment.price);
-            items.push(item);
-        }
-
-        const struct = InvoiceStruct.create({
-            organizationId: organization.id,
-            seller,
-            customer: payment.customer,
-            payingOrganizationId: payment.payingOrganizationId,
-            items,
-        });
-
-        return await this.createFrom(organization, struct, { payments: [payment], balanceItems });
-    }
-
-    static async createFrom(organization: { id: string }, struct: InvoiceStruct, options?: { payments?: Payment[]; balanceItems?: BalanceItem[] }) {
+    static async createFrom(organization: Organization, struct: InvoiceStruct, options?: { payments?: Payment[]; balanceItems?: BalanceItem[] }) {
         if (struct.number) {
             throw new SimpleError({
                 code: 'invalid_field',
@@ -103,6 +41,7 @@ export class InvoiceService {
             throw new SimpleError({
                 code: 'invalid_invoiced_amount',
                 message: 'Unexpected 0 totalBalanceInvoicedAmount',
+                statusCode: 400,
             });
         }
 
@@ -114,6 +53,14 @@ export class InvoiceService {
             });
         }
 
+        if (struct.totalWithVAT === 0) {
+            throw new SimpleError({
+                code: 'invalid_invoiced_amount',
+                message: 'Cannot invoice zero',
+                statusCode: 400,
+            });
+        }
+
         model.seller = struct.seller;
         model.organizationId = organization.id;
         model.payingOrganizationId = struct.payingOrganizationId;
@@ -131,7 +78,8 @@ export class InvoiceService {
         model.stripeAccountId = struct.stripeAccountId;
         model.reference = struct.reference;
 
-        model.negativeInvoiceId = struct.negativeInvoiceId;
+        // todo: permission checks
+        // model.negativeInvoiceId = struct.negativeInvoiceId;
 
         if (Math.abs(model.payableRoundingAmount) > 10_00) {
             throw new SimpleError({
@@ -166,9 +114,27 @@ export class InvoiceService {
                     message: 'You cannot invoice a payment multiple times',
                 });
             }
+
+            if (payment.status === PaymentStatus.Failed) {
+                throw new SimpleError({
+                    code: 'failed_payment',
+                    message: 'You cannot invoice failed payments',
+                    human: $t('%1ZW'),
+                });
+            }
+        }
+
+        const balanceItemIds = Formatter.uniqueArray(struct.items.map(i => i.balanceItemId));
+
+        // Make sure priceInvoiced is up to date for these balances
+        const affected = await BalanceItem.updateInvoiced(balanceItemIds);
+
+        if (affected && options?.balanceItems) {
+            // Force update
+            options!.balanceItems = undefined;
         }
 
-        const balanceItems = options?.balanceItems ?? await BalanceItem.getByIDs(...Formatter.uniqueArray(struct.items.map(i => i.balanceItemId)));
+        const balanceItems = options?.balanceItems ?? await BalanceItem.getByIDs(...balanceItemIds);
         await model.save();
 
         try {
@@ -184,6 +150,95 @@ export class InvoiceService {
                 }
 
                 // Todo: check we are not invoicing more than maximum invoiceable for these items
+                const maximumInvoiceable = balanceItem.priceDue; // € - 10
+                const alreadyInvoiced = balanceItem.priceInvoiced; // € 5
+                const left = maximumInvoiceable - alreadyInvoiced; // € -15
+                const goingToInvoice = item.balanceInvoicedAmount;
+
+                if (item.quantity === 0) {
+                    // should not be saved!
+                    throw new SimpleError({
+                        statusCode: 400,
+                        code: 'zero_quantity',
+                        message: 'Cannot invoice a quantity of zero',
+                        human: $t('%1RZ'),
+                    });
+                }
+
+                if (left < 0) {
+                    if (goingToInvoice > 0) {
+                        // Item should be credited, yet we are trying to invoice it
+                        throw new SimpleError({
+                            code: 'error',
+                            message: 'Cannot invoice',
+                            human: $t('%1RB', {
+                                'a-euro': Formatter.price(goingToInvoice),
+                                'name': balanceItem.getStructure().itemTitle,
+                                'left-euro': Formatter.price(-left),
+                            }),
+                        });
+                    }
+
+                    if (goingToInvoice < left) {
+                        // too much
+                        throw new SimpleError({
+                            code: 'error',
+                            message: 'Cannot invoice',
+                            human: $t('%1Tm', {
+                                'a-euro': Formatter.price(-goingToInvoice),
+                                'name': balanceItem.getStructure().itemTitle,
+                                'left-euro': Formatter.price(-left),
+                            }),
+                        });
+                    }
+                }
+
+                if (left === 0) {
+                    if (goingToInvoice < 0) {
+                        console.log(item);
+                        throw new SimpleError({
+                            code: 'error',
+                            message: 'Cannot invoice',
+                            human: $t('%1R7', {
+                                'a-euro': Formatter.price(-goingToInvoice),
+                                'name': balanceItem.getStructure().itemTitle,
+                            }),
+                        });
+                    } else if (goingToInvoice > 0) {
+                        throw new SimpleError({
+                            code: 'error',
+                            message: 'Cannot invoice',
+                            human: $t('%1QE', {
+                                'a-euro': Formatter.price(-goingToInvoice),
+                                'name': balanceItem.getStructure().itemTitle,
+                            }),
+                        });
+                    }
+                }
+
+                if (left > 0) {
+                    if (goingToInvoice < 0) {
+                        throw new SimpleError({
+                            code: 'error',
+                            message: 'Cannot invoice',
+                            human: $t('%1RA', {
+                                'a-euro': Formatter.price(-goingToInvoice),
+                                'name': balanceItem.getStructure().itemTitle,
+                                'left-euro': Formatter.price(left),
+                            }),
+                        });
+                    } else if (goingToInvoice > left) {
+                        throw new SimpleError({
+                            code: 'error',
+                            message: 'Cannot invoice',
+                            human: $t('%1TS', {
+                                'a-euro': Formatter.price(-goingToInvoice),
+                                'name': balanceItem.getStructure().itemTitle,
+                                'left-euro': Formatter.price(left),
+                            }),
+                        });
+                    }
+                }
 
                 const invoiced = new InvoicedBalanceItem();
                 invoiced.invoiceId = model.id;
@@ -212,12 +267,24 @@ export class InvoiceService {
                 payment.invoiceId = model.id;
                 await payment.save();
             }
-        }
-        catch (e) {
+
+            // Finalize invoice by generating a number
+            await InvoiceCounter.assignNextNumber(model, organization.privateMeta.invoiceSettings);
+
+            // Update invoiced cache
+            await BalanceItemService.updateInvoiced(struct.items.map(i => i.balanceItemId));
+
+            // Create PDF
+            await InvoicePdfService.generatePdf(model);
+            await InvoiceXMlService.generateXml(model);
+
+            if (!await this.forwardInvoice(model, organization)) {
+                await this.sendCustomerEmail(model, organization);
+            }
+        } catch (e) {
             try {
                 await model.delete();
-            }
-            catch (ee) {
+            } catch (ee) {
                 console.error('Error while trying to delete invoice because of fail save', ee, 'Deleting because of error', e);
             }
             throw e;
@@ -225,4 +292,190 @@ export class InvoiceService {
 
         return model;
     }
+
+    private static shouldForwardInvoice(invoice: Invoice, organization: Organization) {
+        if (invoice.didSendPeppol) {
+            return {
+                value: false,
+            };
+        }
+
+        if (!invoice.customer.company?.peppolEndpointId) {
+            return {
+                value: false,
+                reason: 'No customer peppol endpoint id found for this invoice',
+            };
+        }
+
+        // Legally sending an invoice via PEPPOL is not always required.
+        // Logic: send if required or a custom peppol endpoint id is set
+        if (organization.privateMeta.invoiceSettings.forwardOnlyVAT) {
+            if (!invoice.customer.company?.customPeppolEndpointId) {
+                if (!invoice.customer?.company?.VATNumber || !invoice.customer?.company?.VATNumber.startsWith('BE')) {
+                    return {
+                        value: false,
+                        reason: 'Skipping PEPPOL for invoice ' + invoice.id + ', recipient no Belgian VAT number and no custom peppol endpoint id set',
+                    };
+                }
+            }
+        }
+
+        return {
+            value: true,
+        };
+    }
+
+    /**
+     * This is used for PEPPOL.
+     * Invoice is forwarded to an external invoicing tool which will send it via PEPPOL.
+     */
+    static async forwardInvoice(invoice: Invoice, organization: Organization) {
+        const { value, reason } = this.shouldForwardInvoice(invoice, organization);
+
+        if (!value) {
+            if (reason) {
+                console.log('Skipped sending PEPPOL: ', reason);
+            }
+            return;
+        }
+
+        if (!organization.privateMeta.invoiceSettings.forwardEmailHandlers.length) {
+            console.error('PEPPOL email handlers NOT CONFIGURED');
+            return;
+        }
+
+        const xml = await invoice.xml?.withSignedUrl();
+
+        if (!xml) {
+            console.error('Could not send PEPPOL for invoice ' + invoice.id + ', xml not set');
+            return;
+        }
+
+        // Send the e-mail
+        Email.send({
+            // From address is fixed for sender validation
+            from: Email.getWebmasterFromEmail(),
+            to: organization.privateMeta.invoiceSettings.forwardEmailHandlers.map((d) => {
+                return {
+                    email: d,
+                };
+            }),
+            subject: $t('%1Zw') + ' ' + invoice.number,
+            text: $t('%1X5'),
+            attachments: [
+                {
+                    filename: invoice.generateCustomerFilename('xml'),
+                    href: xml.getPublicPath(),
+                    contentType: 'application/xml',
+                },
+            ],
+        });
+
+        invoice.didSendPeppol = true;
+        await invoice.save();
+        return true;
+    }
+
+    static async sendCustomerEmail(invoice: Invoice, organization: Organization) {
+        let email = (invoice.customer.email || invoice.customer.company?.administrationEmail) ?? undefined;
+        let bcc = invoice.customer.company?.administrationEmail;
+
+        if (!email && invoice.payingOrganizationId) {
+            const payingOrganization = await Organization.getByID(invoice.payingOrganizationId);
+            if (payingOrganization) {
+                email = (await payingOrganization.getInvoicingToEmail()) ?? undefined;
+            }
+        }
+
+        if (bcc === email) {
+            bcc = undefined;
+        }
+
+        if (!email) {
+            console.log('Skipped sending invoice email: no email address found for ' + invoice.id);
+            return;
+        }
+
+        const payments = await Payment.select().where('invoiceId', invoice.id).fetch();
+        const isPaid = payments.every(p => p.status === PaymentStatus.Succeeded);
+
+        const pdf = await invoice.pdf?.withSignedUrl();
+        const xml = await invoice.xml?.withSignedUrl();
+
+        const recipients = [
+            Recipient.create({
+                email,
+                replacements: [
+                    Replacement.create({
+                        token: 'invoiceNumber',
+                        value: invoice.number ?? '',
+                    }),
+                    Replacement.create({
+                        token: 'totalPrice',
+                        value: Formatter.price(Math.abs(invoice.totalWithVAT)),
+                    }),
+                ],
+            }),
+        ];
+
+        if (bcc) {
+            recipients.push(Recipient.create({
+                email: bcc,
+                replacements: [
+                    Replacement.create({
+                        token: 'invoiceNumber',
+                        value: invoice.number ?? '',
+                    }),
+                    Replacement.create({
+                        token: 'totalPrice',
+                        value: Formatter.price(Math.abs(invoice.totalWithVAT)),
+                    }),
+                ],
+            }));
+        }
+
+        await sendEmailTemplate(organization, {
+            recipients: [
+                Recipient.create({
+                    email,
+                    replacements: [
+                        Replacement.create({
+                            token: 'invoiceNumber',
+                            value: invoice.number ?? '',
+                        }),
+                        Replacement.create({
+                            token: 'totalPrice',
+                            value: Formatter.price(Math.abs(invoice.totalWithVAT)),
+                        }),
+                    ],
+                }),
+            ],
+            template: {
+                type: isPaid
+                    ? (invoice.totalWithVAT >= 0 ? EmailTemplateType.InvoicePaid : EmailTemplateType.CreditNotePaid)
+                    : (invoice.totalWithVAT >= 0 ? EmailTemplateType.InvoiceUnpaid : EmailTemplateType.CreditNoteUnpaid),
+            },
+            type: 'transactional',
+            attachments: [
+                ...(pdf
+                    ? [
+                            {
+                                filename: invoice.generateCustomerFilename('pdf'),
+                                href: pdf.getPublicPath(),
+                                contentType: 'application/pdf',
+                            },
+                        ]
+                    : []),
+                ...(xml
+                    ? [
+                            {
+                                filename: invoice.generateCustomerFilename('xml'),
+                                href: xml.getPublicPath(),
+                                contentType: 'application/xml',
+                            },
+                        ]
+                    : []),
+            ],
+        });
+    }
 }