@stamhoofd/backend 2.83.5 → 2.84.1

package/src/services/BalanceItemService.ts

@@ -1,57 +1,181 @@
-import { BalanceItem, Order, Organization, Payment, Webshop } from '@stamhoofd/models';
-import { AuditLogSource, BalanceItemStatus, OrderStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import { BalanceItem, CachedBalance, Document, MemberUser, Order, Organization, Payment, Webshop } from '@stamhoofd/models';
+import { AuditLogSource, BalanceItemStatus, BalanceItemType, OrderStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
 import { AuditLogService } from './AuditLogService';
-import { RegistrationService } from './RegistrationService';
 import { PaymentReallocationService } from './PaymentReallocationService';
-import { Formatter } from '@stamhoofd/utility';
+import { RegistrationService } from './RegistrationService';
+import { Model } from '@simonbackx/simple-database';
+import { GroupedThrottledQueue } from '../helpers/GroupedThrottledQueue';
+import { ThrottledQueue } from '../helpers/ThrottledQueue';
+
+const memberUpdateQueue = new GroupedThrottledQueue(async (organizationId: string, memberIds: string[]) => {
+    await CachedBalance.updateForMembers(organizationId, memberIds);
+
+    for (const memberId of memberIds) {
+        await PaymentReallocationService.reallocate(organizationId, memberId, ReceivableBalanceType.member);
+    }
+
+    if (memberIds.length) {
+        // Now also include the userIds of the members
+        const userMemberIds = (await MemberUser.select().where('membersId', memberIds).fetch()).map(m => m.usersId);
+        userUpdateQueue.addItems(organizationId, userMemberIds);
+    }
+}, { maxDelay: 10_000 });
+
+const userUpdateQueue = new GroupedThrottledQueue(async (organizationId: string, userIds: string[]) => {
+    await CachedBalance.updateForUsers(organizationId, userIds);
+
+    for (const userId of userIds) {
+        await PaymentReallocationService.reallocate(organizationId, userId, ReceivableBalanceType.user);
+    }
+}, { maxDelay: 10_000 });
+
+const organizationUpdateQueue = new GroupedThrottledQueue(async (organizationId: string, organizationIds: string[]) => {
+    await CachedBalance.updateForOrganizations(organizationId, organizationIds);
+
+    for (const payingOrganizationId of organizationIds) {
+        await PaymentReallocationService.reallocate(organizationId, payingOrganizationId, ReceivableBalanceType.organization);
+    }
+}, { maxDelay: 60_000 });
+
+export const registrationUpdateQueue = new GroupedThrottledQueue(async (organizationId: string, registrationIds: string[]) => {
+    await CachedBalance.updateForRegistrations(organizationId, registrationIds);
+    await Document.updateForRegistrations(registrationIds, organizationId);
+}, { maxDelay: 10_000 });
+
+const bundleDiscountsUpdateQueue = new ThrottledQueue(async (registrationIds: string[]) => {
+    for (const registrationId of registrationIds) {
+        await RegistrationService.updateDiscounts(registrationId);
+    }
+}, { maxDelay: 10_000 });
 
 export const BalanceItemService = {
-    /**
-     * Safe method to correct balance items that missed a markPaid call, but avoid double marking an order as valid.
-     */
-    async markPaidRepeated(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
-        if (balanceItem.pricePaid <= 0) {
+    listening: false,
+
+    listen() {
+        if (this.listening) {
             return;
         }
+        this.listening = true;
+        Model.modelEventBus.addListener(this, async (event) => {
+            if (!(event.model instanceof BalanceItem)) {
+                return;
+            }
 
-        await this.markDue(balanceItem);
+            if (event.type === 'created' || event.type === 'deleted') {
+                await this.scheduleUpdate(event.model);
+                return;
+            }
 
-        // Registrations are safe to mark valid multiple times
-        if (balanceItem.registrationId) {
-            await RegistrationService.markValid(balanceItem.registrationId);
+            // Check changed:
+            // status, unitPrice, dueAt, amount
+            if (
+                'status' in event.changedFields
+                || 'unitPrice' in event.changedFields
+                || 'dueAt' in event.changedFields
+                || 'amount' in event.changedFields
+                || 'memberId' in event.changedFields
+                || 'userId' in event.changedFields
+                || 'payingOrganizationId' in event.changedFields
+                || 'registrationId' in event.changedFields
+            ) {
+                await this.scheduleUpdate(event.model);
+            }
+        });
+    },
+
+    /**
+     * Schedule an update for the balance item:
+     * - Updates cached outstanding balances for members, users, organizations and registrations
+     *
+     * Does not execute the update immediately, but schedules it to be run in the background.
+     */
+    async scheduleUpdate(item: BalanceItem) {
+        await this.scheduleUpdates([item]);
+
+        // Todo: optimize
+        if (item.type === BalanceItemType.RegistrationBundleDiscount) {
+            // Save the applied discount to the related registration
+            if (item.registrationId) {
+                bundleDiscountsUpdateQueue.addItem(item.registrationId);
+            }
         }
+    },
 
-        // Orders aren't safe to mark paid twice - so only mark paid if not yet valid
-        // The only downside of this is that we won't send a paid email for transfer orders
-        // we should fix that in the future by introducing a paidAt timestamp for orders
-        if (balanceItem.orderId) {
-            const order = await Order.getByID(balanceItem.orderId);
-            if (order && !order.validAt) {
-                await order.markPaid(payment, organization);
+    /**
+     * Call this when a payment or payment balance items have changed.
+     * It will also call updateOutstanding automatically, so no need to call that separately again
+     */
+    async updatePaidAndPending(items: BalanceItem[]) {
+        console.log('updatePaidAndPending for', items.length, 'items');
+        await BalanceItem.updatePricePaid(items.map(i => i.id));
+        await this.scheduleUpdates(items);
+    },
 
-                // Save number in balance description
-                if (order.number !== null) {
-                    const webshop = await Webshop.getByID(order.webshopId);
+    /**
+     * In some situations we need immediate updates
+     */
+    async flushRegistrationDiscountsCache() {
+        await bundleDiscountsUpdateQueue.flushAndWait();
+    },
 
-                    if (webshop) {
-                        balanceItem.description = order.generateBalanceDescription(webshop);
-                        await balanceItem.save();
-                    }
-                }
+    /**
+     * Make sure all the pending changes for cached balances are run
+     */
+    async flushCaches(organizationId: string) {
+        await memberUpdateQueue.flushGroupAndWait(organizationId);
+        await userUpdateQueue.flushGroupAndWait(organizationId);
+        await organizationUpdateQueue.flushGroupAndWait(organizationId);
+        await registrationUpdateQueue.flushGroupAndWait(organizationId);
+        await bundleDiscountsUpdateQueue.flushAndWait();
+    },
+
+    async flushAll() {
+        await memberUpdateQueue.flushAndWait();
+        await userUpdateQueue.flushAndWait();
+        await organizationUpdateQueue.flushAndWait();
+        await registrationUpdateQueue.flushAndWait();
+        await bundleDiscountsUpdateQueue.flushAndWait();
+    },
+
+    /**
+     * Update how many every object in the system owes or needs to be reimbursed
+     * and also updates the pricePaid/pricePending cached values in Balance items and members
+     */
+    async scheduleUpdates(items: BalanceItem[]) {
+        console.log('Schedule outstanding balance for', items.length, 'items');
+
+        for (const item of items) {
+            if (item.memberId) {
+                memberUpdateQueue.addItem(item.organizationId, item.memberId);
+            }
+
+            if (item.userId) {
+                userUpdateQueue.addItem(item.organizationId, item.userId);
+            }
+
+            if (item.payingOrganizationId) {
+                organizationUpdateQueue.addItem(item.organizationId, item.payingOrganizationId);
+            }
+
+            if (item.registrationId) {
+                registrationUpdateQueue.addItem(item.organizationId, item.registrationId);
             }
         }
     },
 
     async markDue(balanceItem: BalanceItem) {
         if (balanceItem.status === BalanceItemStatus.Hidden) {
-            await BalanceItem.reactivateItems([balanceItem]);
+            balanceItem.status = BalanceItemStatus.Due;
+            await balanceItem.save();
         }
 
         // 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]);
+                depending.status = BalanceItemStatus.Due;
+                await balanceItem.save();
             }
         }
     },
@@ -59,13 +183,22 @@ export const BalanceItemService = {
     async markPaid(balanceItem: BalanceItem, payment: Payment | null, organization: Organization) {
         await this.markDue(balanceItem);
 
+        if (balanceItem.paidAt) {
+            // Already ran side effects
+            // If we for example deleted a related order or registration - and we still have the balance item, mark it as paid again, we don't want to reactivate the order or registration
+            await this.markUpdated(balanceItem, payment, organization);
+            return;
+        }
+
         // It is possible this balance item was earlier paid
         // and later the regigstration / order has been canceled and it became a negative balance item - which as some point has been reembursed and marked as 'paid'
         // in that case, we should be careful not to mark the registration as valid again
 
         // If registration
         if (balanceItem.registrationId) {
-            await RegistrationService.markValid(balanceItem.registrationId);
+            if (balanceItem.type === BalanceItemType.Registration) {
+                await RegistrationService.markValid(balanceItem.registrationId);
+            }
         }
 
         // If order
@@ -85,24 +218,9 @@ export const BalanceItemService = {
                 }
             }
         }
-    },
-
-    async reallocate(balanceItems: BalanceItem[], organizationId: string) {
-        const memberIds = Formatter.uniqueArray(balanceItems.map(b => b.memberId).filter(b => b !== null));
-        const payingOrganizationIds = Formatter.uniqueArray(balanceItems.map(b => b.payingOrganizationId).filter(b => b !== null));
-        const userIds = Formatter.uniqueArray(balanceItems.map(b => b.userId).filter(b => b !== null));
-
-        for (const memberId of memberIds) {
-            await PaymentReallocationService.reallocate(organizationId, memberId, ReceivableBalanceType.member);
-        }
-
-        for (const payingOrganizationId of payingOrganizationIds) {
-            await PaymentReallocationService.reallocate(organizationId, payingOrganizationId, ReceivableBalanceType.organization);
-        }
 
-        for (const userId of userIds) {
-            await PaymentReallocationService.reallocate(organizationId, userId, ReceivableBalanceType.user);
-        }
+        balanceItem.paidAt = new Date();
+        await balanceItem.save();
     },
 
     async markUpdated(balanceItem: BalanceItem, payment: Payment, organization: Organization) {
@@ -124,6 +242,7 @@ export const BalanceItemService = {
         if (balanceItem.orderId) {
             const order = await Order.getByID(balanceItem.orderId);
             if (order) {
+                // This is safe to run multiple times. Doesn't have side effects
                 await order.undoPaid(payment, organization);
             }
         }

package/src/services/FileSignService.ts

@@ -1,21 +1,30 @@
+import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3'; // ES Modules import
+import {
+    getSignedUrl,
+} from '@aws-sdk/s3-request-presigner';
 import { DecodedRequest, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { File } from '@stamhoofd/structures';
-import AWS from 'aws-sdk';
-import * as jose from 'jose';
 import chalk from 'chalk';
+import * as jose from 'jose';
 
 /**
  * This service creates signed urls for valid files
  */
 export class FileSignService {
-    static s3 = new AWS.S3({
-        endpoint: STAMHOOFD.SPACES_ENDPOINT,
-        accessKeyId: STAMHOOFD.SPACES_KEY,
-        secretAccessKey: STAMHOOFD.SPACES_SECRET,
-    });
+    static s3: S3Client;
 
     static async load() {
+        this.s3 = new S3Client({
+            forcePathStyle: false, // Configures to use subdomain/virtual calling format.
+            endpoint: 'https://' + STAMHOOFD.SPACES_ENDPOINT,
+            credentials: {
+                accessKeyId: STAMHOOFD.SPACES_KEY,
+                secretAccessKey: STAMHOOFD.SPACES_SECRET,
+            },
+            region: 'eu-west-1', // Not used, but required by the S3Client
+        });
+
         /**
          * Note the algorithm is only used for signing. For verification the algorithm inside the public keys are used
          */
@@ -96,20 +105,16 @@ export class FileSignService {
     }
 
     static async withSignedUrl(file: File, duration = 60 * 60) {
-        console.log('Generating signed url:', file.id);
-
         if (file.signedUrl) {
             console.error('Warning: file already signed');
         }
 
         try {
-            const url = await this.s3.getSignedUrlPromise('getObject', {
+            const command = new GetObjectCommand({
                 Bucket: STAMHOOFD.SPACES_BUCKET,
                 Key: file.path,
-                Expires: duration,
             });
-
-            console.log('Signed url:', url);
+            const url = await getSignedUrl(this.s3, command, { expiresIn: duration });
 
             return new File({
                 ...file,

package/src/services/MemberRecordStore.ts

@@ -1,5 +1,6 @@
 import { Model } from '@simonbackx/simple-database';
 import { Organization, Platform } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
 import { RecordSettings } from '@stamhoofd/structures';
 
 export type RecordCacheEntry = { record: RecordSettings; rootCategoryId: string; organizationId: string | null };
@@ -118,34 +119,42 @@ export class MemberRecordStore {
     static async loadAll() {
         this.cache = new Map<string, RecordCacheEntry>();
 
-        const platform = await Platform.getShared();
-        for (const recordCategory of platform.config.recordsConfiguration.recordCategories) {
-            for (const record of recordCategory.getAllRecords()) {
-                // Add to cache
-                this.cache.set(record.id, {
-                    record: record.clone(),
-                    organizationId: null,
-                    rootCategoryId: recordCategory.id,
-                });
-            }
-        }
+        // We use a queue here so we can abort this long running task properly
+        // + can await it when shutting down the server or tests
+        await QueueHandler.schedule('MemberRecordStore.loadAll', async ({ abort }) => {
+            this.cache = new Map<string, RecordCacheEntry>();
 
-        for await (const organization of Organization.select().all()) {
-            for (const recordCategory of organization.meta.recordsConfiguration.recordCategories) {
+            const platform = await Platform.getShared();
+            for (const recordCategory of platform.config.recordsConfiguration.recordCategories) {
                 for (const record of recordCategory.getAllRecords()) {
-                    if (this.cache.has(record.id)) {
-                        console.error(`Duplicate record id ${record.id} found in organization ${organization.id} for record ${record.name} (${record.id}) in ${recordCategory.name}`);
-                        continue;
-                    }
                     // Add to cache
                     this.cache.set(record.id, {
                         record: record.clone(),
-                        organizationId: organization.id,
+                        organizationId: null,
                         rootCategoryId: recordCategory.id,
                     });
                 }
             }
-        }
+            abort.throwIfAborted();
+
+            for await (const organization of Organization.select().all()) {
+                for (const recordCategory of organization.meta.recordsConfiguration.recordCategories) {
+                    for (const record of recordCategory.getAllRecords()) {
+                        if (this.cache.has(record.id)) {
+                            console.error(`Duplicate record id ${record.id} found in organization ${organization.id} for record ${record.name} (${record.id}) in ${recordCategory.name}`);
+                            continue;
+                        }
+                        // Add to cache
+                        this.cache.set(record.id, {
+                            record: record.clone(),
+                            organizationId: organization.id,
+                            rootCategoryId: recordCategory.id,
+                        });
+                    }
+                }
+                abort.throwIfAborted();
+            }
+        });
     }
 
     static async getRecord(id: string): Promise<RecordCacheEntry | null> {

package/src/services/PaymentReallocationService.test.ts

@@ -1,6 +1,7 @@
 import { BalanceItem, BalanceItemPayment, MemberFactory, Organization, OrganizationFactory, Payment } from '@stamhoofd/models';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, PaymentMethod, PaymentStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, PaymentMethod, PaymentStatus, ReceivableBalanceType, TranslatedString } from '@stamhoofd/structures';
 import { PaymentReallocationService } from './PaymentReallocationService';
+import { BalanceItemService } from './BalanceItemService';
 
 let sharedOrganization: Organization | undefined;
 
@@ -46,7 +47,7 @@ async function createItem(options: {
         for (const [type, id] of Object.entries(options.relations)) {
             b.relations.set(type as BalanceItemRelationType, BalanceItemRelation.create({
                 id,
-                name: 'Test ' + id,
+                name: new TranslatedString('Test ' + id),
             }));
         }
     }
@@ -100,7 +101,7 @@ async function createItem(options: {
         await balanceItemPayment.save();
     }
 
-    await BalanceItem.updateOutstanding([b]);
+    await BalanceItemService.updatePaidAndPending([b]);
     const balance = (await BalanceItem.getByID(b.id))!;
 
     await expectItem(balance, {
@@ -116,7 +117,7 @@ async function createItem(options: {
 }
 
 async function expectItem(b: BalanceItem, options: { pricePaid?: number; priceOpen?: number; pricePending?: number; paid?: number[]; pending?: number[]; failed?: number[] }) {
-    await BalanceItem.updateOutstanding([b]);
+    await BalanceItemService.updatePaidAndPending([b]);
     b = (await BalanceItem.getByID(b.id))!;
 
     const loaded = await BalanceItem.loadPayments([b]);
@@ -460,7 +461,7 @@ describe('PaymentReallocationService', () => {
             });
         });
 
-        it('Balances with different relations should create a reallocation payment', async () => {
+        it.skip('Balances with different relations should create a reallocation payment', async () => {
             const memberId = (await getMember()).id;
             const b1 = await createItem({
                 unitPrice: 30 * 100,
@@ -507,7 +508,7 @@ describe('PaymentReallocationService', () => {
             });
         });
 
-        it('Balances with different relations should create a reallocation payment with 3 items', async () => {
+        it.skip('Balances with different relations should create a reallocation payment with 3 items', async () => {
             const memberId = (await getMember()).id;
             const b1 = await createItem({
                 unitPrice: 45 * 100,
@@ -567,7 +568,7 @@ describe('PaymentReallocationService', () => {
             });
         });
 
-        it('Balances with different relations should create a reallocation payment with 3 items and remaining open should prefer most similar item', async () => {
+        it.skip('Balances with different relations should create a reallocation payment with 3 items and remaining open should prefer most similar item', async () => {
             const memberId = (await getMember()).id;
             const b1 = await createItem({
                 unitPrice: 40 * 100,
@@ -631,7 +632,7 @@ describe('PaymentReallocationService', () => {
         /**
          * Note: if this one fails randomly, it might because it isn't working stable enough and doesn't fulfil the requirements
          */
-        it('Balances with different relations should create a reallocation payment with 3 items and remaining open should prefer largest amount', async () => {
+        it.skip('Balances with different relations should create a reallocation payment with 3 items and remaining open should prefer largest amount', async () => {
             const memberId = (await getMember()).id;
             const b1 = await createItem({
                 unitPrice: 40 * 100,
@@ -686,7 +687,7 @@ describe('PaymentReallocationService', () => {
             });
         });
 
-        it('Balances with different relations should create a reallocation payment with 3 items and remaining open should prefer first due amount', async () => {
+        it('Balances due in the future should not be reallocated', async () => {
             const memberId = (await getMember()).id;
             const b1 = await createItem({
                 unitPrice: 40 * 100,
@@ -710,6 +711,11 @@ describe('PaymentReallocationService', () => {
                 objectId: memberId,
                 // This is due later, so it should be the last one to be paid
                 dueAt: new Date('2050-01-01'),
+                relations: {
+                    [BalanceItemRelationType.Group]: 'group1',
+                    [BalanceItemRelationType.GroupPrice]: 'defaultprice',
+                    [BalanceItemRelationType.Member]: 'member1',
+                },
             });
 
             const b3 = await createItem({
@@ -718,6 +724,11 @@ describe('PaymentReallocationService', () => {
                 paid: [],
                 priceOpen: 15 * 100, // This adds internal assert
                 objectId: memberId,
+                relations: {
+                    [BalanceItemRelationType.Group]: 'group1',
+                    [BalanceItemRelationType.GroupPrice]: 'defaultprice',
+                    [BalanceItemRelationType.Member]: 'member1',
+                },
             });
 
             await PaymentReallocationService.reallocate(
@@ -728,17 +739,17 @@ describe('PaymentReallocationService', () => {
 
             // Check if the balance items are now equal
             await expectItem(b1, {
-                priceOpen: 0,
-                paid: [40 * 100, -40 * 100],
+                priceOpen: -25_00, // Still paid 25 too much
+                paid: [25_00],
             });
 
             await expectItem(b2, {
-                priceOpen: 5 * 100,
-                paid: [25 * 100],
+                priceOpen: 30 * 100,
+                paid: [],
             });
 
             await expectItem(b3, {
-                priceOpen: 0 * 100,
+                priceOpen: 0 * 100, // Paid with canceled balance item that was already paid and should be refunded
                 paid: [15 * 100],
             });
         });

package/src/services/PaymentReallocationService.ts

@@ -2,6 +2,7 @@ import { BalanceItem, BalanceItemPayment, CachedBalance, Payment } from '@stamho
 import { SQL } from '@stamhoofd/sql';
 import { BalanceItemStatus, doBalanceItemRelationsMatch, PaymentMethod, PaymentStatus, PaymentType, ReceivableBalanceType } from '@stamhoofd/structures';
 import { Sorter } from '@stamhoofd/utility';
+import { BalanceItemService } from './BalanceItemService';
 
 type BalanceItemWithRemaining = {
     balanceItem: BalanceItem;
@@ -30,12 +31,12 @@ export const PaymentReallocationService = {
             return;
         }
 
-        let balanceItems = await CachedBalance.balanceForObjects(organizationId, [objectId], type);
+        let balanceItems = (await CachedBalance.balanceForObjects(organizationId, [objectId], type)).filter(b => b.isAfterDueDate);
 
         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;
             }
@@ -46,20 +47,20 @@ export const PaymentReallocationService = {
                 // Not possible to merge into one: there are 2 due items
                 continue;
             }
-            const similarCanceledItems = balanceItems.filter(b => b.id !== balanceItem.id && b.type === balanceItem.type && b.status !== BalanceItemStatus.Due && doBalanceItemRelationsMatch(b.relations, balanceItem.relations, 0));
+            const similarCanceledItems = balanceItems.filter(b => b.id !== balanceItem.id && b.type === balanceItem.type && b.status !== BalanceItemStatus.Due && (b.pricePaid !== 0 || b.pricePending !== 0) && doBalanceItemRelationsMatch(b.relations, balanceItem.relations, 0));
 
             if (similarCanceledItems.length) {
                 await this.mergeBalanceItems(balanceItem, similarCanceledItems);
                 didMerge.push(balanceItem, ...similarCanceledItems);
             }
-        }
+        } */
 
         if (didMerge.length) {
             // Update outstanding
-            await BalanceItem.updateOutstanding(didMerge);
+            await BalanceItemService.updatePaidAndPending(didMerge);
 
             // Reload balance items
-            balanceItems = await CachedBalance.balanceForObjects(organizationId, [objectId], type);
+            balanceItems = (await CachedBalance.balanceForObjects(organizationId, [objectId], type)).filter(b => b.isAfterDueDate);
         }
 
         // The algorithm:
@@ -93,6 +94,13 @@ export const PaymentReallocationService = {
                     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
+                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
                 alterPayments: true,
@@ -101,9 +109,19 @@ export const PaymentReallocationService = {
                 },
             },
             {
+                // Priority 2: 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
                 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);
                 },
             },
@@ -111,6 +129,7 @@ export const PaymentReallocationService = {
                 // 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);
                 },
             },
@@ -120,8 +139,8 @@ export const PaymentReallocationService = {
                 match: (negativeItem, p) => {
                     return p.balanceItem.type === negativeItem.balanceItem.type && p.remaining === -negativeItem.remaining;
                 },
-            },
-            {
+            }, */
+            /* {
                 // Priority 6: same type
                 alterPayments: false,
                 match: (negativeItem, p) => {
@@ -134,7 +153,7 @@ export const PaymentReallocationService = {
                 match: () => {
                     return true;
                 },
-            },
+            }, */
         ];
 
         for (const matchMethod of matchMethods) {
@@ -205,7 +224,7 @@ export const PaymentReallocationService = {
         }
 
         // Update outstanding
-        await BalanceItem.updateOutstanding([
+        await BalanceItemService.updatePaidAndPending([
             ...negativeItems.filter(n => n.remaining !== n.balanceItem.priceOpen).map(n => n.balanceItem),
             ...positiveItems.filter(p => p.remaining !== p.balanceItem.priceOpen).map(p => p.balanceItem),
         ]);