@stamhoofd/backend 2.132.0 → 2.133.0

package/src/helpers/ViesHelper.test.ts

@@ -1,4 +1,4 @@
-import { Address, Company } from '@stamhoofd/structures';
+import { Address, Company, PeppolEndointId } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { Country } from '@stamhoofd/types/Country';
 import nock from 'nock';
@@ -7,6 +7,9 @@ import { ViesHelper } from './ViesHelper.js';
 const VIES_HOST = 'https://ec.europa.eu';
 const VIES_PATH = '/taxation_customs/vies/rest-api/check-vat-number';
 
+const DIRECTORY_HOST = 'https://directory.peppol.eu';
+const DIRECTORY_PATH = '/search/1.0/json';
+
 describe('ViesHelper', () => {
     /**
      * Registers a mock for the (only) external dependency: the VIES check-vat-number endpoint.
@@ -253,5 +256,146 @@ describe('ViesHelper', () => {
             expect(patch.VATNumber).toBe('BE0411905847');
             expect(patch.companyNumber).toBe('0411905847');
         });
+
+        describe('custom PEPPOL endpoint id', () => {
+            function mockDirectoryFound(participant: string, entityName = 'Directory Name') {
+                return nock(DIRECTORY_HOST)
+                    .get(DIRECTORY_PATH)
+                    .query({ participant })
+                    .reply(200, {
+                        'total-result-count': 1,
+                        matches: [{
+                            participantID: { scheme: 'iso6523-actorid-upis', value: participant.split('::')[1] },
+                            entities: [{ name: [{ name: entityName }] }],
+                        }],
+                    } as nock.Body);
+            }
+
+            function mockDirectoryNotFound(participant: string) {
+                return nock(DIRECTORY_HOST)
+                    .get(DIRECTORY_PATH)
+                    .query({ participant })
+                    .reply(200, { 'total-result-count': 0, matches: [] } as nock.Body);
+            }
+
+            // Use a GLN endpoint id for the generic directory/entityName tests: it has no
+            // extra constraints, unlike a KBO (0208) id which must match the company number.
+            const companyWithPeppol = () => Company.create({
+                name: 'Demo Company',
+                address: belgianAddress(),
+                customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0088', id: '5412345000013' }),
+            });
+
+            test('validates the id against the directory when it was changed', async () => {
+                const scope = mockDirectoryFound('iso6523-actorid-upis::0088:5412345000013');
+
+                const company = companyWithPeppol();
+                const patch = Company.patch({ customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0088', id: '5412345000013' }) });
+
+                await expect(ViesHelper.checkCompany(company, patch)).resolves.toBeUndefined();
+                expect(scope.isDone()).toBe(true);
+                // The registered entity name is stored from the directory.
+                expect(company.customPeppolEndpointId?.entityName).toBe('Directory Name');
+            });
+
+            test('overwrites a client-supplied entityName with the value from the directory', async () => {
+                mockDirectoryFound('iso6523-actorid-upis::0088:5412345000013');
+
+                const company = Company.create({
+                    name: 'Demo Company',
+                    address: belgianAddress(),
+                    customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0088', id: '5412345000013', entityName: 'Client supplied name' }),
+                });
+                const patch = Company.patch({ customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0088', id: '5412345000013', entityName: 'Client supplied name' }) });
+
+                await ViesHelper.checkCompany(company, patch);
+
+                // entityName is server-controlled: the client value is discarded.
+                expect(company.customPeppolEndpointId?.entityName).toBe('Directory Name');
+                expect(patch.customPeppolEndpointId).not.toBeNull();
+                expect((patch.customPeppolEndpointId as PeppolEndointId | undefined)?.entityName).toBe('Directory Name');
+            });
+
+            test('does not contact the directory when the id did not change', async () => {
+                const scope = mockDirectoryFound('iso6523-actorid-upis::0088:5412345000013');
+
+                const company = companyWithPeppol();
+                const patch = Company.patch({ name: 'Renamed Company' });
+
+                await ViesHelper.checkCompany(company, patch);
+                expect(scope.isDone()).toBe(false);
+            });
+
+            test('rejects an id that is unknown to the directory', async () => {
+                mockDirectoryNotFound('iso6523-actorid-upis::0088:5412345000013');
+
+                const company = companyWithPeppol();
+                const patch = Company.patch({ customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0088', id: '5412345000013' }) });
+
+                await expect(ViesHelper.checkCompany(company, patch)).rejects.toThrow(
+                    STExpect.simpleError({ code: 'invalid_field', field: 'customPeppolEndpointId' }),
+                );
+            });
+
+            test('does not contact the directory when the id is cleared', async () => {
+                const scope = mockDirectoryFound('iso6523-actorid-upis::0088:5412345000013');
+
+                const company = Company.create({ name: 'Demo Company', address: belgianAddress() });
+                const patch = Company.patch({ customPeppolEndpointId: null });
+
+                await ViesHelper.checkCompany(company, patch);
+                expect(scope.isDone()).toBe(false);
+            });
+
+            test('rejects a KBO endpoint id for a non-Belgian company before contacting the directory', async () => {
+                const scope = mockDirectoryFound('iso6523-actorid-upis::0208:0411905847');
+
+                const company = Company.create({
+                    name: 'Demo Company',
+                    address: Address.create({ street: 'Damstraat', number: '1', city: 'Amsterdam', postalCode: '1012', country: Country.Netherlands }),
+                    customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0208', id: '0411905847' }),
+                });
+                const patch = Company.patch({ customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0208', id: '0411905847' }) });
+
+                await expect(ViesHelper.checkCompany(company, patch)).rejects.toThrow(
+                    STExpect.simpleError({ code: 'invalid_field', field: 'customPeppolEndpointId' }),
+                );
+                expect(scope.isDone()).toBe(false);
+            });
+
+            test('rejects a KBO endpoint id that does not match the company number before contacting the directory', async () => {
+                const scope = mockDirectoryFound('iso6523-actorid-upis::0208:9999999999');
+
+                const company = Company.create({
+                    name: 'Demo Company',
+                    address: belgianAddress(),
+                    companyNumber: '0411905847',
+                    customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0208', id: '9999999999' }),
+                });
+                const patch = Company.patch({ customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0208', id: '9999999999' }) });
+
+                await expect(ViesHelper.checkCompany(company, patch)).rejects.toThrow(
+                    STExpect.simpleError({ code: 'invalid_field', field: 'customPeppolEndpointId' }),
+                );
+                expect(scope.isDone()).toBe(false);
+            });
+
+            test('accepts a KBO endpoint id that matches the company number', async () => {
+                mockVies({ valid: true });
+                const scope = mockDirectoryFound('iso6523-actorid-upis::0208:0411905847');
+
+                const company = Company.create({
+                    name: 'Demo Company',
+                    address: belgianAddress(),
+                    companyNumber: '0411905847',
+                    customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0208', id: '0411905847' }),
+                });
+                const patch = Company.patch({ customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0208', id: '0411905847' }) });
+
+                await expect(ViesHelper.checkCompany(company, patch)).resolves.toBeUndefined();
+                expect(scope.isDone()).toBe(true);
+                expect(company.customPeppolEndpointId?.entityName).toBe('Directory Name');
+            });
+        });
     });
 });

package/src/helpers/ViesHelper.ts

@@ -1,9 +1,11 @@
 import type { AutoEncoderPatchType } from '@simonbackx/simple-encoding';
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import type { Company } from '@stamhoofd/structures';
+import { PeppolScheme } from '@stamhoofd/structures';
 import { Country } from '@stamhoofd/types/Country';
 import axios from 'axios';
 import jsvat from 'jsvat-next';
+import { PeppolDirectoryService } from '../services/PeppolDirectoryService.js';
 
 export class ViesHelperStatic {
     testMode = false;
@@ -27,6 +29,43 @@ export class ViesHelperStatic {
     }
 
     async checkCompany(company: Company, patch: AutoEncoderPatchType<Company> | Company) {
+        // Validate the custom PEPPOL endpoint id, but only when it actually changed.
+        // In a patch, `customPeppolEndpointId` is undefined unless the client changed it;
+        // for a full company it is always set (null or a value), so we validate a set value.
+        if (patch.customPeppolEndpointId !== undefined && company.customPeppolEndpointId) {
+            const endpointId = company.customPeppolEndpointId;
+
+            // A KBO (0208) endpoint id is the Belgian enterprise number, so it must belong to a
+            // Belgian company and be identical to this company's own company number.
+            if (endpointId.schemeID === (PeppolScheme.KBO as string)) {
+                if (company.address?.country !== Country.Belgium) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'A KBO PEPPOL id can only be used for a Belgian company',
+                        human: $t('%Zck'),
+                        field: 'customPeppolEndpointId',
+                    });
+                }
+
+                const companyPeppolId = company.peppolCompanyId;
+                if (!companyPeppolId || endpointId.id.replace(/\D+/g, '') !== companyPeppolId.id.replace(/\D+/g, '')) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'A KBO PEPPOL id must match the company number',
+                        human: $t('%ZcZ'),
+                        field: 'customPeppolEndpointId',
+                    });
+                }
+            }
+
+            // validate() fills in the server-controlled entityName from the PEPPOL directory.
+            await PeppolDirectoryService.validate(endpointId);
+
+            // Write the validated endpoint id back as a full replacement so any client-supplied
+            // entityName is discarded: entityName can only ever be set by the server.
+            patch.customPeppolEndpointId = endpointId;
+        }
+
         if (!company.address) {
             // Not allowed to set
             patch.companyNumber = null;

package/src/seeds/1783520259-make-old-group-filters-readable.ts

@@ -0,0 +1,454 @@
+import { Migration } from '@simonbackx/simple-database';
+import { Group, Organization, RegistrationPeriod } from '@stamhoofd/models';
+import type { RecordCategory, RegistrationPeriodBase, StamhoofdCompareValue, StamhoofdFilter, StamhoofdMagicRelationFilter } from '@stamhoofd/structures';
+import { GroupType } from '@stamhoofd/structures';
+import { SeedTools } from '../helpers/SeedTools.js';
+
+export async function startMigration(dryRun = false) {
+    await SeedTools.loop({
+        batchSize: 100,
+        query: Organization.select(),
+        action: async (organization: Organization) => {
+            await fixUnreadableGroupFilters(organization, dryRun);
+        },
+    });
+
+    if (dryRun) {
+        throw new Error('Migration did not finish because of dryRun');
+    }
+}
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    if (STAMHOOFD.platformName.toLowerCase() !== 'stamhoofd') {
+        console.log('skipped for platform (only runs for Stamhoofd): ' + STAMHOOFD.platformName);
+        return;
+    }
+
+    const dryRun = false;
+    await startMigration(dryRun);
+});
+
+function getAllRecordCategories(organization: Organization): RecordCategory[] {
+    function getAllRecordCategoiesRecursive(category: RecordCategory) {
+        const results: RecordCategory[] = [category];
+
+        for (const child of category.childCategories) {
+            results.push(...getAllRecordCategoiesRecursive(child));
+        }
+        return results;
+    }
+
+    return organization.meta.recordsConfiguration.recordCategories.flatMap(c => getAllRecordCategoiesRecursive(c));
+}
+
+async function fixUnreadableGroupFilters(organization: Organization, dryRun: boolean) {
+    const filtersWithGroupFilters: StamhoofdFilter[] = getAllRecordCategories(organization).flatMap((c) => {
+        const filter = c.filter;
+        if (filter === null) {
+            return [];
+        }
+
+        return [filter.enabledWhen, filter.requiredWhen].filter((f) => {
+            return hasRegistrationsFilter(f);
+        });
+    });
+
+    if (filtersWithGroupFilters.length === 0) {
+        return;
+    }
+
+    console.log('organization:', organization.name);
+
+    for (const filter of filtersWithGroupFilters) {
+        const groupIds = getGroupIdsFromFilter(filter);
+        if (groupIds.length === 0) {
+            continue;
+        }
+
+        const groups = await Group.getByIDs(...new Set(groupIds));
+        const groupMap = new Map(groups.map(g => [g.id, g]));
+
+        console.error('filter before: ', JSON.stringify(filter));
+
+        await makeGroupFiltersReadable(filter, groupMap);
+
+        console.error('filter after: ', JSON.stringify(filter));
+    }
+
+    if (!dryRun) {
+        await organization.save();
+    }
+}
+
+class StamhoofdFilterHelper {
+    static isRecordOrArray(value: StamhoofdFilter): value is { [key: string]: StamhoofdFilter } | StamhoofdFilter[] {
+        if (typeof value !== 'object' || value === null || value instanceof Date) {
+            return false;
+        }
+
+        return true;
+    }
+
+    static isRecord(value: StamhoofdFilter): value is { [key: string]: StamhoofdFilter } {
+        if (!this.isRecordOrArray(value) || Array.isArray(value)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    static isRecordWithSingleEntry(value: StamhoofdFilter): value is { [key: string]: StamhoofdFilter } {
+        if (!this.isRecord(value)) {
+            return false;
+        }
+
+        return Object.entries(value).length === 1;
+    }
+
+    static isEmptyRecord(value: StamhoofdFilter): value is { [key: string]: never } {
+        if (!this.isRecord(value)) {
+            return false;
+        }
+
+        return Object.entries(value).length === 0;
+    }
+
+    static hasRegistrationsFilter(filter: StamhoofdFilter): boolean {
+        if (filter === null) {
+            return false;
+        }
+
+        if (typeof filter !== 'object') {
+            return false;
+        }
+
+        if (filter instanceof Date) {
+            return false;
+        }
+
+        if (Array.isArray(filter)) {
+            return filter.some(f => this.hasRegistrationsFilter(f));
+        }
+
+        if (this.isRegistrationFilter(filter)) {
+            return true;
+        }
+
+        // iterate properties
+        for (const [, value] of Object.entries(filter as object) as [string, StamhoofdFilter | StamhoofdCompareValue][]) {
+            if (this.hasRegistrationsFilter(value)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    static isRegistrationFilter(filter: StamhoofdFilter): filter is { registrations: StamhoofdFilter } & StamhoofdFilter {
+        if (!StamhoofdFilterHelper.isRecord(filter)) {
+            return false;
+        }
+
+        return Object.entries(filter).some(entry => entry[0] === 'registrations');
+    }
+}
+
+function hasRegistrationsFilter(filter: StamhoofdFilter): boolean {
+    if (filter === null) {
+        return false;
+    }
+
+    if (typeof filter !== 'object') {
+        return false;
+    }
+
+    if (filter instanceof Date) {
+        return false;
+    }
+
+    if (Array.isArray(filter)) {
+        return filter.some(f => hasRegistrationsFilter(f));
+    }
+
+    if (isRegistrationFilter(filter)) {
+        return true;
+    }
+
+    // iterate properties
+    for (const [, value] of Object.entries(filter as object) as [string, StamhoofdFilter | StamhoofdCompareValue][]) {
+        if (hasRegistrationsFilter(value)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function isRegistrationFilter(filter: StamhoofdFilter): filter is { registrations: StamhoofdFilter } & StamhoofdFilter {
+    if (!StamhoofdFilterHelper.isRecord(filter)) {
+        return false;
+    }
+
+    return Object.entries(filter).some(entry => entry[0] === 'registrations');
+}
+
+function getGroupIdsFromRegistrationsFilter(registrationFilter: { registrations: StamhoofdFilter }): string[] {
+    if (!StamhoofdFilterHelper.isRecordWithSingleEntry(registrationFilter)) {
+        throw new Error('Invalid registration filter: ' + JSON.stringify(registrationFilter));
+    }
+
+    const entries = Object.entries(registrationFilter);
+
+    let currentEntry = entries[0];
+
+    while (true) {
+        const currentKey = currentEntry[0];
+
+        switch (currentKey) {
+            case 'registrations':
+            case '$elemMatch':
+            case '$or':
+            case '$and':
+            case '$not':
+            {
+                break;
+            }
+            default: throw new Error(`Invalid registration filter (currentKey: ${currentKey}): ` + JSON.stringify(registrationFilter));
+        }
+
+        const currentValue = currentEntry[1];
+
+        if (StamhoofdFilterHelper.isRecordWithSingleEntry(currentValue)) {
+            currentEntry = Object.entries(currentValue)[0];
+        } else if (Array.isArray(currentValue)) {
+            return currentValue.map(item => getGroupIdsFromGroupFilters(item));
+        } else {
+            throw new Error('Invalid registration filter: ' + JSON.stringify(registrationFilter));
+        }
+    }
+}
+
+function getGroupIdsFromGroupFilters(filter: StamhoofdFilter) {
+    const groupId = (filter as { group?: { id?: { $eq?: string } } })?.group?.id?.$eq;
+    if (typeof groupId !== 'string') {
+        throw new Error('Invalid group filter: ' + JSON.stringify(filter));
+    }
+    return groupId;
+}
+
+function getGroupIdsFromFilter(filter: StamhoofdFilter): string[] {
+    if (!StamhoofdFilterHelper.isRecordOrArray(filter)) {
+        throw new Error('Invalid filter: ' + JSON.stringify(filter));
+    }
+
+    if (Array.isArray(filter)) {
+        return filter.flatMap(item => getGroupIdsFromFilter(item));
+    }
+
+    const all: string[] = [];
+
+    for (const [key, value] of Object.entries(filter)) {
+        if (key === 'registrations') {
+            all.push(...getGroupIdsFromRegistrationsFilter({ [key]: value }));
+            continue;
+        }
+        if (!StamhoofdFilterHelper.isRecordOrArray(value)) {
+            continue;
+        }
+
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                continue;
+            }
+
+            const isSomeRecordOrArray = value.some(item => StamhoofdFilterHelper.isRecordOrArray(item));
+
+            if (!isSomeRecordOrArray) {
+                continue;
+            }
+
+            for (const item of value) {
+                // ignore null
+                if (item === null) {
+                    continue;
+                }
+
+                const isRecordOrArray = StamhoofdFilterHelper.isRecordOrArray(item);
+                if (!isRecordOrArray) {
+                    throw new Error('Invalid filter: ' + JSON.stringify(filter));
+                }
+
+                all.push(...getGroupIdsFromFilter(item));
+            }
+            continue;
+        }
+
+        all.push(...getGroupIdsFromFilter(value));
+    }
+
+    return all;
+}
+
+async function makeGroupFiltersReadable(filter: StamhoofdFilter, groupMap: Map<string, Group>): Promise<void> {
+    async function getRelationName(group: Group | null | undefined) {
+        if (!group) {
+            return 'Verwijderde groep';
+        }
+
+        const groupName = group.settings.name.toString();
+
+        let period: RegistrationPeriodBase | undefined = undefined;
+
+        // fetch model if no cached period
+        const periodModel = (await RegistrationPeriod.getByID(group.periodId));
+        if (periodModel) {
+            period = periodModel.getBaseStructure();
+        }
+
+        if (period) {
+            return `${groupName} (${period.nameShort})`;
+        }
+
+        return groupName;
+    }
+
+    async function getRelationFilter(filter: StamhoofdFilter, groupMap: Map<string, Group>): Promise<StamhoofdMagicRelationFilter> {
+        const groupId = (filter as { group?: { id?: { $eq?: string } } })?.group?.id?.$eq;
+        if (typeof groupId !== 'string') {
+            throw new Error('Invalid group filter: ' + JSON.stringify(filter));
+        }
+
+        const group = groupMap.get(groupId);
+        if (!group) {
+            // double check if group exists, if not: set custom name
+            const existingGroup = await Group.getByID(groupId);
+            if (existingGroup) {
+                // should never happen
+                throw new Error(`Group with id ${groupId} exists but is not included in the groupMap`);
+            }
+        }
+
+        const relationFilter: StamhoofdMagicRelationFilter = {
+            $: '$rel',
+            value: groupId,
+            type: GroupType.Membership,
+            name: await getRelationName(group),
+        };
+
+        return relationFilter;
+    }
+
+    async function makeRegistrationFilterReadable(registrationFilter: { registrations: StamhoofdFilter }): Promise<void> {
+        if (!StamhoofdFilterHelper.isRecordWithSingleEntry(registrationFilter)) {
+            throw new Error('Invalid registration filter: ' + JSON.stringify(registrationFilter));
+        }
+
+        const entries = Object.entries(registrationFilter);
+
+        let parentFilter: StamhoofdFilter | null = null;
+        let currentEntry = entries[0];
+        const relationFilterArray: StamhoofdMagicRelationFilter[] = [];
+        let orParentFilter: StamhoofdFilter | null = null;
+
+        while (true) {
+            const currentKey = currentEntry[0];
+
+            switch (currentKey) {
+                case '$not':
+                case '$and': {
+                    throw new Error(`${currentKey} not supported`);
+                }
+                case 'registrations':
+                case '$elemMatch':
+                {
+                    break;
+                }
+                case '$or': {
+                    if (!parentFilter) {
+                        throw new Error('Not expected parentFilter to be null: ' + JSON.stringify(registrationFilter));
+                    }
+                    orParentFilter = parentFilter;
+                    break;
+                }
+                default: throw new Error(`Invalid registration filter (currentKey: ${currentKey}): ` + JSON.stringify(registrationFilter));
+            }
+
+            const currentValue = currentEntry[1];
+
+            if (StamhoofdFilterHelper.isRecordWithSingleEntry(currentValue)) {
+                parentFilter = currentEntry[1];
+                currentEntry = Object.entries(currentValue)[0];
+            } else if (Array.isArray(currentValue)) {
+                if (orParentFilter === null) {
+                    throw new Error('Not expected orParentFilter to be null');
+                }
+                for (const item of currentValue) {
+                    const relationFilter = await getRelationFilter(item, groupMap);
+                    relationFilterArray.push(relationFilter);
+                }
+                delete orParentFilter[currentKey];
+                (orParentFilter as any)['groupId'] = {
+                    $in: relationFilterArray,
+                };
+                return;
+            } else {
+                throw new Error('Invalid registration filter: ' + JSON.stringify(registrationFilter));
+            }
+        }
+    }
+
+    if (!StamhoofdFilterHelper.isRecordOrArray(filter)) {
+        throw new Error('Invalid filter: ' + JSON.stringify(filter));
+    }
+
+    if (Array.isArray(filter)) {
+        for (const item of filter) {
+            await makeGroupFiltersReadable(item, groupMap);
+        }
+        return;
+    }
+
+    for (const [key, value] of Object.entries(filter)) {
+        if (key === 'registrations') {
+            await makeRegistrationFilterReadable({ [key]: value });
+            continue;
+        }
+        if (!StamhoofdFilterHelper.isRecordOrArray(value)) {
+            continue;
+        }
+
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                continue;
+            }
+
+            const isSomeRecordOrArray = value.some(item => StamhoofdFilterHelper.isRecordOrArray(item));
+
+            if (!isSomeRecordOrArray) {
+                continue;
+            }
+
+            for (const item of value) {
+                // ignore null
+                if (item === null) {
+                    continue;
+                }
+
+                const isRecordOrArray = StamhoofdFilterHelper.isRecordOrArray(item);
+                if (!isRecordOrArray) {
+                    throw new Error('Invalid filter: ' + JSON.stringify(filter));
+                }
+
+                await makeGroupFiltersReadable(item, groupMap);
+            }
+            continue;
+        }
+
+        await makeGroupFiltersReadable(value, groupMap);
+    }
+}