updated tenant domain logic

DavidEggenberger · Jan 6, 2025 · 7b1c41e · 7b1c41e
1 parent c5c08ac
commit 7b1c41e
Show file tree

Hide file tree

Showing 18 changed files with 73 additions and 154 deletions.
diff --git a/...s/Application/Commands/AddUserToTenant.cs → ...Application/Commands/AddMemberToTenant.cs b/...s/Application/Commands/AddUserToTenant.cs → ...Application/Commands/AddMemberToTenant.cs
@@ -6,21 +6,21 @@
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.Tenants.Application.Commands
 {
-    public class AddUserToTenant : Command
+    public class AddMemberToTenant : Command
     {
         public Guid TenantId { get; set; }
         public Guid UserId { get; set; }
         public TenantRole Role { get; set; }
     }
-    public class AddUserToTenantCommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<AddUserToTenant>
+    public class AddMemberToTenantCommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<AddMemberToTenant>
     {
-        public AddUserToTenantCommandHandler(IServiceProvider serviceProvider) : base(serviceProvider) { }
+        public AddMemberToTenantCommandHandler(IServiceProvider serviceProvider) : base(serviceProvider) { }
 
-        public async Task HandleAsync(AddUserToTenant command, CancellationToken cancellationToken)
+        public async Task HandleAsync(AddMemberToTenant command, CancellationToken cancellationToken)
         {
             var tenant = await module.TenantIdentityDbContext.Tenants.GetEntityAsync(command.TenantId, command.TenantId);
 
-            tenant.AddUser(command.UserId, command.Role);
+            tenant.AddMember(command.UserId, command.Role);
 
             await module.TenantIdentityDbContext.SaveChangesAsync(cancellationToken);
         }

diff --git a/...ication/Commands/CreateTenantWithAdmin.cs → ...ants/Application/Commands/CreateTenant.cs b/...ication/Commands/CreateTenantWithAdmin.cs → ...ants/Application/Commands/CreateTenant.cs
@@ -6,17 +6,17 @@
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.Tenants.Application.Commands
 {
-    public class CreateTenantWithAdmin : Command<TenantDTO>
+    public class CreateTenant : Command<TenantDTO>
     {
         public string Name { get; set; }
         public Guid AdminId { get; set; }
     }
 
-    public class CreateTenantWithAdminCommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<CreateTenantWithAdmin, TenantDTO>
+    public class CreateTenantWithAdminCommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<CreateTenant, TenantDTO>
     {
         public CreateTenantWithAdminCommandHandler(IServiceProvider serviceProvider) : base(serviceProvider) { }
 
-        public async Task<TenantDTO> HandleAsync(CreateTenantWithAdmin createTenant, CancellationToken cancellationToken)
+        public async Task<TenantDTO> HandleAsync(CreateTenant createTenant, CancellationToken cancellationToken)
         {
             var tenant = Tenant.CreateTenant(createTenant.Name, Guid.Empty);
 

diff --git a/...dules/TenantIdentity/Features/DomainFeatures/Tenants/Application/Commands/DeleteTenant.cs b/...dules/TenantIdentity/Features/DomainFeatures/Tenants/Application/Commands/DeleteTenant.cs
@@ -4,6 +4,7 @@
 using Modules.TenantIdentity.Features.DomainFeatures.Tenants.Domain;
 using Shared.Features.Messaging.Commands;
 using Shared.Features.Errors;
+using Shared.Kernel.DomainKernel;
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.Tenants.Application.Commands
 {
@@ -24,6 +25,11 @@ public async Task HandleAsync(DeleteTenant command, CancellationToken cancellati
                 throw Error.NotFound(nameof(Tenant), command.TenantId);
             }
 
+            if (executionContext.TenantRole != TenantRole.Admin)
+            {
+                throw Error.UnAuthorized;
+            }
+
             module.TenantIdentityDbContext.Entry(tenant.Id).State = EntityState.Deleted;
             await module.TenantIdentityDbContext.SaveChangesAsync();
         }

diff --git a/...lication/Commands/RemoveUserFromTenant.cs → ...cation/Commands/RemoveMemberFromTenant.cs b/...lication/Commands/RemoveUserFromTenant.cs → ...cation/Commands/RemoveMemberFromTenant.cs
@@ -4,21 +4,21 @@
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.Tenants.Application.Commands
 {
-    public class RemoveUserFromTenant : Command
+    public class RemoveMemberFromTenant : Command
     {
         public Guid UserId { get; set; }
         public Guid TenantId { get; set; }
     }
 
-    public class RemoveUserFromTenantommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<RemoveUserFromTenant>
+    public class RemoveMemberFromTenantCommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<RemoveMemberFromTenant>
     {
-        public RemoveUserFromTenantommandHandler(IServiceProvider serviceProvider) : base(serviceProvider) {}
+        public RemoveMemberFromTenantCommandHandler(IServiceProvider serviceProvider) : base(serviceProvider) {}
 
-        public async Task HandleAsync(RemoveUserFromTenant command, CancellationToken cancellationToken)
+        public async Task HandleAsync(RemoveMemberFromTenant command, CancellationToken cancellationToken)
         {
             var tenant = await module.TenantIdentityDbContext.GetTenantExtendedByIdAsync(command.TenantId);
 
-            tenant.DeleteTenantMembership(command.UserId);
+            tenant.RemoveMember(command.UserId);
 
             module.TenantIdentityDbContext.Remove(tenant);
             await module.TenantIdentityDbContext.SaveChangesAsync();

diff --git a/...cation/Commands/UpdateUserRoleInTenant.cs → ...on/Commands/UpdateRoleOfMemberInTenant.cs b/...cation/Commands/UpdateUserRoleInTenant.cs → ...on/Commands/UpdateRoleOfMemberInTenant.cs
@@ -5,20 +5,20 @@
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.Tenants.Application.Commands
 {
-    public class UpdateTenantMembership : Command
+    public class UpdateRoleOfMemberInTenant : Command
     {
         public Guid TenantId { get; set; }
         public Guid UserId { get; set; }
         public TenantRole Role { get; set; }
     }
-    public class UpdateTenantMembershipCommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<UpdateTenantMembership>
+    public class UpdateRoleOfMemberInTenantCommandHandler : ServerExecutionBase<TenantIdentityModule>, ICommandHandler<UpdateRoleOfMemberInTenant>
     {
-        public UpdateTenantMembershipCommandHandler(IServiceProvider serviceProvider) : base(serviceProvider) { }
-        public async Task HandleAsync(UpdateTenantMembership command, CancellationToken cancellationToken)
+        public UpdateRoleOfMemberInTenantCommandHandler(IServiceProvider serviceProvider) : base(serviceProvider) { }
+        public async Task HandleAsync(UpdateRoleOfMemberInTenant command, CancellationToken cancellationToken)
         {
             var tenant = await module.TenantIdentityDbContext.GetTenantExtendedByIdAsync(command.TenantId);
 
-            tenant.ChangeRoleOfTenantMember(command.UserId, command.Role);
+            tenant.ChangeRoleOfMember(command.UserId, command.Role);
 
             await module.TenantIdentityDbContext.SaveChangesAsync();
         }

diff --git a/...tity/Features/DomainFeatures/Tenants/Application/Queries/GetAllTenantMembershipsOfUser.cs b/...tity/Features/DomainFeatures/Tenants/Application/Queries/GetAllTenantMembershipsOfUser.cs
@@ -14,7 +14,7 @@ public GetAllTenantMembershipsOfUserQueryHandler(IServiceProvider serviceProvide
 
         public async Task<List<TenantMembershipDTO>> HandleAsync(GetAllTenantMembershipsOfUser query, CancellationToken cancellation)
         {
-            var tenantMemberships = await module.TenantIdentityDbContext.TenantMeberships.Where(tm => tm.UserId == query.ExecutingUserId).ToListAsync();
+            var tenantMemberships = await module.TenantIdentityDbContext.TenantMemberships.Where(tm => tm.UserId == query.ExecutingUserId).ToListAsync();
             return tenantMemberships.Select(tm => tm.ToDTO()).ToList();
         }
     }

diff --git a/...ants/Application/Queries/GetTenantByID.cs → .../Tenants/Application/Queries/GetTenant.cs b/...ants/Application/Queries/GetTenantByID.cs → .../Tenants/Application/Queries/GetTenant.cs
@@ -5,17 +5,19 @@
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.Tenants.Application.Queries
 {
-    public class GetTenantByID : Query<TenantDTO>
+    public class GetTenant : Query<TenantDTO>
     {
         public Guid TenantId { get; set; }
     }
-    public class GetTenantByIdQueryHandler : ServerExecutionBase<TenantIdentityModule>, IQueryHandler<GetTenantByID, TenantDTO>
+
+    public class GetTenantByIdQueryHandler : ServerExecutionBase<TenantIdentityModule>, IQueryHandler<GetTenant, TenantDTO>
     {
         public GetTenantByIdQueryHandler(IServiceProvider serviceProvider) : base(serviceProvider) { }
 
-        public async Task<TenantDTO> HandleAsync(GetTenantByID query, CancellationToken cancellation)
+        public async Task<TenantDTO> HandleAsync(GetTenant query, CancellationToken cancellation)
         {
             var tenant = await module.TenantIdentityDbContext.GetTenantByIdAsync(query.TenantId);
+
             return tenant.ToDTO();
         }
     }

diff --git a/...enantIdentity/Features/DomainFeatures/Tenants/Application/Queries/GetTenantDetailsByID.cs b/...enantIdentity/Features/DomainFeatures/Tenants/Application/Queries/GetTenantDetailsByID.cs
diff --git a/...tIdentity/Features/DomainFeatures/Tenants/Application/Queries/GetTenantMembershipQuery.cs b/...tIdentity/Features/DomainFeatures/Tenants/Application/Queries/GetTenantMembershipQuery.cs
diff --git a/...nantIdentity/Features/DomainFeatures/Tenants/Domain/Exceptions/MemberNotFoundException.cs b/...nantIdentity/Features/DomainFeatures/Tenants/Domain/Exceptions/MemberNotFoundException.cs
diff --git a/...tIdentity/Features/DomainFeatures/Tenants/Domain/Exceptions/TabsAlreadyClosedException.cs b/...tIdentity/Features/DomainFeatures/Tenants/Domain/Exceptions/TabsAlreadyClosedException.cs
diff --git a/...tIdentity/Features/DomainFeatures/Tenants/Domain/Exceptions/UserAlreadyMemberException.cs b/...tIdentity/Features/DomainFeatures/Tenants/Domain/Exceptions/UserAlreadyMemberException.cs
diff --git a/Source/Modules/TenantIdentity/Features/DomainFeatures/Tenants/Domain/Tenant.cs b/Source/Modules/TenantIdentity/Features/DomainFeatures/Tenants/Domain/Tenant.cs
@@ -1,7 +1,6 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
-using Modules.TenantIdentity.Features.DomainFeatures.Tenants.Domain.Exceptions;
 using Modules.TenantIdentity.Public.DTOs.Tenant;
 using Shared.Features.Domain;
 using Shared.Features.Errors;
@@ -28,7 +27,7 @@ public static Tenant CreateTenant(string tenantName, Guid adminUserId)
             };
         }
 
-        public void AddUser(Guid userId, TenantRole role)
+        public void AddMember(Guid userId, TenantRole role)
         {
             ThrowIfCallerIsNotInRole(TenantRole.Admin);
 
@@ -43,26 +42,32 @@ public void AddUser(Guid userId, TenantRole role)
             }
         }
 
-        public void ChangeRoleOfTenantMember(Guid userId, TenantRole newRole)
+        public void ChangeRoleOfMember(Guid userId, TenantRole newRole)
         {
             ThrowIfCallerIsNotInRole(TenantRole.Admin);
 
             if (CheckIfUserIsMember(userId) is false)
             {
-                throw new MemberNotFoundException();
+                throw Error.DomainException("User is not a member of the tenant", StatusCodes.Status409Conflict);
             }
 
             TenantMembership tenantMembership = Memberships.Single(m => m.UserId == userId);
+
+            if (tenantMembership.Role == TenantRole.Admin && newRole != TenantRole.Admin && Memberships.Count(m => m.Role == TenantRole.Admin) == 1)
+            {
+                throw Error.DomainException("Cant remove only admin from tenant", StatusCodes.Status409Conflict);
+            }
+
             tenantMembership.UpdateRole(newRole);
         }
 
-        public void RemoveUser(Guid userId)
+        public void RemoveMember(Guid userId)
         {
             ThrowIfCallerIsNotInRole(TenantRole.Admin);
 
             if (CheckIfUserIsMember(userId) is false)
             {
-                throw new MemberNotFoundException();
+                throw Error.DomainException("User is not a member of the tenant", StatusCodes.Status409Conflict);
             }
 
             var membership = Memberships.Single(m => m.UserId == userId);
@@ -74,7 +79,7 @@ public void RemoveUser(Guid userId)
             Memberships.Remove(Memberships.Single(m => m.UserId == userId));
         }
 
-        public void InviteUserToRole(string email, TenantRole role)
+        public void InviteUser(string email, TenantRole role)
         {
             ThrowIfCallerIsNotInRole(TenantRole.Admin);
 
@@ -86,19 +91,6 @@ public void InviteUserToRole(string email, TenantRole role)
             Invitations.Add(TenantInvitation.Create(this, email, role));
         }
 
-        public void DeleteTenantMembership(Guid membershipId)
-        {
-            ThrowIfCallerIsNotInRole(TenantRole.Admin);
-
-            var tenantMembership = Memberships.SingleOrDefault(t => t.Id == membershipId);
-            if (tenantMembership == null)
-            {
-                throw Error.NotFound(nameof(TenantMembership), membershipId);
-            }
-
-            Memberships.Remove(tenantMembership);
-        }
-
         public bool CheckIfUserIsMember(Guid userId)
         {
             return Memberships.Any(membership => membership.UserId == userId);
@@ -109,10 +101,7 @@ public void UpdateSubscriptionPlan(SubscriptionPlanType subscriptionPlanType)
             SubscriptionPlan = subscriptionPlanType;
         }
 
-
         public TenantDTO ToDTO() => new TenantDTO();
-        public TenantExtendedDTO ToDetailDTO() => new TenantExtendedDTO();
-
     }
 
     public class TenantEFConfiguration : IEntityTypeConfiguration<Tenant>

diff --git a/Source/Modules/TenantIdentity/Features/DomainFeatures/Users/ApplicationUser.cs b/Source/Modules/TenantIdentity/Features/DomainFeatures/Users/ApplicationUser.cs
@@ -2,7 +2,6 @@
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Microsoft.EntityFrameworkCore;
 using Modules.TenantIdentity.Features.DomainFeatures.Tenants.Domain;
-using Modules.TenantIdentity.Features.DomainFeatures.Tenants.Domain.Exceptions;
 using Shared.Kernel.BuildingBlocks.Auth;
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.Users
@@ -46,7 +45,7 @@ public void DecrementOpenTabCount()
         {
             if (CountOfOpenTabs == 0)
             {
-                throw new TabsAlreadyClosedException("User has no tabs to close");
+                return;
             }
             CountOfOpenTabs--;
         }

diff --git a/Source/Modules/TenantIdentity/Features/Infrastructure/EFCore/TenantIdentityDbContext.cs b/Source/Modules/TenantIdentity/Features/Infrastructure/EFCore/TenantIdentityDbContext.cs
@@ -28,7 +28,7 @@ public TenantIdentityDbContext(IServiceProvider serviceProvider, DbContextOption
         public override DbSet<ApplicationUser> Users { get; set; }
         public DbSet<Tenant> Tenants { get; set; }
         public DbSet<TenantInvitation> TenantInvitations { get; set; }
-        public DbSet<TenantMembership> TenantMeberships { get; set; }
+        public DbSet<TenantMembership> TenantMemberships { get; set; }
 
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {