@stamhoofd/backend 2.58.0 → 2.60.0

package/src/services/MemberNumberService.ts

@@ -0,0 +1,120 @@
+import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
+import { Member, MemberPlatformMembership, Organization } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { SQL, SQLWhereLike, scalarToSQLExpression } from '@stamhoofd/sql';
+
+export class MemberNumberService {
+    static async assignMemberNumber(member: Member, membership: MemberPlatformMembership) {
+        if (member.details?.memberNumber) {
+            console.log('Member already has member number, should not happen');
+            return;
+        }
+
+        return await QueueHandler.schedule('assignMemberNumber', async function (this: undefined) {
+            try {
+                const memberNumber = await MemberNumberService.createMemberNumber(member, membership);
+                member.details.memberNumber = memberNumber;
+                await member.save();
+            }
+            catch (error) {
+                if (isSimpleError(error) || isSimpleErrors(error)) {
+                    throw error;
+                }
+                else {
+                    console.error(error);
+                    throw new SimpleError({
+                        code: 'assign_member_number',
+                        message: error.message,
+                        human: 'Er is iets misgegaan bij het aanmaken van het lidnummer.',
+                    });
+                }
+            }
+        });
+    }
+
+    static async createMemberNumber(member: Member, membership: MemberPlatformMembership): Promise<string> {
+        // example: 5301-101012-1
+
+        // #region get birth date part (ddmmjj)
+        const birthDay = member.details?.birthDay;
+        if (!birthDay) {
+            throw new SimpleError({
+                code: 'assign_member_number',
+                message: 'Missing birthDay',
+                human: 'Er kon geen lidnummer aangemaakt worden omdat er geen geboortedatum is ingesteld.',
+            });
+        }
+
+        const dayPart = birthDay.getDate().toString().padStart(2, '0');
+        const monthPart = (birthDay.getMonth() + 1).toString().padStart(2, '0');
+        const yearPart = birthDay.getFullYear().toString().slice(2, 4);
+        const birthDatePart = `${dayPart}${monthPart}${yearPart}`;
+        // #endregion
+
+        // #region get group number
+        const organizationId = membership.organizationId;
+        const organization = await Organization.getByID(organizationId);
+        if (!organization) {
+            throw new Error(`Organization with id ${organizationId} not found`);
+        }
+        const groupNumber = organization.uri;
+        // #endregion
+
+        // #region get follow up number
+        const firstPart = `${groupNumber}-${birthDatePart}-`;
+
+        const query = SQL.select()
+            .from(SQL.table('members'))
+            .where(
+                new SQLWhereLike(
+                    SQL.column('members', 'memberNumber'),
+                    scalarToSQLExpression(`${SQLWhereLike.escape(firstPart)}%`),
+                ),
+            );
+
+        const count = await query.count();
+        console.log(`Found ${count} members with a memberNumber starting with ${firstPart}`);
+
+        let followUpNumber = count;
+        // #endregion
+
+        // #region check if memberNumber is unique
+        let doesExist = true;
+        let memberNumber: string = '';
+        let tries = 0;
+
+        while (doesExist) {
+            followUpNumber++;
+            memberNumber = firstPart + followUpNumber;
+
+            const result = await SQL.select()
+                .from(SQL.table('members'))
+                .where(
+                    SQL.column('members', 'memberNumber'),
+                    scalarToSQLExpression(memberNumber),
+                )
+                .first(false);
+
+            console.log(`Is ${memberNumber} unique? ${result === null}`);
+
+            if (result !== null) {
+                tries++;
+                if (tries > 9) {
+                    throw new SimpleError({
+                        code: 'assign_member_number',
+                        message: `Duplicate member numbers (last try: ${memberNumber}, tries: ${tries})`,
+                        human: 'Er kon geen uniek lidnummer aangemaakt worden. Mogelijks zijn er teveel leden met dezelfde geboortedatum. Neem contact op met de vereniging.',
+                    });
+                }
+            }
+            else {
+                doesExist = false;
+            }
+        }
+        // #endregion
+
+        console.log(`Created member number: ${memberNumber}`);
+
+        return memberNumber;
+    }
+}

package/src/services/PaymentService.ts

@@ -1,10 +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 { PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
+import { AuditLogSource, PaymentMethod, PaymentProvider, PaymentStatus } from '@stamhoofd/structures';
 import { BuckarooHelper } from '../helpers/BuckarooHelper';
 import { StripeHelper } from '../helpers/StripeHelper';
 import { BalanceItemPaymentService } from './BalanceItemPaymentService';
+import { AuditLogService } from './AuditLogService';
 
 export const PaymentService = {
     async handlePaymentStatusUpdate(payment: Payment, organization: Organization, status: PaymentStatus) {
@@ -12,79 +13,81 @@ export const PaymentService = {
             return;
         }
 
-        if (status === PaymentStatus.Succeeded) {
-            payment.status = PaymentStatus.Succeeded;
-            payment.paidAt = new Date();
-            await payment.save();
-
-            // Prevent concurrency issues
-            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
-                const unloaded = (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment));
-                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
-                    unloaded,
-                );
-
-                for (const balanceItemPayment of balanceItemPayments) {
-                    await BalanceItemPaymentService.markPaid(balanceItemPayment, organization);
-                }
+        await AuditLogService.setContext({ fallbackUserId: payment.payingUserId, source: AuditLogSource.Payment, fallbackOrganizationId: payment.organizationId }, async () => {
+            if (status === PaymentStatus.Succeeded) {
+                payment.status = PaymentStatus.Succeeded;
+                payment.paidAt = new Date();
+                await payment.save();
+
+                // Prevent concurrency issues
+                await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                    const unloaded = (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment));
+                    const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                        unloaded,
+                    );
+
+                    for (const balanceItemPayment of balanceItemPayments) {
+                        await BalanceItemPaymentService.markPaid(balanceItemPayment, organization);
+                    }
 
-                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-            });
-            return;
-        }
+                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+                });
+                return;
+            }
 
-        const oldStatus = payment.status;
+            const oldStatus = payment.status;
 
-        // Save before updating balance items
-        payment.status = status;
-        payment.paidAt = null;
-        await payment.save();
+            // Save before updating balance items
+            payment.status = status;
+            payment.paidAt = null;
+            await payment.save();
 
-        // If OLD status was succeeded, we need to revert the actions
-        if (oldStatus === PaymentStatus.Succeeded) {
+            // If OLD status was succeeded, we need to revert the actions
+            if (oldStatus === PaymentStatus.Succeeded) {
             // No longer succeeded
-            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
-                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
-                    (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
-                );
+                await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                    const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                        (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
+                    );
 
-                for (const balanceItemPayment of balanceItemPayments) {
-                    await BalanceItemPaymentService.undoPaid(balanceItemPayment, organization);
-                }
+                    for (const balanceItemPayment of balanceItemPayments) {
+                        await BalanceItemPaymentService.undoPaid(balanceItemPayment, organization);
+                    }
 
-                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-            });
-        }
+                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+                });
+            }
 
-        // Moved to failed
-        if (status == PaymentStatus.Failed) {
-            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
-                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
-                    (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
-                );
+            // Moved to failed
+            if (status == PaymentStatus.Failed) {
+                await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                    const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                        (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
+                    );
 
-                for (const balanceItemPayment of balanceItemPayments) {
-                    await BalanceItemPaymentService.markFailed(balanceItemPayment, organization);
-                }
+                    for (const balanceItemPayment of balanceItemPayments) {
+                        await BalanceItemPaymentService.markFailed(balanceItemPayment, organization);
+                    }
 
-                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-            });
-        }
+                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+                });
+            }
 
-        // If OLD status was FAILED, we need to revert the actions
-        if (oldStatus === PaymentStatus.Failed) { // OLD FAILED!! -> NOW PENDING
-            await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
-                const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
-                    (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
-                );
+            // If OLD status was FAILED, we need to revert the actions
+            if (oldStatus === PaymentStatus.Failed) { // OLD FAILED!! -> NOW PENDING
+                await QueueHandler.schedule('balance-item-update/' + organization.id, async () => {
+                    const balanceItemPayments = await BalanceItemPayment.balanceItem.load(
+                        (await BalanceItemPayment.where({ paymentId: payment.id })).map(r => r.setRelation(BalanceItemPayment.payment, payment)),
+                    );
 
-                for (const balanceItemPayment of balanceItemPayments) {
-                    await BalanceItemPaymentService.undoFailed(balanceItemPayment, organization);
-                }
+                    for (const balanceItemPayment of balanceItemPayments) {
+                        await BalanceItemPaymentService.undoFailed(balanceItemPayment, organization);
+                    }
 
-                await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-            });
-        }
+                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
+                });
+            }
+        });
     },
 
     /**
@@ -99,181 +102,184 @@ export const PaymentService = {
                 return;
             }
 
-            if (!payment.organizationId) {
-                console.error('Payment without organization not supported', payment.id);
-                return;
-            }
+            // Explicitly set userId to null, because all actions caused by a poll are not caused by the currently signed in user, but the paying user id
+            return await AuditLogService.setContext({ userId: payment.payingUserId ?? null, source: AuditLogSource.Payment }, async () => {
+                if (!payment.organizationId) {
+                    console.error('Payment without organization not supported', payment.id);
+                    return;
+                }
 
-            const organization = org ?? await Organization.getByID(payment.organizationId);
-            if (!organization) {
-                console.error('Organization not found for payment', payment.id);
-                return;
-            }
+                const organization = org ?? await Organization.getByID(payment.organizationId);
+                if (!organization) {
+                    console.error('Organization not found for payment', payment.id);
+                    return;
+                }
 
-            const testMode = organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production';
+                const testMode = organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production';
 
-            if (payment.status === PaymentStatus.Pending || payment.status === PaymentStatus.Created || (payment.provider === PaymentProvider.Buckaroo && payment.status === PaymentStatus.Failed)) {
-                if (payment.provider === PaymentProvider.Stripe) {
-                    try {
-                        let status = await StripeHelper.getStatus(payment, cancel || this.shouldTryToCancel(payment.status, payment), testMode);
+                if (payment.status === PaymentStatus.Pending || payment.status === PaymentStatus.Created || (payment.provider === PaymentProvider.Buckaroo && payment.status === PaymentStatus.Failed)) {
+                    if (payment.provider === PaymentProvider.Stripe) {
+                        try {
+                            let status = await StripeHelper.getStatus(payment, cancel || this.shouldTryToCancel(payment.status, payment), testMode);
 
-                        if (this.isManualExpired(status, payment)) {
-                            console.error('Manually marking Stripe payment as expired', payment.id);
-                            status = PaymentStatus.Failed;
-                        }
+                            if (this.isManualExpired(status, payment)) {
+                                console.error('Manually marking Stripe payment as expired', payment.id);
+                                status = PaymentStatus.Failed;
+                            }
 
-                        await this.handlePaymentStatusUpdate(payment, organization, status);
-                    }
-                    catch (e) {
-                        console.error('Payment check failed Stripe', payment.id, e);
-                        if (this.isManualExpired(payment.status, payment)) {
-                            console.error('Manually marking Stripe payment as expired', payment.id);
-                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                            await this.handlePaymentStatusUpdate(payment, organization, status);
+                        }
+                        catch (e) {
+                            console.error('Payment check failed Stripe', payment.id, e);
+                            if (this.isManualExpired(payment.status, payment)) {
+                                console.error('Manually marking Stripe payment as expired', payment.id);
+                                await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                            }
                         }
                     }
-                }
-                else if (payment.provider === PaymentProvider.Mollie) {
-                    // check status via mollie
-                    const molliePayments = await MolliePayment.where({ paymentId: payment.id }, { limit: 1 });
-                    if (molliePayments.length == 1) {
-                        const molliePayment = molliePayments[0];
-                        // check status
-                        const token = await MollieToken.getTokenFor(organization.id);
-
-                        if (token) {
-                            try {
-                                const mollieClient = createMollieClient({ accessToken: await token.getAccessToken() });
-                                const mollieData = await mollieClient.payments.get(molliePayment.mollieId, {
-                                    testmode: organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production',
-                                });
-
-                                console.log(mollieData); // log to log files to check issues
-
-                                const details = mollieData.details as any;
-                                if (details?.consumerName) {
-                                    payment.ibanName = details.consumerName;
-                                }
-                                if (details?.consumerAccount) {
-                                    payment.iban = details.consumerAccount;
+                    else if (payment.provider === PaymentProvider.Mollie) {
+                        // check status via mollie
+                        const molliePayments = await MolliePayment.where({ paymentId: payment.id }, { limit: 1 });
+                        if (molliePayments.length == 1) {
+                            const molliePayment = molliePayments[0];
+                            // check status
+                            const token = await MollieToken.getTokenFor(organization.id);
+
+                            if (token) {
+                                try {
+                                    const mollieClient = createMollieClient({ accessToken: await token.getAccessToken() });
+                                    const mollieData = await mollieClient.payments.get(molliePayment.mollieId, {
+                                        testmode: organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production',
+                                    });
+
+                                    console.log(mollieData); // log to log files to check issues
+
+                                    const details = mollieData.details as any;
+                                    if (details?.consumerName) {
+                                        payment.ibanName = details.consumerName;
+                                    }
+                                    if (details?.consumerAccount) {
+                                        payment.iban = details.consumerAccount;
+                                    }
+                                    if (details?.cardHolder) {
+                                        payment.ibanName = details.cardHolder;
+                                    }
+                                    if (details?.cardNumber) {
+                                        payment.iban = 'xxxx xxxx xxxx ' + details.cardNumber;
+                                    }
+
+                                    if (mollieData.status === MolliePaymentStatus.paid) {
+                                        await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Succeeded);
+                                    }
+                                    else if (mollieData.status === MolliePaymentStatus.failed || mollieData.status === MolliePaymentStatus.expired || mollieData.status === MolliePaymentStatus.canceled) {
+                                        await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                                    }
+                                    else if (this.isManualExpired(payment.status, payment)) {
+                                        // Mollie still returning pending after 1 day: mark as failed
+                                        console.error('Manually marking Mollie payment as expired', payment.id);
+                                        await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                                    }
                                 }
-                                if (details?.cardHolder) {
-                                    payment.ibanName = details.cardHolder;
-                                }
-                                if (details?.cardNumber) {
-                                    payment.iban = 'xxxx xxxx xxxx ' + details.cardNumber;
-                                }
-
-                                if (mollieData.status === MolliePaymentStatus.paid) {
-                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Succeeded);
-                                }
-                                else if (mollieData.status === MolliePaymentStatus.failed || mollieData.status === MolliePaymentStatus.expired || mollieData.status === MolliePaymentStatus.canceled) {
-                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
-                                }
-                                else if (this.isManualExpired(payment.status, payment)) {
-                                    // Mollie still returning pending after 1 day: mark as failed
-                                    console.error('Manually marking Mollie payment as expired', payment.id);
-                                    await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                                catch (e) {
+                                    console.error('Payment check failed Mollie', payment.id, e);
+                                    if (this.isManualExpired(payment.status, payment)) {
+                                        console.error('Manually marking Mollie payment as expired', payment.id);
+                                        await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                                    }
                                 }
                             }
-                            catch (e) {
-                                console.error('Payment check failed Mollie', payment.id, e);
+                            else {
+                                console.warn('Mollie payment is missing for organization ' + organization.id + ' while checking payment status...');
+
                                 if (this.isManualExpired(payment.status, payment)) {
-                                    console.error('Manually marking Mollie payment as expired', payment.id);
+                                    console.error('Manually marking payment without mollie token as expired', payment.id);
                                     await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
                                 }
                             }
                         }
                         else {
-                            console.warn('Mollie payment is missing for organization ' + organization.id + ' while checking payment status...');
-
                             if (this.isManualExpired(payment.status, payment)) {
-                                console.error('Manually marking payment without mollie token as expired', payment.id);
+                                console.error('Manually marking payment without mollie payments as expired', payment.id);
                                 await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
                             }
                         }
                     }
-                    else {
-                        if (this.isManualExpired(payment.status, payment)) {
-                            console.error('Manually marking payment without mollie payments as expired', payment.id);
-                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
-                        }
-                    }
-                }
-                else if (payment.provider == PaymentProvider.Buckaroo) {
-                    const helper = new BuckarooHelper(organization.privateMeta.buckarooSettings?.key ?? '', organization.privateMeta.buckarooSettings?.secret ?? '', organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
-                    try {
-                        let status = await helper.getStatus(payment);
-
-                        if (this.isManualExpired(status, payment)) {
-                            console.error('Manually marking Buckaroo payment as expired', payment.id);
-                            status = PaymentStatus.Failed;
-                        }
+                    else if (payment.provider == PaymentProvider.Buckaroo) {
+                        const helper = new BuckarooHelper(organization.privateMeta.buckarooSettings?.key ?? '', organization.privateMeta.buckarooSettings?.secret ?? '', organization.privateMeta.useTestPayments ?? STAMHOOFD.environment !== 'production');
+                        try {
+                            let status = await helper.getStatus(payment);
 
-                        await this.handlePaymentStatusUpdate(payment, organization, status);
-                    }
-                    catch (e) {
-                        console.error('Payment check failed Buckaroo', payment.id, e);
-                        if (this.isManualExpired(payment.status, payment)) {
-                            console.error('Manually marking Buckaroo payment as expired', payment.id);
-                            await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                            if (this.isManualExpired(status, payment)) {
+                                console.error('Manually marking Buckaroo payment as expired', payment.id);
+                                status = PaymentStatus.Failed;
+                            }
+
+                            await this.handlePaymentStatusUpdate(payment, organization, status);
+                        }
+                        catch (e) {
+                            console.error('Payment check failed Buckaroo', payment.id, e);
+                            if (this.isManualExpired(payment.status, payment)) {
+                                console.error('Manually marking Buckaroo payment as expired', payment.id);
+                                await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                            }
                         }
                     }
-                }
-                else if (payment.provider == PaymentProvider.Payconiq) {
-                    // Check status
+                    else if (payment.provider == PaymentProvider.Payconiq) {
+                        // Check status
 
-                    const payconiqPayments = await PayconiqPayment.where({ paymentId: payment.id }, { limit: 1 });
-                    if (payconiqPayments.length == 1) {
-                        const payconiqPayment = payconiqPayments[0];
+                        const payconiqPayments = await PayconiqPayment.where({ paymentId: payment.id }, { limit: 1 });
+                        if (payconiqPayments.length == 1) {
+                            const payconiqPayment = payconiqPayments[0];
 
-                        if (cancel) {
-                            console.error('Cancelling Payconiq payment on request', payment.id);
-                            await payconiqPayment.cancel(organization);
-                        }
+                            if (cancel) {
+                                console.error('Cancelling Payconiq payment on request', payment.id);
+                                await payconiqPayment.cancel(organization);
+                            }
 
-                        let status = await payconiqPayment.getStatus(organization);
+                            let status = await payconiqPayment.getStatus(organization);
 
-                        if (!cancel && this.shouldTryToCancel(status, payment)) {
-                            console.error('Manually cancelling Payconiq payment', payment.id);
-                            if (await payconiqPayment.cancel(organization)) {
+                            if (!cancel && this.shouldTryToCancel(status, payment)) {
+                                console.error('Manually cancelling Payconiq payment', payment.id);
+                                if (await payconiqPayment.cancel(organization)) {
+                                    status = PaymentStatus.Failed;
+                                }
+                            }
+
+                            if (this.isManualExpired(status, payment)) {
+                                console.error('Manually marking Payconiq payment as expired', payment.id);
                                 status = PaymentStatus.Failed;
                             }
-                        }
 
-                        if (this.isManualExpired(status, payment)) {
-                            console.error('Manually marking Payconiq payment as expired', payment.id);
-                            status = PaymentStatus.Failed;
+                            await this.handlePaymentStatusUpdate(payment, organization, status);
                         }
+                        else {
+                            console.warn('Payconiq payment is missing for organization ' + organization.id + ' while checking payment status...');
 
-                        await this.handlePaymentStatusUpdate(payment, organization, status);
+                            if (this.isManualExpired(payment.status, payment)) {
+                                console.error('Manually marking Payconiq payment as expired because not found', payment.id);
+                                await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
+                            }
+                        }
                     }
                     else {
-                        console.warn('Payconiq payment is missing for organization ' + organization.id + ' while checking payment status...');
-
+                        console.error('Invalid payment provider', payment.provider, 'for payment', payment.id);
                         if (this.isManualExpired(payment.status, payment)) {
-                            console.error('Manually marking Payconiq payment as expired because not found', payment.id);
+                            console.error('Manually marking unknown payment as expired', payment.id);
                             await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
                         }
                     }
                 }
                 else {
-                    console.error('Invalid payment provider', payment.provider, 'for payment', payment.id);
-                    if (this.isManualExpired(payment.status, payment)) {
-                        console.error('Manually marking unknown payment as expired', payment.id);
-                        await this.handlePaymentStatusUpdate(payment, organization, PaymentStatus.Failed);
-                    }
-                }
-            }
-            else {
-                // Do a manual update if needed
-                if (payment.status === PaymentStatus.Succeeded) {
-                    if (payment.provider === PaymentProvider.Stripe) {
-                        // Update the status
-                        await StripeHelper.getStatus(payment, false, testMode);
+                    // Do a manual update if needed
+                    if (payment.status === PaymentStatus.Succeeded) {
+                        if (payment.provider === PaymentProvider.Stripe) {
+                            // Update the status
+                            await StripeHelper.getStatus(payment, false, testMode);
+                        }
                     }
                 }
-            }
-            return payment;
+                return payment;
+            });
         });
     },