@stamhoofd/backend 2.46.0 → 2.48.1

package/index.ts

@@ -86,9 +86,11 @@ const start = async () => {
     // Register Excel loaders
     await import('./src/excel-loaders/members');
     await import('./src/excel-loaders/payments');
+    await import('./src/excel-loaders/organizations');
 
     // Register Email Recipient loaders
     await import('./src/email-recipient-loaders/members');
+    await import('./src/email-recipient-loaders/orders');
 
     routerServer.listen(STAMHOOFD.PORT ?? 9090);
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.46.0",
+    "version": "2.48.1",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -36,14 +36,14 @@
         "@simonbackx/simple-encoding": "2.15.1",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.46.0",
-        "@stamhoofd/backend-middleware": "2.46.0",
-        "@stamhoofd/email": "2.46.0",
-        "@stamhoofd/models": "2.46.0",
-        "@stamhoofd/queues": "2.46.0",
-        "@stamhoofd/sql": "2.46.0",
-        "@stamhoofd/structures": "2.46.0",
-        "@stamhoofd/utility": "2.46.0",
+        "@stamhoofd/backend-i18n": "2.48.1",
+        "@stamhoofd/backend-middleware": "2.48.1",
+        "@stamhoofd/email": "2.48.1",
+        "@stamhoofd/models": "2.48.1",
+        "@stamhoofd/queues": "2.48.1",
+        "@stamhoofd/sql": "2.48.1",
+        "@stamhoofd/structures": "2.48.1",
+        "@stamhoofd/utility": "2.48.1",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -60,5 +60,5 @@
         "postmark": "^4.0.5",
         "stripe": "^16.6.0"
     },
-    "gitHead": "894c197231d17b270d47f7b4530ccb4e571482e4"
+    "gitHead": "06c0bb89184e23767bf05d75c9ade7e01b9bb77a"
 }

package/src/email-recipient-loaders/orders.ts

@@ -0,0 +1,60 @@
+import { Email, Webshop } from '@stamhoofd/models';
+import { EmailRecipient, EmailRecipientFilterType, LimitedFilteredRequest, mergeFilters, PaginatedResponse, WebshopPreview } from '@stamhoofd/structures';
+import { GetWebshopOrdersEndpoint } from '../endpoints/organization/dashboard/webshops/GetWebshopOrdersEndpoint';
+import { AuthenticatedStructures } from '../helpers/AuthenticatedStructures';
+import { Context } from '../helpers/Context';
+
+Email.recipientLoaders.set(EmailRecipientFilterType.Orders, {
+    fetch: async (query: LimitedFilteredRequest) => {
+        // #region get organization struct
+        const organization = Context.organization;
+        if (organization === undefined) {
+            throw new Error('Organization is undefined');
+        }
+        const organizationStruct = organization.getBaseStructure();
+        // #endregion
+
+        const result = await GetWebshopOrdersEndpoint.buildData(query);
+
+        // #region get webshop previews
+        const webshopIds = new Set(result.results.map(order => order.webshopId));
+        const webshopPreviewMap = new Map<string, WebshopPreview>();
+
+        for (const webshopId of webshopIds) {
+            const webshop = await Webshop.getByID(webshopId);
+
+            if (webshop === undefined) {
+            // todo: change error?
+                throw new Error('Webshop is undefined');
+            }
+
+            webshopPreviewMap.set(webshopId, AuthenticatedStructures.webshopPreview(webshop));
+        }
+        // #endregion
+
+        // #region get recipients
+        const recipients: EmailRecipient[] = [];
+
+        for (const order of result.results) {
+            // todo: filter double emails? => should probably happen in query?
+            const webshopPreview = webshopPreviewMap.get(order.webshopId)!;
+            recipients.push(order.getEmailRecipient(organizationStruct, webshopPreview));
+        }
+        // #endregion
+
+        return new PaginatedResponse({
+            results: recipients,
+            next: result.next,
+        });
+    },
+
+    count: async (query: LimitedFilteredRequest) => {
+        query.filter = mergeFilters([query.filter, {
+            email: {
+                $neq: null,
+            },
+        }]);
+        const q = GetWebshopOrdersEndpoint.buildQuery(query);
+        return await q.count();
+    },
+});

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

@@ -9,6 +9,7 @@ import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructure
 import { Context } from '../../../helpers/Context';
 import { organizationFilterCompilers } from '../../../sql-filters/organizations';
 import { organizationSorters } from '../../../sql-sorters/organizations';
+import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
@@ -55,6 +56,7 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             .select(
                 SQL.wildcard('organizations'),
             )
+            .setMaxExecutionTime(15 * 1000)
             .from(
                 SQL.table('organizations'),
             );
@@ -114,7 +116,23 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             });
         }
 
-        const data = await GetOrganizationsEndpoint.buildQuery(requestQuery).fetch();
+        const query = GetOrganizationsEndpoint.buildQuery(requestQuery);
+        let data: SQLResultNamespacedRow[];
+
+        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: 'Deze opzoeking is te complex en duurt te lang. Probeer een eenvoudigere zoekopdracht of probeer terug op een rustiger tijdstip.',
+                });
+            }
+            throw error;
+        }
+
         const organizations = Organization.fromRows(data, 'organizations');
 
         let next: LimitedFilteredRequest | undefined;

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

@@ -2,11 +2,11 @@ import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArra
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Organization, OrganizationRegistrationPeriod, Platform } from '@stamhoofd/models';
-import { OrganizationMetaData, Organization as OrganizationStruct } from '@stamhoofd/structures';
+import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 
-import { Context } from '../../../helpers/Context';
-import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Formatter } from '@stamhoofd/utility';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
+import { Context } from '../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -55,38 +55,6 @@ export class PatchOrganizationsEndpoint extends Endpoint<Params, Query, Body, Re
             await organization.delete();
         }
 
-        // Bulk tag editing
-        for (const patch of request.body.getPatches()) {
-            const organization = await Organization.getByID(patch.id);
-            if (!organization) {
-                throw new SimpleError({ code: 'not_found', message: 'Organization not found', statusCode: 404 });
-            }
-
-            if (patch.meta?.tags) {
-                const cleanedPatch = OrganizationMetaData.patch({
-                    tags: patch.meta.tags as any,
-                });
-                const patchedMeta = organization.meta.patch(cleanedPatch);
-                for (const tag of patchedMeta.tags) {
-                    if (!platform.config.tags.find(t => t.id === tag)) {
-                        throw new SimpleError({ code: 'invalid_tag', message: 'Invalid tag', statusCode: 400 });
-                    }
-                }
-
-                // Sort tags based on platform config order
-                patchedMeta.tags.sort((a, b) => {
-                    const aIndex = platform.config.tags.findIndex(t => t.id === a);
-                    const bIndex = platform.config.tags.findIndex(t => t.id === b);
-                    return aIndex - bIndex;
-                });
-
-                organization.meta.tags = patchedMeta.tags;
-            }
-
-            await organization.save();
-            result.push(organization);
-        }
-
         // Organization creation
         for (const { put } of request.body.getPuts()) {
             if (!Context.auth.hasPlatformFullAccess()) {

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

@@ -11,6 +11,7 @@ import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructure
 import { Context } from '../../../helpers/Context';
 import { memberFilterCompilers } from '../../../sql-filters/members';
 import { memberSorters } from '../../../sql-sorters/members';
+import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
@@ -120,6 +121,7 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             .select(
                 SQL.column('members', 'id'),
             )
+            .setMaxExecutionTime(15 * 1000)
             .from(
                 SQL.table('members'),
             );
@@ -236,7 +238,21 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
         const query = await GetMembersEndpoint.buildQuery(requestQuery);
-        const data = await query.fetch();
+        let data: SQLResultNamespacedRow[];
+
+        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: 'Deze opzoeking is te complex en duurt te lang. Probeer een eenvoudigere zoekopdracht of probeer terug op een rustiger tijdstip.',
+                });
+            }
+            throw error;
+        }
 
         const memberIds = data.map((r) => {
             if (typeof r.members.id === 'string') {

package/src/endpoints/global/platform/PatchPlatformEnpoint.ts

@@ -9,6 +9,7 @@ import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
 import { MembershipHelper } from '../../../helpers/MembershipHelper';
 import { PeriodHelper } from '../../../helpers/PeriodHelper';
+import { TagHelper } from '../../../helpers/TagHelper';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -78,6 +79,7 @@ export class PatchPlatformEndpoint extends Endpoint<
         let shouldUpdateSetupSteps = false;
         let shouldMoveToPeriod: RegistrationPeriod | null = null;
         let shouldUpdateMemberships = false;
+        let shouldUpdateTags = false;
 
         if (request.body.config) {
             if (!Context.auth.hasPlatformFullAccess()) {
@@ -88,22 +90,39 @@ export class PatchPlatformEndpoint extends Endpoint<
 
             // Update config
             if (newConfig) {
-                if (newConfig.premiseTypes || newConfig.responsibilities) {
-                    const oldConfig = platform.config.clone();
+                const shouldCheckSteps = newConfig.premiseTypes || newConfig.responsibilities;
+                if (shouldCheckSteps) {
+                    const oldConfig: PlatformConfig = platform.config.clone();
                     platform.config = patchObject(platform.config, newConfig);
-                    const currentConfig = platform.config;
-
-                    shouldUpdateSetupSteps = this.shouldUpdateSetupSteps(
-                        currentConfig,
-                        newConfig,
-                        oldConfig,
-                    );
+                    const currentConfig: PlatformConfig = platform.config;
+
+                    if (shouldCheckSteps) {
+                        shouldUpdateSetupSteps = this.shouldUpdateSetupSteps(
+                            currentConfig,
+                            newConfig,
+                            oldConfig,
+                        );
+                    }
                 }
                 else {
                     platform.config = patchObject(platform.config, newConfig);
                 }
             }
 
+            if (newConfig.tags && isPatchableArray(newConfig.tags) && newConfig.tags.changes.length > 0) {
+                let newTags = (platform.config as PlatformConfig).tags;
+                newTags = TagHelper.getCleanedUpTags(newTags);
+                platform.config.tags = newTags;
+                const areTagsValid = TagHelper.validateTags(newTags);
+                if (!areTagsValid) {
+                    throw new SimpleError({
+                        code: 'invalid_tags',
+                        message: 'Invalid tags',
+                    });
+                }
+                shouldUpdateTags = true;
+            }
+
             if (newConfig.membershipTypes && isPatchableArray(newConfig.membershipTypes) && newConfig.membershipTypes.changes.length > 0) {
                 shouldUpdateMemberships = true;
             }
@@ -190,6 +209,10 @@ export class PatchPlatformEndpoint extends Endpoint<
             }
         }
 
+        if (shouldUpdateTags) {
+            await TagHelper.updateOrganizations();
+        }
+
         if (shouldMoveToPeriod) {
             PeriodHelper.moveAllOrganizationsToPeriod(shouldMoveToPeriod).catch(console.error);
         }

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

@@ -713,6 +713,9 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             email: user.email,
         });
 
+        // Use structured transfer description prefix
+        let prefix = '';
+
         if (checkout.asOrganizationId) {
             if (!checkout.customer) {
                 throw new SimpleError({
@@ -751,6 +754,12 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
             }
 
             payment.customer.company = foundCompany;
+
+            const orgNumber = parseInt(payingOrganization.uri);
+
+            if (orgNumber !== 0 && !isNaN(orgNumber)) {
+                prefix = orgNumber + '';
+            }
         }
 
         payment.method = checkout.paymentMethod;
@@ -777,6 +786,7 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
                     name: Formatter.groupNamesByFamily(m),
                     naam: Formatter.groupNamesByFamily(m),
                     email: user.email,
+                    prefix,
                 },
             );
         }

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

@@ -2,12 +2,13 @@ import { AutoEncoderPatchType, Decoder, isPatchableArray, ObjectData, PatchableA
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
 import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, SetupStepUpdater, StripeAccount, Webshop } from '@stamhoofd/models';
-import { BuckarooSettings, Company, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel } from '@stamhoofd/structures';
+import { BuckarooSettings, Company, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, PlatformConfig } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { BuckarooHelper } from '../../../../helpers/BuckarooHelper';
 import { Context } from '../../../../helpers/Context';
+import { TagHelper } from '../../../../helpers/TagHelper';
 import { ViesHelper } from '../../../../helpers/ViesHelper';
 
 type Params = Record<string, never>;
@@ -63,6 +64,7 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
 
         const errors = new SimpleErrors();
         let shouldUpdateSetupSteps = false;
+        let updateTags = false;
 
         if (await Context.auth.hasFullAccess(organization.id)) {
             organization.name = request.body.name ?? organization.name;
@@ -204,26 +206,6 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
             // Allow admin patches (permissions only atm). No put atm
             if (request.body.admins) {
                 throw new Error('Temporary removed to keep code cleaner. Please use different endpoints.');
-                // for (const patch of request.body.admins.getPatches()) {
-                //     if (patch.permissions) {
-                //         const admin = await User.getByID(patch.id)
-                //         if (!admin || !await Context.auth.canAccessUser(admin, PermissionLevel.Full)) {
-                //             throw new SimpleError({
-                //                 code: "invalid_field",
-                //                 message: "De beheerder die je wilt wijzigen bestaat niet (meer)",
-                //                 field: "admins"
-                //             })
-                //         }
-                //         admin.permissions = UserPermissions.limitedPatch(admin.permissions, patch.permissions, organization.id)
-                //         if (admin.id === user.id && (!admin.permissions || !admin.permissions.forOrganization(organization)?.hasFullAccess())) {
-                //             throw new SimpleError({
-                //                 code: "permission_denied",
-                //                 message: "Je kan jezelf niet verwijderen als hoofdbeheerder"
-                //             })
-                //         }
-                //         await admin.save()
-                //     }
-                // }
             }
 
             if (request.body.meta) {
@@ -285,22 +267,19 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                     const cleanedPatch = OrganizationMetaData.patch({
                         tags: request.body.meta.tags as any,
                     });
-                    const platform = await Platform.getShared();
-                    const patchedMeta = organization.meta.patch(cleanedPatch);
+
+                    const platform: Platform = await Platform.getShared();
+                    const patchedMeta: OrganizationMetaData = organization.meta.patch(cleanedPatch);
                     for (const tag of patchedMeta.tags) {
                         if (!platform.config.tags.find(t => t.id === tag)) {
                             throw new SimpleError({ code: 'invalid_tag', message: 'Invalid tag', statusCode: 400 });
                         }
                     }
 
-                    // Sort tags based on platform config order
-                    patchedMeta.tags.sort((a, b) => {
-                        const aIndex = platform.config.tags.findIndex(t => t.id === a);
-                        const bIndex = platform.config.tags.findIndex(t => t.id === b);
-                        return aIndex - bIndex;
-                    });
+                    const platformConfig: PlatformConfig = platform.config;
+                    organization.meta.tags = TagHelper.getAllTagsFromHierarchy(patchedMeta.tags, platformConfig.tags);
 
-                    organization.meta.tags = patchedMeta.tags;
+                    updateTags = true;
                 }
             }
 
@@ -402,6 +381,10 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
             await SetupStepUpdater.updateForOrganization(organization);
         }
 
+        if (updateTags) {
+            await TagHelper.updateOrganizations();
+        }
+
         return new Response(await AuthenticatedStructures.organization(organization));
     }
 

package/src/endpoints/organization/dashboard/payments/GetPaymentsEndpoint.ts

@@ -3,12 +3,13 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Payment } from '@stamhoofd/models';
 import { SQL, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
-import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
+import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, TransferSettings, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
 import { paymentFilterCompilers } from '../../../../sql-filters/payments';
 import { paymentSorters } from '../../../../sql-sorters/payments';
+import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
@@ -52,6 +53,7 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
 
         const query = SQL
             .select()
+            .setMaxExecutionTime(15 * 1000)
             .from(
                 SQL.table('payments'),
             );
@@ -97,6 +99,11 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                             },
                         },
                     },
+                    {
+                        transferDescription: {
+                            $contains: q.search,
+                        },
+                    },
                 ],
             };
 
@@ -123,6 +130,17 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 };
             }
 
+            const transferDescription = q.search.replaceAll('+', '').replaceAll('/', '');
+            if (transferDescription.length === '562100153542'.length && !isNaN(parseInt(transferDescription))) {
+                // Format to
+                const formatted = TransferSettings.structureOGM(transferDescription);
+
+                // Search for structured transfer
+                searchFilter = {
+                    transferDescription: formatted,
+                };
+            }
+
             if (searchFilter) {
                 query.where(compileToSQLFilter(searchFilter, filterCompilers));
             }
@@ -143,7 +161,21 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
 
     static async buildData(requestQuery: LimitedFilteredRequest) {
         const query = await this.buildQuery(requestQuery);
-        const data = await query.fetch();
+        let data: SQLResultNamespacedRow[];
+
+        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: 'Deze opzoeking is te complex en duurt te lang. Probeer een eenvoudigere zoekopdracht of probeer terug op een rustiger tijdstip.',
+                });
+            }
+            throw error;
+        }
 
         const payments = Payment.fromRows(data, 'payments');
 

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

@@ -245,6 +245,8 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
         await organizationPeriod.save();
 
         for (const s of struct.groups) {
+            s.settings.registeredMembers = 0;
+            s.settings.reservedMembers = 0;
             await PatchOrganizationRegistrationPeriodsEndpoint.createGroup(s, organization.id, period);
         }
         const groups = await Group.getAll(organization.id, organizationPeriod.periodId);

package/src/endpoints/organization/dashboard/webshops/GetWebshopOrdersCountEndpoint.ts

@@ -1,12 +1,11 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { CountFilteredRequest, CountResponse, PermissionLevel } from '@stamhoofd/structures';
+import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
 
-import { Webshop } from '@stamhoofd/models';
 import { Context } from '../../../../helpers/Context';
 import { GetWebshopOrdersEndpoint } from './GetWebshopOrdersEndpoint';
 
-type Params = { id: string };
+type Params = Record<string, never>;
 type Query = CountFilteredRequest;
 type Body = undefined;
 type ResponseBody = CountResponse;
@@ -19,7 +18,7 @@ export class GetWebshopOrdersCountEndpoint extends Endpoint<Params, Query, Body,
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/webshop/@id/orders/count', { id: String });
+        const params = Endpoint.parseParameters(request.url, '/webshop/orders/count', {});
 
         if (params) {
             return [true, params as Params];
@@ -36,14 +35,7 @@ export class GetWebshopOrdersCountEndpoint extends Endpoint<Params, Query, Body,
             throw Context.auth.error();
         }
 
-        const webshopId = request.params.id;
-
-        const webshop = await Webshop.getByID(webshopId);
-        if (!webshop || !await Context.auth.canAccessWebshop(webshop, PermissionLevel.Read)) {
-            throw Context.auth.notFoundOrNoAccess('Je hebt geen toegang tot de bestellingen van deze webshop');
-        }
-
-        const query = GetWebshopOrdersEndpoint.buildQuery(webshopId, request.query);
+        const query = GetWebshopOrdersEndpoint.buildQuery(request.query);
 
         const count = await query
             .count();