Refactored UI

Added Role filed to user table and endpoint implementation

PostFundManagement.Application/Abstractions/Services/IUserService.cs

@@ -9,7 +9,7 @@ public interface IUserService
 {
     [Log]
     [Audit]
-    Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default);
+    Task<Result> SyncUserAsync(Guid userId, string email, string role, CancellationToken cancellationToken = default);
 
     [Log]
     Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default);

PostFundManagement.Application/Extensions/General.cs

@@ -12,6 +12,8 @@ public static class General
 
     public static string GetUserEmail(this HttpContext context) => (string)context.Items[Domain.Extensions.Constants.EmailtemKey]!;
 
+    public static string GetUserRole(this HttpContext context) => (string)context.Items[Domain.Extensions.Constants.UserRoleItemKey]!;
+
     public static (bool Decoded, Guid userId) GetUserId(this ClaimsPrincipal principal)
     {
         var subClaim = principal.FindFirst(JwtRegisteredClaimNames.Sub)?.Value ?? principal.FindFirst(ClaimTypes.NameIdentifier)?.Value;
@@ -30,10 +32,19 @@ public static class General
         return (decoded, emailClaim!);
     }
 
-    public static Microsoft.AspNetCore.Mvc.ProblemDetails ToProblems(this IReadOnlyList<IError> errors) => new()
+    public static (bool Decoded, string role) GetUserRole(this ClaimsPrincipal principal)
+    {
+        var roleClaim = principal.FindFirst("role")?.Value ?? principal.FindFirst(ClaimTypes.Role)?.Value;
+
+        var decoded = !string.IsNullOrWhiteSpace(roleClaim);
+
+        return (decoded, roleClaim!);
+    }
+
+    public static Microsoft.AspNetCore.Mvc.ProblemDetails ToProblems(this IReadOnlyList<IError> errors, int statusCode = StatusCodes.Status400BadRequest) => new()
     {
         Detail = string.Join(',', errors.Select(e => e.Message)),
-        Status = StatusCodes.Status400BadRequest,
+        Status = statusCode,
         Title = "Error",
     };
 }

PostFundManagement.Application/Filters/ActiveUserFilter.cs

@@ -15,12 +15,16 @@ public sealed class ActiveUserFilter(IIdentityService identityService) : IEndpoi
 
         var (decoded, userId) = principal.GetUserId();
         var (emailDecoded, email) = principal.GetUserEmail();
+        var (roleDecoded, role) = principal.GetUserRole();
 
         if (!decoded)
-            return Results.Json(new { message = "Invalid user identifier in token." }, statusCode: StatusCodes.Status400BadRequest);
+            return Results.Json(new { message = "Invalid user identifier in token." }, statusCode: StatusCodes.Status401Unauthorized);
 
         if (!emailDecoded)
-            return Results.Json(new { message = "Invalid/missing user email in token." }, statusCode: StatusCodes.Status400BadRequest);
+            return Results.Json(new { message = "Invalid/missing user email in token." }, statusCode: StatusCodes.Status401Unauthorized);
+
+        if (!roleDecoded)
+            return Results.Json(new { message = "Invalid/missing user role in token." }, statusCode: StatusCodes.Status401Unauthorized);
 
         var path = context.HttpContext.Request.Path.Value;
 
@@ -34,6 +38,7 @@ public sealed class ActiveUserFilter(IIdentityService identityService) : IEndpoi
 
         context.HttpContext.Items[UserIdItemKey] = userId;
         context.HttpContext.Items[EmailtemKey] = email;
+        context.HttpContext.Items[UserRoleItemKey] = role;
 
         return await next(context);
     }

PostFundManagement.Application/Services/Communications/CommunicationsService.cs

@@ -17,13 +17,21 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
+            var recipient = await context.TenantUsers.AsNoTracking()
+                .Include(i => i.User)
+                .Include(i => i.Tenant)
+                .FirstOrDefaultAsync(u => u.UserId == request.Recipient && u.Status == ActivityStatus.Active && u.Tenant!.Status == ActivityStatus.Active);
+
+            if (recipient is null)
+                return Result.Fail(ValidationError.Create("Tenant or User is not active, invite not sent"));
+
             var invite = new Domain.Entities.Invite
             {
                 OrganisationId = request.OrganisationId,
                 InvitedOrganisationId = request.InvitedOrganisationId,
                 AwardId = request.AwardId,
                 ContractId = request.ContractId,
-                Recipient = request.Recipient,
+                Recipient = recipient.UserId,
                 CreatedBy = userId,
                 CreatedAt = DateTime.UtcNow,
                 TenantId = tenantContext.TenantId
@@ -31,13 +39,13 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
 
             context.Invites.Add(invite);
 
-            var notificationRequest = new CreateNotificationRequest(request.InvitedOrganisationId, request.Recipient, 
-                request.Platform, "Invitation to Onboard", string.Empty, request.Message);
+            var notificationRequest = new CreateNotificationRequest(request.InvitedOrganisationId, recipient.UserId, 
+                request.Platform, "Funding award invite", recipient!.User!.Email, request.Message);
 
             var notificationResult = await CreateNotificationAsync(notificationRequest, userId, cancellationToken);
 
             return Result.FailIf(await context.SaveChangesAsync(cancellationToken) <= 0 && notificationResult.IsFailed, 
-                CreateError.Create().CausedBy(notificationResult.Errors))
+                CreateError.Create("Failed to create invite, contact support").CausedBy(notificationResult.Errors))
                 .ToResult(invite.Map());
         }));
 
@@ -60,9 +68,11 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
-            var invite = await context.Invites.AsNoTracking().FirstOrDefaultAsync(i => i.Recipient == applicantUserId, cancellationToken);
+            var invite = await context.Invites.AsNoTracking()
+                .OrderByDescending(o => o.Id)
+                .FirstOrDefaultAsync(i => i.Recipient == applicantUserId, cancellationToken);
 
-            return Result.FailIf(invite is null, NotFoundError.New)
+            return Result.FailIf(invite is null, NotFoundError.Create("No active invite found"))
                 .ToResult(invite!.Map());
         }));
 
@@ -97,7 +107,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
                 TenantId = tenantContext.TenantId
             });
 
-            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create entry"));
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, 
+                CreateError.Create("Failed to create entry, contact support"));
         }));
 
     public async Task<Result> UpdateNotificationAsync(UpdateNotificationRequest request, CancellationToken cancellationToken = default) =>
@@ -114,7 +125,7 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
                     .SetProperty(u => u.UpdatedAt, DateTime.UtcNow)
                     .SetProperty(u => u.Status, request.Status), cancellationToken);
 
-            return Result.OkIf(changedTotal > 0, UpdateError.Create($"Failed to update notification: {request.NotificationId}"));
+            return Result.OkIf(changedTotal > 0, UpdateError.Create($"Failed to update notification: {request.NotificationId}, contact support"));
         }));
 
     public async Task<Result<Notification[]>> GetNotificationsAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
@@ -150,7 +161,7 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
             var notification = await context.Notifications.AsNoTracking()
                 .FirstOrDefaultAsync(n => n.Id == decodeResult.Value, cancellationToken);
 
-            return Result.FailIf(notification is null, NotFoundError.New)
+            return Result.FailIf(notification is null, NotFoundError.Create("Notification not found"))
                 .ToResult(notification!.Map());
         }));
 }

PostFundManagement.Application/Services/Users/UserCacheService.cs

@@ -61,8 +61,8 @@ public sealed class UserCacheService(UserService service, IDistributedCache cach
             return Result.Ok(cached.FromJson<User[]>());
         }));
 
-    public async Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
-        await service.SyncUserAsync(userId, email, cancellationToken);
+    public async Task<Result> SyncUserAsync(Guid userId, string email, string role, CancellationToken cancellationToken = default) =>
+        await service.SyncUserAsync(userId, email, role, cancellationToken);
         
     public async Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
         await service.UpdateUserStatusAsync(userId, status, cancellationToken);

PostFundManagement.Application/Services/Users/UserService.cs

@@ -10,11 +10,14 @@ namespace PostFundManagement.Application.Services.Users;
 
 public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextFactory, ITenantContextService tenantContext) : IUserService
 {
-    public async Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
+    public async Task<Result> SyncUserAsync(Guid userId, string email, string role, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
+            if (string.IsNullOrWhiteSpace(role))
+                return Result.Fail(ValidationError.Create("Failed to sync, user role not present, contact support"));
+
             var tenantUser = await context.TenantUsers
                 .Include(i => i.User)
                 .FirstOrDefaultAsync(u => u.UserId == userId, cancellationToken);
@@ -26,7 +29,8 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
                     Id = userId,
                     Email = email,
                     Status = ActivityStatus.Active,
-                    LastLoginAt = DateTime.UtcNow
+                    LastLoginAt = DateTime.UtcNow,
+                    Role = role
                 });
 
                 context.TenantUsers.Add(new Domain.Entities.TenantUser
@@ -42,11 +46,12 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             {
                 tenantUser.User!.Email = email;
                 tenantUser.User.LastLoginAt = DateTime.UtcNow;
+                tenantUser.User.Role = role;
 
                 context.Users.Update(tenantUser.User);
             }
 
-            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to sync user, contact support"));
         }));
 
     public async Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>