♻️ Refactored permission service

2025-11-08 21:03:03 +08:00
parent 637cc0cfa4
commit 0123c74ab8
3 changed files with 447 additions and 80 deletions
--- a/DysonNetwork.Pass/Permission/PermissionServiceGrpc.cs
+++ b/DysonNetwork.Pass/Permission/PermissionServiceGrpc.cs
@@ -1,6 +1,7 @@
 using Grpc.Core;
 using Microsoft.EntityFrameworkCore;
 using DysonNetwork.Shared.Proto;
+using DysonNetwork.Shared.Models;
 using Google.Protobuf.WellKnownTypes;
 using System.Text.Json;
 using NodaTime.Serialization.Protobuf;
@@ -9,69 +10,174 @@ namespace DysonNetwork.Pass.Permission;

 public class PermissionServiceGrpc(
    PermissionService permissionService,
-    AppDatabase db
+    AppDatabase db,
+    ILogger<PermissionServiceGrpc> logger
 ) : DysonNetwork.Shared.Proto.PermissionService.PermissionServiceBase
 {
    public override async Task<HasPermissionResponse> HasPermission(HasPermissionRequest request, ServerCallContext context)
    {
-        var hasPermission = await permissionService.HasPermissionAsync(request.Actor, request.Area, request.Key);
-        return new HasPermissionResponse { HasPermission = hasPermission };
+        try
+        {
+            var hasPermission = await permissionService.HasPermissionAsync(request.Actor, request.Area, request.Key);
+            return new HasPermissionResponse { HasPermission = hasPermission };
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error checking permission for actor {Actor}, area {Area}, key {Key}",
+                request.Actor, request.Area, request.Key);
+            throw new RpcException(new Status(StatusCode.Internal, "Permission check failed"));
+        }
    }

    public override async Task<GetPermissionResponse> GetPermission(GetPermissionRequest request, ServerCallContext context)
    {
-        var permissionValue = await permissionService.GetPermissionAsync<JsonDocument>(request.Actor, request.Area, request.Key);
-        return new GetPermissionResponse { Value = permissionValue != null ? Value.Parser.ParseJson(permissionValue.RootElement.GetRawText()) : null };
+        try
+        {
+            var permissionValue = await permissionService.GetPermissionAsync<JsonDocument>(request.Actor, request.Area, request.Key);
+            return new GetPermissionResponse
+            {
+                Value = permissionValue != null ? Value.Parser.ParseJson(permissionValue.RootElement.GetRawText()) : null
+            };
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error getting permission for actor {Actor}, area {Area}, key {Key}",
+                request.Actor, request.Area, request.Key);
+            throw new RpcException(new Status(StatusCode.Internal, "Failed to retrieve permission"));
+        }
    }

    public override async Task<AddPermissionNodeResponse> AddPermissionNode(AddPermissionNodeRequest request, ServerCallContext context)
    {
-        var node = await permissionService.AddPermissionNode(
-            request.Actor,
-            request.Area,
-            request.Key,
-            JsonDocument.Parse(request.Value.ToString()), // Convert Value to JsonDocument
-            request.ExpiredAt?.ToInstant(),
-            request.AffectedAt?.ToInstant()
-        );
-        return new AddPermissionNodeResponse { Node = node.ToProtoValue() };
+        try
+        {
+            JsonDocument jsonValue;
+            try
+            {
+                jsonValue = JsonDocument.Parse(request.Value.ToString());
+            }
+            catch (JsonException ex)
+            {
+                logger.LogWarning(ex, "Invalid JSON in permission value for actor {Actor}, area {Area}, key {Key}",
+                    request.Actor, request.Area, request.Key);
+                throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid permission value format"));
+            }
+
+            var node = await permissionService.AddPermissionNode(
+                request.Actor,
+                request.Area,
+                request.Key,
+                jsonValue,
+                request.ExpiredAt?.ToInstant(),
+                request.AffectedAt?.ToInstant()
+            );
+            return new AddPermissionNodeResponse { Node = node.ToProtoValue() };
+        }
+        catch (RpcException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error adding permission node for actor {Actor}, area {Area}, key {Key}",
+                request.Actor, request.Area, request.Key);
+            throw new RpcException(new Status(StatusCode.Internal, "Failed to add permission node"));
+        }
    }

    public override async Task<AddPermissionNodeToGroupResponse> AddPermissionNodeToGroup(AddPermissionNodeToGroupRequest request, ServerCallContext context)
    {
-        var group = await db.PermissionGroups.FirstOrDefaultAsync(g => g.Id == Guid.Parse(request.Group.Id));
-        if (group == null)
+        try
        {
-            throw new RpcException(new Status(StatusCode.NotFound, "Permission group not found."));
-        }
+            var group = await FindPermissionGroupAsync(request.Group.Id);
+            if (group == null)
+            {
+                throw new RpcException(new Status(StatusCode.NotFound, "Permission group not found"));
+            }

-        var node = await permissionService.AddPermissionNodeToGroup(
-            group,
-            request.Actor,
-            request.Area,
-            request.Key,
-            JsonDocument.Parse(request.Value.ToString()), // Convert Value to JsonDocument
-            request.ExpiredAt?.ToInstant(),
-            request.AffectedAt?.ToInstant()
-        );
-        return new AddPermissionNodeToGroupResponse { Node = node.ToProtoValue() };
+            JsonDocument jsonValue;
+            try
+            {
+                jsonValue = JsonDocument.Parse(request.Value.ToString());
+            }
+            catch (JsonException ex)
+            {
+                logger.LogWarning(ex, "Invalid JSON in permission value for group {GroupId}, actor {Actor}, area {Area}, key {Key}",
+                    request.Group.Id, request.Actor, request.Area, request.Key);
+                throw new RpcException(new Status(StatusCode.InvalidArgument, "Invalid permission value format"));
+            }
+
+            var node = await permissionService.AddPermissionNodeToGroup(
+                group,
+                request.Actor,
+                request.Area,
+                request.Key,
+                jsonValue,
+                request.ExpiredAt?.ToInstant(),
+                request.AffectedAt?.ToInstant()
+            );
+            return new AddPermissionNodeToGroupResponse { Node = node.ToProtoValue() };
+        }
+        catch (RpcException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error adding permission node to group {GroupId} for actor {Actor}, area {Area}, key {Key}",
+                request.Group.Id, request.Actor, request.Area, request.Key);
+            throw new RpcException(new Status(StatusCode.Internal, "Failed to add permission node to group"));
+        }
    }

    public override async Task<RemovePermissionNodeResponse> RemovePermissionNode(RemovePermissionNodeRequest request, ServerCallContext context)
    {
-        await permissionService.RemovePermissionNode(request.Actor, request.Area, request.Key);
-        return new RemovePermissionNodeResponse { Success = true };
+        try
+        {
+            await permissionService.RemovePermissionNode(request.Actor, request.Area, request.Key);
+            return new RemovePermissionNodeResponse { Success = true };
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error removing permission node for actor {Actor}, area {Area}, key {Key}",
+                request.Actor, request.Area, request.Key);
+            throw new RpcException(new Status(StatusCode.Internal, "Failed to remove permission node"));
+        }
    }

    public override async Task<RemovePermissionNodeFromGroupResponse> RemovePermissionNodeFromGroup(RemovePermissionNodeFromGroupRequest request, ServerCallContext context)
    {
-        var group = await db.PermissionGroups.FirstOrDefaultAsync(g => g.Id == Guid.Parse(request.Group.Id));
-        if (group == null)
+        try
        {
-            throw new RpcException(new Status(StatusCode.NotFound, "Permission group not found."));
+            var group = await FindPermissionGroupAsync(request.Group.Id);
+            if (group == null)
+            {
+                throw new RpcException(new Status(StatusCode.NotFound, "Permission group not found"));
+            }
+
+            await permissionService.RemovePermissionNodeFromGroup<JsonDocument>(group, request.Actor, request.Area, request.Key);
+            return new RemovePermissionNodeFromGroupResponse { Success = true };
+        }
+        catch (RpcException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Error removing permission node from group {GroupId} for actor {Actor}, area {Area}, key {Key}",
+                request.Group.Id, request.Actor, request.Area, request.Key);
+            throw new RpcException(new Status(StatusCode.Internal, "Failed to remove permission node from group"));
+        }
+    }
+
+    private async Task<SnPermissionGroup?> FindPermissionGroupAsync(string groupId)
+    {
+        if (!Guid.TryParse(groupId, out var guid))
+        {
+            logger.LogWarning("Invalid GUID format for group ID: {GroupId}", groupId);
+            return null;
        }

-        await permissionService.RemovePermissionNodeFromGroup<JsonDocument>(group, request.Actor, request.Area, request.Key);
-        return new RemovePermissionNodeFromGroupResponse { Success = true };
+        return await db.PermissionGroups.FirstOrDefaultAsync(g => g.Id == guid);
    }
 }