Maximum tenant identities

Shuttle.Access.Application/Messages/RegisterTenant.cs

@@ -8,6 +8,7 @@ public class RegisterTenant(Guid id, string name, TenantStatus status, Guid audi
     public Guid Id { get; } = Guard.AgainstEmpty(id);
     public string LogoSvg { get; set; } = string.Empty;
     public string LogoUrl { get; set; } = string.Empty;
+    public int MaximumIdentities { get; set; }
     public string Name { get; } = Guard.AgainstEmpty(name);
     public TenantStatus Status { get; } = Guard.AgainstUndefinedEnum<TenantStatus>(status);
     public string AuditIdentityName { get; } = Guard.AgainstEmpty(auditIdentityName);

Shuttle.Access.Application/Messages/SetTenantLogoSvg.cs

@@ -0,0 +1,12 @@
+using Shuttle.Contract;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantLogoSvg(Guid id, string logoSvg, Guid auditTenantId, string auditIdentityName)
+    : IAuditInformation
+{
+    public Guid Id { get; } = Guard.AgainstEmpty(id);
+    public string LogoSvg { get; } = logoSvg;
+    public Guid AuditTenantId { get; } = Guard.AgainstEmpty(auditTenantId);
+    public string AuditIdentityName { get; } = Guard.AgainstEmpty(auditIdentityName);
+}

Shuttle.Access.Application/Messages/SetTenantLogoUrl.cs

@@ -0,0 +1,12 @@
+using Shuttle.Contract;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantLogoUrl(Guid id, string logoUrl, Guid auditTenantId, string auditIdentityName)
+    : IAuditInformation
+{
+    public Guid Id { get; } = Guard.AgainstEmpty(id);
+    public string LogoUrl { get; } = logoUrl;
+    public Guid AuditTenantId { get; } = Guard.AgainstEmpty(auditTenantId);
+    public string AuditIdentityName { get; } = Guard.AgainstEmpty(auditIdentityName);
+}

Shuttle.Access.Application/Messages/SetTenantMaximumIdentities.cs

@@ -0,0 +1,12 @@
+using Shuttle.Contract;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantMaximumIdentities(Guid id, int maximumIdentities, Guid auditTenantId, string auditIdentityName)
+    : IAuditInformation
+{
+    public Guid Id { get; } = Guard.AgainstEmpty(id);
+    public int MaximumIdentities { get; } = maximumIdentities;
+    public Guid AuditTenantId { get; } = Guard.AgainstEmpty(auditTenantId);
+    public string AuditIdentityName { get; } = Guard.AgainstEmpty(auditIdentityName);
+}

Shuttle.Access.Application/Messages/SetTenantName.cs

@@ -0,0 +1,12 @@
+using Shuttle.Contract;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantName(Guid id, string name, Guid auditTenantId, string auditIdentityName)
+    : IAuditInformation
+{
+    public Guid Id { get; } = Guard.AgainstEmpty(id);
+    public string Name { get; } = name;
+    public Guid AuditTenantId { get; } = Guard.AgainstEmpty(auditTenantId);
+    public string AuditIdentityName { get; } = Guard.AgainstEmpty(auditIdentityName);
+}

Shuttle.Access.Application/RegisterTenantParticipant.cs

@@ -35,7 +35,7 @@ public async Task HandleAsync(RegisterTenant message, CancellationToken cancella
 
         if (string.IsNullOrWhiteSpace(aggregate.Name))
         {
-            stream.Add(aggregate.Register(message.Name, (int)message.Status, message.LogoSvg, message.LogoUrl));
+            stream.Add(aggregate.Register(message.Name, (int)message.Status, message.LogoSvg, message.LogoUrl, message.MaximumIdentities));
 
             await eventStore.SaveAsync(stream, builder => builder.Audit(message), cancellationToken);
         }

Shuttle.Access.Application/SetIdentityTenantStatusParticipant.cs

@@ -4,7 +4,7 @@
 
 namespace Shuttle.Access.Application;
 
-public class SetIdentityTenantStatusParticipant(IEventStore eventStore) : IParticipant<SetIdentityTenantStatus>
+public class SetIdentityTenantStatusParticipant(IEventStore eventStore, ITenantQuery tenantQuery, IIdentityQuery identityQuery) : IParticipant<SetIdentityTenantStatus>
 {
     public async Task HandleAsync(SetIdentityTenantStatus message, CancellationToken cancellationToken = default)
     {
@@ -17,6 +17,18 @@ public async Task HandleAsync(SetIdentityTenantStatus message, CancellationToken
 
         if (message.Active && !identity.IsInTenant(message.TenantId))
         {
+            var tenant = (await tenantQuery.SearchAsync(new Query.Tenant.Specification().AddId(message.TenantId), cancellationToken)).FirstOrDefault();
+
+            if (tenant is { MaximumIdentities: > 0 })
+            {
+                var identityCount = await identityQuery.CountAsync(new Query.Identity.Specification().WithTenantId(message.TenantId), cancellationToken);
+
+                if (identityCount >= tenant.MaximumIdentities)
+                {
+                    throw new ApplicationException(string.Format(Access.Resources.TenantMaximumIdentitiesExceededException, tenant.Name, tenant.MaximumIdentities));
+                }
+            }
+
             stream.Add(identity.AddTenant(message.TenantId));
         }
 

Shuttle.Access.Application/SetTenantLogoSvgParticipant.cs

@@ -0,0 +1,25 @@
+using Shuttle.Contract;
+using Shuttle.Mediator;
+using Shuttle.Recall;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantLogoSvgParticipant(IEventStore eventStore) : IParticipant<SetTenantLogoSvg>
+{
+    public async Task HandleAsync(SetTenantLogoSvg message, CancellationToken cancellationToken = default)
+    {
+        Guard.AgainstNull(message);
+
+        var stream = (await eventStore.GetAsync(message.Id, cancellationToken)).MustHaveEvents();
+        var tenant = stream.Get<Tenant>();
+
+        if (tenant.LogoSvg == message.LogoSvg)
+        {
+            return;
+        }
+
+        stream.Add(tenant.SetLogoSvg(message.LogoSvg));
+
+        await eventStore.SaveAsync(stream, builder => builder.Audit(message), cancellationToken);
+    }
+}

Shuttle.Access.Application/SetTenantLogoUrlParticipant.cs

@@ -0,0 +1,25 @@
+using Shuttle.Contract;
+using Shuttle.Mediator;
+using Shuttle.Recall;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantLogoUrlParticipant(IEventStore eventStore) : IParticipant<SetTenantLogoUrl>
+{
+    public async Task HandleAsync(SetTenantLogoUrl message, CancellationToken cancellationToken = default)
+    {
+        Guard.AgainstNull(message);
+
+        var stream = (await eventStore.GetAsync(message.Id, cancellationToken)).MustHaveEvents();
+        var tenant = stream.Get<Tenant>();
+
+        if (tenant.LogoUrl == message.LogoUrl)
+        {
+            return;
+        }
+
+        stream.Add(tenant.SetLogoUrl(message.LogoUrl));
+
+        await eventStore.SaveAsync(stream, builder => builder.Audit(message), cancellationToken);
+    }
+}

Shuttle.Access.Application/SetTenantMaximumIdentitiesParticipant.cs

@@ -0,0 +1,25 @@
+using Shuttle.Contract;
+using Shuttle.Mediator;
+using Shuttle.Recall;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantMaximumIdentitiesParticipant(IEventStore eventStore) : IParticipant<SetTenantMaximumIdentities>
+{
+    public async Task HandleAsync(SetTenantMaximumIdentities message, CancellationToken cancellationToken = default)
+    {
+        Guard.AgainstNull(message);
+
+        var stream = (await eventStore.GetAsync(message.Id, cancellationToken)).MustHaveEvents();
+        var tenant = stream.Get<Tenant>();
+
+        if (tenant.MaximumIdentities == message.MaximumIdentities)
+        {
+            return;
+        }
+
+        stream.Add(tenant.SetMaximumIdentities(message.MaximumIdentities));
+
+        await eventStore.SaveAsync(stream, builder => builder.Audit(message), cancellationToken);
+    }
+}

Shuttle.Access.Application/SetTenantNameParticipant.cs

@@ -0,0 +1,36 @@
+using Shuttle.Contract;
+using Shuttle.Mediator;
+using Shuttle.Recall;
+using Shuttle.Recall.SqlServer.Storage;
+
+namespace Shuttle.Access.Application;
+
+public class SetTenantNameParticipant(IEventStore eventStore, IIdKeyRepository idKeyRepository) : IParticipant<SetTenantName>
+{
+    public async Task HandleAsync(SetTenantName message, CancellationToken cancellationToken = default)
+    {
+        Guard.AgainstNull(message);
+
+        var stream = (await eventStore.GetAsync(message.Id, cancellationToken)).MustHaveEvents();
+        var tenant = stream.Get<Tenant>();
+
+        if (tenant.Name.Equals(message.Name))
+        {
+            return;
+        }
+
+        var key = Tenant.Key(tenant.Name);
+        var rekey = Tenant.Key(message.Name);
+
+        if (await idKeyRepository.ContainsAsync(rekey, cancellationToken) || !await idKeyRepository.ContainsAsync(key, cancellationToken))
+        {
+            return;
+        }
+
+        await idKeyRepository.RekeyAsync(key, rekey, cancellationToken);
+
+        stream.Add(tenant.SetName(message.Name));
+
+        await eventStore.SaveAsync(stream, builder => builder.Audit(message), cancellationToken);
+    }
+}

Shuttle.Access.Messages/v1/RegisterTenant.cs

@@ -7,6 +7,7 @@ public class RegisterTenant : AuditMessage
     public string LogoSvg { get; set; } = string.Empty;
     public string LogoUrl { get; set; } = string.Empty;
     public int Status { get; set; } = 1;
+    public int MaximumIdentities { get; set; }
     public string AdministratorIdentityName { get; set; } = string.Empty;
     public Guid AccessAdministratorRoleId { get; set; }
 }

Shuttle.Access.Messages/v1/SetTenantLogoSvg.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class SetTenantLogoSvg : AuditMessage
+{
+    public Guid Id { get; set; }
+    public string LogoSvg { get; set; } = string.Empty;
+}

Shuttle.Access.Messages/v1/SetTenantLogoUrl.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class SetTenantLogoUrl : AuditMessage
+{
+    public Guid Id { get; set; }
+    public string LogoUrl { get; set; } = string.Empty;
+}

Shuttle.Access.Messages/v1/SetTenantMaximumIdentities.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class SetTenantMaximumIdentities : AuditMessage
+{
+    public Guid Id { get; set; }
+    public int MaximumIdentities { get; set; }
+}

Shuttle.Access.Messages/v1/SetTenantName.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class SetTenantName : AuditMessage
+{
+    public Guid Id { get; set; }
+    public string Name { get; set; } = string.Empty;
+}

Shuttle.Access.Messages/v1/TenantLogoSvgSet.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class TenantLogoSvgSet
+{
+    public Guid Id { get; set; }
+    public string LogoSvg { get; set; } = string.Empty;
+}

Shuttle.Access.Messages/v1/TenantLogoUrlSet.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class TenantLogoUrlSet
+{
+    public Guid Id { get; set; }
+    public string LogoUrl { get; set; } = string.Empty;
+}

Shuttle.Access.Messages/v1/TenantMaximumIdentitiesSet.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class TenantMaximumIdentitiesSet
+{
+    public Guid Id { get; set; }
+    public int MaximumIdentities { get; set; }
+}

Shuttle.Access.Messages/v1/TenantNameSet.cs

@@ -0,0 +1,7 @@
+namespace Shuttle.Access.Messages.v1;
+
+public class TenantNameSet
+{
+    public Guid Id { get; set; }
+    public string Name { get; set; } = string.Empty;
+}

Shuttle.Access.RestClient/v1/ITenantApi.cs

@@ -18,4 +18,16 @@ public interface ITenantApi
 
     [Patch("/v1/tenants/{id}/status")]
     Task<IApiResponse> SetStatusAsync(Guid id, WebApi.Contracts.v1.SetStatus message, CancellationToken cancellationToken = default);
+
+    [Patch("/v1/tenants/{id}/name")]
+    Task<IApiResponse> SetNameAsync(Guid id, WebApi.Contracts.v1.SetName message, CancellationToken cancellationToken = default);
+
+    [Patch("/v1/tenants/{id}/logo-url")]
+    Task<IApiResponse> SetLogoUrlAsync(Guid id, WebApi.Contracts.v1.SetLogoUrl message, CancellationToken cancellationToken = default);
+
+    [Patch("/v1/tenants/{id}/logo-svg")]
+    Task<IApiResponse> SetLogoSvgAsync(Guid id, WebApi.Contracts.v1.SetLogoSvg message, CancellationToken cancellationToken = default);
+
+    [Patch("/v1/tenants/{id}/maximum-identities")]
+    Task<IApiResponse> SetMaximumIdentitiesAsync(Guid id, WebApi.Contracts.v1.SetMaximumIdentities message, CancellationToken cancellationToken = default);
 }