@stamhoofd/backend 2.36.2 → 2.38.0

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/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -37,12 +37,22 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
-        const {user} = await Context.authenticate()
+        const organization = await Context.setOrganizationScope({allowInactive: true});
+        await Context.authenticate()
 
         if (!await Context.auth.hasSomeAccess(organization.id)) {
             throw Context.auth.error()
         }
+
+        if (!organization.active && !Context.auth.hasPlatformFullAccess()) {
+            throw new SimpleError({
+                code: "permission_denied",
+                message: "You do not have permissions to edit an inactive organization",
+                human: 'Je hebt geen toegangsrechten om een inactieve groep te bewerken',
+                statusCode: 403
+            })
+
+        }
         
         // check if organization ID matches
         if (request.body.id !== organization.id) {
@@ -295,6 +305,13 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                 }
             }
 
+            if (request.body.active !== undefined) {
+                if (!Context.auth.hasPlatformFullAccess()) {
+                    throw Context.auth.error('Enkel een platform hoofdbeheerder kan een groep (in)actief maken')
+                }
+                organization.active = request.body.active;
+            }
+
             if (request.body.uri) {
                 if (!Context.auth.hasPlatformFullAccess()) {
                     throw Context.auth.error()

package/src/endpoints/organization/shared/ExchangePaymentEndpoint.ts

@@ -46,7 +46,7 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope()
+        const organization = await Context.setOptionalOrganizationScope()
         if (!request.query.exchange) {
             await Context.authenticate()
         }
@@ -152,7 +152,7 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
     /**
      * ID of payment is needed because of race conditions (need to fetch payment in a race condition save queue)
      */
-    static async pollStatus(paymentId: string, organization: Organization, cancel = false): Promise<Payment | undefined> {
+    static async pollStatus(paymentId: string, org: Organization|null, cancel = false): Promise<Payment | undefined> {
         // Prevent polling the same payment multiple times at the same time: create a queue to prevent races
         QueueHandler.cancel("payments/"+paymentId); // Prevent creating more than one queue item for the same payment
         return await QueueHandler.schedule("payments/"+paymentId, async () => {
@@ -162,6 +162,17 @@ export class ExchangePaymentEndpoint extends Endpoint<Params, Query, Body, Respo
                 return
             }
 
+            if (!payment.organizationId) {
+                console.error('Payment without organization not supported', payment.id)
+                return
+            }
+
+            const organization = org ?? await Organization.getByID(payment.organizationId)
+            if (!organization) {
+                console.error('Organization not found for payment', payment.id)
+                return
+            }
+
             const testMode = organization.privateMeta.useTestPayments ?? STAMHOOFD.environment != 'production'
 
             if (payment.status == PaymentStatus.Pending || payment.status == PaymentStatus.Created || (payment.provider === PaymentProvider.Buckaroo && payment.status == PaymentStatus.Failed)) {

package/src/endpoints/organization/shared/GetPaymentEndpoint.ts

@@ -26,7 +26,7 @@ export class GetPaymentEndpoint extends Endpoint<Params, Query, Body, ResponseBo
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.setOrganizationScope()
+        await Context.setOptionalOrganizationScope()
         await Context.authenticate()
 
         const payment = await Payment.getByID(request.params.id);