@stamhoofd/backend 2.17.4 → 2.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.17.4",
+    "version": "2.19.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -39,10 +39,10 @@
         "@stamhoofd/backend-i18n": "^2.17.0",
         "@stamhoofd/backend-middleware": "^2.17.0",
         "@stamhoofd/email": "^2.17.0",
-        "@stamhoofd/models": "^2.17.3",
+        "@stamhoofd/models": "^2.19.0",
         "@stamhoofd/queues": "^2.17.3",
-        "@stamhoofd/sql": "^2.17.3",
-        "@stamhoofd/structures": "^2.17.3",
+        "@stamhoofd/sql": "^2.18.0",
+        "@stamhoofd/structures": "^2.19.0",
         "@stamhoofd/utility": "^2.17.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
@@ -60,5 +60,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "56f46d516a4a18cffb011caf177b5de9a14607b6"
+    "gitHead": "876e7b976122e1c2f67d4cceebe92ec2af2bc35a"
 }

package/src/crons/setup-steps.ts

@@ -0,0 +1,9 @@
+import { SetupStepUpdater } from "../helpers/SetupStepsUpdater";
+
+export async function updateSetupSteps() {
+    if (STAMHOOFD.userMode !== "platform") {
+        return;
+    }
+
+    await SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod();
+}

package/src/endpoints/admin/memberships/ChargeMembershipsEndpoint.ts

@@ -0,0 +1,49 @@
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { QueueHandler } from '@stamhoofd/queues';
+import { sleep } from '@stamhoofd/utility';
+import { Context } from '../../../helpers/Context';
+import { MembershipCharger } from '../../../helpers/MembershipCharger';
+import { SimpleError } from '@simonbackx/simple-errors';
+
+
+type Params = Record<string, never>;
+type Query = Record<string, never>;
+type Body = undefined;
+type ResponseBody = undefined;
+
+export class ChargeMembershipsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "POST") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/admin/charge-memberships", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.authenticate()
+
+        if (!Context.auth.hasPlatformFullAccess()) {
+            throw Context.auth.error()
+        }
+
+        if (QueueHandler.isRunning('charge-memberships')) {
+            throw new SimpleError({
+                code: 'charge_pending',
+                message: 'Charge already pending',
+                human: 'Er is al een aanrekening bezig, even geduld.'
+            })
+        }
+
+        QueueHandler.schedule('charge-memberships', async () => {
+            await MembershipCharger.charge()
+        }).catch(console.error);
+       
+        return new Response(undefined);
+    }
+}

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -2,6 +2,7 @@ import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-
 import { SQL, SQLAlias, SQLCount, SQLDistinct, SQLSelectAs, SQLSum } from '@stamhoofd/sql';
 import { ChargeMembershipsSummary, ChargeMembershipsTypeSummary } from '@stamhoofd/structures';
 import { Context } from '../../../helpers/Context';
+import { QueueHandler } from '@stamhoofd/queues';
 
 
 type Params = Record<string, never>;
@@ -29,6 +30,14 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
         if (!Context.auth.hasPlatformFullAccess()) {
             throw Context.auth.error()
         }
+
+        if (QueueHandler.isRunning('charge-memberships')) {
+            return new Response(
+                ChargeMembershipsSummary.create({
+                    running: true
+                })
+            );
+        }
         
         const query = SQL
             .select(
@@ -63,12 +72,8 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
                     new SQLAlias('data__price')
                 )
             )
-            .from(
-                SQL.table('member_platform_memberships')
-            )
-            .where(SQL.column('invoiceId'), null)
-            .andWhere(SQL.column('invoiceItemDetailId'), null);
-
+            .from('member_platform_memberships')
+            .where('balanceItemId', null);
 
         const result = await query.fetch();
         const members = result[0]['data']['members'] as number;
@@ -78,6 +83,7 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
 
         return new Response(
             ChargeMembershipsSummary.create({
+                running: false,
                 memberships: memberships ?? 0,
                 members: members ?? 0,
                 price: price ?? 0,
@@ -122,17 +128,13 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
                     new SQLAlias('data__price')
                 )
             )
-            .from(
-                SQL.table('member_platform_memberships')
+            .from('member_platform_memberships')
+            .where('balanceItemId', null)
+            .groupBy(
+                SQL.column('member_platform_memberships', 'membershipTypeId')
             );
-        query.where(SQL.column('invoiceId'), null)
-        query.andWhere(SQL.column('invoiceItemDetailId'), null)
-        query.groupBy(SQL.column('member_platform_memberships', 'membershipTypeId'));
-
 
         const result = await query.fetch();
-        console.log(result);
-
         const membershipsPerType = new Map<string, ChargeMembershipsTypeSummary>();
 
         for (const row of result) {

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

@@ -1,10 +1,11 @@
 import { AutoEncoderPatchType, Decoder, patchObject } from "@simonbackx/simple-encoding";
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Platform, RegistrationPeriod } from "@stamhoofd/models";
-import { Platform as PlatformStruct } from "@stamhoofd/structures";
+import { Organization, Platform, RegistrationPeriod } from "@stamhoofd/models";
+import { PlatformPremiseType, Platform as PlatformStruct } from "@stamhoofd/structures";
 
-import { Context } from "../../../helpers/Context";
 import { SimpleError } from "@simonbackx/simple-errors";
+import { Context } from "../../../helpers/Context";
+import { SetupStepUpdater } from "../../../helpers/SetupStepsUpdater";
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -64,7 +65,18 @@ export class PatchPlatformEndpoint extends Endpoint<Params, Query, Body, Respons
             }
 
             // Update config
-            platform.config = patchObject(platform.config, request.body.config)
+            if(request.body.config.premiseTypes) {
+                const oldConfig = platform.config.clone();
+                platform.config = patchObject(platform.config, request.body.config);
+                const newPremiseTypes = platform.config.premiseTypes;
+
+                // update setup step premise types
+                if(this.shouldUpdateSetupStepPremise(newPremiseTypes, oldConfig.premiseTypes)) {
+                    await SetupStepUpdater.updateSetupStepsForAllOrganizationsInCurrentPeriod({premiseTypes: newPremiseTypes});
+                }
+            } else {
+                platform.config = patchObject(platform.config, request.body.config)
+            }
         }
 
         if (request.body.period && request.body.period.id !== platform.periodId) {
@@ -78,7 +90,57 @@ export class PatchPlatformEndpoint extends Endpoint<Params, Query, Body, Respons
             platform.periodId = period.id
         }
 
+        if (request.body.membershipOrganizationId !== undefined) {
+            if (!Context.auth.hasPlatformFullAccess()) {
+                throw Context.auth.error()
+            }
+
+            if (request.body.membershipOrganizationId) {
+                const organization = await Organization.getByID(request.body.membershipOrganizationId)
+                if (!organization) {
+                    throw new SimpleError({
+                        code: "invalid_organization",
+                        message: "Invalid organization"
+                    })
+                }
+                platform.membershipOrganizationId = organization.id
+            } else {
+                platform.membershipOrganizationId = null
+            }
+        }
+
         await platform.save()
         return new Response(await Platform.getSharedPrivateStruct());
     }
+
+    private shouldUpdateSetupStepPremise(newPremiseTypes: PlatformPremiseType[], oldPremiseTypes: PlatformPremiseType[]) {
+        for(const premiseType of newPremiseTypes) {
+            const id = premiseType.id;
+            const oldVersion = oldPremiseTypes.find(x => x.id === id);
+
+            // if premise type is not new
+            if(oldVersion) {
+                if(oldVersion.min !== premiseType.min || oldVersion.max !== premiseType.max) {
+                    return true;
+                }
+                continue;
+            }
+
+            // if premise type is new
+            if(premiseType.min || premiseType.max) {
+                return true;
+            }
+        }
+
+        for(const oldPremiseType of oldPremiseTypes) {
+            const id = oldPremiseType.id;
+
+            // if premise type is removed
+            if(!newPremiseTypes.some(x => x.id === id)) {
+                if(oldPremiseType.min || oldPremiseType.max) {
+                    return true;
+                }
+            }
+        }
+    }
 }

package/src/endpoints/organization/dashboard/billing/GetBillingStatusEndpoint.ts

@@ -1,14 +1,11 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
-import { STInvoice } from "@stamhoofd/models";
-import { Token } from "@stamhoofd/models";
-import { STBillingStatus  } from "@stamhoofd/structures";
+import { OrganizationBillingStatus } from "@stamhoofd/structures";
 
 import { Context } from "../../../../helpers/Context";
 
 type Params = Record<string, never>;
 type Query = undefined;
-type ResponseBody = STBillingStatus;
+type ResponseBody = OrganizationBillingStatus;
 type Body = undefined;
 
 export class GetBillingStatusEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
@@ -32,8 +29,10 @@ export class GetBillingStatusEndpoint extends Endpoint<Params, Query, Body, Resp
         // If the user has permission, we'll also search if he has access to the organization's key
         if (!await Context.auth.canManageFinances(organization.id)) {
             throw Context.auth.error()
-        }  
+        }
 
-        return new Response(await STInvoice.getBillingStatus(organization));
+        return new Response(
+            OrganizationBillingStatus.create({})
+        )
     }
 }

package/src/endpoints/organization/dashboard/billing/GetDetailedBillingStatusEndpoint.ts

@@ -0,0 +1,77 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { OrganizationDetailedBillingStatus, OrganizationDetailedBillingStatusItem, PaymentMethod, PaymentStatus } from "@stamhoofd/structures";
+
+import { BalanceItem, Organization, Payment } from "@stamhoofd/models";
+import { SQL } from "@stamhoofd/sql";
+import { Formatter } from "@stamhoofd/utility";
+import { AuthenticatedStructures } from "../../../../helpers/AuthenticatedStructures";
+import { Context } from "../../../../helpers/Context";
+
+type Params = Record<string, never>;
+type Query = undefined;
+type ResponseBody = OrganizationDetailedBillingStatus;
+type Body = undefined;
+
+export class GetDetailedBillingStatusEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/billing/status/detailed", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(_: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate()
+
+        // If the user has permission, we'll also search if he has access to the organization's key
+        if (!await Context.auth.canManageFinances(organization.id)) {
+            throw Context.auth.error()
+        }
+        
+        const balanceItemModels = await BalanceItem.balanceItemsForOrganization(organization.id);
+
+        // Hide pending online payments
+        const paymentModels = await Payment.select()
+            .where('payingOrganizationId', organization.id)
+            .andWhere(
+                SQL.whereNot('status', PaymentStatus.Failed)
+            )
+            .fetch()
+
+        const organizationIds = Formatter.uniqueArray([
+            ...balanceItemModels.map(b => b.organizationId),
+            ...paymentModels.map(p => p.organizationId).filter(p => p !== null)
+        ])
+        
+        // Group by organization you'll have to pay to
+        if (organizationIds.length === 0) {
+            return new Response(
+                OrganizationDetailedBillingStatus.create({})
+            )
+        }
+
+        const balanceItems = await BalanceItem.getStructureWithPayments(balanceItemModels)
+        const organizationModels = await Organization.getByIDs(...organizationIds)
+        const organizations = await AuthenticatedStructures.organizations(organizationModels)
+        const payments = await AuthenticatedStructures.paymentsGeneral(paymentModels, false)
+
+        return new Response(
+            OrganizationDetailedBillingStatus.create({
+                organizations: organizations.map(o => {
+                    return OrganizationDetailedBillingStatusItem.create({
+                        organization: o,
+                        balanceItems: balanceItems.filter(b => b.organizationId == o.id),
+                        payments: payments.filter(p => p.organizationId === o.id)
+                    })
+                })
+            })
+        )
+    }
+}

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

@@ -8,6 +8,7 @@ import { Formatter } from '@stamhoofd/utility';
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { BuckarooHelper } from '../../../../helpers/BuckarooHelper';
 import { Context } from '../../../../helpers/Context';
+import { SetupStepUpdater } from '../../../../helpers/SetupStepsUpdater';
 import { ViesHelper } from '../../../../helpers/ViesHelper';
 
 type Params = Record<string, never>;
@@ -100,6 +101,9 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
             if (request.body.privateMeta && request.body.privateMeta.isPatch()) {
                 organization.privateMeta.emails = request.body.privateMeta.emails.applyTo(organization.privateMeta.emails)
                 organization.privateMeta.premises = patchObject(organization.privateMeta.premises, request.body.privateMeta.premises);
+                if(request.body.privateMeta.premises) {
+                    await SetupStepUpdater.updateForOrganization(organization);
+                }
                 organization.privateMeta.roles = request.body.privateMeta.roles.applyTo(organization.privateMeta.roles)
                 organization.privateMeta.responsibilities = request.body.privateMeta.responsibilities.applyTo(organization.privateMeta.responsibilities)
                 organization.privateMeta.inheritedResponsibilityRoles = request.body.privateMeta.inheritedResponsibilityRoles.applyTo(organization.privateMeta.inheritedResponsibilityRoles)

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

@@ -4,7 +4,7 @@ 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, getSortFilter } from '@stamhoofd/structures';
+import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
@@ -134,7 +134,11 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
             }
 
-            query.orderBy(compileToSQLSorter(q.sort, sorters))
+            query.orderBy(compileToSQLSorter(assertSort(q.sort, [
+                {
+                    key: 'id'
+                }
+            ]), sorters))
             query.limit(q.limit)
         }
        

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

@@ -0,0 +1,78 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, SetupStepType } from "@stamhoofd/structures";
+
+import { AutoEncoder, BooleanDecoder, Decoder, EnumDecoder, field } from "@simonbackx/simple-encoding";
+import { SimpleError } from "@simonbackx/simple-errors";
+import { OrganizationRegistrationPeriod } from "@stamhoofd/models";
+import { AuthenticatedStructures } from "../../../../helpers/AuthenticatedStructures";
+import { Context } from "../../../../helpers/Context";
+
+type Params = { readonly id: string };
+type Query = undefined;
+
+class Body extends AutoEncoder {
+    @field({decoder: new EnumDecoder(SetupStepType)})
+    type: SetupStepType
+
+    @field({decoder: BooleanDecoder})
+    isReviewed: boolean
+}
+
+type ResponseBody = OrganizationRegistrationPeriodStruct
+
+/**
+ * Endpoint to mark a setup step as reviewed
+ */
+
+export class SetupStepReviewEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    bodyDecoder = Body as Decoder<Body>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "POST") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/organization/registration-period/@id/setup-steps/review", {id: String});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate()
+
+        if (!await Context.auth.hasFullAccess(organization.id)) {
+            throw Context.auth.error()
+        }
+
+        const periodId = request.params.id;
+        const stepType = request.body.type;
+        const isReviewed = request.body.isReviewed;
+
+        const organizationPeriod = await OrganizationRegistrationPeriod.getByID(periodId);
+        if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
+            throw new SimpleError({
+                code: "not_found",
+                message: "Period not found",
+                statusCode: 404
+            })
+        }
+
+        const setupSteps = organizationPeriod.setupSteps;
+
+        if(isReviewed) {
+            setupSteps.markReviewed(stepType);
+        } else {
+            setupSteps.resetReviewed(stepType);
+        } 
+
+        await organizationPeriod.save();
+
+        return new Response(
+            await AuthenticatedStructures.organizationRegistrationPeriod(organizationPeriod),
+        );
+    }
+}

package/src/excel-loaders/payments.ts

@@ -1,4 +1,4 @@
-import { XlsxBuiltInNumberFormat, XlsxTransformerColumn } from "@stamhoofd/excel-writer";
+import { XlsxBuiltInNumberFormat, XlsxTransformerColumn, XlsxTransformerConcreteColumn } from "@stamhoofd/excel-writer";
 import { StripeAccount as StripeAccountStruct, BalanceItemPaymentDetailed, BalanceItemRelationType, CountryHelper, ExcelExportType, getBalanceItemRelationTypeName, getBalanceItemTypeName, PaymentGeneral, PaymentMethodHelper, PaymentStatusHelper, PaginatedResponse, PaymentProvider } from "@stamhoofd/structures";
 import { ExportToExcelEndpoint } from "../endpoints/global/files/ExportToExcelEndpoint";
 import { GetPaymentsEndpoint } from "../endpoints/organization/dashboard/payments/GetPaymentsEndpoint";
@@ -52,12 +52,44 @@ ExportToExcelEndpoint.loaders.set(ExcelExportType.Payments, {
         {
             id: 'balanceItemPayments',
             name: 'Betaallijnen',
-            transform: (data: PaymentGeneral) => data.balanceItemPayments.map(p => ({
+            transform: (data: PaymentGeneral): PaymentWithItem[] => data.balanceItemPayments.map(p => ({
                 payment: data,
                 balanceItemPayment: p
             })),
             columns: [
-                ...getBalanceItemColumns()
+                ...getBalanceItemColumns(),
+
+                // Repeating columns need to de-transform again
+                ...[
+                    ...getGeneralColumns(),
+                    ...getInvoiceColumns(),
+                ].map(c => {
+                    if ('match' in c) {
+                        return {
+                            ...c,
+                            match: (id: string) => {
+                                const result = c.match(id)
+                                if (!result) {
+                                    return result;
+                                }
+
+                                return result.map(cc => ({
+                                    ...cc,
+                                    getValue: (object: PaymentWithItem) => {
+                                        return cc.getValue(object.payment)
+                                    },
+                                }))
+                            },
+                        }
+                    }
+
+                    return {
+                        ...c,
+                        getValue: (object: PaymentWithItem) => {
+                            return c.getValue(object.payment)
+                        },
+                    }
+                })
             ]
         }
     ]
@@ -164,7 +196,7 @@ function getBalanceItemColumns(): XlsxTransformerColumn<PaymentWithItem>[] {
 }
 
 
-function getGeneralColumns(): XlsxTransformerColumn<PaymentGeneral>[] {
+function getGeneralColumns(): XlsxTransformerConcreteColumn<PaymentGeneral>[] {
     return [
         {
             id: 'id',

package/src/helpers/AuthenticatedStructures.ts

@@ -1,10 +1,9 @@
 import { SimpleError } from "@simonbackx/simple-errors";
 import { Event, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from "@stamhoofd/models";
-import { Event as EventStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberResponsibilityRecord as MemberResponsibilityRecordStruct, MemberWithRegistrationsBlob, MembersBlob, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateWebshop, User as UserStruct, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
-import { OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType } from '@stamhoofd/structures';
+import { Event as EventStruct, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateWebshop, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
 
-import { Context } from "./Context";
 import { Formatter } from "@stamhoofd/utility";
+import { Context } from "./Context";
 
 /**
  * Builds authenticated structures for the current user
@@ -55,7 +54,7 @@ export class AuthenticatedStructures {
     }
 
     static async groups(groups: Group[]) {
-        const waitingListIds = Formatter.uniqueArray(groups.map(g => g.waitingListId).filter(id => id !== null) as string[])
+        const waitingListIds = Formatter.uniqueArray(groups.map(g => g.waitingListId).filter(id => id !== null))
         const waitingLists = waitingListIds.length > 0 ? await Group.getByIDs(...waitingListIds) : []
 
         const structs: GroupStruct[] = []
@@ -194,7 +193,7 @@ export class AuthenticatedStructures {
      */
     static async usersWithMembers(users: User[]): Promise<UserWithMembers[]> {
         const structs: UserWithMembers[] = [];
-        const memberIds = Formatter.uniqueArray(users.map(u => u.memberId).filter(id => id !== null) as string[])
+        const memberIds = Formatter.uniqueArray(users.map(u => u.memberId).filter(id => id !== null))
         const members = memberIds.length > 0 ? await Member.getBlobByIds(...memberIds) : []
 
         for (const user of users) {
@@ -251,7 +250,7 @@ export class AuthenticatedStructures {
         const platformMemberships = members.length > 0 ? await MemberPlatformMembership.where({ deletedAt: null, memberId: { sign: 'IN', value: members.map(m => m.id) } }) : []
 
         // Load missing organizations
-        const organizationIds = Formatter.uniqueArray(responsibilities.map(r => r.organizationId).filter(id => id !== null) as string[])
+        const organizationIds = Formatter.uniqueArray(responsibilities.map(r => r.organizationId).filter(id => id !== null))
         for (const id of organizationIds) {
             if (includeContextOrganization || id !== Context.auth.organization?.id) {
                 const found = organizations.get(id);
@@ -275,7 +274,7 @@ export class AuthenticatedStructures {
 
     static async events(events: Event[]): Promise<EventStruct[]> {
         // Load groups
-        const groupIds = events.map(e => e.groupId).filter(id => id !== null) as string[]
+        const groupIds = events.map(e => e.groupId).filter(id => id !== null)
         const groups = groupIds.length > 0 ? await Group.getByIDs(...groupIds) : []
         const groupStructs = await this.groups(groups)