@stamhoofd/backend 2.119.0 → 2.120.0

package/src/endpoints/global/platform-memberships/GetPlatformMembershipsEndpoint.ts

@@ -0,0 +1,206 @@
+import type { Decoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Member, MemberPlatformMembership, Organization } from '@stamhoofd/models';
+import { applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
+import type { CountFilteredRequest, StamhoofdFilter } from '@stamhoofd/structures';
+import { assertSort, getSortFilter, LimitedFilteredRequest, PaginatedResponse, PlatformMembershiMemberDetails, PlatformMembership, PlatformMembershipOrganizationDetails } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { Context } from '../../../helpers/Context.js';
+import { platformMembershipFilterCompilers } from '../../../sql-filters/platform-memberships.js';
+import { platformMembershipSorters } from '../../../sql-sorters/platform-memberships.js';
+
+type Params = Record<string, never>;
+type Query = LimitedFilteredRequest;
+type Body = undefined;
+type ResponseBody = PaginatedResponse<PlatformMembership[], LimitedFilteredRequest>;
+
+
+const sorters = platformMembershipSorters;
+const filterCompilers = platformMembershipFilterCompilers;
+
+export class GetPlatformMembershipsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/platform-memberships', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+       if (!Context.auth.hasPlatformFullAccess()) {
+           throw Context.auth.error();
+       }
+
+        const query = MemberPlatformMembership.select()
+            .setMaxExecutionTime(15 * 1000)
+            .where('deletedAt', null);
+
+        if (q.filter) {
+            query.where(await compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        const searchFilter = GetPlatformMembershipsEndpoint.buildSearchFilter(q.search);
+
+        if (searchFilter) {
+            query.where(await compileToSQLFilter(searchFilter, filterCompilers));
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(await compileToSQLFilter(q.pageFilter, filterCompilers));
+            }
+
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            applySQLSorter(query, q.sort, sorters);
+            query.limit(q.limit);
+        }
+
+        return query;
+    }
+
+    static buildSearchFilter(search: string | null): StamhoofdFilter | null {
+        if (!search) {
+            return null;
+        }
+
+        // Is member number?
+        if (search.match(/^\d{4}-\d{6}-\d{1,2}$/) || search.match(/^\d{9,10}$/)) {
+            return {
+                member: {
+                        memberNumber: {
+                        $eq: search,
+                    },
+                    
+                }
+            };
+        }
+
+        return {
+                member: {
+                    name: {
+                        $contains: search,
+                    }
+                }
+            };
+    }
+
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const query = await GetPlatformMembershipsEndpoint.buildQuery(requestQuery);
+
+        let data: MemberPlatformMembership[];
+
+        try {
+            data = await query.fetch();
+        }
+        catch (error) {
+            if (error.message.includes('ER_QUERY_TIMEOUT')) {
+                throw new SimpleError({
+                    code: 'timeout',
+                    message: 'Query took too long',
+                    human: $t(`%Cv`),
+                });
+            }
+            throw error;
+        }
+
+        const memberIds = Formatter.uniqueArray(data.map(d => d.memberId));
+        const organizationIds = Formatter.uniqueArray(data.map(d => d.organizationId));
+        const members = await Member.getByIDs(...memberIds);
+        const organizations = await Organization.getByIDs(...organizationIds);
+
+        const results: PlatformMembership[] = [];
+
+        for (const model of data) {
+            const member = members.find(m => m.id === model.memberId);
+            if (!member) {
+                throw new SimpleError({
+                    code: 'not_found',
+                    message: 'Member not found',
+                    human: $t(`Het lid dat bij de aansluiting hoort is niet gevonden.`),
+                    statusCode: 404,
+                });
+            }
+
+            const organization = organizations.find(o => o.id === model.organizationId);
+            if (!organization) {
+                throw new SimpleError({
+                    code: 'not_found',
+                    message: 'Organization not found',
+                    human: $t(`De vereniging die bij de aansluiting hoort is niet gevonden.`),
+                    statusCode: 404,
+                });
+            }
+
+            results.push(PlatformMembership.create({
+                ...model,
+                member: PlatformMembershiMemberDetails.create(member),
+                organization: PlatformMembershipOrganizationDetails.create(organization)
+            }));
+        }
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (results.length >= requestQuery.limit) {
+            const lastObject = results[results.length - 1];
+            const nextFilter = getSortFilter(lastObject, sorters, requestQuery.sort);
+
+            next = new LimitedFilteredRequest({
+                filter: requestQuery.filter,
+                pageFilter: nextFilter,
+                sort: requestQuery.sort,
+                limit: requestQuery.limit,
+                search: requestQuery.search,
+            });
+
+            if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
+                console.error('Found infinite loading loop for', requestQuery);
+                next = undefined;
+            }
+        }
+
+        return new PaginatedResponse<PlatformMembership[], LimitedFilteredRequest>({
+            results,
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate();
+
+       if (!Context.auth.hasPlatformFullAccess()) {
+           throw Context.auth.error();
+       }
+
+        const maxLimit = 1000;
+
+        if (request.query.limit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit,
+            });
+        }
+
+        if (request.query.limit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1',
+            });
+        }
+
+        return new Response(
+            await GetPlatformMembershipsEndpoint.buildData(request.query),
+        );
+    }
+}

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

@@ -1,5 +1,6 @@
-import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { Decoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
 
 import { Context } from '../../../helpers/Context.js';

package/src/endpoints/global/registration/GetRegistrationsEndpoint.test.ts

@@ -1,5 +1,6 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import { EventFactory, GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import type { RegistrationPeriod} from '@stamhoofd/models';
+import { EventFactory, GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { AccessRight, EventMeta, GroupType, LimitedFilteredRequest, NamedObject, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, ResourcePermissions } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';

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

@@ -1,11 +1,14 @@
-import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { Decoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Group, Member, Platform, Registration } from '@stamhoofd/models';
-import { SQL, SQLExpression, SQLSelect, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
-import { CountFilteredRequest, GroupType, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, RegistrationWithMemberBlob, StamhoofdFilter, assertSort, RegistrationsBlob } from '@stamhoofd/structures';
+import type { SQLExpression, SQLSortDefinitions} from '@stamhoofd/sql';
+import { SQL, SQLSelect, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
+import type { CountFilteredRequest, RegistrationWithMemberBlob, StamhoofdFilter, RegistrationsBlob } from '@stamhoofd/structures';
+import { GroupType, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, assertSort } from '@stamhoofd/structures';
 
-import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
+import type { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
 import { Context } from '../../../helpers/Context.js';
 import { LimitedFilteredRequestHelper } from '../../../helpers/LimitedFilteredRequestHelper.js';

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

@@ -1,5 +1,7 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { BalanceItem, Member, Organization, Payment } from '@stamhoofd/models';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import type { Payment } from '@stamhoofd/models';
+import { BalanceItem, Member, Organization } from '@stamhoofd/models';
 import { DetailedPayableBalanceCollection, DetailedPayableBalance } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';

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

@@ -1,6 +1,8 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { Document, DocumentTemplate, Member } from '@stamhoofd/models';
-import { Document as DocumentStruct, DocumentStatus } from '@stamhoofd/structures';
+import type { Document as DocumentStruct} from '@stamhoofd/structures';
+import { DocumentStatus } from '@stamhoofd/structures';
 import { Sorter } from '@stamhoofd/utility';
 
 import { Context } from '../../../helpers/Context.js';

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

@@ -1,6 +1,7 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { Member } from '@stamhoofd/models';
-import { MembersBlob } from '@stamhoofd/structures';
+import type { MembersBlob } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
 import { Context } from '../../../helpers/Context.js';

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

@@ -1,4 +1,5 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { CachedBalance, Organization } from '@stamhoofd/models';
 import { PayableBalance, PayableBalanceCollection, ReceivableBalanceType } from '@stamhoofd/structures';
 

package/src/endpoints/global/registration/PatchUserMembersEndpoint.test.ts

@@ -1,8 +1,10 @@
 import { Database } from '@simonbackx/simple-database';
 import { PatchableArray, PatchMap } from '@simonbackx/simple-encoding';
-import { Endpoint, Request } from '@simonbackx/simple-endpoints';
+import type { Endpoint} from '@simonbackx/simple-endpoints';
+import { Request } from '@simonbackx/simple-endpoints';
 import { GroupFactory, Member, MemberFactory, OrganizationFactory, Platform, RegistrationFactory, Token, UserFactory } from '@stamhoofd/models';
-import { MemberDetails, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PatchAnswers, PermissionLevel, RecordCategory, RecordSettings, RecordTextAnswer, TranslatedString, UitpasNumberDetails, UitpasSocialTariff, UitpasSocialTariffStatus } from '@stamhoofd/structures';
+import type { PatchAnswers} from '@stamhoofd/structures';
+import { MemberDetails, MemberWithRegistrationsBlob, OrganizationMetaData, OrganizationRecordsConfiguration, Parent, PermissionLevel, RecordCategory, RecordSettings, RecordTextAnswer, TranslatedString, UitpasNumberDetails, UitpasSocialTariff, UitpasSocialTariffStatus } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { testServer } from '../../../../tests/helpers/TestServer.js';
 import { initUitpasApi } from '../../../../tests/init/index.js';
@@ -540,7 +542,7 @@ describe('Endpoint.PatchUserMembersEndpoint', () => {
                 expect(result.body.members[0].details.uitpasNumberDetails?.uitpasNumber).toEqual('0900011354819');
                 expect(result.body.members[0].details.uitpasNumberDetails?.socialTariff?.status).toEqual(UitpasSocialTariffStatus.Active);
                 expect(result.body.members[0].details.uitpasNumberDetails?.socialTariff?.updatedAt.getTime()).not.toEqual(new Date(2030, 0, 1).getTime());
-                expect(result.body.members[0].details.uitpasNumberDetails?.socialTariff?.endDate).toBeDate();
+                expect(result.body.members[0].details.uitpasNumberDetails?.socialTariff?.endDate).toBeInstanceOf(Date);
             });
 
             test('Should throw if invalid uitpas number', async () => {

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

@@ -1,10 +1,14 @@
-import { AutoEncoderPatchType, Decoder, isEmptyPatch, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder} from '@simonbackx/simple-encoding';
+import { isEmptyPatch, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Document, Group, Member, RateLimiter, Registration } from '@stamhoofd/models';
-import { MemberDetails, MembersBlob, MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+import type { Group, Registration } from '@stamhoofd/models';
+import { Document, Member, RateLimiter } from '@stamhoofd/models';
+import type { MemberDetails, MembersBlob} from '@stamhoofd/structures';
+import { MemberWithRegistrationsBlob } from '@stamhoofd/structures';
 
-import { OneToManyRelation } from '@simonbackx/simple-database';
+import type { OneToManyRelation } from '@simonbackx/simple-database';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';
 import { Context } from '../../../helpers/Context.js';
 import { MemberUserSyncer } from '../../../helpers/MemberUserSyncer.js';