@stamhoofd/backend 2.121.0 → 2.122.0

package/src/endpoints/organization/dashboard/billing/ApplyRegisterCodeEndpoint.test.ts

@@ -0,0 +1,73 @@
+import { Request } from '@simonbackx/simple-endpoints';
+import { BalanceItem, OrganizationFactory, RegisterCodeFactory, Token, UserFactory } from '@stamhoofd/models';
+import { PermissionLevel, Permissions } from '@stamhoofd/structures';
+
+import { testServer } from '../../../../../tests/helpers/TestServer.js';
+import { ApplyRegisterCodeEndpoint } from './ApplyRegisterCodeEndpoint.js';
+import { initMembershipOrganization } from '../../../../../tests/init/initMembershipOrganization.js';
+
+describe('Endpoint.ApplyRegisterCodeEndpoint', () => {
+    // Test endpoint
+    const endpoint = new ApplyRegisterCodeEndpoint();
+
+    beforeAll(async () => {
+        await initMembershipOrganization();
+    });
+
+    test('Cannot apply a register code if not platform admin', async () => {
+        const otherOrganization = await new OrganizationFactory({}).create();
+        const code = await new RegisterCodeFactory({ organization: otherOrganization }).create();
+
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({ organization, permissions: Permissions.create({ level: PermissionLevel.Full }) }).create();
+        const token = await Token.createToken(user);
+
+        const r = Request.buildJson(
+            'POST',
+            '/billing/register-code',
+            organization.getApiHost(),
+            {
+                registerCode: code.code,
+            },
+        );
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        await expect(testServer.test(endpoint, r)).rejects.toThrow('You do not have permissions for this action');
+    });
+
+    test('Can apply a register code and apply the discount', async () => {
+        const otherOrganization = await new OrganizationFactory({}).create();
+        const code = await new RegisterCodeFactory({ organization: otherOrganization }).create();
+
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({
+            organization,
+            globalPermissions: Permissions.create({ level: PermissionLevel.Full }),
+            email: 'admin@stamhoofd.be',
+        }).create();
+        const token = await Token.createToken(user);
+
+        const r = Request.buildJson(
+            'POST',
+            '/billing/register-code',
+            organization.getApiHost(),
+            {
+                registerCode: code.code,
+            },
+        );
+        r.headers.authorization = 'Bearer ' + token.accessToken;
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeUndefined();
+
+        // Check if this organization has an open register code
+        const credits = await BalanceItem.select().where('payingOrganizationId', organization.id).fetch();
+        expect(credits.length).toBe(1);
+        expect(credits[0].unitPrice).toBe(-code.value);
+
+        // Other not yet applied because no package bought yet
+        // Check if other organization has an open register code
+        const otherCredits = await BalanceItem.select().where('payingOrganizationId', otherOrganization.id).fetch();
+        expect(otherCredits.length).toBe(0);
+    });
+});

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

@@ -0,0 +1,89 @@
+import type { Decoder } from '@simonbackx/simple-encoding';
+import { AutoEncoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import { Email } from '@stamhoofd/email';
+import { RegisterCode, UsedRegisterCode } from '@stamhoofd/models';
+
+import { Context } from '../../../../helpers/Context.js';
+import { ReferralService } from '../../../../services/ReferralService.js';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type ResponseBody = undefined;
+
+class Body extends AutoEncoder {
+    @field({ decoder: StringDecoder })
+    registerCode: string;
+}
+
+/**
+ * One endpoint to create, patch and delete groups. Usefull because on organization setup, we need to create multiple groups at once. Also, sometimes we need to link values and update multiple groups at once
+ */
+
+export class ApplyRegisterCodeEndpoint 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, '/billing/register-code', {});
+
+        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 (!Context.auth.hasPlatformFullAccess()) {
+            throw Context.auth.error();
+        }
+
+        let code = request.body.registerCode;
+
+        if (code.startsWith('https:')) {
+            try {
+                const url = new URL(code);
+                const codeParam = url.searchParams.get('code');
+                if (codeParam) {
+                    console.log('Parsed code from URL', codeParam);
+                    code = codeParam;
+                }
+            } catch (e) {
+                console.error('Tried parsing code as URL but failed', code);
+            }
+        }
+
+        const { models, emails } = await ReferralService.markUsed(organization, code);
+
+        for (const model of models) {
+            await model.save();
+        }
+
+        for (const email of emails) {
+            Email.send({
+                ...email,
+                from: Email.getQuickFromEmail(organization.address.country),
+            });
+        }
+
+        if (organization.meta.packages.isPaid) {
+            // Already bought something: apply credit to other organization immediately
+            const code = await UsedRegisterCode.getFor(organization.id);
+            if (code && !code.balanceItemId) {
+                console.log('Rewarding code ' + code.id + ' for payment');
+
+                // Deze code werd nog niet beloond
+                await ReferralService.reward(code);
+            }
+        }
+
+        return new Response(undefined);
+    }
+}

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

@@ -52,11 +52,7 @@ export class DeactivatePackageEndpoint extends Endpoint<Params, Query, Body, Res
             });
         }
 
-        // Deactivate
-        pack.removeAt = new Date();
-        pack.removeAt.setTime(pack.removeAt.getTime() - 5_000);
-        await pack.save();
-
+        await STPackageService.deactivatePackage(pack);
         await STPackageService.updateOrganizationPackages(organization.id);
 
         return new Response(undefined);

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

@@ -5,10 +5,10 @@ import { Organization } from '@stamhoofd/models';
 import { Context } from '../../../../helpers/Context.js';
 import { PaymentMandateService } from '../../../../services/PaymentMandateService.js';
 
-type Params = { id: string, sellingOrganizationId: string };
+type Params = { id: string; sellingOrganizationId: string };
 type Query = undefined;
 type Body = undefined;
-type ResponseBody = undefined
+type ResponseBody = undefined;
 
 export class DeleteOrganizationMandateEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -16,7 +16,7 @@ export class DeleteOrganizationMandateEndpoint extends Endpoint<Params, Query, B
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/mandates/@id', {sellingOrganizationId: String, id: String});
+        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/mandates/@id', { sellingOrganizationId: String, id: String });
 
         if (params) {
             return [true, params as Params];
@@ -28,15 +28,15 @@ export class DeleteOrganizationMandateEndpoint extends Endpoint<Params, Query, B
         const payingOrganization = await Context.setOrganizationScope();
         const { user } = await Context.authenticate();
 
-       const id = request.params.sellingOrganizationId;
+        const id = request.params.sellingOrganizationId;
         if (!id) {
             throw new SimpleError({
                 code: 'unavailable',
                 message: 'This is temporarily unavailable',
-                human: $t('%1Rz')
-            })
+                human: $t('%1Rz'),
+            });
         }
-        
+
         const sellingOrganization = await Organization.getByID(id);
         if (!sellingOrganization || !sellingOrganization.active) {
             throw new SimpleError({
@@ -44,16 +44,16 @@ export class DeleteOrganizationMandateEndpoint extends Endpoint<Params, Query, B
                 code: 'not_found',
                 message: 'Selling organization not found',
                 human: $t('%1R5'),
-                field: 'sellingOrganization'
-            })
+                field: 'sellingOrganization',
+            });
         }
 
         await PaymentMandateService.deleteMandate({
             mandateId: request.params.id,
             sellingOrganization,
             user,
-            payingOrganization
-        })
+            payingOrganization,
+        });
 
         const r = new Response(undefined);
         r.status = 201;

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

@@ -1,6 +1,6 @@
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
-import type { DetailedPayableBalanceCollection} from '@stamhoofd/structures';
+import type { DetailedPayableBalanceCollection } from '@stamhoofd/structures';
 import { PaymentStatus } from '@stamhoofd/structures';
 
 import { BalanceItem, Payment } from '@stamhoofd/models';

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

@@ -13,12 +13,12 @@ type Query = undefined;
 type ResponseBody = DetailedPayableBalance;
 type Body = undefined;
 
-export class GetOrganizationDetailedPayableBalancendpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+export class GetOrganizationDetailedPayableBalanceEndpoint 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/@sellingOrganizationId/payable-balance', {sellingOrganizationId: String});
+        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/payable-balance', { sellingOrganizationId: String });
 
         if (params) {
             return [true, params as Params];
@@ -40,10 +40,10 @@ export class GetOrganizationDetailedPayableBalancendpoint extends Endpoint<Param
             throw new SimpleError({
                 code: 'unavailable',
                 message: 'This is temporarily unavailable',
-                human: $t('%1Rz')
-            })
+                human: $t('%1Rz'),
+            });
         }
-        
+
         const sellingOrganization = await Organization.getByID(id);
         if (!sellingOrganization || !sellingOrganization.active) {
             throw new SimpleError({
@@ -51,8 +51,8 @@ export class GetOrganizationDetailedPayableBalancendpoint extends Endpoint<Param
                 code: 'not_found',
                 message: 'Selling organization not found',
                 human: $t('%1R5'),
-                field: 'sellingOrganization'
-            })
+                field: 'sellingOrganization',
+            });
         }
 
         const balanceItemModels = await BalanceItem.balanceItemsForOrganization(organization.id, request.params.sellingOrganizationId);
@@ -66,7 +66,7 @@ export class GetOrganizationDetailedPayableBalancendpoint extends Endpoint<Param
             .fetch();
 
         const balanceItems = await BalanceItem.getStructureWithPayments(balanceItemModels);
-        const payments = await AuthenticatedStructures.paymentsGeneral(paymentModels, false);
+        const payments = await AuthenticatedStructures.payments(paymentModels);
 
         const balance = DetailedPayableBalance.create({
             organization: await AuthenticatedStructures.organization(sellingOrganization),

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

@@ -21,7 +21,7 @@ export class GetOrganizationMandatesEndpoint extends Endpoint<Params, Query, Bod
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/mandates', {sellingOrganizationId: String});
+        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/mandates', { sellingOrganizationId: String });
 
         if (params) {
             return [true, params as Params];
@@ -38,10 +38,10 @@ export class GetOrganizationMandatesEndpoint extends Endpoint<Params, Query, Bod
             throw new SimpleError({
                 code: 'unavailable',
                 message: 'This is temporarily unavailable',
-                human: $t('%1Rz')
-            })
+                human: $t('%1Rz'),
+            });
         }
-        
+
         const sellingOrganization = await Organization.getByID(id);
         if (!sellingOrganization || !sellingOrganization.active) {
             throw new SimpleError({
@@ -49,16 +49,16 @@ export class GetOrganizationMandatesEndpoint extends Endpoint<Params, Query, Bod
                 code: 'not_found',
                 message: 'Selling organization not found',
                 human: $t('%1R5'),
-                field: 'sellingOrganization'
-            })
+                field: 'sellingOrganization',
+            });
         }
 
         const mandates = await PaymentMandateService.getMandates({
             sellingOrganization,
             user,
-            payingOrganization
-        })
+            payingOrganization,
+        });
 
-       return new Response(PaymentMandateService.groupByMandate(mandates).mandates);
+        return new Response(PaymentMandateService.groupByMandate(mandates).mandates);
     }
 }

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

@@ -1,6 +1,6 @@
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
-import type { PayableBalanceCollection} from '@stamhoofd/structures';
+import type { PayableBalanceCollection } from '@stamhoofd/structures';
 import { ReceivableBalanceType } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context.js';

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

@@ -0,0 +1,68 @@
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import type { Invoice as InvoiceStruct } from '@stamhoofd/structures';
+import { DetailedPayableBalance, PaymentStatus } from '@stamhoofd/structures';
+
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem, Invoice, Organization, Payment } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
+import { Context } from '../../../../helpers/Context.js';
+
+type Params = { sellingOrganizationId: string };
+type Query = undefined;
+type ResponseBody = InvoiceStruct[];
+type Body = undefined;
+
+export class GetOrganizationPayableInvoicesEndpoint 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/@sellingOrganizationId/invoices', { sellingOrganizationId: 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 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 id = request.params.sellingOrganizationId;
+        if (!id) {
+            throw new SimpleError({
+                code: 'unavailable',
+                message: 'This is temporarily unavailable',
+                human: $t('%1Rz'),
+            });
+        }
+
+        const sellingOrganization = await Organization.getByID(id);
+        if (!sellingOrganization || !sellingOrganization.active) {
+            throw new SimpleError({
+                statusCode: 404,
+                code: 'not_found',
+                message: 'Selling organization not found',
+                human: $t('%1R5'),
+                field: 'sellingOrganization',
+            });
+        }
+
+        const invoices = await Invoice.select()
+            .where('payingOrganizationId', organization.id)
+            .where('organizationId', sellingOrganization.id)
+            .where('number', '!=', null)
+            .orderBy('invoicedAt', 'DESC')
+            .fetch();
+
+        return new Response(await AuthenticatedStructures.invoices(invoices));
+    }
+}

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

@@ -1,9 +1,9 @@
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
 import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { OrganizationPackagesStatus, STPackage as STPackageStruct } from '@stamhoofd/structures';
 import { Context } from '../../../../helpers/Context.js';
 import { STPackageService } from '../../../../services/STPackageService.js';
-import type { Decoder} from '@simonbackx/simple-encoding';
+import type { Decoder } from '@simonbackx/simple-encoding';
 import { AutoEncoder, BooleanDecoder, field } from '@simonbackx/simple-encoding';
 
 type Params = Record<string, never>;
@@ -17,7 +17,7 @@ type Body = undefined;
 
 export class GetPackagesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     queryDecoder = Query as Decoder<Query>;
-    
+
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
             return [false];
@@ -31,7 +31,7 @@ export class GetPackagesEndpoint extends Endpoint<Params, Query, Body, ResponseB
         return [false];
     }
 
-    async handle({query}: DecodedRequest<Params, Query, Body>) {
+    async handle({ query }: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 

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

@@ -0,0 +1,66 @@
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import { BalanceItem, Organization, RegisterCode, UsedRegisterCode } from '@stamhoofd/models';
+import { RegisterCodeStatus, UsedRegisterCode as UsedRegisterCodeStruct } from '@stamhoofd/structures';
+
+import { Context } from '../../../../helpers/Context.js';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = RegisterCodeStatus;
+
+export class GetRegisterCodeEndpoint 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/register-code', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(_: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        if (!await Context.auth.hasSomeAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const codes = await RegisterCode.where({ organizationId: organization.id });
+        let code = codes[0];
+
+        if (codes.length === 0) {
+            code = new RegisterCode();
+            code.organizationId = organization.id;
+            code.description = 'Doorverwezen door ' + organization.name;
+            code.value = 25_00_00;
+            await code.generateCode();
+            await code.save();
+        }
+
+        const usedCodes = await UsedRegisterCode.getAll(code.code);
+        const allOrganizations = await Organization.getByIDs(...usedCodes.flatMap(u => u.organizationId ? [u.organizationId] : []));
+        const allBalances = await BalanceItem.getByIDs(...usedCodes.flatMap(u => u.balanceItemId ? [u.balanceItemId] : []));
+
+        return new Response(RegisterCodeStatus.create({
+            code: code.code,
+            value: code.value,
+            invoiceValue: code.invoiceValue,
+            usedCodes: usedCodes.map((c) => {
+                const creditValue = (c.balanceItemId ? (allBalances.find(credit => credit.id === c.balanceItemId)?.priceWithoutVAT) : null) ?? null;
+                return UsedRegisterCodeStruct.create({
+                    id: c.id,
+                    organizationName: allOrganizations.find(o => o.id === c.organizationId)?.name ?? 'Onbekend',
+                    createdAt: c.createdAt,
+                    creditValue: creditValue !== null ? -creditValue : null,
+                });
+            }),
+        }));
+    }
+}