@stamhoofd/backend 2.120.6 → 2.122.0

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

@@ -0,0 +1,62 @@
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Organization } from '@stamhoofd/models';
+import { Context } from '../../../../helpers/Context.js';
+import { PaymentMandateService } from '../../../../services/PaymentMandateService.js';
+
+type Params = { id: string; sellingOrganizationId: string };
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = undefined;
+
+export class DeleteOrganizationMandateEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'DELETE') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/mandates/@id', { sellingOrganizationId: String, id: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const payingOrganization = await Context.setOrganizationScope();
+        const { user } = await Context.authenticate();
+
+        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',
+            });
+        }
+
+        await PaymentMandateService.deleteMandate({
+            mandateId: request.params.id,
+            sellingOrganization,
+            user,
+            payingOrganization,
+        });
+
+        const r = new Response(undefined);
+        r.status = 201;
+        return r;
+    }
+}

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

@@ -0,0 +1,56 @@
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import type { DetailedPayableBalanceCollection } from '@stamhoofd/structures';
+import { PaymentStatus } from '@stamhoofd/structures';
+
+import { BalanceItem, Payment } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { Context } from '../../../../helpers/Context.js';
+import { GetUserDetailedPayableBalanceEndpoint } from '../../../global/registration/GetUserDetailedPayableBalanceEndpoint.js';
+
+type Params = Record<string, never>;
+type Query = undefined;
+type ResponseBody = DetailedPayableBalanceCollection;
+type Body = undefined;
+
+export class GetOrganizationDetailedPayableBalanceCollectionEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = request.getVersion() >= 339
+            ? Endpoint.parseParameters(request.url, '/organization/payable-balance/detailed', {})
+            : (
+                    request.getVersion() <= 334
+                        ? Endpoint.parseParameters(request.url, '/organization/billing/status', {})
+                        : Endpoint.parseParameters(request.url, '/organization/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);
+
+        const paymentModels = await Payment.select()
+            .where('payingOrganizationId', organization.id)
+            .andWhere(
+                SQL.whereNot('status', PaymentStatus.Failed),
+            )
+            .fetch();
+
+        return new Response(await GetUserDetailedPayableBalanceEndpoint.getDetailedBillingStatus(balanceItemModels, paymentModels));
+    }
+}

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

@@ -1,16 +1,16 @@
-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 { PaymentStatus } from '@stamhoofd/structures';
+import { DetailedPayableBalance, PaymentStatus } from '@stamhoofd/structures';
 
-import { BalanceItem, Payment } from '@stamhoofd/models';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem, Organization, Payment } from '@stamhoofd/models';
 import { SQL } from '@stamhoofd/sql';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures.js';
 import { Context } from '../../../../helpers/Context.js';
-import { GetUserDetailedPayableBalanceEndpoint } from '../../../global/registration/GetUserDetailedPayableBalanceEndpoint.js';
 
-type Params = Record<string, never>;
+type Params = { sellingOrganizationId: string };
 type Query = undefined;
-type ResponseBody = DetailedPayableBalanceCollection;
+type ResponseBody = DetailedPayableBalance;
 type Body = undefined;
 
 export class GetOrganizationDetailedPayableBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
@@ -18,14 +18,7 @@ export class GetOrganizationDetailedPayableBalanceEndpoint extends Endpoint<Para
         if (request.method !== 'GET') {
             return [false];
         }
-
-        const params = request.getVersion() >= 339
-            ? Endpoint.parseParameters(request.url, '/organization/payable-balance/detailed', {})
-            : (
-                    request.getVersion() <= 334
-                        ? Endpoint.parseParameters(request.url, '/organization/billing/status', {})
-                        : Endpoint.parseParameters(request.url, '/organization/billing/status/detailed', {})
-                );
+        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/payable-balance', { sellingOrganizationId: String });
 
         if (params) {
             return [true, params as Params];
@@ -33,7 +26,7 @@ export class GetOrganizationDetailedPayableBalanceEndpoint extends Endpoint<Para
         return [false];
     }
 
-    async handle(_: DecodedRequest<Params, Query, Body>) {
+    async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 
@@ -42,15 +35,45 @@ export class GetOrganizationDetailedPayableBalanceEndpoint extends Endpoint<Para
             throw Context.auth.error();
         }
 
-        const balanceItemModels = await BalanceItem.balanceItemsForOrganization(organization.id);
+        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 balanceItemModels = await BalanceItem.balanceItemsForOrganization(organization.id, request.params.sellingOrganizationId);
 
         const paymentModels = await Payment.select()
             .where('payingOrganizationId', organization.id)
+            .where('organizationId', request.params.sellingOrganizationId)
             .andWhere(
                 SQL.whereNot('status', PaymentStatus.Failed),
             )
             .fetch();
 
-        return new Response(await GetUserDetailedPayableBalanceEndpoint.getDetailedBillingStatus(balanceItemModels, paymentModels));
+        const balanceItems = await BalanceItem.getStructureWithPayments(balanceItemModels);
+        const payments = await AuthenticatedStructures.payments(paymentModels);
+
+        const balance = DetailedPayableBalance.create({
+            organization: await AuthenticatedStructures.organization(sellingOrganization),
+            balanceItems,
+            payments,
+        });
+
+        return new Response(balance);
     }
 }

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

@@ -0,0 +1,64 @@
+import type { Decoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Organization } from '@stamhoofd/models';
+import { OrganizationCheckout } from '@stamhoofd/structures';
+import type { PaymentMandate } from '@stamhoofd/structures/PaymentMandate.js';
+import { Context } from '../../../../helpers/Context.js';
+import { PaymentMandateService } from '../../../../services/PaymentMandateService.js';
+
+type Params = { sellingOrganizationId: string };
+type Query = undefined;
+type Body = undefined;
+type ResponseBody = PaymentMandate[];
+
+export class GetOrganizationMandatesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = OrganizationCheckout as Decoder<Query>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/billing/@sellingOrganizationId/mandates', { sellingOrganizationId: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const payingOrganization = await Context.setOrganizationScope();
+        const { user } = await Context.authenticate();
+
+        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 mandates = await PaymentMandateService.getMandates({
+            sellingOrganization,
+            user,
+            payingOrganization,
+        });
+
+        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,15 +1,23 @@
-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 { AutoEncoder, BooleanDecoder, field } from '@simonbackx/simple-encoding';
 
 type Params = Record<string, never>;
-type Query = undefined;
+class Query extends AutoEncoder {
+    @field({ decoder: BooleanDecoder })
+    includeExpired = false;
+}
+
 type ResponseBody = OrganizationPackagesStatus;
 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];
@@ -23,7 +31,7 @@ export class GetPackagesEndpoint extends Endpoint<Params, Query, Body, ResponseB
         return [false];
     }
 
-    async handle(_: DecodedRequest<Params, Query, Body>) {
+    async handle({ query }: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
         await Context.authenticate();
 
@@ -32,7 +40,7 @@ export class GetPackagesEndpoint extends Endpoint<Params, Query, Body, ResponseB
             throw Context.auth.error();
         }
 
-        const packages = Context.auth.hasPlatformFullAccess() ? await STPackageService.getValidPackagesWithExpired(organization.id) : await STPackageService.getActivePackages(organization.id);
+        const packages = query.includeExpired ? await STPackageService.getValidPackagesWithExpired(organization.id) : await STPackageService.getActivePackages(organization.id);
 
         return new Response(OrganizationPackagesStatus.create({
             packages: packages.map(p => STPackageStruct.create(p)),

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,
+                });
+            }),
+        }));
+    }
+}