Merge branch 'feature/uniqueness-of-key-for-relationshipattributes' o…

…f github.com:nmshd/runtime into feature/uniqueness-of-key-for-relationshipattributes

packages/consumption/src/modules/attributes/AttributesController.ts

@@ -16,7 +16,7 @@ import {
 } from "@nmshd/content";
 import { CoreAddress, CoreDate, CoreId, ICoreDate, ICoreId } from "@nmshd/core-types";
 import * as iql from "@nmshd/iql";
-import { SynchronizedCollection, TransportCoreErrors } from "@nmshd/transport";
+import { SynchronizedCollection, TagClient, TransportCoreErrors } from "@nmshd/transport";
 import _ from "lodash";
 import { nameof } from "ts-simple-nameof";
 import { ConsumptionBaseController } from "../../consumption/ConsumptionBaseController";
@@ -35,6 +35,7 @@ import {
     ThirdPartyRelationshipAttributeSucceededEvent
 } from "./events";
 import { AttributeSuccessorParams, AttributeSuccessorParamsJSON, IAttributeSuccessorParams } from "./local/AttributeSuccessorParams";
+import { AttributeTagCollection } from "./local/AttributeTagCollection";
 import { CreateRepositoryAttributeParams, ICreateRepositoryAttributeParams } from "./local/CreateRepositoryAttributeParams";
 import { CreateSharedLocalAttributeCopyParams, ICreateSharedLocalAttributeCopyParams } from "./local/CreateSharedLocalAttributeCopyParams";
 import { ICreateSharedLocalAttributeParams } from "./local/CreateSharedLocalAttributeParams";
@@ -45,6 +46,7 @@ import { IdentityAttributeQueryTranslator, RelationshipAttributeQueryTranslator,
 
 export class AttributesController extends ConsumptionBaseController {
     private attributes: SynchronizedCollection;
+    private attributeTagClient: TagClient;
 
     public constructor(
         parent: ConsumptionController,
@@ -59,6 +61,7 @@ export class AttributesController extends ConsumptionBaseController {
         await super.init();
 
         this.attributes = await this.parent.accountController.getSynchronizedCollection("Attributes");
+        this.attributeTagClient = new TagClient(this.parent.transport.config, this.parent.accountController.authenticator, this.parent.transport.correlator);
 
         return this;
     }
@@ -1308,5 +1311,9 @@ export class AttributesController extends ConsumptionBaseController {
                 ]
             }
         });
+
+    public async getAttributeTagCollection(): Promise<AttributeTagCollection> {
+        const backboneTagCollection = (await this.attributeTagClient.getTagCollection()).value;
+        return AttributeTagCollection.from(backboneTagCollection);
     }
 }

packages/consumption/src/modules/attributes/index.ts

@@ -1,6 +1,7 @@
 export * from "./AttributesController";
 export * from "./events";
 export * from "./local/AttributeSuccessorParams";
+export * from "./local/AttributeTagCollection";
 export * from "./local/CreateRepositoryAttributeParams";
 export * from "./local/CreateSharedLocalAttributeCopyParams";
 export * from "./local/CreateSharedLocalAttributeParams";

packages/consumption/src/modules/attributes/local/AttributeTagCollection.ts

@@ -0,0 +1,37 @@
+import { Serializable, serialize, type, validate } from "@js-soft/ts-serval";
+
+export interface IAttributeTagCollection {
+    supportedLanguages: string[];
+    tagsForAttributeValueTypes: Record<string, Record<string, IAttributeTag>>;
+}
+
+export interface IAttributeTag {
+    displayNames: Record<string, string>;
+    children?: Record<string, IAttributeTag>;
+}
+
+@type("AttributeTagCollection")
+export class AttributeTagCollection extends Serializable implements IAttributeTagCollection {
+    @serialize({ type: String })
+    @validate()
+    public supportedLanguages: string[];
+
+    @serialize()
+    @validate()
+    public tagsForAttributeValueTypes: Record<string, Record<string, AttributeTag>>;
+
+    public static from(value: IAttributeTagCollection): AttributeTagCollection {
+        return this.fromAny(value);
+    }
+}
+
+@type("AttributeTag")
+export class AttributeTag extends Serializable implements IAttributeTag {
+    @serialize()
+    @validate()
+    public displayNames: Record<string, string>;
+
+    @serialize()
+    @validate({ nullable: true })
+    public children?: Record<string, AttributeTag>;
+}

packages/consumption/test/modules/attributes/AttributeTagCollection.test.ts

@@ -0,0 +1,77 @@
+import { IDatabaseConnection } from "@js-soft/docdb-access-abstractions";
+import { AccountController, ClientResult, TagClient, Transport } from "@nmshd/transport";
+import { spy, when } from "ts-mockito";
+import { AttributeTagCollection, ConsumptionController } from "../../../src";
+import { TestUtil } from "../../core/TestUtil";
+
+describe("AttributeTagCollection", function () {
+    let connection: IDatabaseConnection;
+
+    let transport: Transport;
+
+    let consumptionController: ConsumptionController;
+    let accountController: AccountController;
+
+    let mockedClient: TagClient;
+
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const mockTags = {
+        supportedLanguages: ["de", "en"],
+        tagsForAttributeValueTypes: {
+            PhoneNumber: {
+                emergency: {
+                    displayNames: {
+                        de: "Notfallkontakt",
+                        en: "Emergency Contact"
+                    },
+                    children: {
+                        first: {
+                            displayNames: {
+                                de: "Erster Notfallkontakt",
+                                en: "First Emergency Contact"
+                            }
+                        },
+                        second: {
+                            displayNames: {
+                                de: "Zweiter Notfallkontakt",
+                                en: "Second Emergency Contact"
+                            }
+                        }
+                    }
+                },
+                private: {
+                    displayNames: {
+                        de: "Privat",
+                        en: "Private"
+                    }
+                }
+            }
+        }
+    };
+    /* eslint-enable @typescript-eslint/naming-convention */
+
+    beforeAll(async function () {
+        connection = await TestUtil.createConnection();
+        transport = TestUtil.createTransport(connection);
+
+        await transport.init();
+
+        ({ consumptionController, accountController } = (await TestUtil.provideAccounts(transport, 1))[0]);
+
+        const client = consumptionController.attributes["attributeTagClient"];
+        mockedClient = spy(client);
+    });
+
+    afterAll(async function () {
+        await accountController.close();
+
+        await connection.close();
+    });
+
+    test("should receive the legal tags from the Backbone", async function () {
+        when(mockedClient.getTagCollection()).thenResolve(ClientResult.ok(mockTags));
+        const tags = await consumptionController.attributes.getAttributeTagCollection();
+
+        expect(tags).toStrictEqual(AttributeTagCollection.from(mockTags));
+    });
+});

packages/runtime/src/extensibility/TransportServices.ts

@@ -14,15 +14,15 @@ import {
 
 export class TransportServices {
     public constructor(
+        @Inject public readonly account: AccountFacade,
+        @Inject public readonly challenges: ChallengesFacade,
+        @Inject public readonly devices: DevicesFacade,
         @Inject public readonly files: FilesFacade,
+        @Inject public readonly identityDeletionProcesses: IdentityDeletionProcessesFacade,
         @Inject public readonly messages: MessagesFacade,
+        @Inject public readonly publicRelationshipTemplateReferences: PublicRelationshipTemplateReferencesFacade,
         @Inject public readonly relationships: RelationshipsFacade,
         @Inject public readonly relationshipTemplates: RelationshipTemplatesFacade,
-        @Inject public readonly tokens: TokensFacade,
-        @Inject public readonly account: AccountFacade,
-        @Inject public readonly devices: DevicesFacade,
-        @Inject public readonly challenges: ChallengesFacade,
-        @Inject public readonly identityDeletionProcesses: IdentityDeletionProcessesFacade,
-        @Inject public readonly publicRelationshipTemplateReferences: PublicRelationshipTemplateReferencesFacade
+        @Inject public readonly tokens: TokensFacade
     ) {}
 }

packages/runtime/src/extensibility/facades/consumption/AttributesFacade.ts

@@ -1,6 +1,6 @@
 import { Result } from "@js-soft/ts-utils";
 import { Inject } from "@nmshd/typescript-ioc";
-import { LocalAttributeDTO, LocalRequestDTO } from "../../../types";
+import { AttributeTagCollectionDTO, LocalAttributeDTO, LocalRequestDTO } from "../../../types";
 import {
     ChangeDefaultRepositoryAttributeRequest,
     ChangeDefaultRepositoryAttributeUseCase,
@@ -30,6 +30,7 @@ import {
     ExecuteThirdPartyRelationshipAttributeQueryRequest,
     ExecuteThirdPartyRelationshipAttributeQueryUseCase,
     GetAttributeRequest,
+    GetAttributeTagCollectionUseCase,
     GetAttributeUseCase,
     GetAttributesRequest,
     GetAttributesUseCase,
@@ -84,7 +85,8 @@ export class AttributesFacade {
         @Inject private readonly deletePeerSharedAttributeAndNotifyOwnerUseCase: DeletePeerSharedAttributeAndNotifyOwnerUseCase,
         @Inject private readonly deleteThirdPartyRelationshipAttributeAndNotifyPeerUseCase: DeleteThirdPartyRelationshipAttributeAndNotifyPeerUseCase,
         @Inject private readonly deleteRepositoryAttributeUseCase: DeleteRepositoryAttributeUseCase,
-        @Inject private readonly deleteSharedAttributesForRejectedOrRevokedRelationshipUseCase: DeleteSharedAttributesForRejectedOrRevokedRelationshipUseCase
+        @Inject private readonly deleteSharedAttributesForRejectedOrRevokedRelationshipUseCase: DeleteSharedAttributesForRejectedOrRevokedRelationshipUseCase,
+        @Inject private readonly getAttributeTagCollectionUseCase: GetAttributeTagCollectionUseCase
     ) {}
 
     public async createRepositoryAttribute(request: CreateRepositoryAttributeRequest): Promise<Result<LocalAttributeDTO>> {
@@ -199,4 +201,8 @@ export class AttributesFacade {
     public async deleteSharedAttributesForRejectedOrRevokedRelationship(request: DeleteSharedAttributesForRejectedOrRevokedRelationshipRequest): Promise<Result<void>> {
         return await this.deleteSharedAttributesForRejectedOrRevokedRelationshipUseCase.execute(request);
     }
+
+    public async getAttributeTagCollection(): Promise<Result<AttributeTagCollectionDTO>> {
+        return await this.getAttributeTagCollectionUseCase.execute();
+    }
 }

packages/runtime/src/types/consumption/AttributeTagCollectionDTO.ts

@@ -0,0 +1,9 @@
+export interface AttributeTagCollectionDTO {
+    supportedLanguages: string[];
+    tagsForAttributeValueTypes: Record<string, Record<string, AttributeTagDTO>>;
+}
+
+export interface AttributeTagDTO {
+    displayNames: Record<string, string>;
+    children?: Record<string, AttributeTagDTO>;
+}

packages/runtime/src/types/consumption/index.ts

@@ -1,3 +1,4 @@
+export * from "./AttributeTagCollectionDTO";
 export * from "./DraftDTO";
 export * from "./IdentityMetadataDTO";
 export * from "./LocalAttributeDTO";

packages/runtime/src/useCases/consumption/attributes/AttributeTagCollectionMapper.ts

@@ -0,0 +1,39 @@
+import { AttributeTag, AttributeTagCollection } from "@nmshd/consumption";
+import { AttributeTagCollectionDTO, AttributeTagDTO } from "../../../types";
+
+export class AttributeTagCollectionMapper {
+    public static toAttributeTagCollectionDTO(tagList: AttributeTagCollection): AttributeTagCollectionDTO {
+        return {
+            supportedLanguages: tagList.supportedLanguages,
+            tagsForAttributeValueTypes: Object.entries(tagList.tagsForAttributeValueTypes).reduce(
+                (acc, [key, value]) => {
+                    acc[key] = Object.entries(value).reduce(
+                        (acc2, [key2, value2]) => {
+                            acc2[key2] = AttributeTagCollectionMapper.toAttributeTagDTO(value2);
+                            return acc2;
+                        },
+                        {} as Record<string, AttributeTagDTO>
+                    );
+                    return acc;
+                },
+                {} as Record<string, Record<string, AttributeTagDTO>>
+            )
+        };
+    }
+
+    public static toAttributeTagDTO(tagListDTO: AttributeTag): AttributeTagDTO {
+        const tagDTO: AttributeTagDTO = {
+            displayNames: tagListDTO.displayNames
+        };
+        if (tagListDTO.children) {
+            tagDTO.children = Object.entries(tagListDTO.children).reduce(
+                (acc, [key, value]) => {
+                    acc[key] = AttributeTagCollectionMapper.toAttributeTagDTO(value);
+                    return acc;
+                },
+                {} as Record<string, AttributeTagDTO>
+            );
+        }
+        return tagDTO;
+    }
+}

packages/runtime/src/useCases/consumption/attributes/GetAttributeTagCollection.ts

@@ -0,0 +1,17 @@
+import { Result } from "@js-soft/ts-utils";
+import { AttributesController } from "@nmshd/consumption";
+import { Inject } from "@nmshd/typescript-ioc";
+import { AttributeTagCollectionDTO } from "../../../types";
+import { UseCase } from "../../common";
+import { AttributeTagCollectionMapper } from "./AttributeTagCollectionMapper";
+
+export class GetAttributeTagCollectionUseCase extends UseCase<void, AttributeTagCollectionDTO> {
+    public constructor(@Inject private readonly attributesController: AttributesController) {
+        super();
+    }
+
+    protected async executeInternal(): Promise<Result<AttributeTagCollectionDTO>> {
+        const attributeTagCollection = await this.attributesController.getAttributeTagCollection();
+        return Result.ok(AttributeTagCollectionMapper.toAttributeTagCollectionDTO(attributeTagCollection));
+    }
+}

packages/runtime/src/useCases/consumption/attributes/index.ts

@@ -1,4 +1,5 @@
 export * from "./AttributeMapper";
+export * from "./AttributeTagCollectionMapper";
 export * from "./ChangeDefaultRepositoryAttribute";
 export * from "./CreateAndShareRelationshipAttribute";
 export * from "./CreateRepositoryAttribute";
@@ -13,6 +14,7 @@ export * from "./ExecuteRelationshipAttributeQuery";
 export * from "./ExecuteThirdPartyRelationshipAttributeQuery";
 export * from "./GetAttribute";
 export * from "./GetAttributes";
+export * from "./GetAttributeTagCollection";
 export * from "./GetOwnSharedAttributes";
 export * from "./GetPeerSharedAttributes";
 export * from "./GetRepositoryAttributes";

packages/runtime/test/consumption/attributeTagCollection.test.ts

@@ -0,0 +1,65 @@
+import { ClientResult, TagClient } from "@nmshd/transport";
+import { reset, spy, when } from "ts-mockito";
+import { RuntimeServiceProvider, TestRuntimeServices } from "../lib";
+
+const serviceProvider = new RuntimeServiceProvider();
+let runtimeService: TestRuntimeServices;
+
+let mockedRestClient: TagClient;
+
+beforeAll(async () => {
+    runtimeService = (await serviceProvider.launch(1))[0];
+    const client = runtimeService.consumption.attributes["getAttributeTagCollectionUseCase"]["attributesController"]["attributeTagClient"] as TagClient;
+    mockedRestClient = spy(client);
+}, 30000);
+
+afterAll(() => serviceProvider.stop());
+
+afterEach(() => {
+    reset(mockedRestClient);
+});
+
+describe("get attributeTagCollection", function () {
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const mockTags = {
+        supportedLanguages: ["de", "en"],
+        tagsForAttributeValueTypes: {
+            PhoneNumber: {
+                emergency: {
+                    displayNames: {
+                        de: "Notfallkontakt",
+                        en: "Emergency Contact"
+                    },
+                    children: {
+                        first: {
+                            displayNames: {
+                                de: "Erster Notfallkontakt",
+                                en: "First Emergency Contact"
+                            }
+                        },
+                        second: {
+                            displayNames: {
+                                de: "Zweiter Notfallkontakt",
+                                en: "Second Emergency Contact"
+                            }
+                        }
+                    }
+                },
+                private: {
+                    displayNames: {
+                        de: "Privat",
+                        en: "Private"
+                    }
+                }
+            }
+        }
+    };
+    /* eslint-enable @typescript-eslint/naming-convention */
+
+    test("should receive the legal tags from the Backbone", async function () {
+        when(mockedRestClient.getTagCollection()).thenResolve(ClientResult.ok(mockTags));
+        const tags = await runtimeService.consumption.attributes.getAttributeTagCollection();
+
+        expect(tags.value).toStrictEqual(mockTags);
+    });
+});

packages/transport/src/modules/index.ts

@@ -115,6 +115,8 @@ export * from "./sync/DatawalletModificationsProcessor";
 export * from "./sync/local/DatawalletModification";
 export * from "./sync/SyncController";
 export * from "./sync/SynchronizedCollection";
+export * from "./tags/backbone/BackboneGetTagCollection";
+export * from "./tags/backbone/TagClient";
 export * from "./tokens/AnonymousTokenController";
 export * from "./tokens/backbone/BackboneGetTokens";
 export * from "./tokens/backbone/BackbonePostTokens";

packages/transport/src/modules/tags/backbone/BackboneGetTagCollection.ts

@@ -0,0 +1,9 @@
+export interface BackboneGetTagCollection {
+    supportedLanguages: string[];
+    tagsForAttributeValueTypes: Record<string, Record<string, BackboneGetTag>>;
+}
+
+interface BackboneGetTag {
+    displayNames: Record<string, string>;
+    children?: Record<string, BackboneGetTag>;
+}