@stamhoofd/backend 2.9.0 → 2.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.9.0",
+    "version": "2.14.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -35,6 +35,14 @@
         "@simonbackx/simple-database": "1.24.0",
         "@simonbackx/simple-endpoints": "1.13.0",
         "@simonbackx/simple-logging": "^1.0.1",
+        "@stamhoofd/backend-i18n": "^2.13.0",
+        "@stamhoofd/backend-middleware": "^2.13.0",
+        "@stamhoofd/email": "^2.13.0",
+        "@stamhoofd/models": "^2.13.0",
+        "@stamhoofd/queues": "^2.13.0",
+        "@stamhoofd/sql": "^2.13.0",
+        "@stamhoofd/structures": "^2.14.0",
+        "@stamhoofd/utility": "^2.13.0",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
         "cookie": "^0.5.0",
@@ -50,5 +58,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "d1959fa457e81e41797c4f7fe216095505f50aeb"
+    "gitHead": "93374a0a3799ee54f387d4cff70c7cf70afc0ac8"
 }

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.ts

@@ -30,33 +30,23 @@ export const filterCompilers: SQLFilterDefinitions = {
     ),
     city: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     country: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.country'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     umbrellaOrganization: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.umbrellaOrganization'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     type: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.type'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     tags: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.tags'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
     packages: createSQLRelationFilterCompiler(
         SQL.select().from(
@@ -103,9 +93,7 @@ export const filterCompilers: SQLFilterDefinitions = {
             ...baseSQLFilterCompilers,
             "type": createSQLExpressionFilterCompiler(
                 SQL.jsonValue(SQL.column('meta'), '$.value.type'),
-                undefined,
-                true,
-                false
+                {isJSONValue: true}
             )
         }
     ),

package/src/endpoints/global/events/GetEventsEndpoint.ts

@@ -24,21 +24,15 @@ const filterCompilers: SQLFilterDefinitions = {
     endDate: createSQLColumnFilterCompiler('endDate'),
     groupIds: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
     defaultAgeGroupIds: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
     organizationTagIds: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     )
 }
 

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

@@ -75,25 +75,12 @@ Email.recipientLoaders.set(EmailRecipientFilterType.MemberUnverified, {
 
 const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    "price": createSQLColumnFilterCompiler('price'),
+    "price": createSQLColumnFilterCompiler('price', {nullable: true}),
     "pricePaid": createSQLColumnFilterCompiler('pricePaid'),
-    "waitingList": createSQLColumnFilterCompiler('waitingList'),
     "canRegister": createSQLColumnFilterCompiler('canRegister'),
-    "cycle": createSQLColumnFilterCompiler('cycle'),
-
-    "cycleOffset": createSQLExpressionFilterCompiler({
-        getSQL(options) {
-            return joinSQLQuery([
-                SQL.column('groups', 'cycle').getSQL(options),
-                ' - ',
-                SQL.column('registrations', 'cycle').getSQL(options)
-            ])
-        },
-    }),
-
     "organizationId": createSQLColumnFilterCompiler('organizationId'),
     "groupId": createSQLColumnFilterCompiler('groupId'),
-    "registeredAt": createSQLColumnFilterCompiler('registeredAt'),
+    "registeredAt": createSQLColumnFilterCompiler('registeredAt', {nullable: true}),
     "periodId": createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
 
     "group": createSQLFilterNamespace({
@@ -105,7 +92,7 @@ const registrationFilterCompilers: SQLFilterDefinitions = {
         status: createSQLExpressionFilterCompiler(
             SQL.column('groups', 'status')
         ),
-        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId')),
+        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), {nullable: true}),
     })
 }
 
@@ -120,20 +107,21 @@ const filterCompilers: SQLFilterDefinitions = {
         )
     ),
     age: createSQLExpressionFilterCompiler(
-        new SQLAge(SQL.column('birthDay'))
+        new SQLAge(SQL.column('birthDay')), 
+        {nullable: true}
     ),
     gender: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.gender'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
-    birthDay: createSQLColumnFilterCompiler('birthDay', (d) => {
-        if (typeof d === 'number') {
-            const date = new Date(d)
-            return Formatter.dateIso(date);
+    birthDay: createSQLColumnFilterCompiler('birthDay', {
+        normalizeValue: (d) => {
+            if (typeof d === 'number') {
+                const date = new Date(d)
+                return Formatter.dateIso(date);
+            }
+            return d;
         }
-        return d;
     }),
     organizationName: createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'name')
@@ -141,16 +129,12 @@ const filterCompilers: SQLFilterDefinitions = {
 
     email: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.email'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
 
     parentEmail: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.parents[*].email'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
 
     registrations: createSQLRelationFilterCompiler(

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

@@ -6,7 +6,7 @@ import { SimpleError } from '@simonbackx/simple-errors';
 import { I18n } from '@stamhoofd/backend-i18n';
 import { Email } from '@stamhoofd/email';
 import { BalanceItem, BalanceItemPayment, Group, Member, MemberWithRegistrations, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, IDRegisterCheckout, BalanceItemWithPayments, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PermissionLevel, PlatformFamily, PlatformMember, RegisterItem, RegisterResponse, Version } from "@stamhoofd/structures";
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, BalanceItemWithPayments, IDRegisterCheckout, PaymentCustomer, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PermissionLevel, PlatformFamily, PlatformMember, RegisterItem, RegisterResponse, Version } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -678,11 +678,61 @@ export class RegisterMembersEndpoint extends Endpoint<Params, Query, Body, Respo
         }
 
         const payment = new Payment()
-        payment.userId = user.id
 
         // Who will receive this money?
         payment.organizationId = organization.id
 
+        // Who paid
+        payment.payingUserId = user.id
+        payment.payingOrganizationId = checkout.asOrganizationId ?? null
+
+        // Fill in customer:
+        payment.customer = PaymentCustomer.create({
+            firstName: user.firstName,
+            lastName: user.lastName,
+            email: user.email,
+        })
+
+        if (checkout.asOrganizationId) {
+            if (!checkout.customer) {
+                throw new SimpleError({
+                    code: "missing_fields",
+                    message: "customer is required when paying as an organization",
+                    human: "Vul je facturatiegegevens in om verder te gaan."
+                })
+            }
+
+            if (!checkout.customer.company) {
+                throw new SimpleError({
+                    code: "missing_fields",
+                    message: "customer.company is required when paying as an organization",
+                    human: "Als je een betaling uitvoert in naam van je vereniging, is het noodzakelijk om facturatiegegevens met bedrijfsgegevens in te vullen."
+                })
+            }
+
+            const payingOrganization = await Organization.getByID(checkout.asOrganizationId);
+            if (!payingOrganization) {
+                throw new SimpleError({
+                    code: "invalid_data",
+                    message: "Oeps, de organisatie waarvoor je probeert te betalen lijkt niet meer te bestaan. Herlaad de pagina en probeer opnieuw."
+                })
+            }
+
+            // Search company id
+            // this avoids needing to check the VAT number every time
+            const id = checkout.customer.company.id
+            const foundCompany = payingOrganization.meta.companies.find(c => c.id === id)
+
+            if (!foundCompany) {
+                throw new SimpleError({
+                    code: "invalid_data",
+                    message: "Oeps, de facturatiegegevens die je probeerde te selecteren lijken niet meer te bestaan. Herlaad de pagina en probeer opnieuw."
+                })
+            }
+
+            payment.customer.company = foundCompany
+        }
+
         payment.method = checkout.paymentMethod
         payment.status = PaymentStatus.Created
         payment.price = totalPrice

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

@@ -1,13 +1,14 @@
-import { AutoEncoderPatchType, Decoder, ObjectData, patchObject } from '@simonbackx/simple-encoding';
+import { AutoEncoderPatchType, Decoder, isPatchableArray, ObjectData, PatchableArrayAutoEncoder, patchObject } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
 import { Organization, OrganizationRegistrationPeriod, PayconiqPayment, Platform, RegistrationPeriod, StripeAccount, Webshop } from '@stamhoofd/models';
-import { BuckarooSettings, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel } from "@stamhoofd/structures";
+import { BuckarooSettings, Company, OrganizationMetaData, OrganizationPatch, Organization as OrganizationStruct, PayconiqAccount, PaymentMethod, PaymentMethodHelper, PermissionLevel } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { BuckarooHelper } from '../../../../helpers/BuckarooHelper';
 import { Context } from '../../../../helpers/Context';
+import { ViesHelper } from '../../../../helpers/ViesHelper';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -208,6 +209,10 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
             }
 
             if (request.body.meta) {
+                if (request.body.meta.companies) {
+                   await this.validateCompanies(organization, request.body.meta.companies)
+                }
+
                 const savedPackages = organization.meta.packages
                 organization.meta.patchOrPut(request.body.meta)
                 organization.meta.packages = savedPackages
@@ -366,5 +371,52 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
         errors.throwIfNotEmpty()
         return new Response(await AuthenticatedStructures.organization(organization));
     }
+
+    async validateCompanies(organization: Organization, companies: PatchableArrayAutoEncoder<Company>|Company[]) {
+        if (isPatchableArray(companies)) {
+            for (const patch of companies.getPatches()) {
+                // Changed VAT number
+                const original = organization.meta.companies.find(c => c.id === patch.id)
+
+                if (!original) {
+                    throw new Error('Could not find company')
+                }
+                
+                // Changed VAT number
+                const prepatched = original.patch(patch)
+                await ViesHelper.checkCompany(prepatched, patch)
+            }
+
+            let c = 0;
+            for (const {put} of companies.getPuts()) {
+                c++;
+                
+                if ((organization.meta.companies.length + c) > 5) {
+                    throw new SimpleError({
+                        code: "invalid_field",
+                        message: "Too many companies",
+                        human: "Je kan maximaal 5 bedrijven toevoegen",
+                        field: "companies"
+                    })
+                }
+
+                await ViesHelper.checkCompany(put, put)
+            }
+
+        } else {
+            if (companies.length > 5) {
+                throw new SimpleError({
+                    code: "invalid_field",
+                    message: "Too many companies",
+                    human: "Je kan maximaal 5 bedrijven toevoegen",
+                    field: "companies"
+                })
+            }
+
+            for (const company of companies) {
+                await ViesHelper.checkCompany(company, company)
+            }
+        }
+    }
 }
 

package/src/endpoints/organization/dashboard/payments/GetPaymentsCountEndpoint.ts

@@ -0,0 +1,43 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
+
+import { Context } from '../../../../helpers/Context';
+import { GetPaymentsEndpoint } from './GetPaymentsEndpoint';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetPaymentsCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/payments/count", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOrganizationScope();
+        await Context.authenticate()
+        const query = await GetPaymentsEndpoint.buildQuery(request.query)
+        
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count
+            })
+        );
+    }
+}