@stamhoofd/backend 2.36.1 → 2.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.36.1",
+    "version": "2.37.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -36,14 +36,14 @@
         "@simonbackx/simple-encoding": "2.15.1",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.36.1",
-        "@stamhoofd/backend-middleware": "2.36.1",
-        "@stamhoofd/email": "2.36.1",
-        "@stamhoofd/models": "2.36.1",
-        "@stamhoofd/queues": "2.36.1",
-        "@stamhoofd/sql": "2.36.1",
-        "@stamhoofd/structures": "2.36.1",
-        "@stamhoofd/utility": "2.36.1",
+        "@stamhoofd/backend-i18n": "2.37.0",
+        "@stamhoofd/backend-middleware": "2.37.0",
+        "@stamhoofd/email": "2.37.0",
+        "@stamhoofd/models": "2.37.0",
+        "@stamhoofd/queues": "2.37.0",
+        "@stamhoofd/sql": "2.37.0",
+        "@stamhoofd/structures": "2.37.0",
+        "@stamhoofd/utility": "2.37.0",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -60,5 +60,5 @@
         "postmark": "^4.0.5",
         "stripe": "^16.6.0"
     },
-    "gitHead": "209901c6c8bc34d2dab23b1ce26b8aab61f27e9d"
+    "gitHead": "c01fc82d46188cc4e35a7edb90ee595ff7129e6f"
 }

package/src/endpoints/global/addresses/SearchRegionsEndpoint.ts

@@ -85,6 +85,18 @@ export class SearchRegionsEndpoint extends Endpoint<Params, Query, Body, Respons
         if (StringCompare.typoCount(request.query.query, "Nederland") < 3) {
             countries.push(Country.Netherlands)
         }
+
+        if (StringCompare.typoCount(request.query.query, "Luxemburg") < 3) {
+            countries.push(Country.Luxembourg)
+        }
+
+        if (StringCompare.typoCount(request.query.query, "Duitsland") < 3) {
+            countries.push(Country.Germany)
+        }
+
+        if (StringCompare.typoCount(request.query.query, "Frankrijk") < 3) {
+            countries.push(Country.France)
+        }
         
         return new Response(SearchRegions.create({
             cities: loadedCities.map(c => CityStruct.create(Object.assign({...c}, { province: ProvinceStruct.create(c.province) }))),

package/src/endpoints/global/email/CreateEmailEndpoint.ts

@@ -83,6 +83,8 @@ export class CreateEmailEndpoint extends Endpoint<Params, Query, Body, ResponseB
         model.fromAddress = request.body.fromAddress;
         model.fromName = request.body.fromName;
 
+        model.validateAttachments()
+
         // Check default
         if (JSON.stringify(model.json).length < 3 && model.recipientFilter.filters[0].type && EmailTemplateStruct.getDefaultForRecipient(model.recipientFilter.filters[0].type)) {
             const type = EmailTemplateStruct.getDefaultForRecipient(model.recipientFilter.filters[0].type)

package/src/endpoints/global/email/PatchEmailEndpoint.ts

@@ -89,6 +89,12 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             rebuild = true;
         }
 
+        // Attachments
+        if (request.body.attachments !== undefined) {
+            model.attachments = patchObject(model.attachments, request.body.attachments);
+            model.validateAttachments()
+        }
+
         await model.save();
 
         if (rebuild) {

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

@@ -71,8 +71,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             }
             return null
         }
-        const updateGroups = new Map<string, Group>();
-        const updateRegistrations = new Map<string, Registration>();
+
         const updateMembershipMemberIds = new Set<string>()
 
         // Loop all members one by one
@@ -489,8 +488,30 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             }
         }
 
+        await PatchOrganizationMembersEndpoint.deleteMembers(request.body.getDeletes())
+        
+        for (const member of members) {
+            if (updateMembershipMemberIds.has(member.id)) {
+                await member.updateMemberships()
+            }
+        }
+
+        if(shouldUpdateSetupSteps && organization) {
+            SetupStepUpdater.updateForOrganization(organization).catch(console.error);
+        }
+
+        return new Response(
+            await AuthenticatedStructures.membersBlob(members)
+        );
+    }
+
+    static async deleteMembers(ids: string[]) {
+        const updateGroups = new Set<string>();
+        const updateRegistrations = new Map<string, Registration>();
+        const updateSteps = new Set<string>();
+        
         // Loop all members one by one
-        for (const id of request.body.getDeletes()) {
+        for (const id of ids) {
             const member = await Member.getWithRegistrations(id)
             if (!member || !await Context.auth.canDeleteMember(member)) {
                 throw Context.auth.error("Je hebt niet voldoende rechten om dit lid te verwijderen")
@@ -500,16 +521,12 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             await User.deleteForDeletedMember(member.id)
             await BalanceItem.deleteForDeletedMember(member.id)
             await member.delete()
-            shouldUpdateSetupSteps = true
 
             for(const registration of member.registrations) {
                 const groupId = registration.groupId;
-                const group = await getGroup(groupId);
                 updateRegistrations.set(registration.id, registration);
-                if (group) {
-                    // We need to update this group occupancy because we moved one member away from it
-                    updateGroups.set(group.id, group)
-                }
+                updateGroups.add(groupId);
+                updateSteps.add(registration.organizationId);
             }
         }
 
@@ -517,25 +534,19 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
             registration.scheduleStockUpdate();
         }
 
+        const groups = await Group.getByIDs(...Array.from(updateGroups));
+
         // Loop all groups and update occupancy if needed
-        for (const group of updateGroups.values()) {
+        for (const group of groups) {
             await group.updateOccupancy()
             await group.save()
         }
-        
-        for (const member of members) {
-            if (updateMembershipMemberIds.has(member.id)) {
-                await member.updateMemberships()
-            }
-        }
 
-        if(shouldUpdateSetupSteps && organization) {
+        const organizations = await Organization.getByIDs(...Array.from(updateSteps));
+        
+        for (const organization of organizations) {
             SetupStepUpdater.updateForOrganization(organization).catch(console.error);
         }
-
-        return new Response(
-            await AuthenticatedStructures.membersBlob(members)
-        );
     }
 
     static async checkDuplicate(member: Member) {

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

@@ -134,6 +134,8 @@ export class PatchUserMembersEndpoint extends Endpoint<Params, Query, Body, Resp
             // Give access to created members
             await Member.users.reverse("members").link(user, addedMembers)
         }
+
+        await PatchOrganizationMembersEndpoint.deleteMembers(request.body.getDeletes())
         
         members = await Member.getMembersWithRegistrationForUser(user)
 

package/src/endpoints/global/registration/RegisterMembersEndpoint.test.ts

@@ -0,0 +1,453 @@
+import { Request } from "@simonbackx/simple-endpoints";
+import { Group, GroupFactory, MemberFactory, MemberWithRegistrations, Organization, OrganizationFactory, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, User, UserFactory } from "@stamhoofd/models";
+import { GroupPrice, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, PayconiqAccount, PaymentMethod, PermissionLevel, Permissions, Version } from "@stamhoofd/structures";
+import nock from "nock";
+import { v4 as uuidv4 } from "uuid";
+import { testServer } from "../../../../tests/helpers/TestServer";
+import { RegisterMembersEndpoint } from "./RegisterMembersEndpoint";
+
+const baseUrl = `/v${Version}/members/register`
+
+describe("Endpoint.RegisterMembers", () => {
+    //#region global
+    const endpoint = new RegisterMembersEndpoint();
+    let period: RegistrationPeriod;
+    let organization: Organization;
+    let user: User;
+    let token: Token;
+    let member: MemberWithRegistrations;
+    let group1: Group;
+    let groupPrice1: GroupPrice;
+    let group2: Group;
+    let groupPrice2: GroupPrice;
+
+    //#region helpers
+    const post = async (body: IDRegisterCheckout) => {
+        const request = Request.buildJson("POST", baseUrl,organization.getApiHost(), body);
+        request.headers.authorization = "Bearer "+token.accessToken;
+        return await testServer.test(endpoint, request);
+    }
+    //#endregion
+
+    //#endregion
+
+    beforeAll(async () => {
+        period = await new RegistrationPeriodFactory({}).create();
+        organization = await new OrganizationFactory({ period }).create();
+        organization.meta.registrationPaymentConfiguration.paymentMethods = [PaymentMethod.PointOfSale, PaymentMethod.Payconiq];
+        
+        organization.privateMeta.payconiqAccounts = [PayconiqAccount.create({
+            id: uuidv4(),
+            apiKey: 'test',
+            merchantId: 'test',
+            profileId: 'test',
+            name: 'test',
+            iban: 'BE56587127952688', // = random IBAN
+            callbackUrl: 'https://example.com'
+        })]
+
+        user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full
+            })
+        }).create();
+        token = await Token.createToken(user);
+        member = await new MemberFactory({ organization, user }).create();
+    });
+
+    beforeEach(async () => {
+        //#region groups
+        group1 = await new GroupFactory({
+            organization,
+            price: 25,
+            stock: 5
+        }).create();
+
+        groupPrice1 = group1.settings.prices[0];
+
+        group2 = await new GroupFactory({
+            organization,
+            price: 15,
+            stock: 4,
+            maxMembers: 1
+        }).create();
+
+        groupPrice2 = group2.settings.prices[0];
+        //#endregion
+    });
+
+    describe('Register member', () => {
+
+        test("Should update registered mmebers", async () => {
+            //#region arrange
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice: groupPrice1,
+                            organizationId: organization.id,
+                            groupId: group1.id,
+                            memberId: member.id
+                        })
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: []
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 25,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            //#endregion
+
+            // act
+            const response = await post(body);
+
+            // assert
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            const updatedGroup = await Group.getByID(group1.id);
+            expect(updatedGroup!.settings.registeredMembers).toBe(1);
+            expect(updatedGroup!.settings.reservedMembers).toBe(0);
+        })
+
+        test("Should update reserved members", async () => {
+            //#region arrange
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice: groupPrice2,
+                            organizationId: organization.id,
+                            groupId: group2.id,
+                            memberId: member.id
+                        })
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: []
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.Payconiq,
+                redirectUrl: new URL("https://www.example.com"),
+                cancelUrl: new URL("https://www.example.com"),
+                totalPrice: 15,
+                customer: null,
+            });
+            
+            nock('https://api.ext.payconiq.com')
+            .post('/v3/payments')
+            .reply(200, {
+                paymentId: 'testPaymentId',
+                _links: {
+                    checkout: {
+                        href: 'https://www.example.com'
+                    }
+                }
+            });
+            //#endregion
+
+            // act
+            const response = await post(body);
+
+            // assert
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            const updatedGroup = await Group.getByID(group2.id);
+            expect(updatedGroup!.settings.registeredMembers).toBe(0);
+            expect(updatedGroup!.settings.reservedMembers).toBe(1);
+        })
+    })
+
+    describe('Register member with replace registration', () => {
+        
+        test("Should update registered members", async () => {
+            //#region arrange
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1
+            })
+            .create();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5
+            }).create();
+
+            const groupPrice = group.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [registration.id],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id
+                        })
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: []
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            //#endregion
+
+            //#region act and assert
+
+            // update occupancy to be sure occupancy is 1
+            await group1.updateOccupancy();
+            expect(group1.settings.registeredMembers).toBe(1);
+
+            // send request and check occupancy
+            const response = await post(body);
+
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            const updatedGroup = await Group.getByID(group.id);
+            expect(updatedGroup!.settings.registeredMembers).toBe(1);
+            expect(updatedGroup!.settings.reservedMembers).toBe(0);
+
+            const updatedGroup1After = await Group.getByID(group1.id);
+            // occupancy should go from 1 to 0 because the registration should be replaced
+            expect(updatedGroup1After!.settings.registeredMembers).toBe(0);
+            expect(updatedGroup1After!.settings.reservedMembers).toBe(0);
+            //#endregion
+        })
+
+        test("Should throw error if with payment", async () => {
+            //#region arrange
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1
+            })
+            .create();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+                maxMembers: 1
+            }).create();
+
+            const groupPrice = group.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [registration.id],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id
+                        })
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: []
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.Payconiq,
+                redirectUrl: new URL("https://www.example.com"),
+                cancelUrl: new URL("https://www.example.com"),
+                totalPrice: 5,
+                customer: null,
+            });
+            //#endregion
+
+            //#region act and assert
+
+            // update occupancy to be sure occupancy is 1
+            await group1.updateOccupancy();
+            expect(group1.settings.registeredMembers).toBe(1);
+
+            await expect(async () => await post(body)).rejects.toThrow("Not allowed to move registrations");
+            //#endregion
+        })
+    })
+
+    describe('Register member with delete registration', () => {
+        
+        test("Should update registered members", async () => {
+            //#region arrange
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1
+            })
+            .create();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5
+            }).create();
+
+            const groupPrice = group.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id
+                        })
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [registration.id]
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.PointOfSale,
+                totalPrice: 5,
+                asOrganizationId: organization.id,
+                customer: null,
+            });
+            //#endregion
+
+            //#region act and assert
+
+            // update occupancy to be sure occupancy is 1
+            await group1.updateOccupancy();
+            expect(group1.settings.registeredMembers).toBe(1);
+
+            // send request and check occupancy
+            const response = await post(body);
+
+            expect(response.body).toBeDefined();
+            expect(response.body.registrations.length).toBe(1);
+
+            const updatedGroup = await Group.getByID(group.id);
+            expect(updatedGroup!.settings.registeredMembers).toBe(1);
+            expect(updatedGroup!.settings.reservedMembers).toBe(0);
+
+            const updatedGroup1After = await Group.getByID(group1.id);
+            // occupancy should go from 1 to 0 because the registration should be deleted
+            expect(updatedGroup1After!.settings.registeredMembers).toBe(0);
+            expect(updatedGroup1After!.settings.reservedMembers).toBe(0);
+            //#endregion
+        })
+
+        test("Should throw error if with payment", async () => {
+            //#region arrange
+            const registration = await new RegistrationFactory({
+                member,
+                group: group1,
+                groupPrice: groupPrice1
+            })
+            .create();
+
+            const group = await new GroupFactory({
+                organization,
+                price: 30,
+                stock: 5,
+                maxMembers: 1
+            }).create();
+
+            const groupPrice = group.settings.prices[0];
+
+            const body = IDRegisterCheckout.create({
+                cart: IDRegisterCart.create({
+                    items: [
+                        IDRegisterItem.create({
+                            id: uuidv4(),
+                            replaceRegistrationIds: [],
+                            options: [],
+                            groupPrice,
+                            organizationId: organization.id,
+                            groupId: group.id,
+                            memberId: member.id
+                        })
+                    ],
+                    balanceItems: [],
+                    deleteRegistrationIds: [registration.id]
+                }),
+                administrationFee: 0,
+                freeContribution: 0,
+                paymentMethod: PaymentMethod.Payconiq,
+                redirectUrl: new URL("https://www.example.com"),
+                cancelUrl: new URL("https://www.example.com"),
+                totalPrice: 5,
+                customer: null,
+            });
+            //#endregion
+
+            //#region act and assert
+
+            // update occupancy to be sure occupancy is 1
+            await group1.updateOccupancy();
+            expect(group1.settings.registeredMembers).toBe(1);
+
+            await expect(async () => await post(body)).rejects.toThrow("Permission denied: you are not allowed to delete registrations");
+            //#endregion
+        })
+    })
+
+    it('Register member that is already registered should throw error', async () => {
+        // create existing registration
+        await new RegistrationFactory({
+            member,
+            group: group1,
+            groupPrice: groupPrice1
+        })
+        .create();
+
+        // register again
+        const body = IDRegisterCheckout.create({
+            cart: IDRegisterCart.create({
+                items: [
+                    IDRegisterItem.create({
+                        id: uuidv4(),
+                        replaceRegistrationIds: [],
+                        options: [],
+                        groupPrice: groupPrice1,
+                        organizationId: organization.id,
+                        groupId: group1.id,
+                        memberId: member.id
+                    })
+                ],
+                balanceItems: [],
+                deleteRegistrationIds: []
+            }),
+            administrationFee: 0,
+            freeContribution: 0,
+            paymentMethod: PaymentMethod.PointOfSale,
+            totalPrice: groupPrice1.price.price,
+            asOrganizationId: organization.id,
+            customer: null,
+        });
+
+        await expect(async () => await post(body)).rejects.toThrow("Already registered");
+    })
+})

package/src/helpers/AddressValidator.ts

@@ -55,6 +55,17 @@ export class AddressValidatorStatic {
                 })
             }
         }
+
+        if (address.country !== Country.Belgium && address.country !== Country.Netherlands) {
+            // No validation for other countries
+            return ValidatedAddress.create(Object.assign({ ... address }, {
+                postalCode: address.postalCode,
+                city: address.city,
+                cityId: 'unknown',
+                parentCityId: null,
+                provinceId: 'unknown',
+            }))
+        }
         
         const city = await PostalCode.getCity(postalCode, address.city, address.country)
 

package/src/helpers/AdminPermissionChecker.ts

@@ -1,6 +1,6 @@
 import { AutoEncoderPatchType, PatchMap } from "@simonbackx/simple-encoding"
 import { SimpleError } from "@simonbackx/simple-errors"
-import { BalanceItem, Document, DocumentTemplate, EmailTemplate, Event, Group, Member, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, User, Webshop } from "@stamhoofd/models"
+import { BalanceItem, CachedOutstandingBalance, Document, DocumentTemplate, EmailTemplate, Event, Group, Member, MemberPlatformMembership, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, User, Webshop } from "@stamhoofd/models"
 import { AccessRight, FinancialSupportSettings, GroupCategory, GroupStatus, MemberWithRegistrationsBlob, PermissionLevel, PermissionsResourceType, Platform as PlatformStruct, RecordCategory } from "@stamhoofd/structures"
 import { Formatter } from "@stamhoofd/utility"
 
@@ -250,7 +250,20 @@ export class AdminPermissionChecker {
      * Only full admins can delete members permanently
      */
     async canDeleteMember(member: MemberWithRegistrations) {
+        if (member.registrations.length === 0 && this.isUserManager(member)) {
+            const platformMemberships = await MemberPlatformMembership.where({ memberId: member.id })
+            if (platformMemberships.length === 0) {
+                return true;
+            }
+
+            const cachedBalance = await CachedOutstandingBalance.getForObjects([member.id])
+            if (cachedBalance.length === 0 || (cachedBalance[0].amount === 0 && cachedBalance[0].amountPending === 0)) {
+                return true;
+            }
+        }
+
         if (member.organizationId) {
+            // Not a platform
             return await this.hasFullAccess(member.organizationId)
         }
         return this.hasPlatformFullAccess()

package/src/seeds/1726494420-update-cached-outstanding-balance-from-items.ts

@@ -0,0 +1,40 @@
+import { Migration } from '@simonbackx/simple-database';
+import { logger } from '@simonbackx/simple-logging';
+import { BalanceItem } from '@stamhoofd/models';
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment == "test") {
+        console.log("skipped in tests")
+        return;
+    }
+
+    process.stdout.write('\n');
+    let c = 0;
+    let id: string = '';
+
+    await logger.setContext({tags: ['silent-seed', 'seed']}, async () => {
+        while(true) {
+            const items = await BalanceItem.where({
+                id: {
+                    value: id,
+                    sign: '>'
+                }
+            }, {limit: 1000, sort: ['id']});
+
+            await BalanceItem.updateOutstanding(items)
+
+            c += items.length;
+            process.stdout.write('.');
+
+            if (items.length < 1000) {
+                break;
+            }
+            id = items[items.length - 1].id;
+        }
+    })
+
+    console.log("Updated outstanding balance for " + c + " items")
+
+    // Do something here
+    return Promise.resolve()
+})