♻️ Extract the Developer to new service, add PublisherServiceGrpc

DysonNetwork.Sphere/Publisher/Publisher.cs

@@ -5,6 +5,7 @@ using DysonNetwork.Shared.Data;
 using DysonNetwork.Sphere.Post;
 using Microsoft.EntityFrameworkCore;
 using NodaTime;
+using NodaTime.Serialization.Protobuf;
 using VerificationMark = DysonNetwork.Shared.Data.VerificationMark;
 using Account = DysonNetwork.Pass.Account.Account;
 
@@ -49,6 +50,49 @@ public class Publisher : ModelBase, IIdentifiedResource
     [NotMapped] public Account? Account { get; set; }
 
     public string ResourceIdentifier => $"publisher:{Id}";
+
+    public Shared.Proto.Publisher ToProto(AppDatabase db)
+    {
+        var p = new Shared.Proto.Publisher()
+        {
+            Id = Id.ToString(),
+            Type = Type == PublisherType.Individual
+                ? Shared.Proto.PublisherType.Individual
+                : Shared.Proto.PublisherType.Organizational,
+            Name = Name,
+            Nick = Nick,
+            Bio = Bio,
+            AccountId = AccountId?.ToString() ?? string.Empty,
+            RealmId = RealmId?.ToString() ?? string.Empty,
+            CreatedAt = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTimeOffset(CreatedAt.ToDateTimeOffset()),
+            UpdatedAt = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTimeOffset(UpdatedAt.ToDateTimeOffset())
+        };
+        if (Picture is not null)
+        {
+            p.Picture = new Shared.Proto.CloudFile
+            {
+                Id = Picture.Id,
+                Name = Picture.Name,
+                MimeType = Picture.MimeType,
+                Hash = Picture.Hash,
+                Size = Picture.Size,
+            };
+        }
+
+        if (Background is not null)
+        {
+            p.Background = new Shared.Proto.CloudFile
+            {
+                Id = Background.Id,
+                Name = Background.Name,
+                MimeType = Background.MimeType,
+                Hash = Background.Hash,
+                Size = Background.Size,
+            };
+        }
+
+        return p;
+    }
 }
 
 public enum PublisherMemberRole
@@ -68,6 +112,25 @@ public class PublisherMember : ModelBase
 
     public PublisherMemberRole Role { get; set; } = PublisherMemberRole.Viewer;
     public Instant? JoinedAt { get; set; }
+    
+    
+    public Shared.Proto.PublisherMember ToProto()
+    {
+        return new Shared.Proto.PublisherMember()
+        {
+            PublisherId = PublisherId.ToString(),
+            AccountId = AccountId.ToString(),
+            Role = Role switch
+            {
+                PublisherMemberRole.Owner => Shared.Proto.PublisherMemberRole.Owner,
+                PublisherMemberRole.Manager => Shared.Proto.PublisherMemberRole.Manager,
+                PublisherMemberRole.Editor => Shared.Proto.PublisherMemberRole.Editor,
+                PublisherMemberRole.Viewer => Shared.Proto.PublisherMemberRole.Viewer,
+                _ => throw new ArgumentOutOfRangeException(nameof(Role), Role, null)
+            },
+            JoinedAt = JoinedAt?.ToTimestamp()
+        };
+    }
 }
 
 public enum PublisherSubscriptionStatus

DysonNetwork.Sphere/Publisher/PublisherServiceGrpc.cs

@@ -0,0 +1,68 @@
+using DysonNetwork.Shared.Proto;
+using Grpc.Core;
+using Microsoft.EntityFrameworkCore;
+
+namespace DysonNetwork.Sphere.Publisher;
+
+public class PublisherServiceGrpc(PublisherService service, AppDatabase db)
+    : Shared.Proto.PublisherService.PublisherServiceBase
+{
+    public override async Task<GetPublisherResponse> GetPublisher(GetPublisherRequest request,
+        ServerCallContext context)
+    {
+        var p = await service.GetPublisherByName(request.Name);
+        if (p is null) throw new RpcException(new Status(StatusCode.NotFound, "publisher not found"));
+        return new GetPublisherResponse { Publisher = p.ToProto(db) };
+    }
+
+    public override async Task<ListPublishersResponse> ListPublishers(ListPublishersRequest request,
+        ServerCallContext context)
+    {
+        IQueryable<Publisher> query = db.Publishers.AsQueryable();
+        if (!string.IsNullOrWhiteSpace(request.AccountId) && Guid.TryParse(request.AccountId, out var aid))
+        {
+            var ids = await db.PublisherMembers.Where(m => m.AccountId == aid).Select(m => m.PublisherId).ToListAsync();
+            query = query.Where(p => ids.Contains(p.Id));
+        }
+
+        if (!string.IsNullOrWhiteSpace(request.RealmId) && Guid.TryParse(request.RealmId, out var rid))
+        {
+            query = query.Where(p => p.RealmId == rid);
+        }
+
+        var list = await query.Take(request.PageSize > 0 ? request.PageSize : 100).ToListAsync();
+        var resp = new ListPublishersResponse();
+        resp.Publishers.AddRange(list.Select(p => p.ToProto(db)));
+        resp.TotalSize = list.Count;
+        return resp;
+    }
+
+    public override async Task<ListPublisherMembersResponse> ListPublisherMembers(ListPublisherMembersRequest request,
+        ServerCallContext context)
+    {
+        if (!Guid.TryParse(request.PublisherId, out var pid))
+            throw new RpcException(new Status(StatusCode.InvalidArgument, "invalid publisher_id"));
+        var members = await service.GetPublisherMembers(pid);
+        var resp = new ListPublisherMembersResponse();
+        resp.Members.AddRange(members.Select(m => m.ToProto()));
+        return resp;
+    }
+
+    public override async Task<Google.Protobuf.WellKnownTypes.StringValue> SetPublisherFeatureFlag(
+        SetPublisherFeatureFlagRequest request, ServerCallContext context)
+    {
+        if (!Guid.TryParse(request.PublisherId, out var pid))
+            throw new RpcException(new Status(StatusCode.InvalidArgument, "invalid publisher_id"));
+        await service.SetFeatureFlag(pid, request.Flag);
+        return new Google.Protobuf.WellKnownTypes.StringValue { Value = request.Flag };
+    }
+
+    public override async Task<HasPublisherFeatureResponse> HasPublisherFeature(HasPublisherFeatureRequest request,
+        ServerCallContext context)
+    {
+        if (!Guid.TryParse(request.PublisherId, out var pid))
+            throw new RpcException(new Status(StatusCode.InvalidArgument, "invalid publisher_id"));
+        var enabled = await service.HasFeature(pid, request.Flag);
+        return new HasPublisherFeatureResponse { Enabled = enabled };
+    }
+}