@stamhoofd/backend 2.79.8 → 2.80.1

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

@@ -0,0 +1,429 @@
+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 { ChargeMembersEndpoint } from '../../src/endpoints/admin/members/ChargeMembersEndpoint';
+import { GetMemberBalanceEndpoint } from '../../src/endpoints/organization/dashboard/payments/GetMemberBalanceEndpoint';
+import { testServer } from '../helpers/TestServer';
+
+describe('E2E.ChargeMembers', () => {
+    const chargeMembersEndpoint = new ChargeMembersEndpoint();
+    const memberBalanceEndpoint = new GetMemberBalanceEndpoint();
+    let period: RegistrationPeriod;
+    let organization: Organization;
+    let otherOrganization: Organization;
+    let financialDirectorToken: Token;
+    let financialDirectorRole: PermissionRoleDetailed;
+    let financialDirectorRoleOfOtherOrganization: PermissionRoleDetailed;
+
+    const postCharge = async (filter: StamhoofdFilter, organization: Organization, body: ChargeMembersRequest, token: Token) => {
+        const request = Request.buildJson('POST', `/v${Version}/admin/charge-members`, organization.getApiHost(), body);
+        const filterRequest = new LimitedFilteredRequest({
+            filter,
+            limit: 100,
+        });
+        request.query = filterRequest.encode({ version: Version }) as any;
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+        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());
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+        return await testServer.test(memberBalanceEndpoint, request);
+    };
+
+    const createUserData = async (permissions: Permissions | null | undefined, roles: PermissionRoleDetailed[]) => {
+        const organization = await new OrganizationFactory({ period, roles })
+            .create();
+
+        const user = await new UserFactory({
+            organization,
+            permissions,
+        })
+            .create();
+
+        const token = await Token.createToken(user);
+
+        return { organization, user, token };
+    };
+
+    const createFinancialDirectorData = async () => {
+        const role = PermissionRoleDetailed.create({
+            name: 'financial director',
+            accessRights: [AccessRight.OrganizationFinanceDirector],
+        });
+
+        const { organization, user: financialDirector, token } = await createUserData(Permissions.create({
+            level: PermissionLevel.None,
+            roles: [
+                role,
+            ],
+            resources: new Map([[PermissionsResourceType.Groups, new Map([[
+                '',
+                ResourcePermissions.create({
+                    level: PermissionLevel.Write,
+                }),
+            ]])]]),
+        }), [role]);
+
+        return { role, organization, financialDirector, token };
+    };
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        period = await new RegistrationPeriodFactory({
+            startDate: new Date(2023, 0, 1),
+            endDate: new Date(2023, 11, 31),
+        }).create();
+
+        const financialDirectorData = await createFinancialDirectorData();
+        financialDirectorRole = financialDirectorData.role;
+        financialDirectorToken = financialDirectorData.token;
+        organization = financialDirectorData.organization;
+
+        const otherFinancialDirectorData = await createFinancialDirectorData();
+        otherOrganization = otherFinancialDirectorData.organization;
+        financialDirectorRoleOfOtherOrganization = otherFinancialDirectorData.role;
+    });
+
+    test('Should fail if user does can not manage the payments of the organization', async () => {
+        // arrange
+        const member1 = await new MemberFactory({ }).create();
+        const member2 = await new MemberFactory({ }).create();
+
+        await new RegistrationFactory({ member: member1, organization }).create();
+        await new RegistrationFactory({ member: member2, organization }).create();
+
+        const filter: StamhoofdFilter = {
+            id: {
+                $in: [member1.id, member2.id],
+            },
+        };
+
+        const body = ChargeMembersRequest.create({
+            description: 'test description',
+            price: 3,
+            amount: 4,
+            dueAt: new Date(2023, 0, 10),
+            createdAt: new Date(2023, 0, 4),
+        });
+
+        const testUserFactories: UserFactory[] = [
+            new UserFactory({
+                organization,
+                permissions: Permissions.create({
+                    level: PermissionLevel.None,
+                    roles: [
+                        financialDirectorRole,
+                    ],
+                    resources: new Map([[PermissionsResourceType.Groups, new Map([[
+                        '',
+                        ResourcePermissions.create({
+                            level: PermissionLevel.Read,
+                        }),
+                    ]])]]),
+                }),
+            }),
+            new UserFactory({
+                organization,
+                permissions: Permissions.create({
+                    level: PermissionLevel.None,
+                    resources: new Map([[PermissionsResourceType.Groups, new Map([[
+                        '',
+                        ResourcePermissions.create({
+                            level: PermissionLevel.Write,
+                        }),
+                    ]])]]),
+                }),
+            }),
+        ];
+
+        for (const userFactory of testUserFactories) {
+            const user = await userFactory.create();
+
+            const token = await Token.createToken(user);
+
+            await expect(async () => await postCharge(filter, organization, body, token))
+                .rejects
+                .toThrow('You do not have permissions for this action');
+        }
+    });
+
+    test('Should create balance items for members', async () => {
+        // arrange
+        const member1 = await new MemberFactory({ }).create();
+
+        const member2 = await new MemberFactory({ }).create();
+
+        await new RegistrationFactory({ member: member1, organization }).create();
+        await new RegistrationFactory({ member: member2, organization }).create();
+
+        const filter: StamhoofdFilter = {
+            id: {
+                $in: [member1.id, member2.id],
+            },
+        };
+
+        const body = ChargeMembersRequest.create({
+            description: 'test description',
+            price: 3,
+            amount: 4,
+            dueAt: new Date(2023, 0, 10),
+            createdAt: new Date(2023, 0, 4),
+        });
+
+        const result = await postCharge(filter, organization, body, financialDirectorToken);
+        expect(result).toBeDefined();
+        expect(result.body).toBeUndefined();
+
+        // act and assert
+        const testBalanceResponse = (response: Response<BalanceItemWithPayments[]>) => {
+            expect(response).toBeDefined();
+            expect(response.body.length).toBe(1);
+            const balanceItem1 = response.body[0];
+            expect(balanceItem1.price).toEqual(12);
+            expect(balanceItem1.amount).toEqual(body.amount);
+            expect(balanceItem1.description).toEqual(body.description);
+            expect(balanceItem1.organizationId).toEqual(organization.id);
+            // const dueAt = balanceItem1.dueAt!;
+            expect(balanceItem1.dueAt).toEqual(body.dueAt);
+            expect(balanceItem1.createdAt).toEqual(body.createdAt);
+        };
+
+        testBalanceResponse(await getBalance(member1.id, organization, financialDirectorToken));
+        testBalanceResponse(await getBalance(member2.id, organization, financialDirectorToken));
+    });
+
+    test('Should not charge members of other organization', async () => {
+        // arrange
+        const member1 = await new MemberFactory({ }).create();
+
+        const member2 = await new MemberFactory({ }).create();
+
+        await new RegistrationFactory({ member: member1, organization: otherOrganization }).create();
+        await new RegistrationFactory({ member: member2, organization: otherOrganization }).create();
+
+        const filter: StamhoofdFilter = {
+            id: {
+                $in: [member1.id, member2.id],
+            },
+        };
+
+        const otherFinancialDirector = await new UserFactory({
+            organization: otherOrganization,
+            permissions: Permissions.create({
+                level: PermissionLevel.None,
+                roles: [
+                    financialDirectorRoleOfOtherOrganization,
+                ],
+                resources: new Map([[PermissionsResourceType.Groups, new Map([[
+                    '',
+                    ResourcePermissions.create({
+                        level: PermissionLevel.Write,
+                    }),
+                ]])]]),
+            }),
+        })
+            .create();
+
+        const otherFinancialDirectorToken = await Token.createToken(otherFinancialDirector);
+
+        const body = ChargeMembersRequest.create({
+            description: 'test description',
+            price: 3,
+            amount: 4,
+            dueAt: new Date(2023, 0, 10),
+            createdAt: new Date(2023, 0, 4),
+        });
+
+        // act and assert
+        const result = await postCharge(filter, organization, body, financialDirectorToken);
+        expect(result).toBeDefined();
+        expect(result.body).toBeUndefined();
+
+        const testBalanceResponse = (response: Response<BalanceItemWithPayments[]>) => {
+            expect(response).toBeDefined();
+            expect(response.body.length).toBe(0);
+        };
+
+        testBalanceResponse(await getBalance(member1.id, otherOrganization, otherFinancialDirectorToken));
+        testBalanceResponse(await getBalance(member2.id, otherOrganization, otherFinancialDirectorToken));
+    });
+
+    test('Should fail if invalid request', async () => {
+        // arrange
+        const member1 = await new MemberFactory({ }).create();
+
+        const member2 = await new MemberFactory({ }).create();
+
+        await new RegistrationFactory({ member: member1, organization }).create();
+        await new RegistrationFactory({ member: member2, organization }).create();
+
+        const filter: StamhoofdFilter = {
+            id: {
+                $in: [member1.id, member2.id],
+            },
+        };
+
+        const testCases: [body: ChargeMembersRequest, expectedErrorMessage: string][] = [
+            // empty description
+            [ChargeMembersRequest.create({
+                description: ' ',
+                price: 3,
+                amount: 4,
+                dueAt: new Date(2023, 0, 10),
+                createdAt: new Date(2023, 0, 4),
+            }), 'Invalid description'],
+
+            // price 0
+            [ChargeMembersRequest.create({
+                description: 'test description',
+                price: 0,
+                amount: 4,
+                dueAt: new Date(2023, 0, 10),
+                createdAt: new Date(2023, 0, 4),
+            }), 'Invalid price'],
+
+            // amount 0
+            [ChargeMembersRequest.create({
+                description: 'test description',
+                price: 3,
+                amount: 0,
+                dueAt: new Date(2023, 0, 10),
+                createdAt: new Date(2023, 0, 4),
+            }), 'Invalid amount'],
+        ];
+
+        // act and assert
+        for (const [body, expectedErrorMessage] of testCases) {
+            await expect(async () => await postCharge(filter, organization, body, financialDirectorToken))
+                .rejects
+                .toThrow(expectedErrorMessage);
+        }
+    });
+
+    describe('Access for single group', () => {
+        test('Should create balance items for members if can manage payments of group', async () => {
+            // arrange
+            const role = PermissionRoleDetailed.create({
+                name: 'financial director',
+                accessRights: [AccessRight.OrganizationFinanceDirector],
+            });
+
+            const resources = new Map();
+
+            const { organization, token, user } = await createUserData(Permissions.create({
+                level: PermissionLevel.None,
+                roles: [
+                    role,
+                ],
+                resources,
+            }), [role]);
+
+            const member1 = await new MemberFactory({ }).create();
+
+            const member2 = await new MemberFactory({ }).create();
+
+            const group = await new GroupFactory({ organization, period }).create();
+
+            resources.set(PermissionsResourceType.Groups, new Map([[group.id, ResourcePermissions.create({
+                level: PermissionLevel.Write,
+            })]]));
+
+            await user.save();
+
+            await new RegistrationFactory({ member: member1, group }).create();
+            await new RegistrationFactory({ member: member2, group }).create();
+
+            const filter: StamhoofdFilter = {
+                id: {
+                    $in: [member1.id, member2.id],
+                },
+            };
+
+            const body = ChargeMembersRequest.create({
+                description: 'test description',
+                price: 3,
+                amount: 4,
+                dueAt: new Date(2023, 0, 10),
+                createdAt: new Date(2023, 0, 4),
+            });
+
+            const result = await postCharge(filter, organization, body, token);
+            expect(result).toBeDefined();
+            expect(result.body).toBeUndefined();
+
+            // act and assert
+            const testBalanceResponse = (response: Response<BalanceItemWithPayments[]>) => {
+                expect(response).toBeDefined();
+                expect(response.body.length).toBe(1);
+                const balanceItem1 = response.body[0];
+                expect(balanceItem1.price).toEqual(12);
+                expect(balanceItem1.amount).toEqual(body.amount);
+                expect(balanceItem1.description).toEqual(body.description);
+                expect(balanceItem1.organizationId).toEqual(organization.id);
+                // const dueAt = balanceItem1.dueAt!;
+                expect(balanceItem1.dueAt).toEqual(body.dueAt);
+                expect(balanceItem1.createdAt).toEqual(body.createdAt);
+            };
+
+            testBalanceResponse(await getBalance(member1.id, organization, token));
+            testBalanceResponse(await getBalance(member2.id, organization, token));
+        });
+
+        test('Should fail if no write access for group', async () => {
+            // arrange
+            const role = PermissionRoleDetailed.create({
+                name: 'financial director',
+                accessRights: [AccessRight.OrganizationFinanceDirector],
+            });
+
+            const resources = new Map();
+
+            const { organization, token, user } = await createUserData(Permissions.create({
+                level: PermissionLevel.None,
+                roles: [
+                    role,
+                ],
+                resources,
+            }), [role]);
+
+            const member1 = await new MemberFactory({ }).create();
+
+            const member2 = await new MemberFactory({ }).create();
+
+            const group = await new GroupFactory({ organization, period }).create();
+
+            resources.set(PermissionsResourceType.Groups, new Map([[group.id, ResourcePermissions.create({
+                level: PermissionLevel.Read,
+            })]]));
+
+            await user.save();
+
+            await new RegistrationFactory({ member: member1, group }).create();
+            await new RegistrationFactory({ member: member2, group }).create();
+
+            const filter: StamhoofdFilter = {
+                id: {
+                    $in: [member1.id, member2.id],
+                },
+            };
+
+            const body = ChargeMembersRequest.create({
+                description: 'test description',
+                price: 3,
+                amount: 4,
+                dueAt: new Date(2023, 0, 10),
+                createdAt: new Date(2023, 0, 4),
+            });
+
+            await expect(async () => await postCharge(filter, organization, body, token))
+                .rejects
+                .toThrow('You do not have permissions for this action');
+        });
+    });
+});

package/tests/jest.setup.ts

@@ -3,13 +3,14 @@ backendEnv.load({ path: __dirname + '/../../.env.test.json' });
 
 import { Column, Database } from '@simonbackx/simple-database';
 import { Request } from '@simonbackx/simple-endpoints';
-import { Email } from '@stamhoofd/email';
+import { Email, EmailMocker } from '@stamhoofd/email';
 import { Version } from '@stamhoofd/structures';
 import { sleep } from '@stamhoofd/utility';
 import nock from 'nock';
 import { GlobalHelper } from '../src/helpers/GlobalHelper';
 import * as jose from 'jose';
 import { TestUtils } from '@stamhoofd/test-utils';
+import './toMatchMap';
 
 // Set version of saved structures
 Column.setJSONVersion(Version);
@@ -43,6 +44,7 @@ beforeAll(async () => {
     await Database.delete('DELETE FROM `provinces`');
     await Database.delete('DELETE FROM `email_recipients`');
     await Database.delete('DELETE FROM `emails`');
+    await Database.delete('DELETE FROM `email_templates`');
 
     await Database.delete('DELETE FROM `webshop_orders`');
     await Database.delete('DELETE FROM `webshops`');
@@ -67,6 +69,9 @@ beforeAll(async () => {
     TestUtils.setPermanentEnvironment('FILE_SIGNING_PRIVATE_KEY', exportedPrivateKey);
 
     await GlobalHelper.load();
+
+    // Override default $t handlers
+    TestUtils.loadEnvironment();
 });
 
 afterAll(async () => {
@@ -79,3 +84,4 @@ afterAll(async () => {
 });
 
 TestUtils.setup();
+EmailMocker.infect();

package/tests/toMatchMap.ts

@@ -0,0 +1,68 @@
+import { expect } from '@jest/globals';
+import type { MatcherFunction } from 'expect';
+import 'jest';
+
+const toMatchMap: MatcherFunction<[map: unknown]> = function (actual, map: Map<any, any>) {
+    if (
+        !(map instanceof Map)
+    ) {
+        throw new TypeError('You need to pass a Map to toMatchMap');
+    }
+
+    if (
+        !(actual instanceof Map)
+    ) {
+        return {
+            message: () =>
+                `expected ${this.utils.printReceived(
+                    actual,
+                )} to be a Map`,
+            pass: false,
+        };
+    }
+
+    for (const key of map.keys()) {
+        // Check key exists
+        if (!actual.has(key)) {
+            return {
+                message: () =>
+                    `expected ${this.utils.printReceived(
+                        actual,
+                    )} to have key ${this.utils.printExpected(key)}`,
+                pass: false,
+            };
+        }
+
+        // Compare values
+        const expectedValue = map.get(key);
+        const actualValue = actual.get(key);
+
+        if (!this.equals(expectedValue, actualValue)) {
+            return {
+                message: () =>
+                    `expected ${this.utils.diff(actualValue, expectedValue)} at key ${this.utils.printExpected(key)}`,
+                pass: false,
+            };
+        }
+    }
+
+    // Check for extra keys in actual
+    for (const key of actual.keys()) {
+        if (!map.has(key)) {
+            return {
+                message: () =>
+                    `unexpected key ${this.utils.printExpected(key)} in Map`,
+                pass: false,
+            };
+        }
+    }
+
+    return {
+        message: () => `ok`,
+        pass: true,
+    };
+};
+
+expect.extend({
+    toMatchMap,
+});