@stamhoofd/backend 2.1.2 → 2.1.3

package/.env.json

@@ -23,14 +23,14 @@
         "demoApi": "api.stamhoofd",
         "rendererApi": "renderer.stamhoofd"
     },
-        "translationNamespace": "stamhoofd",
+        "translationNamespace": "digit",
     "userMode": "organization",
     
     "PORT": 9091,
     "DB_HOST": "127.0.0.1",
     "DB_USER": "root",
     "DB_PASS": "root",
-    "DB_DATABASE": "stamhoofd1",
+    "DB_DATABASE": "stamhoofd",
 
     "SMTP_HOST": "0.0.0.0",
     "SMTP_USERNAME": "username",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.1.2",
+    "version": "2.1.3",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -50,5 +50,5 @@
         "postmark": "4.0.2",
         "stripe": "^11.5.0"
     },
-    "gitHead": "2332fe7ce5922e32a7e9c5c947fdde572aadcc03"
+    "gitHead": "b5773c547dceaae52b9c2a098b222417fcd42e4f"
 }

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

@@ -48,6 +48,7 @@ const registrationFilterCompilers: SQLFilterDefinitions = {
         status: createSQLExpressionFilterCompiler(
             SQL.column('groups', 'status')
         ),
+        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId')),
     })
 }
 
@@ -125,6 +126,25 @@ const filterCompilers: SQLFilterDefinitions = {
         }
     ),
 
+    responsibilities: createSQLRelationFilterCompiler(
+        SQL.select()
+        .from(
+            SQL.table('member_responsibility_records')
+        )
+        .where(
+            SQL.column('memberId'),
+            SQL.column('members', 'id'),
+        ),
+        {
+            // Alias for responsibilityId
+            "id": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
+            "responsibilityId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
+            "organizationId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'organizationId')),
+            "startDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'startDate')),
+            "endDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'endDate')),
+        }
+    ),
+
     /**
      * @deprecated?
      */
@@ -270,6 +290,11 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
                             periodId: platform.periodId,
                             registeredAt: {
                                 $neq: null
+                            },
+                            group: {
+                                defaultAgeGroupId: {
+                                    $neq: null
+                                }
                             }
                         }
                     }

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

@@ -2,7 +2,7 @@ import { OneToManyRelation } from '@simonbackx/simple-database';
 import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from "@simonbackx/simple-errors";
-import { BalanceItem, BalanceItemPayment, Document, Group, Member, MemberFactory, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Payment, Platform, Registration, User } from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, Document, Group, Member, MemberFactory, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Payment, Platform, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
 import { BalanceItemStatus, MemberWithRegistrationsBlob, MembersBlob, PaymentMethod, PaymentStatus, PermissionLevel, Registration as RegistrationStruct, User as UserStruct } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
@@ -121,6 +121,14 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     throw Context.auth.notFoundOrNoAccess("Je hebt niet voldoende rechten om leden toe te voegen in deze groep")
                 }
 
+                const period = await RegistrationPeriod.getByID(group.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
+
                 // Set organization id of member based on registrations
                 if (!organization && STAMHOOFD.userMode !== 'platform' && !member.organizationId) {
                     member.organizationId = group.organizationId
@@ -263,6 +271,14 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                     })
                 }
 
+                const period = await RegistrationPeriod.getByID(group.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
+
                 // TODO: allow group changes
                 registration.waitingList = patchRegistration.waitingList ?? registration.waitingList
 
@@ -337,13 +353,20 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 if (!await Context.auth.canAccessRegistration(registration, PermissionLevel.Write)) {
                     throw Context.auth.error("Je hebt niet voldoende rechten om deze inschrijving te verwijderen")
                 }
+                const oldGroup = await getGroup(registration.groupId)
+                const period = oldGroup && await RegistrationPeriod.getByID(oldGroup.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
 
                 balanceItemMemberIds.push(member.id)                
                 await BalanceItem.deleteForDeletedRegistration(registration.id)
                 await registration.delete()
                 member.registrations = member.registrations.filter(r => r.id !== deleteId)
 
-                const oldGroup = await getGroup(registration.groupId)
                 if (oldGroup) {
                     // We need to update this group occupancy because we moved one member away from it
                     updateGroups.set(oldGroup.id, oldGroup)
@@ -358,6 +381,13 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 if (!group || group.organizationId !== struct.organizationId || !await Context.auth.canAccessGroup(group, PermissionLevel.Write)) {
                     throw Context.auth.error("Je hebt niet voldoende rechten om inschrijvingen in deze groep te maken")
                 }
+                const period = await RegistrationPeriod.getByID(group.periodId)
+                if (!period || period.locked) {
+                    throw new SimpleError({
+                        code: "period_locked",
+                        message: "Deze inschrijvingsperiode is afgesloten en staat geen wijzigingen meer toe.",
+                    })
+                }
 
                 const reg = await this.addRegistration(member, struct, group)
                 balanceItemMemberIds.push(member.id)

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

@@ -1,9 +1,10 @@
 import { AutoEncoderPatchType, Decoder, patchObject } from "@simonbackx/simple-encoding";
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Platform } from "@stamhoofd/models";
+import { Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { Platform as PlatformStruct } from "@stamhoofd/structures";
 
 import { Context } from "../../../helpers/Context";
+import { SimpleError } from "@simonbackx/simple-errors";
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -57,6 +58,17 @@ export class PatchPlatformEndpoint extends Endpoint<Params, Query, Body, Respons
             platform.config = patchObject(platform.config, request.body.config)
         }
 
+        if (request.body.period && request.body.period.id !== platform.periodId) {
+            const period = await RegistrationPeriod.getByID(request.body.period.id)
+            if (!period || period.organizationId) {
+                throw new SimpleError({
+                    code: "invalid_period",
+                    message: "Invalid period"
+                })
+            }
+            platform.periodId = period.id
+        }
+
         await platform.save()
         return new Response(await Platform.getSharedPrivateStruct());
     }

package/src/endpoints/global/registration-periods/PatchRegistrationPeriodsEndpoint.ts

@@ -4,7 +4,7 @@ import { RegistrationPeriod as RegistrationPeriodStruct } from "@stamhoofd/struc
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
-import { RegistrationPeriod } from '@stamhoofd/models';
+import { Platform, RegistrationPeriod } from '@stamhoofd/models';
 import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;
@@ -107,6 +107,9 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
             await model.delete();
         }
 
+        // Clear platform cache
+        Platform.clearCache()
+
         return new Response(
             periods.map(p => p.getStructure())
         );

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

@@ -1,8 +1,8 @@
 import { AutoEncoderPatchType, Decoder, ObjectData, patchObject } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
-import { Group, Organization,PayconiqPayment, Platform, StripeAccount, Token, User, Webshop } from '@stamhoofd/models';
-import { BuckarooSettings, GroupPrivateSettings, Organization as OrganizationStruct, OrganizationPatch, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, Permissions, PermissionsResourceType,ResourcePermissions, UserPermissions, Version, OrganizationMetaData } from "@stamhoofd/structures";
+import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, StripeAccount, User, Webshop } from '@stamhoofd/models';
+import { BuckarooSettings, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel, UserPermissions } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
@@ -297,6 +297,36 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 organization.uri = request.body.uri
             }
 
+            if (request.body.period && request.body.period.id !== organization.periodId) {
+                const organizationPeriod = await OrganizationRegistrationPeriod.getByID(request.body.period.id)
+                if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "De periode die je wilt instellen bestaat niet (meer)",
+                        field: "period"
+                    })
+                }
+
+                const period = await RegistrationPeriod.getByID(organizationPeriod.periodId)
+                if (!period || (period.organizationId && period.organizationId !== organization.id)) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "De periode die je wilt instellen bestaat niet (meer)",
+                        field: "period"
+                    })
+                }
+
+                if (period.locked) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "De periode die je wilt instellen is reeds afgesloten",
+                        field: "period"
+                    })
+                }
+
+                organization.periodId = period.id
+            }
+
             // Save the organization
             await organization.save()
         } else {

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

@@ -3,7 +3,7 @@ import { GroupPrivateSettings, OrganizationRegistrationPeriod as OrganizationReg
 
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from "@simonbackx/simple-encoding";
 import { Context } from "../../../../helpers/Context";
-import { Group, OrganizationRegistrationPeriod, RegistrationPeriod } from "@stamhoofd/models";
+import { Group, OrganizationRegistrationPeriod, Platform, RegistrationPeriod } from "@stamhoofd/models";
 import { SimpleError } from "@simonbackx/simple-errors";
 
 type Params = Record<string, never>;
@@ -37,10 +37,70 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
 
         if (!await Context.auth.hasFullAccess(organization.id)) {
             throw Context.auth.error()
-        } 
+        }
+
+        const platform = await Platform.getShared()
+
+        function validateDefaultGroupId(id: string|null): string|null {
+            if (id === null) {
+                return id;
+            }
+
+            if (platform.config.defaultAgeGroups.find(g => g.id === id)) {
+                return id;
+            }
+
+            throw new SimpleError({
+                code: "invalid_default_age_group",
+                message: "Invalid default age group",
+                human: "De standaard leeftijdsgroep is ongeldig",
+                statusCode: 400
+            })
+        }
 
         const structs: OrganizationRegistrationPeriodStruct[] = [];
 
+        for (const {put} of request.body.getPuts()) {
+            if (!await Context.auth.hasFullAccess(organization.id)) {
+                throw Context.auth.error()
+            }
+            const period = await RegistrationPeriod.getByID(put.period.id);
+
+            if (!period) {
+                throw new SimpleError({
+                    code: "not_found",
+                    message: "Period not found",
+                    statusCode: 404
+                })
+            }
+
+            const organizationPeriod = new OrganizationRegistrationPeriod();
+            organizationPeriod.id = put.id;
+            organizationPeriod.organizationId = organization.id;
+            organizationPeriod.periodId = put.period.id;
+            organizationPeriod.settings = put.settings;
+            await organizationPeriod.save();
+
+            for (const struct of put.groups) {
+                const model = new Group()
+                model.id = struct.id
+                model.organizationId = organization.id
+                model.defaultAgeGroupId = validateDefaultGroupId(struct.defaultAgeGroupId)
+                model.periodId = organizationPeriod.periodId
+                model.settings = struct.settings
+                model.privateSettings = struct.privateSettings ?? GroupPrivateSettings.create({})
+                model.status = struct.status
+                await model.updateOccupancy()
+                await model.save();
+            }
+            const groups = await Group.getAll(organization.id, organizationPeriod.periodId)
+
+            // Delete unreachable categories first
+            await organizationPeriod.cleanCategories(groups);
+            await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
+            structs.push(organizationPeriod.getStructure(period, groups));
+        }
+
         for (const patch of request.body.getPatches()) {
             const organizationPeriod = await OrganizationRegistrationPeriod.getByID(patch.id);
             if (!organizationPeriod || organizationPeriod.organizationId !== organization.id) {
@@ -112,6 +172,7 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                 const model = new Group()
                 model.id = struct.id
                 model.organizationId = organization.id
+                model.defaultAgeGroupId = validateDefaultGroupId(struct.defaultAgeGroupId)
                 model.periodId = organizationPeriod.periodId
                 model.settings = struct.settings
                 model.privateSettings = struct.privateSettings ?? GroupPrivateSettings.create({})
@@ -181,6 +242,10 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
                 if (struct.deletedAt !== undefined) {
                     model.deletedAt = struct.deletedAt
                 }
+
+                if (struct.defaultAgeGroupId !== undefined) {
+                    model.defaultAgeGroupId = validateDefaultGroupId(struct.defaultAgeGroupId)
+                }
                 
                 await model.updateOccupancy()
                 await model.save();
@@ -191,15 +256,13 @@ export class PatchRegistrationPeriodsEndpoint extends Endpoint<Params, Query, Bo
 
             if (deleteUnreachable) {
                 // Delete unreachable categories first
-                await organization.cleanCategories(groups);
+                await organizationPeriod.cleanCategories(groups);
                 await Group.deleteUnreachable(organization.id, organizationPeriod, groups)
             }
 
             if (period) {
-
                 structs.push(organizationPeriod.getStructure(period, groups));
             }
-
         }
 
         return new Response(

package/src/helpers/AuthenticatedStructures.ts

@@ -144,7 +144,7 @@ export class AuthenticatedStructures {
         }
 
         // Load responsibilities
-        const responsibilities = await MemberResponsibilityRecord.where({ memberId: { sign: 'IN', value: members.map(m => m.id) } })
+        const responsibilities = members.length > 0 ? await MemberResponsibilityRecord.where({ memberId: { sign: 'IN', value: members.map(m => m.id) } }) : []
 
         for (const blob of memberBlobs) {
             blob.responsibilities = responsibilities.filter(r => r.memberId == blob.id).map(r => MemberResponsibilityRecordStruct.create(r))