@stamhoofd/backend 2.96.1 → 2.96.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.96.1",
+    "version": "2.96.3",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -45,14 +45,14 @@
         "@simonbackx/simple-encoding": "2.22.0",
         "@simonbackx/simple-endpoints": "1.20.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.96.1",
-        "@stamhoofd/backend-middleware": "2.96.1",
-        "@stamhoofd/email": "2.96.1",
-        "@stamhoofd/models": "2.96.1",
-        "@stamhoofd/queues": "2.96.1",
-        "@stamhoofd/sql": "2.96.1",
-        "@stamhoofd/structures": "2.96.1",
-        "@stamhoofd/utility": "2.96.1",
+        "@stamhoofd/backend-i18n": "2.96.3",
+        "@stamhoofd/backend-middleware": "2.96.3",
+        "@stamhoofd/email": "2.96.3",
+        "@stamhoofd/models": "2.96.3",
+        "@stamhoofd/queues": "2.96.3",
+        "@stamhoofd/sql": "2.96.3",
+        "@stamhoofd/structures": "2.96.3",
+        "@stamhoofd/utility": "2.96.3",
         "archiver": "^7.0.1",
         "axios": "^1.8.2",
         "cookie": "^0.7.0",
@@ -70,5 +70,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "649831e89207ca962da599f6a9e8e69e1f8abd58"
+    "gitHead": "9da200d4958b6959f604def8861ac00595a668cf"
 }

package/src/crons/balance-emails.ts

@@ -21,7 +21,7 @@ async function balanceEmails() {
         return;
     }
 
-    if ((new Date().getHours() > 10 || new Date().getHours() < 6) && STAMHOOFD.environment !== 'development') {
+    if ((new Date().getHours() > 18 || new Date().getHours() < 6) && STAMHOOFD.environment !== 'development') {
         return;
     }
 

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

@@ -1,8 +1,8 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Group, Member, Platform } from '@stamhoofd/models';
-import { SQL, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
+import { Group, Member, Platform, Registration } from '@stamhoofd/models';
+import { SQL, SQLExpression, SQLSelect, SQLSortDefinitions, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, GroupType, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort } from '@stamhoofd/structures';
 
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
@@ -11,7 +11,7 @@ import { RegistrationWithMemberBlob } from '@stamhoofd/structures/dist/src/membe
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
 import { LimitedFilteredRequestHelper } from '../../../helpers/LimitedFilteredRequestHelper';
-import { registrationFilterCompilers } from '../../../sql-filters/registrations';
+import { groupJoin, registrationFilterCompilers } from '../../../sql-filters/registrations';
 import { registrationSorters } from '../../../sql-sorters/registrations';
 import { GetMembersEndpoint } from '../members/GetMembersEndpoint';
 import { validateGroupFilter } from '../members/helpers/validateGroupFilter';
@@ -40,6 +40,29 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
+    static selectRegistrationWithGroup(...columns: (SQLExpression | string)[]): SQLSelect<Registration & { group: Group }> {
+        const transformer = (row: SQLResultNamespacedRow): Registration & { group: Group } => {
+            const d = Registration.fromRow(row[Registration.table]);
+
+            if (!d) {
+                console.error('Could not transform row', row, 'into model', Registration.table, 'check if the primary key is returned in the query');
+                throw new Error('Missing data for model ' + Registration.table);
+            }
+
+            const g = Group.fromRow(row[Group.table]);
+            if (!g) {
+                console.error('Could not transform row', row, 'into model', Group.table, 'check if the primary key is returned in the query');
+                throw new Error('Missing data for model ' + Group.table);
+            }
+
+            return d.setRelation(Registration.group, g);
+        };
+
+        const select = new SQLSelect(transformer, ...(columns.length === 0 ? [SQL.wildcard(), SQL.wildcard(Group.table)] : columns));
+        select.join(groupJoin);
+        return select.from(SQL.table(Registration.table));
+    }
+
     static async buildQuery(q: CountFilteredRequest | LimitedFilteredRequest, permissionLevel: PermissionLevel = PermissionLevel.Read) {
         const organization = Context.organization;
         let scopeFilter: StamhoofdFilter | undefined = undefined;
@@ -115,15 +138,8 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
             }
         }
 
-        const query = SQL
-            .select(
-                SQL.column('registrations', 'id'),
-                SQL.column('registrations', 'memberId'),
-            )
+        const query = this.selectRegistrationWithGroup()
             .setMaxExecutionTime(15 * 1000)
-            .from(
-                SQL.table('registrations'),
-            )
             .where('registeredAt', '!=', null);
 
         if (scopeFilter) {
@@ -161,7 +177,9 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
 
     static async buildData(requestQuery: LimitedFilteredRequest, permissionLevel = PermissionLevel.Read) {
         const query = await GetRegistrationsEndpoint.buildQuery(requestQuery, permissionLevel);
-        let data: SQLResultNamespacedRow[];
+        let data: (Registration & {
+            group: Group;
+        })[];
 
         try {
             data = await query.fetch();
@@ -177,14 +195,13 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
             throw error;
         }
 
-        const registrationData = data.map((r) => {
-            if (typeof r.registrations.memberId === 'string' && typeof r.registrations.id === 'string') {
-                return { memberId: r.registrations.memberId, id: r.registrations.id };
+        for (const registration of data) {
+            if (!await Context.auth.canAccessRegistration(registration, permissionLevel)) {
+                throw Context.auth.error();
             }
-            throw new Error('Expected string');
-        });
+        }
 
-        const members = await Member.getBlobByIds(...registrationData.map(r => r.memberId));
+        const members = await Member.getBlobByIds(...data.map(r => r.memberId));
 
         for (const member of members) {
             if (!await Context.auth.canAccessMember(member, permissionLevel)) {
@@ -192,7 +209,7 @@ export class GetRegistrationsEndpoint extends Endpoint<Params, Query, Body, Resp
             }
         }
 
-        const registrationsBlob = await AuthenticatedStructures.registrationsBlob(registrationData, members);
+        const registrationsBlob = await AuthenticatedStructures.registrationsBlob(data, members);
 
         const next = LimitedFilteredRequestHelper.fixInfiniteLoadingLoop({
             request: requestQuery,

package/src/helpers/AuthenticatedStructures.ts

@@ -456,6 +456,9 @@ export class AuthenticatedStructures {
 
         const memberBlobs: MemberWithRegistrationsBlob[] = [];
         for (const member of members) {
+            const filtered: (Registration & {
+                group: Group;
+            })[] = [];
             for (const registration of member.registrations) {
                 if (includeContextOrganization || registration.organizationId !== Context.auth.organization?.id) {
                     const found = organizations.get(registration.id);
@@ -464,8 +467,11 @@ export class AuthenticatedStructures {
                         organizations.set(organization.id, organization);
                     }
                 }
+                if (organizations.get(registration.organizationId)?.active || (Context.auth.organization && Context.auth.organization.active && registration.organizationId === Context.auth.organization.id) || await Context.auth.hasFullAccess(registration.organizationId)) {
+                    filtered.push(registration);
+                }
             }
-            member.registrations = member.registrations.filter(r => (Context.auth.organization && Context.auth.organization.active && r.organizationId === Context.auth.organization.id) || (organizations.get(r.organizationId)?.active ?? false));
+            member.registrations = filtered;
             const balancesPermission = await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, Context.organization?.id);
 
             let memberBalances: GenericBalance[] = [];
@@ -521,7 +527,13 @@ export class AuthenticatedStructures {
             }
         }
 
-        const activeOrganizations = [...organizations.values()].filter(o => o.active);
+        const activeOrganizations: Organization[] = [];
+
+        for (const organization of organizations.values()) {
+            if (organization.active || await Context.auth.hasFullAccess(organization.id)) {
+                activeOrganizations.push(organization);
+            }
+        }
         const organizationStructs = await this.organizations(activeOrganizations);
 
         // Load missing groups
@@ -588,30 +600,44 @@ export class AuthenticatedStructures {
         return (await this.eventNotifications([eventNotification]))[0];
     }
 
-    static async registrationsBlob(registrationData: {
-        memberId: string;
-        id: string;
-    }[], members: MemberWithRegistrations[], includeContextOrganization = false, includeUser?: User): Promise<RegistrationsBlob> {
+    static async registrationsBlob(registrations: (Registration & { group: Group })[], members: MemberWithRegistrations[], includeContextOrganization = false, includeUser?: User): Promise<RegistrationsBlob> {
         const membersBlob = await this.membersBlob(members, includeContextOrganization, includeUser);
 
         const memberBlobs = membersBlob.members;
 
-        const registrationWithMemberBlobs = registrationData.map(({ id, memberId }) => {
-            const memberBlob = memberBlobs.find(m => m.id === memberId);
+        const registrationWithMemberBlobs = await Promise.all(registrations.map(async (registration) => {
+            const memberBlob = memberBlobs.find(m => m.id === registration.memberId);
             if (!memberBlob) {
                 throw new Error('Member not found');
             }
 
-            const registration = memberBlob.registrations.find(r => r.id === id);
-            if (!registration) {
-                throw new Error('Registration not found: ' + id);
+            let r = memberBlob.registrations.find(r => r.id === registration.id);
+
+            if (!r) {
+                const member = members.find(m => m.id === registration.memberId);
+                const balancesPermission = member ? (await Context.auth.hasFinancialMemberAccess(member, PermissionLevel.Read, Context.organization?.id)) : false;
+                r = registration.getStructure();
+                r.balances = balancesPermission
+                    ? ((await CachedBalance.getForObjects([registration.id], null)).map((b) => {
+                            return GenericBalance.create(b);
+                        }))
+                    : [];
+                r.group = await this.group(registration.group);
+
+                memberBlob.registrations.push(r);
+
+                // Add organization if missing
+                if (!membersBlob.organizations.find(o => o.id === r!.organizationId)) {
+                    const organization = await Context.auth.getOrganization(r!.organizationId);
+                    membersBlob.organizations.push(organization.getBaseStructure());
+                }
             }
 
             return RegistrationWithMemberBlob.create({
-                ...registration,
+                ...r,
                 member: memberBlob,
             });
-        });
+        }));
 
         return RegistrationsBlob.create({
             registrations: registrationWithMemberBlobs,

package/src/sql-filters/registrations.ts

@@ -5,7 +5,7 @@ import { memberFilterCompilers } from './members';
 
 export const memberJoin = SQL.join(Member.table).where(SQL.column(Member.table, 'id'), SQL.column(Registration.table, 'memberId'));
 
-const groupJoin = SQL.join(Group.table).where(SQL.column(Group.table, 'id'), SQL.column(Registration.table, 'groupId'));
+export const groupJoin = SQL.join(Group.table).where(SQL.column(Group.table, 'id'), SQL.column(Registration.table, 'groupId'));
 
 export const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,