@stamhoofd/backend 2.106.1 → 2.107.0

package/src/services/PaymentReallocationService.ts

@@ -36,7 +36,7 @@ export const PaymentReallocationService = {
         const didMerge: BalanceItem[] = [];
 
         // First try to merge balance items that are the same and have canceled variants
-        /* for (const balanceItem of balanceItems) {
+        for (const balanceItem of balanceItems) {
             if (balanceItem.status !== BalanceItemStatus.Due) {
                 continue;
             }
@@ -53,7 +53,7 @@ export const PaymentReallocationService = {
                 await this.mergeBalanceItems(balanceItem, similarCanceledItems);
                 didMerge.push(balanceItem, ...similarCanceledItems);
             }
-        } */
+        }
 
         if (didMerge.length) {
             // Update outstanding
@@ -79,6 +79,13 @@ export const PaymentReallocationService = {
         const negativeItems = balanceItems.filter(b => b.priceOpen < 0).map(balanceItem => ({ balanceItem, remaining: balanceItem.priceOpen }));
         const positiveItems = balanceItems.filter(b => b.priceOpen > 0).map(balanceItem => ({ balanceItem, remaining: balanceItem.priceOpen }));
 
+        // If the total remaining is zero, we'll just merge everything together. This removes the restriction that two merged balance items should have the same remaining amount.
+        const canReachZero = (negativeItems.reduce((p, i) => p + i.remaining, 0) === -positiveItems.reduce((p, i) => p + i.remaining, 0));
+
+        // Rules:
+        // Total outstanding amount should be zero to merge all items into one payment reallocation
+        // otherwise, only swap if the amounts match exactly
+
         if (negativeItems.length === 0 || positiveItems.length === 0) {
             return;
         }
@@ -88,48 +95,58 @@ export const PaymentReallocationService = {
 
         const matchMethods: { alterPayments: boolean; match: (negativeItem: BalanceItemWithRemaining, positive: BalanceItemWithRemaining) => boolean }[] = [
             {
-                // Priority 1: same relation ids, same amount
+                // Priority 1: same type, same relation ids, same amount
                 alterPayments: true,
                 match: (negativeItem, p) => {
                     return p.remaining === -negativeItem.remaining && p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 0);
                 },
             },
             {
-                // Priority 1: same relation ids, same amount
+                // Priority 1: same type, same relation ids, same amount
                 alterPayments: false,
                 match: (negativeItem, p) => {
                     return p.remaining === -negativeItem.remaining && p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 0);
                 },
             },
             {
-                // Priority 2: same relation ids, different amount
+                // Priority 2: same type, same relation ids, different amount
                 alterPayments: true,
                 match: (negativeItem, p) => {
                     return p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 0);
                 },
             },
             {
-                // Priority 2: same relation ids, different amount
+                // Priority 2: same type, same relation ids, different amount
                 alterPayments: false,
                 match: (negativeItem, p) => {
                     return p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 0);
                 },
             },
-
-            // For now I would skip the next priorties because merging these often creates a lot of confusion
-            /* {
+            {
+                // Priority 3: same type, one mismatching relation id, same amount
+                alterPayments: false,
+                match: (negativeItem, p) => {
+                    return p.remaining === -negativeItem.remaining && p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 1);
+                },
+            },
+            {
                 // Priority 3: same type, one mismatching relation id
                 alterPayments: false,
                 match: (negativeItem, p) => {
-                    // todo: maybe do allow this, but only if the amount is the same
                     return p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 1);
                 },
             },
+            {
+                // Priority 4: same type, two mismatching relation ids, same amount
+                alterPayments: false,
+                match: (negativeItem, p) => {
+                    return p.remaining === -negativeItem.remaining && p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 2);
+                },
+            },
             {
                 // Priority 4: same type, two mismatching relation ids
                 alterPayments: false,
                 match: (negativeItem, p) => {
-                    // todo: maybe do allow this, but only if the amount is the same
                     return p.balanceItem.type === negativeItem.balanceItem.type && doBalanceItemRelationsMatch(p.balanceItem.relations, negativeItem.balanceItem.relations, 2);
                 },
             },
@@ -139,8 +156,15 @@ export const PaymentReallocationService = {
                 match: (negativeItem, p) => {
                     return p.balanceItem.type === negativeItem.balanceItem.type && p.remaining === -negativeItem.remaining;
                 },
-            }, */
-            /* {
+            },
+            {
+                // Priority 6: same amount
+                alterPayments: false,
+                match: (negativeItem, p) => {
+                    return p.remaining === -negativeItem.remaining;
+                },
+            },
+            {
                 // Priority 6: same type
                 alterPayments: false,
                 match: (negativeItem, p) => {
@@ -150,10 +174,10 @@ export const PaymentReallocationService = {
             {
                 // Priority: any
                 alterPayments: false,
-                match: () => {
+                match: (negativeItem, p) => {
                     return true;
                 },
-            }, */
+            },
         ];
 
         for (const matchMethod of matchMethods) {
@@ -172,7 +196,7 @@ export const PaymentReallocationService = {
                 }
 
                 const match = positiveItems.find((p) => {
-                    return p.remaining > 0 && matchMethod.match(negativeItem, p);
+                    return p.remaining > 0 && matchMethod.match(negativeItem, p) && (matchMethod.alterPayments || canReachZero || p.remaining === -negativeItem.remaining);
                 });
 
                 if (!match) {
@@ -183,6 +207,12 @@ export const PaymentReallocationService = {
                     await this.swapPayments(negativeItem, match);
                 }
                 else {
+                    if (match.remaining !== -negativeItem.remaining) {
+                        if (!canReachZero) {
+                            continue;
+                        }
+                    }
+
                     // Add to pending payment
                     const moveAmount = Math.min(match.remaining, -negativeItem.remaining);
 

package/src/services/PaymentService.ts

@@ -1,11 +1,11 @@
 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 { AuditLogSource, PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
+import { AuditLogSource, BalanceItemRelation, BalanceItemStatus, BalanceItemType, PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
 import { BuckarooHelper } from '../helpers/BuckarooHelper';
 import { StripeHelper } from '../helpers/StripeHelper';
-import { BalanceItemPaymentService } from './BalanceItemPaymentService';
 import { AuditLogService } from './AuditLogService';
+import { BalanceItemPaymentService } from './BalanceItemPaymentService';
 import { BalanceItemService } from './BalanceItemService';
 
 export const PaymentService = {
@@ -331,4 +331,51 @@ export const PaymentService = {
         }
         return false;
     },
+
+    /**
+     * Say the total amount to pay is 15,238 because (e.g. because of VAT). In that case,
+     * we'll need to round the payment to 1 cent. That can cause issues in the financial statements because
+     * the total amount of balances does not match the total amount received/paid.
+     * 
+     * To fix that, we create an extra balance item with the difference. So the rounding always matches.
+     */
+    async round(payment: Payment) {
+        if (!payment.organizationId) {
+            throw new Error('Cannot round payments without organizationId')
+        }
+        
+        const amount = payment.price;
+        const rounded = Payment.roundPrice(payment.price)
+        const difference = rounded - amount;
+
+        if (difference === 0) {
+            return;
+        }
+
+        if (difference > 100) {
+            throw new Error('Unexpected rounding difference.')
+        }
+
+        const balanceItem = new BalanceItem();
+        balanceItem.type = BalanceItemType.Rounding;
+        balanceItem.userId = payment.payingUserId;
+        balanceItem.payingOrganizationId = payment.payingOrganizationId
+        balanceItem.unitPrice = difference;
+        balanceItem.pricePaid = 0;
+        balanceItem.organizationId = payment.organizationId;
+        balanceItem.status = BalanceItemStatus.Hidden;
+        await balanceItem.save();
+
+        // Create balance item payment
+        const balanceItemPayment = new BalanceItemPayment();
+        balanceItemPayment.organizationId = payment.organizationId;
+        balanceItemPayment.balanceItemId = balanceItem.id;
+        balanceItemPayment.price = difference;
+        balanceItemPayment.paymentId = payment.id;
+        await balanceItemPayment.save();
+
+        // Change payment total price
+        payment.price += difference
+        await payment.save();
+    }
 };

package/src/services/uitpas/getSocialTariffForEvent.ts

@@ -29,7 +29,7 @@ function assertsIsStaticSocialTariffResponse(json: unknown): asserts json is Sta
 export async function getSocialTariffForEvent(access_token: string, basePrice: number, uitpasEventUrl: string) {
     const baseUrl = 'https://api-test.uitpas.be/tariffs/static';
     const params = new URLSearchParams();
-    params.append('regularPrice', (basePrice / 100).toFixed(2));
+    params.append('regularPrice', (basePrice / 10_000).toFixed(2));
     const eventId = uitpasEventUrl.split('/').pop(); // Extract the event ID from the URL
     if (!eventId) {
         throw new SimpleError({
@@ -86,5 +86,5 @@ export async function getSocialTariffForEvent(access_token: string, basePrice: n
     if (json.available.length > 1) {
         console.warn('Multiple social tariffs available for event', eventId, '(used ', json.available[0].price, ' as base price. All options:', json.available);
     }
-    return Math.round(json.available[0].price * 100);
+    return Math.round(json.available[0].price * 100) * 100;
 }

package/src/services/uitpas/getSocialTariffForUitpasNumbers.ts

@@ -54,7 +54,7 @@ function isSocialTariffErrorResponse(
 async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber: string, basePrice: number, uitpasEventUrl: string) {
     const baseUrl = 'https://api-test.uitpas.be/tariffs';
     const params = new URLSearchParams();
-    params.append('regularPrice', (basePrice / 100).toFixed(2));
+    params.append('regularPrice', (basePrice / 1_0000).toFixed(2));
     const eventId = uitpasEventUrl.split('/').pop();
     if (!eventId) {
         throw new SimpleError({
@@ -156,7 +156,7 @@ async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber
     console.log('Social tariff for UiTPAS number', uitpasNumber, 'with event id', uitpasEventUrl, 'is', json.available[0].price, 'euros');
     return UitpasNumberAndPrice.create({
         uitpasNumber,
-        price: Math.round((json.available[0].price) * 100),
+        price: Math.round((json.available[0].price) * 100) * 100,
         uitpasTariffId: json.available[0].id,
     });
 }

package/src/services/uitpas/registerTicketSales.ts

@@ -76,7 +76,7 @@ export async function registerTicketSales(access_token: string, registerTicketSa
         return {
             uitpasNumber: ticketSale.uitpasNumber,
             eventId,
-            regularPrice: (ticketSale.basePrice / 100).toFixed(2), // Convert from cents to euros
+            regularPrice: (ticketSale.basePrice / 10000).toFixed(2), // Convert from 4 decimals to 0 decimals
             regularPriceLabel: ticketSale.basePriceLabel,
             tariff: {
                 id: ticketSale.uitpasTariffId,
@@ -131,7 +131,7 @@ export async function registerTicketSales(access_token: string, registerTicketSa
         }
         results.set(request, {
             ticketSaleId: ticketSale.id,
-            reducedPriceUitpas: Math.round(ticketSale.tariff.price * 100),
+            reducedPriceUitpas: Math.round(ticketSale.tariff.price * 100) * 100,
             registeredAt: now,
         });
     }