@stamhoofd/backend 2.45.0 → 2.48.0

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

@@ -1,8 +1,8 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, PrivateOrder, StamhoofdFilter } from '@stamhoofd/structures';
+import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, PaginatedResponse, PrivateOrder, StamhoofdFilter } from '@stamhoofd/structures';
 
-import { Order, Webshop } from '@stamhoofd/models';
+import { Order } from '@stamhoofd/models';
 import { compileToSQLFilter, compileToSQLSorter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
@@ -10,7 +10,7 @@ import { LimitedFilteredRequestHelper } from '../../../../helpers/LimitedFiltere
 import { orderFilterCompilers } from '../../../../sql-filters/orders';
 import { orderSorters } from '../../../../sql-sorters/orders';
 
-type Params = { id: string };
+type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<PrivateOrder[], LimitedFilteredRequest>;
@@ -26,7 +26,7 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/webshop/@id/orders', { id: String });
+        const params = Endpoint.parseParameters(request.url, '/webshop/orders', {});
 
         if (params) {
             return [true, params as Params];
@@ -34,37 +34,24 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    static buildQuery(webshopId: string, q: CountFilteredRequest | LimitedFilteredRequest) {
+    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
         // todo: filter userId???
         const organization = Context.organization!;
 
-        if (!webshopId) {
-            // todo
-            throw new Error();
-        }
-
         const ordersTable: string = Order.table;
 
         const query = SQL
             .select(SQL.wildcard(ordersTable))
             .from(SQL.table(ordersTable))
-            // todo: extra check on webshopId to prevent all orders are returned if webshopId is null?
-            .where('webshopId', webshopId)
             .where(compileToSQLFilter({
-                $or: [
-                    {
-                        organizationId: organization.id,
-                    },
-                    {
-                        organizationId: null,
-                    },
-                ],
+                organizationId: organization.id,
             }, filterCompilers));
 
         if (q.filter) {
             query.where(compileToSQLFilter(q.filter, filterCompilers));
         }
 
+        // todo: use same logic as frontend
         if (q.search) {
             let searchFilter: StamhoofdFilter | null = null;
 
@@ -93,8 +80,8 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
         return query;
     }
 
-    static async buildData(webshopId: string, requestQuery: LimitedFilteredRequest) {
-        const query = this.buildQuery(webshopId, requestQuery);
+    static async buildData(requestQuery: LimitedFilteredRequest) {
+        const query = this.buildQuery(requestQuery);
         const data = await query.fetch();
 
         const orders: Order[] = Order.fromRows(data, Order.table);
@@ -139,15 +126,8 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
             maxLimit: Context.auth.hasSomePlatformAccess() ? 1000 : 100,
         });
 
-        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');
-        }
-
         return new Response(
-            await GetWebshopOrdersEndpoint.buildData(webshopId, request.query),
+            await GetWebshopOrdersEndpoint.buildData(request.query),
         );
 
         /*

package/src/excel-loaders/organizations.ts

@@ -0,0 +1,47 @@
+import { XlsxTransformerSheet } from '@stamhoofd/excel-writer';
+import { ExcelExportType, LimitedFilteredRequest, Organization as OrganizationStruct } from '@stamhoofd/structures';
+import { GetOrganizationsEndpoint } from '../endpoints/admin/organizations/GetOrganizationsEndpoint';
+import { ExportToExcelEndpoint } from '../endpoints/global/files/ExportToExcelEndpoint';
+
+// Assign to a typed variable to assure we have correct type checking in place
+const sheet: XlsxTransformerSheet<OrganizationStruct, OrganizationStruct> = {
+    id: 'organizations',
+    name: 'Leden',
+    columns: [
+        {
+            id: 'id',
+            name: 'ID',
+            width: 20,
+            getValue: (object: OrganizationStruct) => ({
+                value: object.id,
+            }),
+        },
+        {
+            id: 'uri',
+            name: 'Groepsnummer',
+            width: 20,
+            getValue: (object: OrganizationStruct) => ({
+                value: object.uri,
+            }),
+        },
+        {
+            id: 'name',
+            name: 'Naam',
+            width: 50,
+            getValue: (object: OrganizationStruct) => ({
+                value: object.name,
+            }),
+        },
+    ],
+};
+
+ExportToExcelEndpoint.loaders.set(ExcelExportType.Organizations, {
+    fetch: async (query: LimitedFilteredRequest) => {
+        const result = await GetOrganizationsEndpoint.buildData(query);
+
+        return result;
+    },
+    sheets: [
+        sheet,
+    ],
+});

package/src/helpers/AuthenticatedStructures.ts

@@ -1,6 +1,6 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { CachedBalance, Event, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from '@stamhoofd/models';
-import { AccessRight, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, Event as EventStruct, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateOrder, PrivateWebshop, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { AccessRight, Event as EventStruct, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateOrder, PrivateWebshop, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';
 import { Context } from './Context';
@@ -130,6 +130,10 @@ export class AuthenticatedStructures {
         return (await this.organizations([organization]))[0];
     }
 
+    static webshopPreview(webshop: Webshop) {
+        return WebshopPreview.create(webshop);
+    }
+
     static async organizations(organizations: Organization[]): Promise<OrganizationStruct[]> {
         if (organizations.length === 0) {
             return [];
@@ -210,7 +214,7 @@ export class AuthenticatedStructures {
 
             const organizationId = w.organizationId;
             const array = webshopPreviews.get(organizationId);
-            const preview = WebshopPreview.create(w);
+            const preview = this.webshopPreview(w);
 
             if (array) {
                 array.push(preview);

package/src/helpers/ModelHelper.ts

@@ -0,0 +1,28 @@
+import { Model } from '@simonbackx/simple-database';
+
+// todo: move for reuse?
+type KeysMatching<T, V> = { [K in keyof T]-?: T[K] extends V ? K : never }[keyof T];
+
+export class ModelHelper {
+    static async loop<M extends typeof Model>(m: M, idKey: KeysMatching<InstanceType<M>, string> & string, onBatchReceived: (batch: InstanceType<M>[]) => Promise<void>, options: { limit?: number } = {}) {
+        let lastId = '';
+        const limit = options.limit ?? 10;
+
+        while (true) {
+            const models = await m.where(
+                { [idKey]: { sign: '>', value: lastId } },
+                { limit, sort: [idKey] });
+
+            if (models.length === 0) {
+                break;
+            }
+
+            await onBatchReceived(models);
+
+            lastId
+                    = models[
+                    models.length - 1
+                ][idKey] as string;
+        }
+    }
+}

package/src/helpers/TagHelper.test.ts

@@ -0,0 +1,373 @@
+import { OrganizationTag } from '@stamhoofd/structures';
+import { TagHelper } from './TagHelper';
+
+// todo: move tests for methods of shared package to shared package
+describe('TagHelper', () => {
+    describe('containsDeep', () => {
+        it('should return true if the tag contains the tag to search recursively or false otherwise', () => {
+            // arrange
+            const tags = new Map<string, OrganizationTag>([
+                [
+                    'id1',
+                    OrganizationTag.create({
+                        id: 'id1',
+                        name: 'tag1',
+                        childTags: [],
+                    }),
+                ],
+                [
+                    'id2',
+                    OrganizationTag.create({
+                        id: 'id2',
+                        name: 'tag2',
+                        childTags: [],
+                    }),
+                ],
+                [
+                    'id3',
+                    OrganizationTag.create({
+                        id: 'id3',
+                        name: 'tag3',
+                        childTags: ['id2', 'id4'],
+                    }),
+                ],
+                [
+                    'id4',
+                    OrganizationTag.create({
+                        id: 'id4',
+                        name: 'tag4',
+                        childTags: ['id5'],
+                    }),
+                ],
+                [
+                    'id5',
+                    OrganizationTag.create({
+                        id: 'id5',
+                        name: 'tag5',
+                        childTags: [],
+                    }),
+                ],
+            ]);
+
+            // act
+            const doesTag3ContainTag4 = TagHelper.containsDeep('id3', 'id4', tags);
+            const doesTag3ContainTag5 = TagHelper.containsDeep('id3', 'id5', tags);
+            const doesTag3ContainTag1 = TagHelper.containsDeep('id3', 'id1', tags);
+
+            // assert
+            expect(doesTag3ContainTag4).toBe(true);
+            expect(doesTag3ContainTag5).toBe(true);
+            expect(doesTag3ContainTag1).toBe(false);
+        });
+    });
+
+    describe('getAllTagsFromHierarchy', () => {
+        it('should return array with the tag ids that are known by the platform and add tag ids if the organization has a tag that is a child tag of that tag', () => {
+            // arrange
+            const originalTagIds: string[] = ['id5', 'id3', 'unknownTagId'];
+            const platformTags: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id0',
+                    name: 'tag0',
+                    childTags: ['id7', 'id9'],
+                }),
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id2',
+                    name: 'tag2',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id3',
+                    name: 'tag3',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id4',
+                    name: 'tag4',
+                    childTags: ['id3'],
+                }),
+                OrganizationTag.create({
+                    id: 'id5',
+                    name: 'tag5',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id6',
+                    name: 'tag6',
+                    childTags: ['id5'],
+                }),
+                OrganizationTag.create({
+                    id: 'id7',
+                    name: 'tag7',
+                    childTags: ['id6', 'id8', 'id9'],
+                }),
+                OrganizationTag.create({
+                    id: 'id8',
+                    name: 'tag8',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id9',
+                    name: 'tag9',
+                    childTags: [],
+                }),
+            ];
+
+            // act
+            const result = TagHelper.getAllTagsFromHierarchy(originalTagIds, platformTags);
+
+            // assert
+            expect(result).toHaveLength(6);
+            expect(result).toInclude('id5');
+            expect(result).toInclude('id3');
+            expect(result).toInclude('id4');
+            expect(result).toInclude('id6');
+            expect(result).toInclude('id7');
+            expect(result).toInclude('id0');
+            expect(result).not.toInclude('unknownTagId');
+        });
+    });
+
+    describe('getCleanedUpTags', () => {
+        it('should remove child tag ids that do not exist', () => {
+            // arrange
+            const tag5 = OrganizationTag.create({
+                id: 'id5',
+                name: 'tag5',
+                childTags: ['doesNotExist2'],
+            });
+
+            const tag7 = OrganizationTag.create({
+                id: 'id7',
+                name: 'tag7',
+                childTags: ['id6', 'id8', 'id9', 'doesNotExist1'],
+            });
+
+            const platformTags: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id0',
+                    name: 'tag0',
+                    childTags: ['id7', 'id9'],
+                }),
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id2',
+                    name: 'tag2',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id3',
+                    name: 'tag3',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id4',
+                    name: 'tag4',
+                    childTags: ['id3'],
+                }),
+                tag5,
+                OrganizationTag.create({
+                    id: 'id6',
+                    name: 'tag6',
+                    childTags: ['id5'],
+                }),
+                tag7,
+                OrganizationTag.create({
+                    id: 'id8',
+                    name: 'tag8',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id9',
+                    name: 'tag9',
+                    childTags: [],
+                }),
+            ];
+
+            // act
+            TagHelper.getCleanedUpTags(platformTags);
+
+            // assert
+            expect(tag5.childTags).toHaveLength(0);
+            expect(tag7.childTags).toHaveLength(3);
+            expect(tag7.childTags).not.toInclude('doesNotExist1');
+        });
+
+        it('should return array of tags in the correct order', () => {
+            // arrange
+            const platformTags: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id2b1',
+                    name: 'tag2b1',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id2',
+                    name: 'tag2',
+                    childTags: ['id2a', 'id2b'],
+                }),
+                OrganizationTag.create({
+                    id: 'id3',
+                    name: 'tag3',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id2a',
+                    name: 'tag2a',
+                    childTags: ['id2a1', 'id2a2'],
+                }),
+                OrganizationTag.create({
+                    id: 'id2b',
+                    name: 'tag2b',
+                    childTags: ['id2b1'],
+                }),
+                OrganizationTag.create({
+                    id: 'id2a1',
+                    name: 'tag2a1',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id2a2',
+                    name: 'tag2a2',
+                    childTags: [],
+                }),
+            ];
+
+            // act
+            const result = TagHelper.getCleanedUpTags(platformTags);
+
+            // assert
+            expect(result).toHaveLength(8);
+            expect(result[0].id).toBe('id1');
+            expect(result[1].id).toBe('id2');
+            expect(result[2].id).toBe('id2a');
+            expect(result[3].id).toBe('id2a1');
+            expect(result[4].id).toBe('id2a2');
+            expect(result[5].id).toBe('id2b');
+            expect(result[6].id).toBe('id2b1');
+            expect(result[7].id).toBe('id3');
+        });
+    });
+
+    describe('validateTags', () => {
+        it('should return false if a tag is a child tag of itself', () => {
+            // arrange
+            const invalidPlatformTags: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: ['id1'],
+                }),
+            ];
+
+            const validPlatformTags: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: ['id2'],
+                }),
+                OrganizationTag.create({
+                    id: 'id2',
+                    name: 'tag2',
+                    childTags: [],
+                }),
+            ];
+
+            // act
+            const result1 = TagHelper.validateTags(invalidPlatformTags);
+            const result2 = TagHelper.validateTags(validPlatformTags);
+
+            // assert
+            expect(result1).toBeFalse();
+            expect(result2).toBeTrue();
+        });
+
+        it('should return false if a tag is a child tag of multiple tags', () => {
+            // arrange
+            const invalidPlatformTags: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id2',
+                    name: 'tag2',
+                    childTags: ['id1'],
+                }),
+                OrganizationTag.create({
+                    id: 'id3',
+                    name: 'tag3',
+                    childTags: ['id1'],
+                }),
+            ];
+
+            const validPlatformTags: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: [],
+                }),
+                OrganizationTag.create({
+                    id: 'id2',
+                    name: 'tag2',
+                    childTags: ['id3'],
+                }),
+                OrganizationTag.create({
+                    id: 'id3',
+                    name: 'tag3',
+                    childTags: ['id1'],
+                }),
+            ];
+
+            // act
+            const result1 = TagHelper.validateTags(invalidPlatformTags);
+            const result2 = TagHelper.validateTags(validPlatformTags);
+
+            // assert
+            expect(result1).toBeFalse();
+            expect(result2).toBeTrue();
+        });
+
+        it('should return false if the child tags contain an infinite loop', () => {
+            // arrange
+            const platformTagsWithInfiniteLoop: OrganizationTag[] = [
+                OrganizationTag.create({
+                    id: 'id1',
+                    name: 'tag1',
+                    childTags: ['id2'],
+                }),
+                OrganizationTag.create({
+                    id: 'id2',
+                    name: 'tag2',
+                    childTags: ['id3'],
+                }),
+                OrganizationTag.create({
+                    id: 'id3',
+                    name: 'tag3',
+                    childTags: ['id1'],
+                }),
+            ];
+
+            // act
+            const result = TagHelper.validateTags(platformTagsWithInfiniteLoop);
+
+            // assert
+            expect(result).toBeFalse();
+        });
+    });
+});