@stamhoofd/backend 2.124.0 → 2.124.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.124.0",
+    "version": "2.124.1",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -57,20 +57,20 @@
         "@simonbackx/simple-endpoints": "1.21.1",
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
-        "@stamhoofd/backend-env": "2.124.0",
-        "@stamhoofd/backend-i18n": "2.124.0",
-        "@stamhoofd/backend-middleware": "2.124.0",
-        "@stamhoofd/crons": "2.124.0",
-        "@stamhoofd/email": "2.124.0",
-        "@stamhoofd/excel-writer": "2.124.0",
-        "@stamhoofd/logging": "2.124.0",
-        "@stamhoofd/models": "2.124.0",
-        "@stamhoofd/object-differ": "2.124.0",
-        "@stamhoofd/queues": "2.124.0",
-        "@stamhoofd/sql": "2.124.0",
-        "@stamhoofd/structures": "2.124.0",
-        "@stamhoofd/types": "2.124.0",
-        "@stamhoofd/utility": "2.124.0",
+        "@stamhoofd/backend-env": "2.124.1",
+        "@stamhoofd/backend-i18n": "2.124.1",
+        "@stamhoofd/backend-middleware": "2.124.1",
+        "@stamhoofd/crons": "2.124.1",
+        "@stamhoofd/email": "2.124.1",
+        "@stamhoofd/excel-writer": "2.124.1",
+        "@stamhoofd/logging": "2.124.1",
+        "@stamhoofd/models": "2.124.1",
+        "@stamhoofd/object-differ": "2.124.1",
+        "@stamhoofd/queues": "2.124.1",
+        "@stamhoofd/sql": "2.124.1",
+        "@stamhoofd/structures": "2.124.1",
+        "@stamhoofd/types": "2.124.1",
+        "@stamhoofd/utility": "2.124.1",
         "archiver": "7.0.1",
         "axios": "1.16.0",
         "base-x": "3.0.11",
@@ -91,7 +91,7 @@
         "stripe": "16.12.0"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.124.0",
+        "@stamhoofd/test-utils": "2.124.1",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.1",
         "@types/mailparser": "3.4.6",
@@ -107,5 +107,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "7783583e6555a28cce7c7ad26cb223a4623ca005"
+    "gitHead": "d520495d0c1a5f376b10a60ebbceec63b2228bd5"
 }

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.test.ts

@@ -1,7 +1,8 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import type { Organization, Token } from '@stamhoofd/models';
-import { OrganizationFactory, UserFactory } from '@stamhoofd/models';
-import { LimitedFilteredRequest, PermissionLevel, Permissions } from '@stamhoofd/structures';
+import { OrganizationFactory, STPackageFactory, UserFactory } from '@stamhoofd/models';
+import { LimitedFilteredRequest, OrganizationMetaData, OrganizationType, PermissionLevel, Permissions, STPackageBundle, type StamhoofdFilter, UmbrellaOrganization } from '@stamhoofd/structures';
+import { Country } from '@stamhoofd/types/Country';
 import { TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
 import { initPlatformAdmin } from '../../../../tests/init/index.js';
@@ -37,6 +38,22 @@ describe('Endpoint.GetOrganizationsEndpoint', () => {
         return response.body.results.map(o => o.id);
     };
 
+    const filter = async (filter: StamhoofdFilter, token: Token): Promise<string[]> => {
+        const request = Request.get({
+            path: baseUrl,
+            host: '',
+            query: new LimitedFilteredRequest({
+                filter,
+                limit: 100,
+            }),
+            headers: {
+                authorization: 'Bearer ' + token.accessToken,
+            },
+        });
+        const response = await testServer.test(endpoint, request);
+        return response.body.results.map(o => o.id);
+    };
+
     // Creates an admin (user with permissions) for the given organization
     const createAdmin = async (organization: Organization, data: { firstName?: string; lastName?: string; email?: string }) => {
         return await new UserFactory({
@@ -104,4 +121,112 @@ describe('Endpoint.GetOrganizationsEndpoint', () => {
         expect(results).toContain(organization.id);
         expect(results).not.toContain(otherOrganization.id);
     });
+
+    test('Filters organizations by active package type', async () => {
+        const { adminToken } = await initPlatformAdmin();
+
+        const membersOrg = await new OrganizationFactory({ name: 'Packaged Members Club' }).create();
+        await new STPackageFactory({ organization: membersOrg, bundle: STPackageBundle.Members }).create();
+
+        const webshopsOrg = await new OrganizationFactory({ name: 'Packaged Webshops Club' }).create();
+        await new STPackageFactory({ organization: webshopsOrg, bundle: STPackageBundle.Webshops }).create();
+
+        const results = await filter({
+            packages: {
+                $elemMatch: {
+                    type: {
+                        $in: ['Members'],
+                    },
+                },
+            },
+        }, adminToken);
+
+        expect(results).toContain(membersOrg.id);
+        expect(results).not.toContain(webshopsOrg.id);
+    });
+
+    test('Does not match organizations whose package is no longer valid', async () => {
+        const { adminToken } = await initPlatformAdmin();
+
+        const expiredOrg = await new OrganizationFactory({ name: 'Expired Members Club' }).create();
+        // removeAt in the past => package is no longer active
+        await new STPackageFactory({
+            organization: expiredOrg,
+            bundle: STPackageBundle.Members,
+            removeAt: new Date(Date.now() - 1000 * 60 * 60 * 24),
+        }).create();
+
+        const results = await filter({
+            packages: {
+                $elemMatch: {
+                    type: {
+                        $in: ['Members'],
+                    },
+                },
+            },
+        }, adminToken);
+
+        expect(results).not.toContain(expiredOrg.id);
+    });
+
+    // Creates an organization with a specific type and/or umbrella organization
+    const createOrganizationWithMeta = async (name: string, metaPatch: { type?: OrganizationType; umbrellaOrganization?: UmbrellaOrganization | null }) => {
+        const meta = OrganizationMetaData.create({
+            type: metaPatch.type ?? OrganizationType.Other,
+            umbrellaOrganization: metaPatch.umbrellaOrganization ?? null,
+            defaultEndDate: new Date(),
+            defaultStartDate: new Date(),
+            defaultPrices: [],
+        });
+        return await new OrganizationFactory({ name, meta }).create();
+    };
+
+    test('Filters organizations by type', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const youthOrg = await createOrganizationWithMeta('Youthful Club', { type: OrganizationType.Youth });
+        const sportOrg = await createOrganizationWithMeta('Sporty Club', { type: OrganizationType.Sport });
+
+        const results = await filter({ type: { $in: [OrganizationType.Youth] } }, adminToken);
+        expect(results).toContain(youthOrg.id);
+        expect(results).not.toContain(sportOrg.id);
+    });
+
+    test('Filters organizations by umbrella organization', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const scoutsOrg = await createOrganizationWithMeta('Scouts Club', { umbrellaOrganization: UmbrellaOrganization.ScoutsEnGidsenVlaanderen });
+        const otherOrg = await createOrganizationWithMeta('No Umbrella Club', { umbrellaOrganization: null });
+
+        const results = await filter({ umbrellaOrganization: { $in: [UmbrellaOrganization.ScoutsEnGidsenVlaanderen] } }, adminToken);
+        expect(results).toContain(scoutsOrg.id);
+        expect(results).not.toContain(otherOrg.id);
+    });
+
+    test('Filters organizations by country', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        // OrganizationFactory creates organizations in Belgium by default
+        const org = await new OrganizationFactory({ name: 'Belgian Club' }).create();
+
+        expect(await filter({ country: { $in: [Country.Belgium] } }, adminToken)).toContain(org.id);
+        expect(await filter({ country: { $in: [Country.Netherlands] } }, adminToken)).not.toContain(org.id);
+    });
+
+    test('Filters organizations by street', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        // OrganizationFactory uses 'Demostraat' as the street
+        const org = await new OrganizationFactory({ name: 'Streeted Club' }).create();
+
+        expect(await filter({ street: { $contains: 'Demostraat' } }, adminToken)).toContain(org.id);
+        expect(await filter({ street: { $contains: 'Nonexistentstreet' } }, adminToken)).not.toContain(org.id);
+    });
+
+    test('Filters organizations by creation date', async () => {
+        const { adminToken } = await initPlatformAdmin();
+        const org = await new OrganizationFactory({ name: 'Freshly Created Club' }).create();
+
+        const anHourAgo = new Date(Date.now() - 1000 * 60 * 60);
+        const inAnHour = new Date(Date.now() + 1000 * 60 * 60);
+
+        expect(await filter({ createdAt: { $gt: anHourAgo } }, adminToken)).toContain(org.id);
+        expect(await filter({ createdAt: { $gt: inAnHour } }, adminToken)).not.toContain(org.id);
+    });
 });

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.ts

@@ -125,7 +125,7 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             query.limit(q.limit);
         }
 
-        console.log('GetOrganizationsEndpoint query', query.getSQL());
+        // console.log('GetOrganizationsEndpoint query', query.getSQL());
 
         return query;
     }

package/src/endpoints/organization/dashboard/receivable-balances/GetReceivableBalanceEndpoint.ts

@@ -1,8 +1,8 @@
 import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
-import { DetailedReceivableBalance, PaymentStatus, ReceivableBalanceType } from '@stamhoofd/structures';
+import { DetailedReceivableBalance, PaymentStatus, PermissionLevel, ReceivableBalanceType } from '@stamhoofd/structures';
 
-import { BalanceItem, BalanceItemPayment, CachedBalance, MemberUser, Payment } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, CachedBalance, Member, MemberUser, Payment, Registration } from '@stamhoofd/models';
 import { Context } from '../../../../helpers/Context.js';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
 import { SQL } from '@stamhoofd/sql';
@@ -35,9 +35,23 @@ export class GetReceivableBalanceEndpoint extends Endpoint<Params, Query, Body,
         const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 
-        // If the user has permission, we'll also search if he has access to the organization's key
         if (!await Context.auth.canManageFinances(organization.id)) {
-            throw Context.auth.error();
+            // Group-level financial access is sufficient for member and registration balance views
+            if (request.params.type === ReceivableBalanceType.member) {
+                const member = await Member.getByIdWithUsersAndRegistrations(request.params.id);
+                if (!member || !await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, organization.id)) {
+                    throw Context.auth.error();
+                }
+            } else if (request.params.type === ReceivableBalanceType.registration) {
+                const registration = await Registration.select().where('id', request.params.id).first(false);
+                if (!registration) throw Context.auth.error();
+                const member = await Member.getByIdWithUsersAndRegistrations(registration.memberId);
+                if (!member || !await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, organization.id)) {
+                    throw Context.auth.error();
+                }
+            } else {
+                throw Context.auth.error();
+            }
         }
 
         let paymentModels: Payment[] = [];

package/src/seeds/{1782421124-group-permissions.ts → 1782421125-group-permissions.ts}

@@ -35,10 +35,6 @@ async function start(dryRun: boolean) {
                 .where('periodId', organization.periodId)
                 .fetch();
 
-            if (groups.length === 0) {
-                return;
-            }
-
             // handle group permissions
             for (const group of groups) {
                 const groupPermissions = group.privateSettings.permissions;

package/src/sql-filters/organizations.ts

@@ -29,6 +29,16 @@ export const organizationFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.Boolean,
         nullable: false,
     }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('organizations', 'createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    street: createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column('organizations', 'address'), '$.value.street'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
     city: createColumnFilter({
         expression: SQL.jsonExtract(SQL.column('organizations', 'address'), '$.value.city'),
         type: SQLValueType.JSONString,

package/src/sql-sorters/organizations.ts

@@ -88,4 +88,26 @@ export const organizationSorters: SQLSortDefinitions<Organization> = {
             });
         },
     },
+    umbrellaOrganization: {
+        getValue(a) {
+            return a.meta.umbrellaOrganization;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.jsonValue(SQL.column('meta'), '$.value.umbrellaOrganization', 'CHAR'),
+                direction,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return a.createdAt;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
 };