Query RelationshipTemplates for password protection

packages/runtime/src/useCases/common/Schemas.ts

@@ -22756,6 +22756,26 @@ export const GetRelationshipTemplatesRequest: any = {
                             }
                         }
                     ]
+                },
+                "passwordProtection.password": {
+                    "anyOf": [
+                        {
+                            "type": "string"
+                        },
+                        {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        }
+                    ]
+                },
+                "passwordProtection.passwordIsPin": {
+                    "type": "string",
+                    "enum": [
+                        "true",
+                        "!"
+                    ]
                 }
             },
             "additionalProperties": false

packages/runtime/src/useCases/transport/relationshipTemplates/GetRelationshipTemplates.ts

@@ -1,6 +1,6 @@
 import { QueryTranslator } from "@js-soft/docdb-querytranslator";
 import { Result } from "@js-soft/ts-utils";
-import { CachedRelationshipTemplate, RelationshipTemplate, RelationshipTemplateController } from "@nmshd/transport";
+import { CachedRelationshipTemplate, PasswordProtection, RelationshipTemplate, RelationshipTemplateController } from "@nmshd/transport";
 import { Inject } from "@nmshd/typescript-ioc";
 import { nameof } from "ts-simple-nameof";
 import { RelationshipTemplateDTO } from "../../../types";
@@ -15,6 +15,8 @@ export interface GetRelationshipTemplatesQuery {
     createdByDevice?: string | string[];
     maxNumberOfAllocations?: string | string[];
     forIdentity?: string | string[];
+    "passwordProtection.password"?: string | string[];
+    "passwordProtection.passwordIsPin"?: "true" | "!";
 }
 
 export interface GetRelationshipTemplatesRequest {
@@ -37,7 +39,9 @@ export class GetRelationshipTemplatesUseCase extends UseCase<GetRelationshipTemp
             [nameof<RelationshipTemplateDTO>((r) => r.createdBy)]: true,
             [nameof<RelationshipTemplateDTO>((r) => r.createdByDevice)]: true,
             [nameof<RelationshipTemplateDTO>((r) => r.maxNumberOfAllocations)]: true,
-            [nameof<RelationshipTemplateDTO>((r) => r.forIdentity)]: true
+            [nameof<RelationshipTemplateDTO>((r) => r.forIdentity)]: true,
+            [`${nameof<RelationshipTemplateDTO>((r) => r.passwordProtection)}.password`]: true,
+            [`${nameof<RelationshipTemplateDTO>((r) => r.passwordProtection)}.passwordIsPin`]: true
         },
         alias: {
             [nameof<RelationshipTemplateDTO>((r) => r.isOwn)]: nameof<RelationshipTemplate>((r) => r.isOwn),
@@ -51,6 +55,23 @@ export class GetRelationshipTemplatesUseCase extends UseCase<GetRelationshipTemp
                 (t) => t.maxNumberOfAllocations
             )}`,
             [nameof<RelationshipTemplateDTO>((r) => r.forIdentity)]: `${nameof<RelationshipTemplate>((r) => r.cache)}.${nameof<CachedRelationshipTemplate>((t) => t.forIdentity)}`
+        },
+        custom: {
+            [`${nameof<RelationshipTemplateDTO>((r) => r.passwordProtection)}.password`]: (query: any, input: string) => {
+                query[`${nameof<RelationshipTemplate>((t) => t.passwordProtection)}.${nameof<PasswordProtection>((t) => t.password)}`] = input;
+            },
+            [`${nameof<RelationshipTemplateDTO>((t) => t.passwordProtection)}.passwordIsPin`]: (query: any, input: string) => {
+                if (input === "true") {
+                    query[`${nameof<RelationshipTemplate>((t) => t.passwordProtection)}.${nameof<PasswordProtection>((t) => t.passwordType)}`] = {
+                        $regex: "^pin"
+                    };
+                }
+                if (input === "!") {
+                    query[`${nameof<RelationshipTemplate>((t) => t.passwordProtection)}.${nameof<PasswordProtection>((t) => t.passwordType)}`] = {
+                        $in: ["pw", undefined]
+                    };
+                }
+            }
         }
     });
 

packages/runtime/test/transport/relationshipTemplates.test.ts

@@ -1,7 +1,7 @@
 import { RelationshipTemplateContent, RelationshipTemplateContentJSON } from "@nmshd/content";
 import { DateTime } from "luxon";
 import { GetRelationshipTemplatesQuery, OwnerRestriction } from "../../src";
-import { emptyRelationshipTemplateContent, QueryParamConditions, RuntimeServiceProvider, TestRuntimeServices } from "../lib";
+import { createTemplate, emptyRelationshipTemplateContent, QueryParamConditions, RuntimeServiceProvider, TestRuntimeServices } from "../lib";
 
 const serviceProvider = new RuntimeServiceProvider();
 let runtimeServices1: TestRuntimeServices;
@@ -327,4 +327,54 @@ describe("RelationshipTemplates query", () => {
 
         await conditions.executeTests((c, q) => c.relationshipTemplates.getRelationshipTemplates({ query: q, ownerRestriction: OwnerRestriction.Peer }));
     });
+
+    test("password query with password", async () => {
+        const passwordProtectedTemplate = await createTemplate(runtimeServices1.transport, undefined, { password: "password" });
+
+        const conditions = new QueryParamConditions<GetRelationshipTemplatesQuery>(passwordProtectedTemplate, runtimeServices1.transport).addStringSet(
+            "passwordProtection.password"
+        );
+        await conditions.executeTests((c, q) => c.relationshipTemplates.getRelationshipTemplates({ query: q }));
+    });
+
+    test("password query with pin", async () => {
+        const pinProtectedTemplate = await createTemplate(runtimeServices1.transport, undefined, { password: "1234", passwordIsPin: true });
+
+        const conditions = new QueryParamConditions<GetRelationshipTemplatesQuery>(pinProtectedTemplate, runtimeServices1.transport).addStringSet("passwordProtection.password");
+        await conditions.executeTests((c, q) => c.relationshipTemplates.getRelationshipTemplates({ query: q }));
+    });
+
+    test("passwordIsPin query", async () => {
+        const passwordProtectedTemplate = await createTemplate(runtimeServices1.transport, undefined, { password: "password" });
+
+        const pinProtectedTemplate = await createTemplate(runtimeServices1.transport, undefined, { password: "1234", passwordIsPin: true });
+
+        const unprotectedTemplate = await createTemplate(runtimeServices1.transport);
+
+        const templatesWithoutPin = (
+            await runtimeServices1.transport.relationshipTemplates.getRelationshipTemplates({
+                query: {
+                    "passwordProtection.passwordIsPin": "!"
+                }
+            })
+        ).value;
+        const templateIdsWithoutPin = templatesWithoutPin.map((t) => t.id);
+
+        expect(templateIdsWithoutPin).toContain(passwordProtectedTemplate.id);
+        expect(templateIdsWithoutPin).not.toContain(pinProtectedTemplate.id);
+        expect(templateIdsWithoutPin).toContain(unprotectedTemplate.id);
+
+        const templatesWithPin = (
+            await runtimeServices1.transport.relationshipTemplates.getRelationshipTemplates({
+                query: {
+                    "passwordProtection.passwordIsPin": "true"
+                }
+            })
+        ).value;
+        const templateIdsWithPin = templatesWithPin.map((t) => t.id);
+
+        expect(templateIdsWithPin).not.toContain(passwordProtectedTemplate.id);
+        expect(templateIdsWithPin).toContain(pinProtectedTemplate.id);
+        expect(templateIdsWithPin).not.toContain(unprotectedTemplate.id);
+    });
 });