@stamhoofd/backend 2.121.0 → 2.122.0

package/src/helpers/StripeInvoicer.ts

@@ -0,0 +1,419 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Email } from '@stamhoofd/email';
+import { BalanceItem, BalanceItemPayment, Invoice, 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 { 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 {
+    transferFee = 0;
+    serviceFee = 0;
+    count = 0;
+    minimumDate: Date | null = null;
+    maximumDate: Date | null = null;
+
+    constructor(details: { count?: number; transferFee: number; serviceFee: number; minimumDate: Date | null; maximumDate: Date | null }) {
+        this.count = details.count ?? 0;
+        this.transferFee = details.transferFee;
+        this.serviceFee = details.serviceFee;
+        this.minimumDate = details.minimumDate;
+        this.maximumDate = details.maximumDate;
+    }
+
+    get amount() {
+        return this.transferFee + this.serviceFee;
+    }
+
+    static fromStripe(transaction: Stripe.BalanceTransaction) {
+        const source = transaction.source as Stripe.ApplicationFee;
+        const metadata = (source.originating_transaction as Stripe.Charge).metadata;
+
+        const serviceFeeStr = metadata.serviceFee as unknown;
+        if (serviceFeeStr === undefined || typeof serviceFeeStr !== 'string') {
+            throw new Error('Missing serviceFee metadata');
+        }
+
+        const parsed = parseInt(serviceFeeStr);
+        if (isNaN(parsed) || !isFinite(parsed)) {
+            throw new Error('Invalid serviceFee metadata');
+        }
+        const serviceFee = parsed * 100; // in cents
+        const transferFee = transaction.amount * 100 - serviceFee;
+
+        return new ApplicationFeeDetails({
+            count: 1,
+            serviceFee,
+            transferFee,
+            minimumDate: new Date(transaction.created * 1000),
+            maximumDate: new Date(transaction.created * 1000),
+        });
+    }
+
+    add(fee: Stripe.BalanceTransaction) {
+        this.combine(ApplicationFeeDetails.fromStripe(fee));
+    }
+
+    remove(fee: Stripe.BalanceTransaction) {
+        this.combine(ApplicationFeeDetails.fromStripe(fee));
+    }
+
+    combine(other: ApplicationFeeDetails) {
+        this.serviceFee += other.serviceFee;
+        this.transferFee += other.transferFee;
+        this.count += other.count;
+        if (other.minimumDate && (this.minimumDate === null || other.minimumDate < this.minimumDate)) {
+            this.minimumDate = other.minimumDate;
+        }
+        if (other.maximumDate && (this.maximumDate === null || other.maximumDate > this.maximumDate)) {
+            this.maximumDate = other.maximumDate;
+        }
+    }
+}
+
+class StripeReport {
+    readonly applicationFeesPerAccount = new Map<string, ApplicationFeeDetails>();
+
+    add(balanceTransaction: Stripe.BalanceTransaction) {
+        if (balanceTransaction.type === 'application_fee' || balanceTransaction.type === 'application_fee_refund') {
+            const source = balanceTransaction.source as Stripe.ApplicationFee;
+            const account = typeof source.account === 'string' ? source.account : source.account.id;
+
+            if (account) {
+                // We don't included refunded fees because these are test payments from test account
+                const currentAmount = this.applicationFeesPerAccount.get(account);
+                if (currentAmount === undefined) {
+                    this.applicationFeesPerAccount.set(account, ApplicationFeeDetails.fromStripe(balanceTransaction));
+                } else {
+                    currentAmount.add(balanceTransaction);
+                }
+            }
+        }
+    }
+
+    combine(report: StripeReport) {
+        for (const [account, amount] of report.applicationFeesPerAccount.entries()) {
+            const currentAmount = this.applicationFeesPerAccount.get(account);
+            if (currentAmount === undefined) {
+                this.applicationFeesPerAccount.set(account, amount);
+            } else {
+                currentAmount.combine(amount);
+            }
+        }
+        return this;
+    }
+}
+
+export class StripeReportInvoicer {
+    private readonly report: StripeReport;
+    start: Date;
+    end: Date;
+
+    constructor(report: StripeReport, start: Date, end: Date) {
+        this.report = report;
+        this.start = start;
+        this.end = end;
+    }
+
+    async generateInvoices(sellingOrganization: Organization, reference: string) {
+        const invoices: Invoice[] = [];
+        for (const [account, details] of this.report.applicationFeesPerAccount) {
+            try {
+                const invoice = await this.generateInvoice(sellingOrganization, reference, account, details);
+                if (invoice) {
+                    invoices.push(invoice);
+                }
+            } catch (e) {
+                console.error(e);
+                // Send email notification of this error
+                Email.sendWebmaster({
+                    subject: 'Aanmaken Stripe facturen voor ' + account + ' - ' + reference + ' mislukt',
+                    html: 'Aanmaken Stripe facturen voor ' + account + ' - ' + reference + ' mislukt. <br><br> ' + e.toString(),
+                });
+            }
+        }
+        return invoices;
+    }
+
+    static async hasInvoice(sellingOrganization: Organization, reference: string) {
+        return !!await Invoice.select().where('organizationId', sellingOrganization.id).where('reference', reference).where('number', '!=', null).first(false);
+    }
+
+    async generateInvoice(sellingOrganization: Organization, reference: string, accountId: string, applicationFee: ApplicationFeeDetails) {
+        if (applicationFee.amount === 0) {
+            return;
+        }
+
+        const seller = sellingOrganization.meta.companies[0];
+        if (!seller) {
+            return;
+        }
+
+        // Search for the organization in Stamhoofd
+        const stripeAccount = await StripeAccount.select().where('accountId', accountId).first(false);
+        if (!stripeAccount) {
+            if (STAMHOOFD.environment === 'test') {
+                console.error('No organization found for Stripe account ' + accountId);
+                return;
+            }
+            throw new SimpleError({
+                code: 'stripe_account_not_found',
+                message: 'No organization found for Stripe account ' + accountId,
+            });
+        }
+        const organization = await Organization.getByID(stripeAccount.organizationId);
+
+        if (!organization) {
+            throw new SimpleError({
+                code: 'organization_not_found',
+                message: 'No organization found for Stripe account ' + accountId,
+            });
+        }
+
+        const existingInvoices = await Invoice.select()
+            .where('organizationId', sellingOrganization.id)
+            .where('payingOrganizationId', organization.id)
+            .where('reference', reference)
+            .where('number', '!=', null)
+            .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) {
+                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,
+                });
+            }
+
+            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;
+            }
+        }
+
+        const customer = PaymentCustomer.create({
+            company: sellingOrganization.defaultCompanies[0],
+        });
+
+        const balanceItems: BalanceItem[] = [];
+
+        if (applicationFee.serviceFee !== 0) {
+            const item = new BalanceItem();
+            item.type = BalanceItemType.ServiceFee;
+            item.description = $t('%1Wd', {
+                startDate: Formatter.startDate(this.start, false, true),
+                endDate: Formatter.endDate(this.end, false, true),
+            });
+            item.relations.set(BalanceItemRelationType.PaymentProvider, BalanceItemRelation.create({
+                id: PaymentProvider.Stripe,
+                name: TranslatedString.create(getPaymentProviderName(PaymentProvider.Stripe)),
+            }));
+            item.payingOrganizationId = organization.id;
+            item.organizationId = sellingOrganization.id;
+            item.VATPercentage = 21;
+            item.VATExcempt = VATService.getVATExcempt({
+                company: organization.defaultCompanies[0] ?? null,
+                sellingOrganization,
+                type: 'services',
+            });
+            item.VATIncluded = true;
+            item.quantity = 1;
+            item.unitPrice = applicationFee.serviceFee;
+            item.createdAt = new Date();
+            item.status = BalanceItemStatus.Hidden;
+            item.startDate = this.start;
+            item.endDate = this.end;
+            await item.save();
+            balanceItems.push(item);
+        }
+
+        if (applicationFee.transferFee !== 0) {
+            const item = new BalanceItem();
+            item.type = BalanceItemType.TransferFee;
+            item.description = $t('%1Xx', {
+                startDate: Formatter.startDate(this.start, false, true),
+                endDate: Formatter.endDate(this.end, false, true),
+            });
+            item.relations.set(BalanceItemRelationType.PaymentProvider, BalanceItemRelation.create({
+                id: PaymentProvider.Stripe,
+                name: TranslatedString.create(getPaymentProviderName(PaymentProvider.Stripe)),
+            }));
+            item.payingOrganizationId = organization.id;
+            item.organizationId = sellingOrganization.id;
+            item.VATPercentage = 21;
+            item.VATExcempt = VATService.getVATExcempt({
+                company: organization.defaultCompanies[0] ?? null,
+                sellingOrganization,
+                type: 'services',
+            });
+            item.VATIncluded = true;
+            item.quantity = 1;
+            item.unitPrice = applicationFee.transferFee;
+            item.createdAt = new Date();
+            item.status = BalanceItemStatus.Hidden;
+            item.startDate = this.start;
+            item.endDate = this.end;
+            await item.save();
+            balanceItems.push(item);
+        }
+
+        const systemUser = await User.getSystem();
+
+        // Done validation
+        const payment = new Payment();
+        payment.adminUserId = systemUser.id;
+
+        // Who will receive this money?
+        payment.organizationId = sellingOrganization.id;
+
+        // Who paid
+        payment.payingOrganizationId = organization.id;
+        payment.customer = customer;
+
+        payment.status = PaymentStatus.Pending;
+        payment.price = applicationFee.amount;
+        payment.roundingAmount = 0;
+        payment.method = PaymentMethod.Unknown;
+        payment.type = PaymentType.Payment;
+        payment.createMandate = null;
+
+        payment.provider = PaymentProvider.Stripe;
+        payment.stripeAccountId = stripeAccount.id;
+        await payment.save();
+
+        for (const balanceItem of balanceItems) {
+            // Create one balance item payment to pay it in one payment
+            const balanceItemPayment = new BalanceItemPayment();
+            balanceItemPayment.balanceItemId = balanceItem.id;
+            balanceItemPayment.paymentId = payment.id;
+            balanceItemPayment.organizationId = organization.id;
+            balanceItemPayment.price = balanceItem.priceWithVAT;
+            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;
+    }
+}
+
+export class StripeInvoicer {
+    private stripe: Stripe;
+
+    constructor({ secretKey }: { secretKey: string }) {
+        this.stripe = new Stripe(secretKey, { apiVersion: '2024-06-20', typescript: true, maxNetworkRetries: 1, timeout: 10000 });
+    }
+
+    static getMonthUnixStartEnd(date: Date) {
+        const start = Math.floor((new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0).getTime()) / 1000);
+        const end = Math.ceil((new Date(date.getFullYear(), date.getMonth() + 1, 1, 0, 0, 0, 0).getTime() - 1000) / 1000);
+        return { start, end };
+    }
+
+    // Loops all months until all invoices are generated
+    async generateAllInvoices(sellingOrganization: Organization, options?: { force?: boolean; start?: Date }) {
+        const startMonth = options?.start ?? new Date(2026, 0, 1);
+        const stopAt = new Date(Date.now() + (STAMHOOFD.environment === 'production' ? (-60 * 60 * 24 * 1000) : (60 * 60 * 24 * 1000 * 31))); // One day margin before creating invoices
+        let currentMonth = new Date(startMonth);
+
+        while (true) {
+            const { start, end } = StripeInvoicer.getMonthUnixStartEnd(currentMonth);
+
+            if (end >= stopAt.getTime() / 1000) {
+                // Stop
+                break;
+            }
+            await this.generateInvoices(sellingOrganization, currentMonth, options);
+            currentMonth = new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1);
+        }
+    }
+
+    async generateInvoices(sellingOrganization: Organization, month: Date, options?: { force?: boolean }) {
+        const { start, end } = StripeInvoicer.getMonthUnixStartEnd(month);
+        const reference = 'stripe-fees-' + Formatter.dateIso(new Date(start * 1000));
+
+        try {
+            await QueueHandler.schedule(reference, async () => {
+                if (!options?.force && await StripeReportInvoicer.hasInvoice(sellingOrganization, reference)) {
+                    console.log('Already invoiced month', reference);
+                    return;
+                }
+
+                console.log('Generating invoices for ', reference, start, end);
+                const reportFees = await this.fetchBalanceItems({
+                    created: {
+                        gte: start,
+                        lte: end,
+                    },
+                    type: 'application_fee',
+                    expand: ['data.source', 'data.source.originating_transaction'],
+                });
+                const reportRefund = await this.fetchBalanceItems({
+                    created: {
+                        gte: start,
+                        lte: end,
+                    },
+                    type: 'application_fee_refund',
+                    expand: ['data.source', 'data.source.originating_transaction'],
+                });
+
+                const report = reportFees.combine(reportRefund);
+                const invoicer = new StripeReportInvoicer(report, new Date(start * 1000), new Date(end * 1000));
+                await invoicer.generateInvoices(sellingOrganization, reference);
+            });
+        } catch (e) {
+            console.error(e);
+
+            // Send email notification of this error
+            Email.sendWebmaster({
+                subject: 'Aanmaken Stripe facturen voor ' + Formatter.dateNumber(month) + ' mislukt',
+                html: 'Aanmaken Stripe facturen voor ' + Formatter.dateNumber(month) + ' mislukt. <br><br> ' + e.toString(),
+            });
+        }
+    }
+
+    private async fetchBalanceItems(options: Stripe.BalanceTransactionListParams) {
+        // For the given payout, fetch all balance items
+        const params = { ...options };
+        const report = new StripeReport();
+
+        for await (const balanceItem of this.stripe.balanceTransactions.list(params)) {
+            report.add(balanceItem);
+        }
+
+        return report;
+    }
+}

package/src/helpers/StripePayoutChecker.ts

@@ -53,14 +53,12 @@ export class StripePayoutChecker {
                 // Get all payments for this payout
                 try {
                     await this.fetchBalanceItems(payout);
-                }
-                catch (e) {
+                } catch (e) {
                     console.error('Error for payout ' + payout.id);
                     console.error(e);
                 }
             }
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
     }
@@ -119,8 +117,7 @@ export class StripePayoutChecker {
                             if (stripePayments.length === 1) {
                                 paymentId = stripePayments[0].paymentId;
                                 console.log('Found missing payment metadata for payment intent ', originatingTransaction.payment_intent, paymentId);
-                            }
-                            else {
+                            } else {
                                 // Probably a card payment
                                 // Search for the checkout session
                                 const checkoutSession = await this.stripePlatform.checkout.sessions.list({
@@ -138,12 +135,10 @@ export class StripePayoutChecker {
                                     if (stripeCheckoutSessions.length === 1) {
                                         paymentId = stripeCheckoutSessions[0].paymentId;
                                         console.log('Found missing payment metadata for payment intent ', originatingTransaction.payment_intent, paymentId);
-                                    }
-                                    else {
+                                    } else {
                                         console.log('No payment found for checkout session ' + session.id);
                                     }
-                                }
-                                else {
+                                } else {
                                     console.log('No Stripe Checkout Sessions found for payment intent ' + paymentIntentId);
                                 }
                             }

package/src/helpers/TagHelper.ts

@@ -1,21 +1,22 @@
 import { Organization, Platform } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import type { OrganizationTag} from '@stamhoofd/structures';
+import type { OrganizationTag } from '@stamhoofd/structures';
 import { AuditLogSource, TagHelper as SharedTagHelper } from '@stamhoofd/structures';
 import { AuditLogService } from '../services/AuditLogService.js';
 
 export class TagHelper extends SharedTagHelper {
     static async updateOrganizations() {
         const queueId = 'update-tags-on-organizations';
-        QueueHandler.cancel(queueId);
+        QueueHandler.abort(queueId);
 
         await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
-            await QueueHandler.schedule(queueId, async () => {
+            await QueueHandler.schedule(queueId, async ({ abort }) => {
                 const sharedPlatform = await Platform.getShared();
 
                 const tagCounts = new Map<string, number>();
 
                 for await (const organization of Organization.select().all()) {
+                    abort.throwIfAborted();
                     organization.meta.tags = this.getAllTagsFromHierarchy(organization.meta.tags, sharedPlatform.config.tags);
 
                     for (const tag of organization.meta.tags) {
@@ -26,11 +27,9 @@ export class TagHelper extends SharedTagHelper {
 
                 // Reload platform to avoid race conditions
                 const platform = await Platform.getForEditing();
-                for (const [tag, count] of tagCounts.entries()) {
-                    const tagObject = platform.config.tags.find(t => t.id === tag);
-                    if (tagObject) {
-                        tagObject.organizationCount = count;
-                    }
+                for (const tagObject of platform.config.tags) {
+                    abort.throwIfAborted();
+                    tagObject.organizationCount = tagCounts.get(tagObject.id) ?? 0;
                 }
                 await platform.save();
             });

package/src/helpers/TemporaryMemberAccess.ts

@@ -33,8 +33,7 @@ export function deleteExpiredTemporaryMemberAccess() {
 
         if (filtered.length === 0) {
             userMemberTemporaryAccessCache.delete(userId);
-        }
-        else {
+        } else {
             userMemberTemporaryAccessCache.set(userId, filtered);
         }
     }

package/src/helpers/ThrottledQueue.ts

@@ -83,8 +83,7 @@ export class ThrottledQueue<T> {
             const batch = batchSize < items.length ? items.slice(i, i + batchSize) : items;
             try {
                 await this.handler(batch);
-            }
-            catch (error) {
+            } catch (error) {
                 console.error('Error processing batch in ThrottledQueue:', error);
             }
         }

package/src/helpers/UitpasTokenRepository.ts

@@ -51,8 +51,7 @@ export class UitpasTokenRepository {
             let repo = new UitpasTokenRepository(model);
             try {
                 await repo.getNewAccessToken();
-            }
-            catch (e) {
+            } catch (e) {
                 return false; // not valid
             }
             // valid -> store

package/src/helpers/ViesHelper.ts

@@ -55,8 +55,7 @@ export class ViesHelperStatic {
         if (company.companyNumber) {
             if (company.VATNumber !== null && company.address.country === Country.Belgium) {
                 // Already validated
-            }
-            else {
+            } else {
                 // Need to validate
                 const result = await ViesHelper.checkCompanyNumber(company.address.country, company.companyNumber);
                 patch.companyNumber = result.companyNumber;
@@ -103,12 +102,10 @@ export class ViesHelperStatic {
                 companyNumber: corrected.substring(2),
                 VATNumber: corrected,
             };
-        }
-        catch (e) {
+        } catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {
                 // Ignore: normal that it is not a valid VAT number
-            }
-            else {
+            } else {
                 // Other errors should be thrown
                 throw e;
             }
@@ -128,7 +125,7 @@ export class ViesHelperStatic {
         if (!result.isValid) {
             throw new SimpleError({
                 code: 'invalid_field',
-                message: $t('%1To', {'number': vatNumber}),
+                message: $t('%1To', { number: vatNumber }),
                 field: 'VATNumber',
             });
         }
@@ -136,7 +133,7 @@ export class ViesHelperStatic {
         const formatted = result.value ?? vatNumber;
 
         if (STAMHOOFD.environment === 'development' && formatted === 'NL301828519B01') {
-            return formatted
+            return formatted;
         }
 
         try {
@@ -154,12 +151,11 @@ export class ViesHelperStatic {
             if (!response.valid) {
                 throw new SimpleError({
                     code: 'invalid_field',
-                    message: $t('%1TG', {'vat-number': formatted}),
+                    message: $t('%1TG', { 'vat-number': formatted }),
                     field: 'VATNumber',
                 });
             }
-        }
-        catch (e) {
+        } catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {
                 throw e;
             }

package/src/helpers/XlsxTransformerColumnHelper.ts

@@ -1,6 +1,6 @@
 import type { XlsxTransformerColumn, XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
 import { isXlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
-import type { Address, Parent, PlatformMember, RecordAnswer, RecordSettings} from '@stamhoofd/structures';
+import type { Address, Parent, PlatformMember, RecordAnswer, RecordSettings } from '@stamhoofd/structures';
 import { CountryHelper, ParentTypeHelper, RecordCategory, RecordType } from '@stamhoofd/structures';
 
 export class XlsxTransformerColumnHelper {

package/src/helpers/outstandingBalanceJoin.ts

@@ -25,7 +25,7 @@ export const registrationCachedBalanceJoin = SQL.leftJoin(
         new SQLSelectAs(
             new SQLSum(
                 SQL.calculation(SQL.column('amountOpen'))
-                    .add(SQL.column('amountPending'))
+                    .add(SQL.column('amountPending')),
             ),
             new SQLAlias('toPay'),
         ),
@@ -33,7 +33,7 @@ export const registrationCachedBalanceJoin = SQL.leftJoin(
             new SQLSum(
                 SQL.calculation(SQL.column('amountOpen'))
                     .add(SQL.column('amountPaid'))
-                    .add(SQL.column('amountPending'))
+                    .add(SQL.column('amountPending')),
             ),
             new SQLAlias('price'),
         ),

package/src/helpers/updateMemberDetailsUitpasNumber.ts

@@ -1,7 +1,7 @@
 import type { AutoEncoderPatchType } from '@simonbackx/simple-encoding';
 import { isSimpleError, SimpleError } from '@simonbackx/simple-errors';
 import { Member } from '@stamhoofd/models';
-import type { MemberDetails, ReviewTimes} from '@stamhoofd/structures';
+import type { MemberDetails, ReviewTimes } from '@stamhoofd/structures';
 import { UitpasSocialTariff, UitpasSocialTariffStatus } from '@stamhoofd/structures';
 import type { GetPassResponse } from '../services/uitpas/PassholderEndpoints.js';
 import { UitpasService } from '../services/uitpas/UitpasService.js';
@@ -42,8 +42,7 @@ export async function updateMemberDetailsUitpasNumberForPatch(memberId: string,
 
     try {
         isUpdated = await updateMemberDetailsUitpasNumber(details);
-    }
-    catch (error: any) {
+    } catch (error: any) {
         const isUitpasEqual = previousUitpasNumber !== null && previousUitpasNumber === details.uitpasNumberDetails.uitpasNumber;
 
         if (isSimpleError(error)) {
@@ -94,8 +93,7 @@ export function uitpasApiResponseToSocialTariff(response: GetPassResponse): Uitp
     if (response.socialTariff.endDate) {
         try {
             endDate = new Date(response.socialTariff.endDate);
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
             console.error('endDate: ', response.socialTariff.endDate);