@stamhoofd/backend 2.79.6 → 2.79.8

package/.nvmrc

@@ -0,0 +1 @@
+20.12

package/index.ts

@@ -1,5 +1,5 @@
 import backendEnv from '@stamhoofd/backend-env';
-backendEnv.load();
+backendEnv.load({ service: 'api' });
 
 import { Column, Database, Migration } from '@simonbackx/simple-database';
 import { CORSPreflightEndpoint, Router, RouterServer } from '@simonbackx/simple-endpoints';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.79.6",
+    "version": "2.79.8",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -38,14 +38,14 @@
         "@simonbackx/simple-encoding": "2.21.0",
         "@simonbackx/simple-endpoints": "1.19.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.79.6",
-        "@stamhoofd/backend-middleware": "2.79.6",
-        "@stamhoofd/email": "2.79.6",
-        "@stamhoofd/models": "2.79.6",
-        "@stamhoofd/queues": "2.79.6",
-        "@stamhoofd/sql": "2.79.6",
-        "@stamhoofd/structures": "2.79.6",
-        "@stamhoofd/utility": "2.79.6",
+        "@stamhoofd/backend-i18n": "2.79.8",
+        "@stamhoofd/backend-middleware": "2.79.8",
+        "@stamhoofd/email": "2.79.8",
+        "@stamhoofd/models": "2.79.8",
+        "@stamhoofd/queues": "2.79.8",
+        "@stamhoofd/sql": "2.79.8",
+        "@stamhoofd/structures": "2.79.8",
+        "@stamhoofd/utility": "2.79.8",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -65,5 +65,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "5ed5677f28e62a73283527518b8e7ac0c8b4818e"
+    "gitHead": "06e4690b6413a21c3466d6ab76da3a883e1441c8"
 }

package/src/endpoints/global/members/GetMembersEndpoint.ts

@@ -2,7 +2,7 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Member, Platform } from '@stamhoofd/models';
-import { SQL, compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { SQL, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, Country, CountryCode, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 import { DataValidator } from '@stamhoofd/utility';
 
@@ -168,7 +168,7 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             }
 
             // Is lidnummer?
-            if (!searchFilter && (q.search.match(/^[0-9]{4}-[0-9]{6}-[0-9]{1,2}$/) || q.search.match(/^[0-9]{10}$/))) {
+            if (!searchFilter && (q.search.match(/^[0-9]{4}-[0-9]{6}-[0-9]{1,2}$/) || q.search.match(/^[0-9]{9,10}$/))) {
                 searchFilter = {
                     memberNumber: {
                         $eq: q.search,

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.test.ts

@@ -1,5 +1,5 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import { OrganizationFactory } from '@stamhoofd/models';
+import { Organization, OrganizationFactory } from '@stamhoofd/models';
 import { v4 as uuidv4 } from 'uuid';
 
 import { testServer } from '../../../../tests/helpers/TestServer';
@@ -9,6 +9,10 @@ describe('Endpoint.SearchOrganization', () => {
     // Test endpoint
     const endpoint = new SearchOrganizationEndpoint();
 
+    afterEach(async () => {
+        await Organization.delete();
+    });
+
     test('Search for a given organization using exact search', async () => {
         const organization = await new OrganizationFactory({
             name: (uuidv4()).replace(/-/g, ''),
@@ -51,4 +55,184 @@ describe('Endpoint.SearchOrganization', () => {
         expect(response.status).toEqual(200);
         expect(response.body.map(o => o.id).sort()).toEqual(organizations.map(o => o.id).sort());
     });
+
+    test('Search organization by name using word should return best match first', async () => {
+        const name = 'WAT?';
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization ' + (i + 1),
+                city: 'Waterloo',
+            }).create();
+        }
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization 2 ' + (i + 1),
+                city: 'Wats',
+            }).create();
+        }
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'De Watten ' + (i + 1),
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name,
+        }).create();
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'De Watten 2 ' + (i + 1),
+            }).create();
+        }
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query: name,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(9);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using sentence should return best match first', async () => {
+        const query = 'Spaghetti Vreters';
+
+        for (const name of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'De Spaghetti Vretersschool']) {
+            await new OrganizationFactory({
+                name,
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(6);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using word should return organization with searchindex that starts with query first if limit reached', async () => {
+        const query = 'Gent';
+
+        for (let i = 0; i < 10; i++) {
+            await new OrganizationFactory({
+                name: 'Some other Gent organization ' + (i + 1),
+                city: 'Gent',
+            }).create();
+        }
+
+        for (let i = 0; i < 5; i++) {
+            await new OrganizationFactory({
+                name: 'De Gentenaars ' + (i + 1),
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'Gent',
+        }).create();
+
+        for (let i = 0; i < 3; i++) {
+            await new OrganizationFactory({
+                name: 'De Gentenaars 2 ' + (i + 1),
+            }).create();
+        }
+
+        for (let i = 0; i < 10; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization 2 ' + (i + 1),
+                city: 'Gent',
+            }).create();
+        }
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(15);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using sentence should return organization with name that starts with query first if limit reached', async () => {
+        const query = 'De Spaghetti Vreters';
+
+        // without the where like (if the limit is reached), 'Spaghetti Vreters Spaghetti Vreters' would come first ('De' is a stopword)
+        for (const name of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'Spaghetti Vreters', 'Spaghetti Vreters Spaghetti Vreters', 'De Spaghetti Vretersschool', 'Spaghetti 2', 'Spaghetti 3', 'Spaghetti 4', 'Spaghetti 5', 'Spaghetti 6', 'Spaghetti 7', 'Spaghetti 8', 'Spaghetti 9', 'Spaghetti 10']) {
+            await new OrganizationFactory({
+                name,
+            }).create();
+        }
+
+        let i = 1;
+        for (const city of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'De Spaghetti Vretersschool']) {
+            await new OrganizationFactory({
+                name: 'name ' + i,
+                city,
+            }).create();
+            i = i + 1;
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(15);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name and city should return organization that matches city and name first', async () => {
+        const query = 'De Spaghetti Vreters Gent';
+
+        for (let i = 0; i < 5; i++) {
+            await new OrganizationFactory({
+                name: 'De Spaghetti Vreters ' + (i + 1),
+                city: 'Wetteren',
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters 16',
+            city: 'Gent',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(6);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
 });

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.ts

@@ -1,6 +1,7 @@
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Organization } from '@stamhoofd/models';
+import { scalarToSQLExpression, SQL, SQLMatch, SQLWhere, SQLWhereLike } from '@stamhoofd/sql';
 import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 
@@ -32,28 +33,45 @@ export class SearchOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         // Escape query
-        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '');
-        if (query.length == 0) {
+        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '').trim();
+        if (query.length === 0) {
             // Do not try searching...
             return new Response([]);
         }
 
-        const match = {
-            sign: 'MATCH',
-            value: query + '*', // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
-            mode: 'BOOLEAN',
-        };
-
-        // We had to add an order by in the query to fix the limit. MySQL doesn't want to limit the results correctly if we don't explicitly sort the results on their relevance
-        const organizations = await Organization.where({ searchIndex: match, active: 1 }, {
-            limit: 15,
-            sort: [
-                {
-                    column: { searchIndex: match },
-                    direction: 'DESC',
-                },
-            ],
-        });
+        let matchValue: string;
+
+        if (query.includes(' ')) {
+            // give higher relevance if the searchindex includes the exact sentence
+            // give lower relevance if the last word is not a complete match
+            matchValue = `>("${query}") (${query}) <(${query}*)`;
+        }
+        else {
+            // give higher relevance if the searchindex includes the exact word
+            matchValue = `>${query} ${query}*`;
+        }
+
+        const limit = 15;
+
+        const whereMatch: SQLWhere = new SQLMatch(SQL.column(Organization.table, 'searchIndex'), scalarToSQLExpression(matchValue));
+
+        let organizations = await Organization.select()
+            .where(whereMatch)
+            .orderBy(whereMatch, 'DESC')
+            .limit(limit).fetch();
+
+        // if the limit is reached it is possible that organizations where the name starts with the query are missing -> fetch them and add them at the start
+        if (organizations.length === limit) {
+            const organizationsStartingWith = await Organization.select()
+                .where(new SQLWhereLike(SQL.column(Organization.table, 'name'), scalarToSQLExpression(`${query}%`)))
+                // order by relevance
+                .orderBy(whereMatch, 'DESC')
+                .limit(limit).fetch();
+
+            const organizationsStartingWithIds = new Set(organizationsStartingWith.map(o => o.id));
+
+            organizations = organizationsStartingWith.concat(organizations.filter(o => !organizationsStartingWithIds.has(o.id)));
+        }
 
         return new Response(await Promise.all(organizations.map(o => AuthenticatedStructures.organization(o))));
     }

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -457,41 +457,9 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             balanceItem.organizationId = organization.id;
 
             // Who is responsible for payment?
-            let balanceItem2: BalanceItem | null = null;
             if (registration.payingOrganizationId) {
-                // Create a separate balance item for this meber to pay back the paying organization
-                // this is not yet associated with a payment but will be added to the outstanding balance of the member
-
+                // We no longer also charge the member. This has been removed, ref STA-288
                 balanceItem.payingOrganizationId = registration.payingOrganizationId;
-
-                balanceItem2 = new BalanceItem();
-
-                // NOTE: we don't connect the registrationId here
-                // because otherwise the total price and pricePaid for the registration would be incorrect
-                // balanceItem2.registrationId = registration.id;
-
-                balanceItem2.unitPrice = unitPrice;
-                balanceItem2.amount = amount ?? 1;
-                balanceItem2.description = description;
-                balanceItem2.relations = relations;
-                balanceItem2.type = type;
-
-                // Who needs to receive this money?
-                balanceItem2.organizationId = registration.payingOrganizationId;
-
-                // Who is responsible for payment?
-                balanceItem2.memberId = registration.memberId;
-
-                if (registration.trialUntil) {
-                    balanceItem2.dueAt = registration.trialUntil;
-                }
-
-                // If the paying organization hasn't paid yet, this should be hidden and move to pending as soon as the paying organization has paid
-                balanceItem2.status = BalanceItemStatus.Hidden;
-                await balanceItem2.save();
-
-                // do not add to createdBalanceItems array because we don't want to add this to the payment if we create a payment
-                unrelatedCreatedBalanceItems.push(balanceItem2);
             }
             else {
                 balanceItem.memberId = registration.memberId;
@@ -501,9 +469,6 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             balanceItem.status = BalanceItemStatus.Hidden;
             balanceItem.pricePaid = 0;
 
-            // Connect the 'pay back' balance item to this balance item. As soon as this balance item is paid, we'll mark the other one as pending so the outstanding balance for the member increases
-            balanceItem.dependingBalanceItemId = balanceItem2?.id ?? null;
-
             if (registration.trialUntil) {
                 balanceItem.dueAt = registration.trialUntil;
             }

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -352,6 +352,15 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                     });
                 }
 
+                const maximumStart = 1000 * 60 * 60 * 24 * 31 * 2; // 2 months in advance
+                if (period.startDate > new Date(Date.now() + maximumStart)) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'Het werkjaar die je wilt instellen is nog niet gestart',
+                        field: 'period',
+                    });
+                }
+
                 organization.periodId = period.id;
                 shouldUpdateSetupSteps = true;
             }

package/src/endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint.ts

@@ -280,6 +280,15 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             });
         }
 
+        const maximumStart = 1000 * 60 * 60 * 24 * 31 * 2; // 2 months in advance
+        if (period.startDate > new Date(Date.now() + maximumStart)) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Het werkjaar die je wilt instellen is nog niet gestart',
+                field: 'period',
+            });
+        }
+
         const organizationPeriod = new OrganizationRegistrationPeriod();
         organizationPeriod.id = struct.id;
         organizationPeriod.organizationId = organization.id;

package/src/helpers/AuthenticatedStructures.ts

@@ -391,7 +391,7 @@ export class AuthenticatedStructures {
         const organizations = new Map<string, Organization>();
 
         const registrationIds = Formatter.uniqueArray(members.flatMap(m => m.registrations.map(r => r.id)));
-        const balances = await CachedBalance.getForObjects(registrationIds, Context.organization?.id ?? null);
+        const balances = await CachedBalance.getForObjects(registrationIds, null);
 
         if (includeUser) {
             for (const organizationId of includeUser.permissions?.organizationPermissions.keys() ?? []) {