@stamhoofd/backend 2.121.0 → 2.122.0

package/src/services/PaymentMandateService.ts

@@ -1,8 +1,8 @@
 import type { User } from '@stamhoofd/models';
 import { Organization } from '@stamhoofd/models';
 import { Platform } from '@stamhoofd/models';
-import { PaymentMandateStatus  } from '@stamhoofd/structures/PaymentMandate.js';
-import type {PaymentMandate} from '@stamhoofd/structures/PaymentMandate.js';
+import { PaymentMandateStatus } from '@stamhoofd/structures/PaymentMandate.js';
+import type { PaymentMandate } from '@stamhoofd/structures/PaymentMandate.js';
 import { MollieService } from './MollieService.js';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Context } from '../helpers/Context.js';
@@ -10,25 +10,25 @@ import { PaymentProvider } from '@stamhoofd/structures';
 
 export class PaymentMandateService {
     static async getMandates({ sellingOrganization, user, payingOrganization }: {
-        sellingOrganization: Organization,
+        sellingOrganization: Organization;
 
         /**
          * Mandates for B2B payments
          */
-        payingOrganization: Organization | null, 
+        payingOrganization: Organization | null;
 
         /**
          * Not yet supported, but in the future you'll be able to save mandates for a certain user.
          * Only for B2C payments
          */
-        user: User | null,
+        user: User | null;
     }): Promise<PaymentMandate[]> {
         if (!payingOrganization) {
             // Not yet supportedd
             return [];
         }
 
-        const mollieService = await MollieService.create({sellingOrganization});
+        const mollieService = await MollieService.create({ sellingOrganization });
         if (!mollieService) {
             return [];
         }
@@ -38,31 +38,31 @@ export class PaymentMandateService {
             return [];
         }
 
-        return await mollieService.getMandates({payingOrganization, user});
+        return await mollieService.getMandates({ payingOrganization, user });
     }
 
     static async deleteMandate({ mandateId, sellingOrganization, user, payingOrganization }: {
-        mandateId: string, 
+        mandateId: string;
 
-        sellingOrganization: Organization,
+        sellingOrganization: Organization;
 
         /**
          * Mandates for B2B payments
          */
-        payingOrganization: Organization | null, 
+        payingOrganization: Organization | null;
 
         /**
          * Not yet supported, but in the future you'll be able to save mandates for a certain user.
          * Only for B2C payments
          */
-        user: User | null,
+        user: User | null;
     }) {
         const mandates = await PaymentMandateService.getMandates({
             sellingOrganization,
             user,
-            payingOrganization
+            payingOrganization,
         });
-        const {grouped} = this.groupByMandate(mandates);
+        const { grouped } = this.groupByMandate(mandates);
         const match = mandates.find(m => m.id === mandateId);
 
         if (!match) {
@@ -70,8 +70,8 @@ export class PaymentMandateService {
             throw new SimpleError({
                 code: 'not_allowed',
                 message: 'Mandate not found',
-                human: $t('%1Q1')
-            })
+                human: $t('%1Q1'),
+            });
         }
 
         if (match.isDefault) {
@@ -79,8 +79,8 @@ export class PaymentMandateService {
                 throw new SimpleError({
                     code: 'not_allowed',
                     message: 'You cannot delete the default mandate',
-                    human: $t('%1Qu')
-                })
+                    human: $t('%1Qu'),
+                });
             }
         }
 
@@ -89,8 +89,8 @@ export class PaymentMandateService {
                 throw new SimpleError({
                     code: 'not_allowed',
                     message: 'You cannot delete the last mandate',
-                    human: $t('%1Q7')
-                })
+                    human: $t('%1Q7'),
+                });
             }
         }
 
@@ -100,7 +100,7 @@ export class PaymentMandateService {
             if (mandate.identifier === deleteId) {
                 // delete (todo)
                 if (mandate.provider === PaymentProvider.Mollie) {
-                    const mollieService = await MollieService.create({sellingOrganization});
+                    const mollieService = await MollieService.create({ sellingOrganization });
                     if (!mollieService) {
                         return [];
                     }
@@ -109,31 +109,31 @@ export class PaymentMandateService {
                         await mollieService.deleteMandate({
                             mandateId: mandate.id,
                             payingOrganization,
-                            user
-                        })
+                            user,
+                        });
                     } catch (e) {
-                        console.error('Failed to delete Mollie mandate', mandateId, e)
+                        console.error('Failed to delete Mollie mandate', mandateId, e);
                     }
                 }
             }
         }
     }
 
-    static async setDefaultMandate({ mandateId, sellingOrganization, payingUserId, payingOrganizationId }: {
-        mandateId: string, 
+    static async setDefaultMandate({ mandateId, sellingOrganizationId, payingUserId, payingOrganizationId }: {
+        mandateId: string;
 
-        sellingOrganization: Organization,
+        sellingOrganizationId: string;
 
         /**
          * Mandates for B2B payments
          */
-        payingOrganizationId: Organization | string | null, 
+        payingOrganizationId: Organization | string | null;
 
         /**
          * Not yet supported, but in the future you'll be able to save mandates for a certain user.
          * Only for B2C payments
          */
-        payingUserId: string | null,
+        payingUserId: string | null;
     }) {
         try {
             if (!payingOrganizationId) {
@@ -141,28 +141,28 @@ export class PaymentMandateService {
                 return;
             }
 
-            if (sellingOrganization.id !== (await Platform.getShared()).membershipOrganizationId) {
+            if (sellingOrganizationId !== (await Platform.getShared()).membershipOrganizationId) {
                 // Not yet supported
                 return [];
             }
-        
+
             // Set as default
             if (payingOrganizationId) {
                 const payingOrganization = typeof payingOrganizationId === 'string' ? await Organization.getByID(payingOrganizationId) : payingOrganizationId;
                 if (payingOrganization) {
-                    console.log('Saving ' + mandateId + ' as default mandate for organization ' + payingOrganization.id + ' ' + payingOrganization.name)
-                    payingOrganization.serverMeta.mollieMandateId = mandateId
-                    await payingOrganization.save()
+                    console.log('Saving ' + mandateId + ' as default mandate for organization ' + payingOrganization.id + ' ' + payingOrganization.name);
+                    payingOrganization.serverMeta.mollieMandateId = mandateId;
+                    await payingOrganization.save();
                 }
             }
         } catch (e) {
-            console.error('Failed to save default mandate for mandate ' + mandateId + ' in organization ' + (typeof payingOrganizationId === 'string' ? payingOrganizationId : payingOrganizationId?.id), {cause: e})
+            console.error('Failed to save default mandate for mandate ' + mandateId + ' in organization ' + (typeof payingOrganizationId === 'string' ? payingOrganizationId : payingOrganizationId?.id), { cause: e });
 
             throw new SimpleError({
                 code: 'failed',
                 message: 'Failed to update default mandate',
-                human: $t('%1S4')
-            })
+                human: $t('%1S4'),
+            });
         }
     }
 
@@ -171,8 +171,8 @@ export class PaymentMandateService {
      */
     static groupByMandate(base: PaymentMandate[]) {
         base.sort((a, b) => {
-            if (a.status === PaymentMandateStatus.Valid && b.status !== PaymentMandateStatus.Valid ) return -1;
-            if (a.status !== PaymentMandateStatus.Valid && b.status === PaymentMandateStatus.Valid ) return 1;
+            if (a.status === PaymentMandateStatus.Valid && b.status !== PaymentMandateStatus.Valid) return -1;
+            if (a.status !== PaymentMandateStatus.Valid && b.status === PaymentMandateStatus.Valid) return 1;
             if (a.isDefault && !b.isDefault) return -1;
             if (!a.isDefault && b.isDefault) return 1;
             return b.createdAt.getTime() - a.createdAt.getTime();
@@ -189,7 +189,7 @@ export class PaymentMandateService {
                     // Make sure first is also marked as default
                     existing[0].isDefault = true;
                 }
-                existing.push(mandate)
+                existing.push(mandate);
                 continue; // Skip duplicates
             }
 
@@ -199,16 +199,16 @@ export class PaymentMandateService {
 
         // Restort as isDefault might have changed
         cleaned.sort((a, b) => {
-            if (a.status === PaymentMandateStatus.Valid && b.status !== PaymentMandateStatus.Valid ) return -1;
-            if (a.status !== PaymentMandateStatus.Valid && b.status === PaymentMandateStatus.Valid ) return 1;
+            if (a.status === PaymentMandateStatus.Valid && b.status !== PaymentMandateStatus.Valid) return -1;
+            if (a.status !== PaymentMandateStatus.Valid && b.status === PaymentMandateStatus.Valid) return 1;
             if (a.isDefault && !b.isDefault) return -1;
             if (!a.isDefault && b.isDefault) return 1;
             return b.createdAt.getTime() - a.createdAt.getTime();
         });
-        
+
         return {
-            mandates: cleaned.filter(b => b.status === PaymentMandateStatus.Valid  || b.isDefault),
-            grouped: found
-        }
+            mandates: cleaned.filter(b => b.status === PaymentMandateStatus.Valid || b.isDefault),
+            grouped: found,
+        };
     }
 }

package/src/services/PaymentReallocationService.test.ts

@@ -1,4 +1,4 @@
-import type { Organization} from '@stamhoofd/models';
+import type { Organization } from '@stamhoofd/models';
 import { BalanceItem, BalanceItemPayment, MemberFactory, OrganizationFactory, Payment } from '@stamhoofd/models';
 import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, PaymentMethod, PaymentStatus, ReceivableBalanceType, TranslatedString } from '@stamhoofd/structures';
 import { PaymentReallocationService } from './PaymentReallocationService.js';

package/src/services/PaymentReallocationService.ts

@@ -1,4 +1,4 @@
-import { BalanceItem, BalanceItemPayment, CachedBalance, Payment } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, CachedBalance, Payment, User } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
 import type { ReceivableBalanceType } from '@stamhoofd/structures';
 import { BalanceItemStatus, doBalanceItemRelationsMatch, PaymentMethod, PaymentStatus, PaymentType } from '@stamhoofd/structures';
@@ -206,8 +206,7 @@ export const PaymentReallocationService = {
 
                 if (matchMethod.alterPayments) {
                     await this.swapPayments(negativeItem, match);
-                }
-                else {
+                } else {
                     if (match.remaining !== -negativeItem.remaining) {
                         if (!canReachZero) {
                             continue;
@@ -233,8 +232,10 @@ export const PaymentReallocationService = {
             if (total !== 0) {
                 throw new Error('Total is not zero');
             }
+            const systemUser = await User.getSystem();
 
             const payment = new Payment();
+            payment.adminUserId = systemUser.id;
             payment.organizationId = organizationId;
             payment.price = 0;
             payment.type = PaymentType.Reallocation;
@@ -320,8 +321,7 @@ export const PaymentReallocationService = {
 
                         negativeItem.remaining -= swap;
                         match.remaining += swap;
-                    }
-                    else {
+                    } else {
                         if (options.exactOnly && !(price === negativeItem.remaining || price === -match.remaining)) {
                             continue;
                         }
@@ -339,8 +339,7 @@ export const PaymentReallocationService = {
                         return;
                     }
                 }
-            }
-            else {
+            } else {
                 if (price > 0) {
                     if (price > -negativeItem.remaining || price > match.remaining) {
                         if (!options.split) {
@@ -364,8 +363,7 @@ export const PaymentReallocationService = {
 
                         negativeItem.remaining += swap;
                         match.remaining -= swap;
-                    }
-                    else {
+                    } else {
                         if (options.exactOnly && !(price === -negativeItem.remaining || price === match.remaining)) {
                             continue;
                         }