Consumer API: Password-protected RelationshipTemplates

Applications/ConsumerApi/test/ConsumerApi.Tests.Integration/Features/RelationshipTemplates/GET.feature

@@ -0,0 +1,47 @@
+@Integration
+Feature: GET /RelationshipTemplates
+
+User requests Relationship Templates
+
+	Scenario Outline: Requesting a list of Relationship Templates in a variety of scenarios
+		Given Identities i1, i2, i3 and i4
+		And the following Relationship Templates
+			| rTempName | rTempOwner | forIdentity | password |
+			| rt1       | i1         | -           | -        |
+			| rt2       | i2         | -           | -        |
+			| rt3       | i1         | -           | -        |
+			| rt4       | i2         | -           | -        |
+			| rt5       | i1         | -           | password |
+			| rt6       | i1         | -           | password |
+			| rt7       | i2         | -           | password |
+			| rt8       | i2         | -           | password |
+			| rt9       | i1         | i1          | -        |
+			| rt10      | i2         | i3          | -        |
+			| rt11      | i2         | i2          | -        |
+			| rt12      | i2         | i3          | -        |
+			| rt13      | i2         | i3          | password |
+			| rt14      | i2         | i3          | password |
+		When <activeIdentity> sends a GET request to the /RelationshipTemplate endpoint with the following payloads
+			| rTempName | passwordOnGet |
+			| rt1       | -             |
+			| rt2       | -             |
+			| rt3       | password      |
+			| rt4       | password      |
+			| rt5       | password      |
+			| rt6       | -             |
+			| rt7       | password      |
+			| rt8       | -             |
+			| rt9       | -             |
+			| rt10      | -             |
+			| rt11      | -             |
+			| rt12      | -             |
+			| rt13      | password      |
+			| rt14      | wordpass      |
+		Then the response contains Relationship Template(s) <retreivedTemplates>
+
+	Examples:
+		| activeIdentity | retreivedTemplates                                              |
+		| i1             | rt1, rt2, rt3, rt4, rt5, rt6, rt7, rt9                          |
+		| i2             | rt1, rt2, rt3, rt4, rt5, rt7, rt8, rt10, rt11, rt12, rt13, rt14 |
+		| i3             | rt1, rt2, rt3, rt4, rt5, rt7, rt10, rt12, rt13                  |
+		| i4             | rt1, rt2, rt3, rt4, rt5, rt7                                    |

Applications/ConsumerApi/test/ConsumerApi.Tests.Integration/Features/RelationshipTemplates/POST.feature

@@ -8,3 +8,14 @@ User creates a Relationship Template
 		When i sends a POST request to the /RelationshipTemplates endpoint
 		Then the response status code is 201 (Created)
         And the response contains a RelationshipMetadata
+
+	Scenario: Creating a relationship template with a password
+		Given Identity i
+		When i sends a POST request to the /RelationshipTemplates endpoint with the password "my-password"
+		Then the response status code is 201 (Created)
+        And the response contains a RelationshipMetadata
+
+	Scenario: Create a personalized Relationship Template with a password
+		Given Identities i1 and i2
+		When i1 sends a POST request to the /RelationshipTemplate endpoint with password "my-password" and forIdentity i2
+		Then the response status code is 201 (Created)

Applications/ConsumerApi/test/ConsumerApi.Tests.Integration/Features/RelationshipTemplates/{id}/GET.feature

@@ -3,22 +3,26 @@ Feature: GET /RelationshipTemplates/{id}
 
 User requests a Relationship Template
 
-	Scenario: Requesting a Relationship Template with ForIdentity created for me
-		Given Identities i1 and i2
-		And Relationship Template rt created by i1 where ForIdentity is the address of i2
-		When i2 sends a GET request to the /RelationshipTemplates/{id} endpoint with rt.Id
-		Then the response status code is 200 (Ok)
-		And the response contains a rt 
+    Scenario Outline: Requesting a Relationship Template in a variety of scenarios
+        Given Identities <givenIdentities>
+        And Relationship Template rt created by <rTempOwner> with password "<password>" and forIdentity <forIdentity>
+        When <activeIdentity> sends a GET request to the /RelationshipTemplate/rt.Id endpoint with password "<passwordOnGet>"
+        Then the response status code is <responseStatusCode>
 
-	Scenario: Requesting a Relationship Template with ForIdentity created by me
-		Given Identities i1 and i2 
-		And Relationship Template rt created by i1 where ForIdentity is the address of i2 
-		When i1 sends a GET request to the /RelationshipTemplates/{id} endpoint with rt.Id
-		Then the response status code is 200 (Ok) 
-		And the response contains a rt
-
-	Scenario: Requesting a Relationship Template with ForIdentity created for someone else
-		Given Identities i1, i2 and i3
-		And Relationship Template rt created by i1 where ForIdentity is the address of i2
-		When i3 sends a GET request to the /RelationshipTemplates/{id} endpoint with rt.Id
-		Then the response status code is 404 (Not Found)
+        Examples:
+          | givenIdentities | rTempOwner | forIdentity | password | activeIdentity | passwordOnGet | responseStatusCode | description                                                       |
+          | i               | i          | -           | -        | i              | -             | 200 (OK)           | owner tries to get                                                |
+          | i1 and i2       | i1         | -           | -        | i2             | -             | 200 (OK)           | non-owner tries to get                                            |
+          | i               | i          | -           | -        | i              | password      | 200 (OK)           | owner passes password even though none is set                     |
+          | i1 and i2       | i1         | -           | -        | i2             | password      | 200 (OK)           | non-owner identity passes password even though none is set        |
+          | i               | i          | -           | password | i              | password      | 200 (OK)           | owner passes correct password                                     |
+          | i               | i          | -           | password | i              | -             | 200 (OK)           | owner doesn't pass password, even though one is set               |
+          | i1 and i2       | i1         | -           | password | i2             | password      | 200 (OK)           | non-owner identity passes correct password                        |
+          | i1 and i2       | i1         | -           | password | i2             | -             | 404 (Not Found)    | non-owner identity passes no password even though one is set      |
+          | i               | i          | i           | -        | i              | -             | 200 (OK)           | owner is forIdentity and tries to get                             |
+          | i1 and i2       | i1         | i2          | -        | i1             | -             | 200 (OK)           | non-owner is forIdentity, creator tries to get                    |
+          | i1 and i2       | i1         | i1          | -        | i2             | -             | 404 (Not Found)    | owner is forIdentity and non-owner tries to get                   |
+          | i1 and i2       | i1         | i2          | -        | i2             | -             | 200 (OK)           | non-owner is forIdentity and tries to get                         |
+          | i1 and i2       | i1         | i2          | password | i2             | password      | 200 (OK)           | non-owner is forIdentity and tries to get with correct password   |
+          | i1 and i2       | i1         | i2          | password | i2             | wordpass      | 404 (Not Found)    | non-owner is forIdentity and tries to get with incorrect password |
+          | i1, i2 and i3   | i1         | i2          | password | i3             | password      | 404 (Not Found)    | non-owner is forIdentity, and thirdParty tries to get             |

Applications/ConsumerApi/test/ConsumerApi.Tests.Integration/Helpers/RegexFor.cs

@@ -3,5 +3,6 @@
 public static class RegexFor
 {
     public const string SINGLE_THING = "([a-zA-Z0-9]+)";
+    public const string OPTIONAL_SINGLE_THING = "([a-zA-Z0-9-]+)";
     public const string LIST_OF_THINGS = "([a-zA-Z0-9, ]+)";
 }

Applications/ConsumerApi/test/ConsumerApi.Tests.Integration/StepDefinitions/RelationshipTemplatesStepDefinitions.cs

@@ -1,6 +1,13 @@
-using Backbone.ConsumerApi.Sdk.Endpoints.RelationshipTemplates.Types.Requests;
+using System.Text;
+using Backbone.BuildingBlocks.SDK.Endpoints.Common.Types;
+using Backbone.ConsumerApi.Sdk.Endpoints.RelationshipTemplates.Types.Requests;
+using Backbone.ConsumerApi.Sdk.Endpoints.RelationshipTemplates.Types.Responses;
 using Backbone.ConsumerApi.Tests.Integration.Contexts;
 using Backbone.ConsumerApi.Tests.Integration.Helpers;
+using TechTalk.SpecFlow.Assist;
+
+// ReSharper disable ClassNeverInstantiated.Local
+// ReSharper disable UnusedAutoPropertyAccessor.Local
 
 namespace Backbone.ConsumerApi.Tests.Integration.StepDefinitions;
 
@@ -13,6 +20,8 @@ internal class RelationshipTemplatesStepDefinitions
     private readonly RelationshipTemplatesContext _relationshipTemplatesContext;
     private readonly ClientPool _clientPool;
 
+    private ApiResponse<ListRelationshipTemplatesResponse>? _listRelationshipTemplatesResponse;
+
     public RelationshipTemplatesStepDefinitions(ResponseContext responseContext, RelationshipTemplatesContext relationshipTemplatesContext, ClientPool clientPool)
     {
         _responseContext = responseContext;
@@ -24,18 +33,37 @@ public RelationshipTemplatesStepDefinitions(ResponseContext responseContext, Rel
 
     #region Given
 
-    [Given($"Relationship Template {RegexFor.SINGLE_THING} created by {RegexFor.SINGLE_THING} where ForIdentity is the address of {RegexFor.SINGLE_THING}")]
-    public async Task GivenRelationshipTemplateCreatedByIWhereForIdentityIsTheAddressOfI(string relationshipTemplateName, string identityName, string forIdentityName)
+    [Given($@"Relationship Template {RegexFor.SINGLE_THING} created by {RegexFor.SINGLE_THING} with password ""([^""]*)"" and forIdentity {RegexFor.OPTIONAL_SINGLE_THING}")]
+    public async Task GivenRelationshipTemplateCreatedByTokenOwnerWithPasswordAndForIdentity(string relationshipTemplateName, string identityName, string passwordString, string forIdentityName)
     {
         var client = _clientPool.FirstForIdentityName(identityName);
-        var forClient = _clientPool.FirstForIdentityName(forIdentityName);
+        var forClient = forIdentityName != "-" ? _clientPool.FirstForIdentityName(forIdentityName).IdentityData!.Address : null;
+        var password = passwordString.Trim() != "-" ? Convert.FromBase64String(passwordString.Trim()) : null;
 
         var response = await client.RelationshipTemplates
-            .CreateTemplate(new CreateRelationshipTemplateRequest { Content = TestData.SOME_BYTES, ForIdentity = forClient.IdentityData!.Address });
+            .CreateTemplate(new CreateRelationshipTemplateRequest { Content = TestData.SOME_BYTES, ForIdentity = forClient, Password = password });
 
         _relationshipTemplatesContext.CreateRelationshipTemplatesResponses[relationshipTemplateName] = response.Result!;
     }
 
+    [Given(@"the following Relationship Templates")]
+    public async Task GivenRelationshipTemplatesWithTheFollowingProperties(Table table)
+    {
+        var relationshipTemplatePropertiesSet = table.CreateSet<RelationshipTemplateProperties>();
+
+        foreach (var relationshipTemplateProperties in relationshipTemplatePropertiesSet)
+        {
+            var client = _clientPool.FirstForIdentityName(relationshipTemplateProperties.RTempOwner);
+            var forClient = relationshipTemplateProperties.ForIdentity != "-" ? _clientPool.FirstForIdentityName(relationshipTemplateProperties.ForIdentity).IdentityData!.Address : null;
+            var password = relationshipTemplateProperties.Password.Trim() != "-" ? Convert.FromBase64String(relationshipTemplateProperties.Password.Trim()) : null;
+
+            var response = await client.RelationshipTemplates
+                .CreateTemplate(new CreateRelationshipTemplateRequest { Content = TestData.SOME_BYTES, ForIdentity = forClient, Password = password });
+
+            _relationshipTemplatesContext.CreateRelationshipTemplatesResponses[relationshipTemplateProperties.RTempName] = response.Result!;
+        }
+    }
+
     #endregion
 
     #region When
@@ -45,19 +73,85 @@ public async Task WhenIdentitySendsAPostRequestToTheRelationshipTemplatesEndpoin
     {
         var client = _clientPool.FirstForIdentityName(identityName);
 
-        _responseContext.WhenResponse = await client.RelationshipTemplates.CreateTemplate(new CreateRelationshipTemplateRequest { Content = TestData.SOME_BYTES });
+        _responseContext.WhenResponse = await client.RelationshipTemplates.CreateTemplate(
+            new CreateRelationshipTemplateRequest { Content = TestData.SOME_BYTES });
+    }
+
+    [When($@"{RegexFor.SINGLE_THING} sends a POST request to the /RelationshipTemplates endpoint with the password ""(.*)""")]
+    public async Task WhenIdentitySendsAPostRequestToTheRelationshipTemplatesEndpointWithThePassword(string identityName, string passwordString)
+    {
+        var client = _clientPool.FirstForIdentityName(identityName);
+        var password = Encoding.UTF8.GetBytes(passwordString);
+
+        _responseContext.WhenResponse = await client.RelationshipTemplates.CreateTemplate(
+            new CreateRelationshipTemplateRequest { Content = TestData.SOME_BYTES, Password = password });
+    }
+
+    [When($@"{RegexFor.SINGLE_THING} sends a POST request to the /RelationshipTemplate endpoint with password ""(.*)"" and forIdentity {RegexFor.SINGLE_THING}")]
+    public async Task WhenIdentitySendsAPostRequestToTheRelationshipTemplatesEndpointWithPasswordAndForIdentity(string identityName, string passwordString, string forIdentityName)
+    {
+        var client = _clientPool.FirstForIdentityName(identityName);
+        var forClient = _clientPool.FirstForIdentityName(forIdentityName);
+        var password = Encoding.UTF8.GetBytes(passwordString);
+
+        _responseContext.WhenResponse = await client.RelationshipTemplates.CreateTemplate(
+            new CreateRelationshipTemplateRequest { Content = TestData.SOME_BYTES, ForIdentity = forClient.IdentityData!.Address, Password = password });
     }
 
-    [When($"{RegexFor.SINGLE_THING} sends a GET request to the /RelationshipTemplates/{{id}} endpoint with {RegexFor.SINGLE_THING}.Id")]
-    public async Task WhenISendsAGetRequestToTheRelationshipTemplatesIdEndpointWithId(string identityName, string relationshipTemplateName)
+    [When($@"{RegexFor.SINGLE_THING} sends a GET request to the /RelationshipTemplate/{RegexFor.SINGLE_THING}.Id endpoint with password ""([^""]*)""")]
+    public async Task WhenIdentitySendsAGetRequestToTheRelationshipTemplatesIdEndpointWithPassword(string identityName, string relationshipTemplateName, string password)
     {
         var client = _clientPool.FirstForIdentityName(identityName);
 
         var relationshipTemplateId = _relationshipTemplatesContext.CreateRelationshipTemplatesResponses[relationshipTemplateName].Id;
 
-        _responseContext.WhenResponse = await client.RelationshipTemplates.GetTemplate(relationshipTemplateId);
+        _responseContext.WhenResponse = password != "-"
+            ? await client.RelationshipTemplates.GetTemplate(relationshipTemplateId, Convert.FromBase64String(password.Trim()))
+            : await client.RelationshipTemplates.GetTemplate(relationshipTemplateId);
     }
 
+    [When($@"{RegexFor.SINGLE_THING} sends a GET request to the /RelationshipTemplate endpoint with the following payloads")]
+    public async Task WhenISendsAGETRequestToTheRelationshipTemplateEndpointWithTheFollowingPayloads(string identityName, Table table)
+    {
+        var client = _clientPool.FirstForIdentityName(identityName);
+
+        var getRequestPayloadSet = table.CreateSet<GetRequestPayload>();
+
+        var queries = getRequestPayloadSet.Select(payload =>
+        {
+            var relationshipTemplateId = _relationshipTemplatesContext.CreateRelationshipTemplatesResponses[payload.RTempName].Id;
+            var password = payload.PasswordOnGet == "-" ? null : Convert.FromBase64String(payload.PasswordOnGet.Trim());
+
+            return new RelationshipTemplateQuery { Id = relationshipTemplateId, Password = password };
+        }).ToList();
+
+        _responseContext.WhenResponse = _listRelationshipTemplatesResponse = await client.RelationshipTemplates.ListTemplates(queries);
+    }
 
     #endregion
+
+    #region Then
+
+    [Then($@"the response contains Relationship Template\(s\) {RegexFor.LIST_OF_THINGS}")]
+    public void ThenTheResponseContainsRelationshipTemplates(string relationshipTemplateNames)
+    {
+        var relationshipTemplates = relationshipTemplateNames.Split(',').Select(item => _relationshipTemplatesContext.CreateRelationshipTemplatesResponses[item.Trim()]).ToList();
+        _listRelationshipTemplatesResponse!.Result!.Should().BeEquivalentTo(relationshipTemplates, options => options.WithStrictOrdering());
+    }
+
+    #endregion
+}
+
+file class RelationshipTemplateProperties
+{
+    public required string RTempName { get; set; }
+    public required string RTempOwner { get; set; }
+    public required string ForIdentity { get; set; }
+    public required string Password { get; set; }
+}
+
+file class GetRequestPayload
+{
+    public required string RTempName { get; set; }
+    public required string PasswordOnGet { get; set; }
 }

BuildingBlocks/src/BuildingBlocks.Application/FluentValidation/NumberOfBytesValidator.cs

@@ -59,7 +59,7 @@ public static class NumberOfBytesValidatorRuleBuilderExtensions
             .WithErrorCode(GenericApplicationErrors.Validation.InvalidPropertyValue().Code);
     }
 
-    public static IRuleBuilderOptions<T, byte[]?> NumberOfBytes<T>(this IRuleBuilder<T, byte[]> ruleBuilder,
+    public static IRuleBuilderOptions<T, byte[]?> NumberOfBytes<T>(this IRuleBuilder<T, byte[]?> ruleBuilder,
         int numberOfBytes)
     {
         return ruleBuilder

Modules/Relationships/src/Relationships.Application/Infrastructure/Persistence/Repository/IRelationshipTemplatesRepository.cs

@@ -2,14 +2,16 @@
 using Backbone.BuildingBlocks.Application.Abstractions.Infrastructure.Persistence.Database;
 using Backbone.BuildingBlocks.Application.Pagination;
 using Backbone.DevelopmentKit.Identity.ValueObjects;
+using Backbone.Modules.Relationships.Application.RelationshipTemplates.Queries.ListRelationshipTemplates;
 using Backbone.Modules.Relationships.Domain.Aggregates.RelationshipTemplates;
 
 namespace Backbone.Modules.Relationships.Application.Infrastructure.Persistence.Repository;
 
 public interface IRelationshipTemplatesRepository
 {
-    Task<DbPaginationResult<RelationshipTemplate>> FindTemplatesWithIds(IEnumerable<RelationshipTemplateId> ids, IdentityAddress identityAddress, PaginationFilter paginationFilter,
+    Task<DbPaginationResult<RelationshipTemplate>> FindTemplatesWithIds(IEnumerable<RelationshipTemplateQueryItem> queryItems, IdentityAddress activeIdentity, PaginationFilter paginationFilter,
         CancellationToken cancellationToken, bool track = false);
+
     Task<RelationshipTemplate?> Find(RelationshipTemplateId id, IdentityAddress identityAddress, CancellationToken cancellationToken, bool track = false);
     Task Add(RelationshipTemplate template, CancellationToken cancellationToken);
     Task Update(RelationshipTemplate template);
@@ -21,5 +23,4 @@ Task<DbPaginationResult<RelationshipTemplate>> FindTemplatesWithIds(IEnumerable<
     Task UpdateRelationshipTemplateAllocations(List<RelationshipTemplateAllocation> templateAllocations, CancellationToken cancellationToken);
 
     #endregion RelationshipTemplateAllocations
-
 }

Modules/Relationships/src/Relationships.Application/RelationshipTemplates/Commands/CreateRelationshipTemplate/CreateRelationshipTemplateCommand.cs

@@ -10,4 +10,5 @@ public class CreateRelationshipTemplateCommand : IRequest<CreateRelationshipTemp
     public int? MaxNumberOfAllocations { get; set; }
     public required byte[] Content { get; set; }
     public string? ForIdentity { get; set; }
+    public byte[]? Password { get; set; }
 }

Modules/Relationships/src/Relationships.Application/RelationshipTemplates/Commands/CreateRelationshipTemplate/Handler.cs

@@ -26,7 +26,8 @@ public async Task<CreateRelationshipTemplateResponse> Handle(CreateRelationshipT
             request.MaxNumberOfAllocations,
             request.ExpiresAt,
             request.Content,
-            forIdentity);
+            forIdentity,
+            request.Password);
 
         await _relationshipTemplatesRepository.Add(template, cancellationToken);