@stamhoofd/backend 2.83.5 → 2.84.1

package/tests/e2e/charge-members.test.ts

@@ -1,14 +1,14 @@
 import { Request, Response } from '@simonbackx/simple-endpoints';
 import { GroupFactory, MemberFactory, Organization, OrganizationFactory, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { AccessRight, BalanceItemWithPayments, ChargeMembersRequest, LimitedFilteredRequest, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, ResourcePermissions, StamhoofdFilter, Version } from '@stamhoofd/structures';
-import { TestUtils } from '@stamhoofd/test-utils';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { ChargeMembersEndpoint } from '../../src/endpoints/admin/members/ChargeMembersEndpoint';
-import { GetMemberBalanceEndpoint } from '../../src/endpoints/organization/dashboard/payments/GetMemberBalanceEndpoint';
 import { testServer } from '../helpers/TestServer';
+import { GetReceivableBalanceEndpoint } from '../../src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint';
 
 describe('E2E.ChargeMembers', () => {
     const chargeMembersEndpoint = new ChargeMembersEndpoint();
-    const memberBalanceEndpoint = new GetMemberBalanceEndpoint();
+    const getReceivableBalanceEndpoint = new GetReceivableBalanceEndpoint();
     let period: RegistrationPeriod;
     let organization: Organization;
     let otherOrganization: Organization;
@@ -27,10 +27,10 @@ describe('E2E.ChargeMembers', () => {
         return await testServer.test(chargeMembersEndpoint, request);
     };
 
-    const getBalance = async (memberId: string, organization: Organization, token: Token): Promise<Response<BalanceItemWithPayments[]>> => {
-        const request = Request.buildJson('GET', `/v${Version}/organization/members/${memberId}/balance`, organization.getApiHost());
+    const getBalance = async (memberId: string, organization: Organization, token: Token): Promise<BalanceItemWithPayments[]> => {
+        const request = Request.buildJson('GET', `/v${Version}/receivable-balances/member/${memberId}`, organization.getApiHost());
         request.headers.authorization = 'Bearer ' + token.accessToken;
-        return await testServer.test(memberBalanceEndpoint, request);
+        return (await testServer.test(getReceivableBalanceEndpoint, request)).body.balanceItems;
     };
 
     const createUserData = async (permissions: Permissions | null | undefined, roles: PermissionRoleDetailed[]) => {
@@ -149,7 +149,7 @@ describe('E2E.ChargeMembers', () => {
 
             await expect(async () => await postCharge(filter, organization, body, token))
                 .rejects
-                .toThrow('You do not have permissions for this action');
+                .toThrow(STExpect.errorWithCode('permission_denied'));
         }
     });
 
@@ -181,10 +181,10 @@ describe('E2E.ChargeMembers', () => {
         expect(result.body).toBeUndefined();
 
         // act and assert
-        const testBalanceResponse = (response: Response<BalanceItemWithPayments[]>) => {
+        const testBalanceResponse = (response: BalanceItemWithPayments[]) => {
             expect(response).toBeDefined();
-            expect(response.body.length).toBe(1);
-            const balanceItem1 = response.body[0];
+            expect(response.length).toBe(1);
+            const balanceItem1 = response[0];
             expect(balanceItem1.price).toEqual(12);
             expect(balanceItem1.amount).toEqual(body.amount);
             expect(balanceItem1.description).toEqual(body.description);
@@ -245,9 +245,9 @@ describe('E2E.ChargeMembers', () => {
         expect(result).toBeDefined();
         expect(result.body).toBeUndefined();
 
-        const testBalanceResponse = (response: Response<BalanceItemWithPayments[]>) => {
+        const testBalanceResponse = (response: BalanceItemWithPayments[]) => {
             expect(response).toBeDefined();
-            expect(response.body.length).toBe(0);
+            expect(response.length).toBe(0);
         };
 
         testBalanceResponse(await getBalance(member1.id, otherOrganization, otherFinancialDirectorToken));
@@ -340,8 +340,10 @@ describe('E2E.ChargeMembers', () => {
             await new RegistrationFactory({ member: member2, group }).create();
 
             const filter: StamhoofdFilter = {
-                id: {
-                    $in: [member1.id, member2.id],
+                registrations: {
+                    $elemMatch: {
+                        groupId: group.id,
+                    },
                 },
             };
 
@@ -358,16 +360,15 @@ describe('E2E.ChargeMembers', () => {
             expect(result.body).toBeUndefined();
 
             // act and assert
-            const testBalanceResponse = (response: Response<BalanceItemWithPayments[]>) => {
+            const testBalanceResponse = (response: BalanceItemWithPayments[]) => {
                 expect(response).toBeDefined();
-                expect(response.body.length).toBe(1);
-                const balanceItem1 = response.body[0];
+                expect(response.length).toBe(1);
+                const balanceItem1 = response[0];
                 expect(balanceItem1.price).toEqual(12);
-                expect(balanceItem1.amount).toEqual(body.amount);
-                expect(balanceItem1.description).toEqual(body.description);
+                expect(balanceItem1.amount).toEqual(4);
+                expect(balanceItem1.description).toEqual('test description');
                 expect(balanceItem1.organizationId).toEqual(organization.id);
-                // const dueAt = balanceItem1.dueAt!;
-                expect(balanceItem1.dueAt).toEqual(body.dueAt);
+                expect(balanceItem1.dueAt).toEqual(new Date(2023, 0, 10));
                 expect(balanceItem1.createdAt).toEqual(body.createdAt);
             };
 
@@ -408,8 +409,10 @@ describe('E2E.ChargeMembers', () => {
             await new RegistrationFactory({ member: member2, group }).create();
 
             const filter: StamhoofdFilter = {
-                id: {
-                    $in: [member1.id, member2.id],
+                registrations: {
+                    $elemMatch: {
+                        groupId: group.id,
+                    },
                 },
             };
 
@@ -423,7 +426,7 @@ describe('E2E.ChargeMembers', () => {
 
             await expect(async () => await postCharge(filter, organization, body, token))
                 .rejects
-                .toThrow('You do not have permissions for this action');
+                .toThrow(STExpect.errorWithCode('permission_denied'));
         });
     });
 });

package/tests/e2e/documents.test.ts

@@ -0,0 +1,398 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { Document, DocumentTemplateFactory, Group, GroupFactory, Member, MemberFactory, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import { IDRegisterCart, IDRegisterCheckout, IDRegisterItem, MemberDetails, MemberWithRegistrationsBlob, PaymentMethod } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { Formatter } from '@stamhoofd/utility';
+import { RegisterMembersEndpoint } from '../../src/endpoints/global/registration/RegisterMembersEndpoint';
+import { patchOrganizationMember } from '../actions/patchOrganizationMember';
+import { markNotPaid, markPaid } from '../actions/patchPaymentStatus';
+import { patchUserMember } from '../actions/patchUserMember';
+import { testServer } from '../helpers/TestServer';
+import { initAdmin } from '../init/initAdmin';
+import { initStripe } from '../init/initStripe';
+import { registrationUpdateQueue } from '../../src/services/BalanceItemService';
+
+const baseUrl = `/members/register`;
+
+describe('E2E.Documents', () => {
+    const endpoint = new RegisterMembersEndpoint();
+    let period: RegistrationPeriod;
+
+    const post = async (body: IDRegisterCheckout, organization: Organization, token: Token) => {
+        const request = Request.post({
+            path: baseUrl,
+            host: organization.getApiHost(),
+            body,
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+        return await testServer.test(endpoint, request);
+    };
+
+    beforeAll(async () => {
+        const previousPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2022, 0, 1),
+            endDate: new Date(2022, 11, 31),
+        }).create();
+
+        period = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1),
+            endDate: new Date(2030, 11, 31),
+            previousPeriodId: previousPeriod.id,
+        }).create();
+    });
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    const initOrganization = async (registrationPeriod: RegistrationPeriod = period) => {
+        const organization = await new OrganizationFactory({ period: registrationPeriod })
+            .create();
+
+        const organizationRegistrationPeriod = await new OrganizationRegistrationPeriodFactory({ organization, period: registrationPeriod }).create();
+
+        return { organization, organizationRegistrationPeriod };
+    };
+
+    async function initData(options?: { paidOnly?: boolean; maxAge?: number }) {
+        const { organization, organizationRegistrationPeriod } = await initOrganization(period);
+
+        const user = await new UserFactory({
+            organization,
+            permissions: null,
+        }).create();
+
+        const token = await Token.createToken(user);
+
+        const member = await new MemberFactory({ organization, user })
+            .create();
+
+        const group = await new GroupFactory({
+            organization,
+            price: 25_00,
+        }).create();
+
+        const group2 = await new GroupFactory({
+            organization,
+            price: 15_00,
+        }).create();
+
+        const documentTemplate = await new DocumentTemplateFactory({
+            groups: [
+                group,
+                group2,
+            ],
+            minPricePaid: options?.paidOnly ? 1 : null,
+            maxAge: options?.maxAge ?? null,
+        }).create();
+
+        return {
+            organization,
+            organizationRegistrationPeriod,
+            user,
+            token,
+            member,
+            group,
+            group2,
+            documentTemplate,
+        };
+    }
+
+    async function assertNoDocument(registration: { id: string }) {
+        await registrationUpdateQueue.flushAndWait();
+        const document = await Document.select().where('registrationId', registration.id).first(false);
+        expect(document).toBeNull();
+    }
+
+    async function assertDocument({ registration, organization, member, group, price, pricePaid }: { registration: { id: string }; organization: Organization; member: Member; group: Group; price: number; pricePaid?: number }) {
+        await registrationUpdateQueue.flushAndWait();
+        const document = await Document.select().where('registrationId', registration.id).first(false);
+        expect(document).not.toBeNull();
+
+        const html = await document!.getRenderedHtml(organization);
+
+        const registrationModel = (await Registration.getByID(registration.id))!;
+
+        const expectations = [
+            member.firstName,
+            'Member name using other variable: ' + member.firstName,
+            member.lastName,
+            group.settings.name.toString(),
+            'Price: ' + Formatter.price(price),
+            organization.name,
+            Formatter.dateNumber(registrationModel.startDate!, true),
+            Formatter.dateNumber(group.settings.endDate, true),
+        ];
+
+        if (pricePaid !== undefined) {
+            expectations.push('Price paid: ' + Formatter.price(pricePaid));
+        }
+
+        // Assert some things in the HTML
+        for (const expectation of expectations || []) {
+            expect(html).toContain(expectation);
+        }
+
+        return document!;
+    }
+
+    test('A document is created when a member registers and pays online', async () => {
+        const { organization, group, token, member } = await initData();
+        const { stripeMocker } = await initStripe({ organization });
+
+        // First register the member for group 1. No discount should be applied yet
+        const checkout1 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        groupPrice: group.settings.prices[0],
+                        groupId: group.id,
+                        organizationId: organization.id,
+                        memberId: member.id,
+                    }),
+                ],
+            }),
+            paymentMethod: PaymentMethod.Bancontact,
+            totalPrice: 25_00,
+            redirectUrl: new URL('https://example.com/redirect'),
+            cancelUrl: new URL('https://example.com/cancel'),
+        });
+
+        const response = await post(checkout1, organization, token);
+        const registration = response.body.registrations[0];
+        await assertNoDocument(registration);
+
+        // Check no document for this registration yet
+        await stripeMocker.succeedPayment(stripeMocker.getLastIntent());
+
+        const registrationModel = await Registration.getByID(registration.id);
+        expect(registrationModel).not.toBeNull();
+        expect(registrationModel?.registeredAt).not.toBeNull();
+
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 25_00 });
+    });
+
+    test('Documents are created for non-paid registrations by default', async () => {
+        const { organization, group, token, member } = await initData({ paidOnly: false });
+
+        // First register the member for group 1. No discount should be applied yet
+        const checkout1 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        groupPrice: group.settings.prices[0],
+                        groupId: group.id,
+                        organizationId: organization.id,
+                        memberId: member.id,
+                    }),
+                ],
+            }),
+            paymentMethod: PaymentMethod.PointOfSale,
+            totalPrice: 25_00,
+        });
+
+        const response = await post(checkout1, organization, token);
+        const registration = response.body.registrations[0];
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 0 });
+
+        // Mark paid
+        await markPaid({ payment: response.body.payment!, organization });
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 25_00 });
+
+        // Mark unpaid
+        await markNotPaid({ payment: response.body.payment!, organization });
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 0 });
+    });
+
+    test('A paid-only document is only created when a payment is marked as paid', async () => {
+        const { organization, group, token, member } = await initData({ paidOnly: true });
+
+        // First register the member for group 1. No discount should be applied yet
+        const checkout1 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        groupPrice: group.settings.prices[0],
+                        groupId: group.id,
+                        organizationId: organization.id,
+                        memberId: member.id,
+                    }),
+                ],
+            }),
+            paymentMethod: PaymentMethod.PointOfSale,
+            totalPrice: 25_00,
+        });
+
+        const response = await post(checkout1, organization, token);
+        const registration = response.body.registrations[0];
+        await assertNoDocument(registration);
+
+        await markPaid({ payment: response.body.payment!, organization });
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 25_00 });
+
+        // Should be deleted again
+        await markNotPaid({ payment: response.body.payment!, organization });
+        await assertNoDocument(registration);
+    });
+
+    test('A maximum age document is not created for older members', async () => {
+        const { organization, group, token, member, user } = await initData({ maxAge: 10 });
+        member.details.birthDay = new Date(2000, 0, 1); // Make the member older than the maximum age
+        await member.save();
+
+        // First register the member for group 1. No discount should be applied yet
+        const checkout1 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        groupPrice: group.settings.prices[0],
+                        groupId: group.id,
+                        organizationId: organization.id,
+                        memberId: member.id,
+                    }),
+                ],
+            }),
+            paymentMethod: PaymentMethod.PointOfSale,
+            totalPrice: 25_00,
+        });
+
+        const response = await post(checkout1, organization, token);
+        const registration = response.body.registrations[0];
+        await assertNoDocument(registration);
+        await markPaid({ payment: response.body.payment!, organization });
+        await assertNoDocument(registration);
+
+        // Change the age of this member via an API endpoint
+        await patchOrganizationMember({
+            organization,
+            patch: MemberWithRegistrationsBlob.patch({
+                id: member.id,
+                details: MemberDetails.patch({
+                    birthDay: new Date(),
+                }),
+            }),
+        });
+
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 25_00 });
+        await markNotPaid({ payment: response.body.payment!, organization });
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 0 });
+
+        // Change age again
+        await patchOrganizationMember({
+            organization,
+            patch: MemberWithRegistrationsBlob.patch({
+                id: member.id,
+                details: MemberDetails.patch({
+                    birthDay: new Date(2000, 0, 1), // Make the member older than the maximum age
+                }),
+            }),
+        });
+
+        await assertNoDocument(registration);
+
+        // Change age as user (different endpoint, but should also have the same side effect)
+        await patchUserMember({
+            organization,
+            user,
+            patch: MemberWithRegistrationsBlob.patch({
+                id: member.id,
+                details: MemberDetails.patch({
+                    birthDay: new Date(),
+                }),
+            }),
+        });
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 0 });
+    });
+
+    test('A document is updated when a registration is moved by an admin', async () => {
+        const { organization, group, group2, token, member } = await initData({ paidOnly: false });
+        const { adminToken } = await initAdmin({ organization });
+
+        // First register the member for group 1. No discount should be applied yet
+        const checkout1 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        groupPrice: group.settings.prices[0],
+                        groupId: group.id,
+                        organizationId: organization.id,
+                        memberId: member.id,
+                    }),
+                ],
+            }),
+            paymentMethod: PaymentMethod.PointOfSale,
+            totalPrice: 25_00,
+        });
+
+        const response = await post(checkout1, organization, token);
+        const registration = response.body.registrations[0];
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 0 });
+
+        // Move
+        const checkout2 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        groupPrice: group2.settings.prices[0],
+                        groupId: group2.id,
+                        organizationId: organization.id,
+                        memberId: member.id,
+                        replaceRegistrationIds: [registration.id],
+                    }),
+                ],
+            }),
+            paymentMethod: PaymentMethod.PointOfSale,
+            asOrganizationId: organization.id,
+            totalPrice: -10_00,
+        });
+
+        const response2 = await post(checkout2, organization, adminToken);
+        const registration2 = response2.body.registrations[0];
+        await assertDocument({ registration: registration2, organization, member, group: group2, price: 15_00, pricePaid: 0 });
+        await assertNoDocument(registration);
+    });
+
+    test('A document is deleted when a registration is deleted by an admin', async () => {
+        const { organization, group, token, member } = await initData({ paidOnly: false });
+        const { adminToken } = await initAdmin({ organization });
+
+        // First register the member for group 1. No discount should be applied yet
+        const checkout1 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        groupPrice: group.settings.prices[0],
+                        groupId: group.id,
+                        organizationId: organization.id,
+                        memberId: member.id,
+                    }),
+                ],
+            }),
+            paymentMethod: PaymentMethod.PointOfSale,
+            totalPrice: 25_00,
+        });
+
+        const response = await post(checkout1, organization, token);
+        const registration = response.body.registrations[0];
+        await assertDocument({ registration, organization, member, group, price: 25_00, pricePaid: 0 });
+
+        // Move
+        const checkout2 = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                deleteRegistrationIds: [registration.id],
+            }),
+            paymentMethod: PaymentMethod.PointOfSale,
+            asOrganizationId: organization.id,
+            totalPrice: -25_00,
+        });
+
+        await post(checkout2, organization, adminToken);
+        await assertNoDocument(registration);
+    });
+});