@stamhoofd/backend 2.120.6 → 2.122.0

package/src/endpoints/global/events/PatchEventsEndpoint.ts

@@ -1,9 +1,9 @@
-import type { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder} from '@simonbackx/simple-encoding';
+import type { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
 import { PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { Event, Group, OrganizationRegistrationPeriod, Platform, RegistrationPeriod, Webshop } from '@stamhoofd/models';
-import { AuditLogSource, Event as EventStruct, Group as GroupStruct, GroupType, NamedObject, PermissionLevel } from '@stamhoofd/structures';
+import { AuditLogSource, Event as EventStruct, Group as GroupStruct, GroupType, NamedObject, OrganizationEventType, PermissionLevel, PlatformEventType } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
@@ -67,8 +67,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 period,
                 { allowedIds: [putGroup.id] },
             );
-        }
-        else {
+        } else {
             if (group.type !== GroupType.EventRegistration) {
                 throw new SimpleError({
                     code: 'invalid_group',
@@ -88,8 +87,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             if (!await Context.auth.hasSomeAccess(organization.id)) {
                 throw Context.auth.error();
             }
-        }
-        else {
+        } else {
             if (!Context.auth.hasSomePlatformAccess()) {
                 throw Context.auth.error();
             }
@@ -138,13 +136,16 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.endDate = put.endDate;
             event.typeId = put.typeId;
 
+            event.meta = put.meta;
             event.meta.organizationCache = eventOrganization ? NamedObject.create({ id: eventOrganization.id, name: eventOrganization.name }) : null;
+
+            PatchEventsEndpoint.validateOrCorrectEventMeta(event);
+
             await PatchEventsEndpoint.checkEventLimits(event);
 
             if (put.group) {
                 await this.saveEventAndLinkExistingGroup(event, put.group);
-            }
-            else {
+            } else {
                 await event.save();
             }
 
@@ -181,40 +182,12 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 event.organizationId = patch.organizationId;
             }
 
-            if (event.organizationId === null && event.meta.groups !== null) {
-                event.meta.groups = null;
-                console.error('Removed groups because organizationId is null for event', event.id);
-            }
-
-            if (event.meta.groups && event.meta.groups.length === 0) {
-                throw new SimpleError({
-                    code: 'invalid_field',
-                    message: 'Empty groups',
-                    human: $t(`%DV`),
-                });
-            }
-
-            if (event.meta.defaultAgeGroupIds && event.meta.defaultAgeGroupIds.length === 0) {
-                throw new SimpleError({
-                    code: 'invalid_field',
-                    message: 'Empty default age groups',
-                    human: $t(`%DW`),
-                });
-            }
-
-            if (event.meta.organizationTagIds && event.meta.organizationTagIds.length === 0) {
-                throw new SimpleError({
-                    code: 'invalid_field',
-                    message: 'Empty organization tag ids',
-                    human: $t(`%DX`),
-                });
-            }
+            PatchEventsEndpoint.validateOrCorrectEventMeta(event);
 
             const eventOrganization = await Context.auth.checkEventAccess(event);
             if (eventOrganization) {
                 event.meta.organizationCache = NamedObject.create({ id: eventOrganization.id, name: eventOrganization.name });
-            }
-            else {
+            } else {
                 event.meta.organizationCache = null;
             }
 
@@ -237,8 +210,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                         await PatchOrganizationRegistrationPeriodsEndpoint.deleteGroup(event.groupId);
                         event.groupId = null;
                     }
-                }
-                else if (patch.group.isPatch()) {
+                } else if (patch.group.isPatch()) {
                     if (!event.groupId) {
                         throw new SimpleError({
                             code: 'invalid_field',
@@ -251,13 +223,11 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
 
                     const period = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
                     group = await PatchOrganizationRegistrationPeriodsEndpoint.patchGroup(patch.group, period, { isPatchingEvent: true });
-                }
-                else {
+                } else {
                     if (event.groupId === patch.group.id) {
                         // ignore: bad practice: puts are not allowed like this
                         // risk of deleting data
-                    }
-                    else {
+                    } else {
                         if (event.groupId) {
                             // need to delete old group first
                             await PatchOrganizationRegistrationPeriodsEndpoint.deleteGroup(event.groupId);
@@ -267,8 +237,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                         event.groupId = group.id;
                     }
                 }
-            }
-            else {
+            } else {
                 if (patch.startDate || patch.endDate) {
                     // Correct period id if needed
                     const period = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
@@ -292,8 +261,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             if (group || patch.organizationId !== undefined) {
                 if (event.organizationId === null) {
                     // No validation required
-                }
-                else {
+                } else {
                     // Validate organizationId of group
                     if (event.groupId) {
                         group = group ?? (await Group.getByID(event.groupId) ?? null);
@@ -312,8 +280,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             if (patch.webshopId !== undefined) {
                 if (patch.webshopId === null) {
                     event.webshopId = null;
-                }
-                else {
+                } else {
                     const webshop = await Webshop.getByID(patch.webshopId);
                     if (!webshop || (event.organizationId && webshop.organizationId !== event.organizationId)) {
                         throw new SimpleError({
@@ -366,13 +333,47 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
         );
     }
 
-    static async validateEventType(typeId: string) {
-        return (await this.getEventType(typeId)).id;
+    static validateOrCorrectEventMeta(event: Event) {
+        if (event.organizationId === null && event.meta.groups !== null) {
+            event.meta.groups = null;
+            console.error('Removed groups because organizationId is null for event', event.id);
+        }
+
+        if (event.meta.groups && event.meta.groups.length === 0) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Empty groups',
+                human: $t(`%DV`),
+            });
+        }
+
+        if (event.meta.defaultAgeGroupIds && event.meta.defaultAgeGroupIds.length === 0) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Empty default age groups',
+                human: $t(`%DW`),
+            });
+        }
+
+        if (event.meta.organizationTagIds && event.meta.organizationTagIds.length === 0) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Empty organization tag ids',
+                human: $t(`%DX`),
+            });
+        }
     }
 
-    static async getEventType(typeId: string) {
-        const platform = await Platform.getSharedStruct();
-        const type = platform.config.eventTypes.find(t => t.id == typeId);
+    static async getEventType(typeId: string): Promise<OrganizationEventType | PlatformEventType> {
+        let type: OrganizationEventType | PlatformEventType | undefined = undefined;
+
+        if (STAMHOOFD.userMode === 'platform') {
+            const platform = await Platform.getSharedStruct();
+            type = platform.config.eventTypes.find(t => t.id === typeId);
+        } else if (typeId === OrganizationEventType.DEFAULT_ID) {
+            type = OrganizationEventType.createDefault();
+        }
+
         if (!type) {
             throw new SimpleError({
                 code: 'invalid_field',
@@ -387,21 +388,6 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
     static async checkEventLimits(event: Event) {
         const type = await this.getEventType(event.typeId);
 
-        if (type.isLocationRequired) {
-            const address = event.meta.location?.address;
-
-            if (!address) {
-                throw new SimpleError({
-                    code: 'invalid_field',
-                    message: 'Empty number',
-                    human: $t(`%vQ`),
-                    field: 'event_required',
-                });
-            }
-
-            address.throwIfIncomplete();
-        }
-
         if (event.name.length < 2) {
             throw new SimpleError({
                 code: 'invalid_field',
@@ -420,69 +406,85 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             });
         }
 
-        if (type.maximumDays !== null || type.minimumDays !== null) {
-            const start = Formatter.luxon(event.startDate).startOf('day');
-            const end = Formatter.luxon(event.endDate).startOf('day');
-
-            const days = end.diff(start, 'days').days + 1;
+        if (type instanceof PlatformEventType) {
+            if (type.isLocationRequired) {
+                const address = event.meta.location?.address;
 
-            console.log('Detected days:', days);
+                if (!address) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'Empty number',
+                        human: $t(`%vQ`),
+                        field: 'event_required',
+                    });
+                }
 
-            if (type.minimumDays !== null && days < type.minimumDays) {
-                throw new SimpleError({
-                    code: 'minimum_days',
-                    message: 'An event with this type has a minimum of ' + type.minimumDays + ' days',
-                    human: $t(`%14D`, {
-                        name: type.name,
-                        days: Formatter.pluralText(type.minimumDays, $t(`%1N7`), $t(`%1N6`)),
-                    }),
-                    field: 'startDate',
-                });
+                address.throwIfIncomplete();
             }
 
-            if (type.maximumDays !== null && days > type.maximumDays) {
-                throw new SimpleError({
-                    code: 'maximum_days',
-                    message: 'An event with this type has a maximum of ' + type.maximumDays + ' days',
-                    human: $t(`%14E`, {
-                        name: type.name,
-                        days: Formatter.pluralText(type.maximumDays, $t(`%1N7`), $t(`%1N6`)),
-                    }),
-                    field: 'startDate',
-                });
-            }
-        }
+            if (type.maximumDays !== null || type.minimumDays !== null) {
+                const start = Formatter.luxon(event.startDate).startOf('day');
+                const end = Formatter.luxon(event.endDate).startOf('day');
+
+                const days = end.diff(start, 'days').days + 1;
+
+                console.log('Detected days:', days);
 
-        if (type.maximum && (!event.existsInDatabase || ('typeId' in (event.getChangedDatabaseProperties()).fields))) {
-            const currentPeriod = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
-            console.log('event.startDate', event.startDate);
-            if (currentPeriod) {
-                const count = await SQL.select().from(
-                    SQL.table(Event.table),
-                )
-                    .where(SQL.column('organizationId'), event.organizationId)
-                    .where(SQL.column('typeId'), event.typeId)
-                    .where(SQL.column('id'), SQLWhereSign.NotEqual, event.id)
-                    .where(SQL.column('startDate'), SQLWhereSign.GreaterEqual, currentPeriod.startDate)
-                    .where(SQL.column('endDate'), SQLWhereSign.LessEqual, currentPeriod.endDate)
-                    .count();
-
-                if (count >= type.maximum) {
+                if (type.minimumDays !== null && days < type.minimumDays) {
                     throw new SimpleError({
-                        code: 'type_maximum_reached',
-                        message: 'Maximum number of events with this type reached',
-                        human: $t(`%Dd`) + ' ' + type.name + ' ' + $t(`%De`) + type.maximum + ')',
-                        field: 'typeId',
+                        code: 'minimum_days',
+                        message: 'An event with this type has a minimum of ' + type.minimumDays + ' days',
+                        human: $t(`%14D`, {
+                            name: type.name,
+                            days: Formatter.pluralText(type.minimumDays, $t(`%1N7`), $t(`%1N6`)),
+                        }),
+                        field: 'startDate',
+                    });
+                }
+
+                if (type.maximumDays !== null && days > type.maximumDays) {
+                    throw new SimpleError({
+                        code: 'maximum_days',
+                        message: 'An event with this type has a maximum of ' + type.maximumDays + ' days',
+                        human: $t(`%14E`, {
+                            name: type.name,
+                            days: Formatter.pluralText(type.maximumDays, $t(`%1N7`), $t(`%1N6`)),
+                        }),
+                        field: 'startDate',
                     });
                 }
             }
-            else {
-                throw new SimpleError({
-                    code: 'invalid_period',
-                    message: 'No period found for this start date',
-                    human: $t(`%Df`),
-                    field: 'startDate',
-                });
+
+            if (type.maximum && (!event.existsInDatabase || ('typeId' in (event.getChangedDatabaseProperties()).fields))) {
+                const currentPeriod = await RegistrationPeriod.getByDate(event.startDate, event.organizationId);
+                console.log('event.startDate', event.startDate);
+                if (currentPeriod) {
+                    const count = await SQL.select().from(
+                        SQL.table(Event.table),
+                    )
+                        .where(SQL.column('organizationId'), event.organizationId)
+                        .where(SQL.column('typeId'), event.typeId)
+                        .where(SQL.column('id'), SQLWhereSign.NotEqual, event.id)
+                        .where(SQL.column('startDate'), SQLWhereSign.GreaterEqual, currentPeriod.startDate)
+                        .where(SQL.column('endDate'), SQLWhereSign.LessEqual, currentPeriod.endDate)
+                        .count();
+
+                    if (count >= type.maximum) {
+                        throw new SimpleError({
+                            code: 'type_maximum_reached',
+                            message: 'Maximum number of events with this type reached',
+                            human: $t(`%Dd`) + ' ' + type.name + ' ' + $t(`%De`) + type.maximum + ')',
+                            field: 'typeId',
+                        });
+                    }
+                } else {
+                    throw new SimpleError({
+                        code: 'invalid_period',
+                        message: 'No period found for this start date',
+                        human: $t(`%Df`),
+                        field: 'startDate',
+                    });
+                }
             }
         }
     }
@@ -553,8 +555,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
                 await event.syncGroupRequirements(existingGroup);
             });
-        }
-        catch (e) {
+        } catch (e) {
             // reset the group
             existingGroup.type = originalGroupType;
             existingGroup.settings.eventId = null;

package/src/endpoints/global/files/ExportToExcelEndpoint.ts

@@ -1,12 +1,12 @@
 import type { Decoder } from '@simonbackx/simple-encoding';
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import type { XlsxTransformerSheet} from '@stamhoofd/excel-writer';
+import type { XlsxTransformerSheet } from '@stamhoofd/excel-writer';
 import { ArchiverWriterAdapter, exportToExcel, XlsxWriter } from '@stamhoofd/excel-writer';
 import { Platform, RateLimiter, sendEmailTemplate } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import type { ExcelExportType, IPaginatedResponse, LimitedFilteredRequest} from '@stamhoofd/structures';
+import type { ExcelExportType, IPaginatedResponse, LimitedFilteredRequest } from '@stamhoofd/structures';
 import { EmailTemplateType, ExcelExportRequest, ExcelExportResponse, Replacement, Version } from '@stamhoofd/structures';
 import { sleep } from '@stamhoofd/utility';
 import { Context } from '../../../helpers/Context.js';
@@ -89,7 +89,7 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
         await Platform.getSharedStruct();
 
         const result = await Promise.race([
-            this.job(loader, request.body, request.params.type).then(async (url: string) => {
+            this.job(loader, request.body, request.params.type, user.id).then(async (url: string) => {
                 if (sendEmail) {
                     await sendEmailTemplate(null, {
                         template: {
@@ -138,10 +138,10 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
         }));
     }
 
-    async job(loader: ExcelExporter<unknown>, request: ExcelExportRequest, type: string): Promise<string> {
+    async job(loader: ExcelExporter<unknown>, request: ExcelExportRequest, type: string, userId: string): Promise<string> {
         // Only run 1 export per user at the same time
-        return await QueueHandler.schedule('user-export-to-excel-' + Context.user!.id, async () => {
-            // Allow maximum 2 running Excel jobs at the same time for all users
+        return await QueueHandler.schedule('user-export-to-excel-' + userId, async () => {
+            // Allow maximum 5 running Excel jobs at the same time for all users; queue the rest.
             return await QueueHandler.schedule('export-to-excel', async () => {
                 // Estimate how long it will take.
                 // If too long, we'll schedule it and write it to Digitalocean Spaces
@@ -163,9 +163,9 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
 
                 console.log('Done writing excel file');
 
-                const url = 'https://' + STAMHOOFD.domains.api + '/v' + Version + '/file-cache?file=' + encodeURIComponent(file) + '&name=' + encodeURIComponent(type);
+                const url = 'https://' + STAMHOOFD.domains.api + '/v' + Version + '/file-cache?file=' + encodeURIComponent(file) + '&name=' + encodeURIComponent(request.title ?? type);
                 return url;
-            }, 2);
+            }, 5);
         });
     }
 }

package/src/endpoints/global/files/GetFileCache.ts

@@ -1,6 +1,6 @@
-import type { Decoder} from '@simonbackx/simple-encoding';
+import type { Decoder } from '@simonbackx/simple-encoding';
 import { AutoEncoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import type { Readable } from 'node:stream';
 import { Context } from '../../../helpers/Context.js';
@@ -60,8 +60,7 @@ export class GetFileCache extends Endpoint<Params, Query, Body, ResponseBody> {
         if (request.query.name) {
             const slug = Formatter.fileSlug(request.query.name) + extension;
             response.headers['Content-Disposition'] = `attachment; filename="${slug}"`;
-        }
-        else {
+        } else {
             response.headers['Content-Disposition'] = `attachment; filename="bestand${extension}"`;
         }
         response.headers['Content-Length'] = contentLength.toString();

package/src/endpoints/global/files/UploadFile.ts

@@ -1,5 +1,5 @@
 import { PutObjectCommand, S3Client } from '@aws-sdk/client-s3'; // ES Modules import
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { File } from '@stamhoofd/structures';
@@ -8,7 +8,7 @@ import formidable from 'formidable';
 import { promises as fs } from 'fs';
 import { v4 as uuidv4 } from 'uuid';
 
-import type { Decoder} from '@simonbackx/simple-encoding';
+import type { Decoder } from '@simonbackx/simple-encoding';
 import { AutoEncoder, BooleanDecoder, field } from '@simonbackx/simple-encoding';
 import { Context } from '../../../helpers/Context.js';
 import { limiter } from './UploadImage.js';
@@ -133,8 +133,7 @@ export class UploadFile extends Endpoint<Params, Query, Body, ResponseBody> {
         if (request.query.isPrivate && user) {
             // Private files
             prefix += 'users/' + user.id + '/';
-        }
-        else {
+        } else {
             // Public files
             prefix += 'p/';
         }

package/src/endpoints/global/files/UploadImage.ts

@@ -1,6 +1,6 @@
-import type { Decoder} from '@simonbackx/simple-encoding';
+import type { Decoder } from '@simonbackx/simple-encoding';
 import { AutoEncoder, BooleanDecoder, field, ObjectData } from '@simonbackx/simple-encoding';
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Image, RateLimiter } from '@stamhoofd/models';
@@ -125,8 +125,7 @@ export class UploadImage extends Endpoint<Params, Query, Body, ResponseBody> {
                 try {
                     const resolutions = new ObjectData(JSON.parse(fields.resolutions[0]), { version: request.request.getVersion() }).array(ResolutionRequest as Decoder<ResolutionRequest>);
                     resolve([files.file[0], resolutions]);
-                }
-                catch (e) {
+                } catch (e) {
                     reject(e);
                 }
             });

package/src/endpoints/global/groups/GetGroupsCountEndpoint.ts

@@ -0,0 +1,51 @@
+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';
+import { GetGroupsEndpoint } from './GetGroupsEndpoint.js';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetGroupsCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/groups/count', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOptionalOrganizationScope();
+        await Context.optionalAuthenticate();
+
+        if (!organization) {
+            if (!Context.auth.hasSomePlatformAccess()) {
+                throw Context.auth.error();
+            }
+        }
+
+        const query = await GetGroupsEndpoint.buildQuery(request.query);
+
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count,
+            }),
+        );
+    }
+}

package/src/endpoints/global/groups/GetGroupsEndpoint.test.ts

@@ -1,5 +1,5 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import type { Organization, RegistrationPeriod} from '@stamhoofd/models';
+import type { Organization, RegistrationPeriod } from '@stamhoofd/models';
 import { GroupFactory, OrganizationFactory, OrganizationRegistrationPeriodFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import type { StamhoofdFilter } from '@stamhoofd/structures';
 import { BundleDiscountGroupPriceSettings, GroupPrice, GroupType, LimitedFilteredRequest } from '@stamhoofd/structures';

package/src/endpoints/global/groups/GetGroupsEndpoint.ts

@@ -1,4 +1,4 @@
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import type { CountFilteredRequest, Group as GroupStruct, StamhoofdFilter } from '@stamhoofd/structures';
 import { assertSort, getSortFilter, LimitedFilteredRequest, PaginatedResponse } from '@stamhoofd/structures';
@@ -61,7 +61,9 @@ export class GetGroupsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
             let searchFilter: StamhoofdFilter | null = null;
 
             searchFilter = {
-                id: q.search,
+                name: {
+                    $contains: q.search,
+                },
             };
 
             if (searchFilter) {

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

@@ -1,4 +1,4 @@
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import type { MemberWithUsersRegistrationsAndGroups } from '@stamhoofd/models';
 import { Member } from '@stamhoofd/models';
@@ -38,8 +38,7 @@ export class GetMemberFamilyEndpoint extends Endpoint<Params, Query, Body, Respo
             if (!await Context.auth.hasSomeAccess(organization.id)) {
                 throw Context.auth.error();
             }
-        }
-        else {
+        } else {
             if (!Context.auth.hasSomePlatformAccess()) {
                 throw Context.auth.error();
             }

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

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

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

@@ -1,6 +1,6 @@
-import type { Endpoint} from '@simonbackx/simple-endpoints';
+import type { Endpoint } from '@simonbackx/simple-endpoints';
 import { Request } from '@simonbackx/simple-endpoints';
-import type { RegistrationPeriod} from '@stamhoofd/models';
+import type { RegistrationPeriod } from '@stamhoofd/models';
 import { EventFactory, GroupFactory, MemberFactory, OrganizationFactory, RecordCategoryFactory, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { AccessRight, EventMeta, GroupType, LimitedFilteredRequest, NamedObject, PermissionLevel, PermissionRoleDetailed, Permissions, PermissionsResourceType, RecordAnswer, RecordTextAnswer, RecordType, ResourcePermissions } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';