✨ Posting

DysonNetwork.Sphere/Account/Account.cs

@@ -1,9 +1,11 @@
 using System.ComponentModel.DataAnnotations;
 using System.Text.Json.Serialization;
+using Microsoft.EntityFrameworkCore;
 using NodaTime;
 
 namespace DysonNetwork.Sphere.Account;
 
+[Index(nameof(Name), IsUnique = true)]
 public class Account : ModelBase
 {
     public long Id { get; set; }

DysonNetwork.Sphere/Account/AccountController.cs

@@ -3,12 +3,13 @@ using DysonNetwork.Sphere.Storage;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
 
 namespace DysonNetwork.Sphere.Account;
 
 [ApiController]
 [Route("/accounts")]
-public class AccountController(AppDatabase db, FileService fs) : ControllerBase
+public class AccountController(AppDatabase db, FileService fs, IMemoryCache memCache) : ControllerBase
 {
     [HttpGet("{name}")]
     [ProducesResponseType<Account>(StatusCodes.Status200OK)]
@@ -77,9 +78,8 @@ public class AccountController(AppDatabase db, FileService fs) : ControllerBase
     [ProducesResponseType<Account>(StatusCodes.Status200OK)]
     public async Task<ActionResult<Account>> GetMe()
     {
-        var userIdClaim = User.FindFirst("user_id")?.Value;
-        long? userId = long.TryParse(userIdClaim, out var id) ? id : null;
-        if (userId is null) return new BadRequestObjectResult("Invalid or missing user_id claim.");
+        if (HttpContext.Items["CurrentUser"] is not Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
 
         var account = await db.Accounts
             .Include(e => e.Profile)
@@ -101,16 +101,13 @@ public class AccountController(AppDatabase db, FileService fs) : ControllerBase
     [HttpPatch("me")]
     public async Task<ActionResult<Account>> UpdateBasicInfo([FromBody] BasicInfoRequest request)
     {
-        var userIdClaim = User.FindFirst("user_id")?.Value;
-        long? userId = long.TryParse(userIdClaim, out var id) ? id : null;
-        if (userId is null) return new BadRequestObjectResult("Invalid or missing user_id claim.");
-
-        var account = await db.Accounts.FindAsync(userId);
-        if (account is null) return BadRequest("Unable to get your account.");
+        if (HttpContext.Items["CurrentUser"] is not Account account) return Unauthorized();
 
         if (request.Nick is not null) account.Nick = request.Nick;
         if (request.Language is not null) account.Language = request.Language;
         
+        memCache.Remove($"user_${account.Id}");
+
         await db.SaveChangesAsync();
         return account;
     }
@@ -130,9 +127,8 @@ public class AccountController(AppDatabase db, FileService fs) : ControllerBase
     [HttpPatch("me/profile")]
     public async Task<ActionResult<Profile>> UpdateProfile([FromBody] ProfileRequest request)
     {
-        var userIdClaim = User.FindFirst("user_id")?.Value;
-        long? userId = long.TryParse(userIdClaim, out var id) ? id : null;
-        if (userId is null) return new BadRequestObjectResult("Invalid or missing user_id claim.");
+        if (HttpContext.Items["CurrentUser"] is not Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
 
         var profile = await db.AccountProfiles
             .Where(p => p.Account.Id == userId)
@@ -170,6 +166,9 @@ public class AccountController(AppDatabase db, FileService fs) : ControllerBase
 
         db.Update(profile);
         await db.SaveChangesAsync();
+        
+        memCache.Remove($"user_${userId}");
+        
         return profile;
     }
 }

DysonNetwork.Sphere/Account/AccountService.cs

@@ -1,8 +1,10 @@
+using Casbin;
 using Microsoft.EntityFrameworkCore;
+using NodaTime;
 
 namespace DysonNetwork.Sphere.Account;
 
-public class AccountService(AppDatabase db)
+public class AccountService(AppDatabase db, IEnforcer enforcer)
 {
     public async Task<Account?> LookupAccount(string probe)
     {
@@ -17,4 +19,144 @@ public class AccountService(AppDatabase db)
 
         return null;
     }
+
+    public async Task<bool> HasExistingRelationship(Account userA, Account userB)
+    {
+        var count = await db.AccountRelationships
+            .Where(r => (r.AccountId == userA.Id && r.AccountId == userB.Id) ||
+                        (r.AccountId == userB.Id && r.AccountId == userA.Id))
+            .CountAsync();
+        return count > 0;
+    }
+
+    public async Task<Relationship?> GetRelationship(
+        Account account,
+        Account related,
+        RelationshipStatus? status,
+        bool ignoreExpired = false
+    )
+    {
+        var now = Instant.FromDateTimeUtc(DateTime.UtcNow);
+        var queries = db.AccountRelationships
+            .Where(r => r.AccountId == account.Id && r.AccountId == related.Id);
+        if (ignoreExpired) queries = queries.Where(r => r.ExpiredAt > now);
+        if (status is not null) queries = queries.Where(r => r.Status == status);
+        var relationship = await queries.FirstOrDefaultAsync();
+        return relationship;
+    }
+
+    public async Task<Relationship> CreateRelationship(Account sender, Account target, RelationshipStatus status)
+    {
+        if (status == RelationshipStatus.Pending)
+            throw new InvalidOperationException(
+                "Cannot create relationship with pending status, use SendFriendRequest instead.");
+        if (await HasExistingRelationship(sender, target))
+            throw new InvalidOperationException("Found existing relationship between you and target user.");
+
+        var relationship = new Relationship
+        {
+            Account = sender,
+            AccountId = sender.Id,
+            Related = target,
+            RelatedId = target.Id,
+            Status = status
+        };
+
+        db.AccountRelationships.Add(relationship);
+        await db.SaveChangesAsync();
+        await ApplyRelationshipPermissions(relationship);
+
+        return relationship;
+    }
+
+    public async Task<Relationship> SendFriendRequest(Account sender, Account target)
+    {
+        if (await HasExistingRelationship(sender, target))
+            throw new InvalidOperationException("Found existing relationship between you and target user.");
+
+        var relationship = new Relationship
+        {
+            Account = sender,
+            AccountId = sender.Id,
+            Related = target,
+            RelatedId = target.Id,
+            Status = RelationshipStatus.Pending,
+            ExpiredAt = Instant.FromDateTimeUtc(DateTime.UtcNow.AddDays(7))
+        };
+
+        db.AccountRelationships.Add(relationship);
+        await db.SaveChangesAsync();
+
+        return relationship;
+    }
+
+    public async Task<Relationship> AcceptFriendRelationship(
+        Relationship relationship,
+        RelationshipStatus status = RelationshipStatus.Friends
+    )
+    {
+        if (relationship.Status == RelationshipStatus.Pending)
+            throw new ArgumentException("Cannot accept friend request by setting the new status to pending.");
+
+        // Whatever the receiver decides to apply which status to the relationship,
+        // the sender should always see the user as a friend since the sender ask for it
+        relationship.Status = RelationshipStatus.Friends;
+        relationship.ExpiredAt = null;
+        db.Update(relationship);
+
+        var relationshipBackward = new Relationship
+        {
+            Account = relationship.Related,
+            AccountId = relationship.RelatedId,
+            Related = relationship.Account,
+            RelatedId = relationship.AccountId,
+            Status = status
+        };
+        db.AccountRelationships.Add(relationshipBackward);
+
+        await db.SaveChangesAsync();
+
+        await Task.WhenAll(
+            ApplyRelationshipPermissions(relationship),
+            ApplyRelationshipPermissions(relationshipBackward)
+        );
+
+        return relationshipBackward;
+    }
+
+    public async Task<Relationship> UpdateRelationship(Account account, Account related, RelationshipStatus status)
+    {
+        var relationship = await GetRelationship(account, related, status);
+        if (relationship is null) throw new ArgumentException("There is no relationship between you and the user.");
+        if (relationship.Status == status) return relationship;
+        relationship.Status = status;
+        db.Update(relationship);
+        await db.SaveChangesAsync();
+        await ApplyRelationshipPermissions(relationship);
+        return relationship;
+    }
+
+    private async Task ApplyRelationshipPermissions(Relationship relationship)
+    {
+        // Apply the relationship permissions to casbin enforcer
+        // domain: the user
+        // status is friends: all permissions are allowed by default, expect specially specified
+        // status is blocked: all permissions are disallowed by default, expect specially specified
+        // others: use the default permissions by design
+
+        var domain = $"user:{relationship.AccountId.ToString()}";
+        var target = relationship.RelatedId.ToString();
+
+        await enforcer.DeleteRolesForUserAsync(target, domain);
+
+        string role = relationship.Status switch
+        {
+            RelationshipStatus.Friends => "friends",
+            RelationshipStatus.Blocked => "blocked",
+            _ => "default" // fallback role
+        };
+        if (role == "default") return;
+
+        await enforcer.AddRoleForUserAsync(target, role, domain);
+    }
 }

DysonNetwork.Sphere/Account/Relationship.cs

@@ -1,18 +1,22 @@
+using NodaTime;
+
 namespace DysonNetwork.Sphere.Account;
 
-public enum RelationshipType
+public enum RelationshipStatus
 {
-    Friend,
+    Pending,
+    Friends,
     Blocked
 }
 
 public class Relationship : ModelBase
 {
-    public long FromAccountId { get; set; }
-    public Account FromAccount { get; set; } = null!;
+    public long AccountId { get; set; }
+    public Account Account { get; set; } = null!;
+    public long RelatedId { get; set; }
+    public Account Related { get; set; } = null!;
 
-    public long ToAccountId { get; set; }
-    public Account ToAccount { get; set; } = null!;
+    public Instant? ExpiredAt { get; set; }
 
-    public RelationshipType Type { get; set; }
+    public RelationshipStatus Status { get; set; } = RelationshipStatus.Pending;
 }

DysonNetwork.Sphere/Account/RelationshipController.cs

@@ -0,0 +1,61 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Build.Framework;
+using Microsoft.EntityFrameworkCore;
+
+namespace DysonNetwork.Sphere.Account;
+
+[ApiController]
+[Route("/relationships")]
+public class RelationshipController(AppDatabase db, AccountService accounts) : ControllerBase
+{
+    [HttpGet]
+    [Authorize]
+    public async Task<ActionResult<List<Relationship>>> ListRelationships([FromQuery] int offset = 0,
+        [FromQuery] int take = 20)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var totalCount = await db.AccountRelationships
+            .CountAsync(r => r.Account.Id == userId);
+        var relationships = await db.AccountRelationships
+            .Where(r => r.Account.Id == userId)
+            .Include(r => r.Related)
+            .Skip(offset)
+            .Take(take)
+            .ToListAsync();
+
+        Response.Headers["X-Total"] = totalCount.ToString();
+
+        return relationships;
+    }
+
+    public class RelationshipCreateRequest
+    {
+        [Required] public long UserId { get; set; }
+        [Required] public RelationshipStatus Status { get; set; }
+    }
+
+    [HttpPost]
+    [Authorize]
+    public async Task<ActionResult<Relationship>> CreateRelationship([FromBody] RelationshipCreateRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account currentUser) return Unauthorized();
+        
+        var relatedUser = await db.Accounts.FindAsync(request.UserId);
+        if (relatedUser is null) return BadRequest("Invalid related user");
+
+        try
+        {
+            var relationship = await accounts.CreateRelationship(
+                currentUser, relatedUser, request.Status
+            );
+            return relationship;
+        }
+        catch (InvalidOperationException err)
+        {
+            return BadRequest(err.Message);
+        }
+    }
+}

DysonNetwork.Sphere/AppDatabase.cs

@@ -27,6 +27,13 @@ public class AppDatabase(
     public DbSet<Auth.Session> AuthSessions { get; set; }
     public DbSet<Auth.Challenge> AuthChallenges { get; set; }
     public DbSet<Storage.CloudFile> Files { get; set; }
+    public DbSet<Post.Publisher> Publishers { get; set; }
+    public DbSet<Post.PublisherMember> PublisherMembers { get; set; }
+    public DbSet<Post.Post> Posts { get; set; }
+    public DbSet<Post.PostReaction> PostReactions { get; set; }
+    public DbSet<Post.PostTag> PostTags { get; set; }
+    public DbSet<Post.PostCategory> PostCategories { get; set; }
+    public DbSet<Post.PostCollection> PostCollections { get; set; }
 
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
     {
@@ -53,15 +60,55 @@ public class AppDatabase(
             .HasForeignKey<Account.Profile>(p => p.Id);
 
         modelBuilder.Entity<Account.Relationship>()
-            .HasKey(r => new { r.FromAccountId, r.ToAccountId });
+            .HasKey(r => new { FromAccountId = r.AccountId, ToAccountId = r.RelatedId });
         modelBuilder.Entity<Account.Relationship>()
-            .HasOne(r => r.FromAccount)
+            .HasOne(r => r.Account)
             .WithMany(a => a.OutgoingRelationships)
-            .HasForeignKey(r => r.FromAccountId);
+            .HasForeignKey(r => r.AccountId);
         modelBuilder.Entity<Account.Relationship>()
-            .HasOne(r => r.ToAccount)
+            .HasOne(r => r.Related)
             .WithMany(a => a.IncomingRelationships)
-            .HasForeignKey(r => r.ToAccountId);
+            .HasForeignKey(r => r.RelatedId);
+        
+        modelBuilder.Entity<Post.PublisherMember>()
+            .HasKey(pm => new { pm.PublisherId, pm.AccountId });
+        modelBuilder.Entity<Post.PublisherMember>()
+            .HasOne(pm => pm.Publisher)
+            .WithMany(p => p.Members)
+            .HasForeignKey(pm => pm.PublisherId)
+            .OnDelete(DeleteBehavior.Cascade);
+        modelBuilder.Entity<Post.PublisherMember>()
+            .HasOne(pm => pm.Account)
+            .WithMany()
+            .HasForeignKey(pm => pm.AccountId)
+            .OnDelete(DeleteBehavior.Cascade);
+        
+        modelBuilder.Entity<Post.Post>()
+            .HasOne(p => p.ThreadedPost)
+            .WithOne()
+            .HasForeignKey<Post.Post>(p => p.ThreadedPostId);
+        modelBuilder.Entity<Post.Post>()
+            .HasOne(p => p.RepliedPost)
+            .WithMany()
+            .HasForeignKey(p => p.RepliedPostId)
+            .OnDelete(DeleteBehavior.Restrict);
+        modelBuilder.Entity<Post.Post>()
+            .HasOne(p => p.ForwardedPost)
+            .WithMany()
+            .HasForeignKey(p  => p.ForwardedPostId)
+            .OnDelete(DeleteBehavior.Restrict);
+        modelBuilder.Entity<Post.Post>()
+            .HasMany(p => p.Tags)
+            .WithMany(t => t.Posts)
+            .UsingEntity(j => j.ToTable("post_tag_links"));
+        modelBuilder.Entity<Post.Post>()
+            .HasMany(p => p.Categories)
+            .WithMany(c => c.Posts)
+            .UsingEntity(j => j.ToTable("post_category_links"));
+        modelBuilder.Entity<Post.Post>()
+            .HasMany(p => p.Collections)
+            .WithMany(c => c.Posts)
+            .UsingEntity(j => j.ToTable("post_collection_links"));
 
         // Automatically apply soft-delete filter to all entities inheriting BaseModel
         foreach (var entityType in modelBuilder.Model.GetEntityTypes())

DysonNetwork.Sphere/Auth/UserInfoMiddleware.cs

@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace DysonNetwork.Sphere.Auth;
+
+public class UserInfoMiddleware(RequestDelegate next, IMemoryCache cache)
+{
+    public async Task InvokeAsync(HttpContext context, AppDatabase db)
+    {
+        var userIdClaim = context.User.FindFirst("user_id")?.Value;
+        if (userIdClaim is not null && long.TryParse(userIdClaim, out var userId))
+        {
+            if (!cache.TryGetValue($"user_{userId}", out Account.Account? user))
+            {
+                user = await db.Accounts
+                    .Include(e => e.Profile)
+                    .Where(e => e.Id == userId)
+                    .FirstOrDefaultAsync();
+
+                if (user is not null)
+                {
+                    cache.Set($"user_{userId}", user, TimeSpan.FromMinutes(10));
+                }
+            }
+
+            if (user is not null)
+            {
+                context.Items["CurrentUser"] = user;
+            }
+        }
+
+        await next(context);
+    }
+}

DysonNetwork.Sphere/Migrations/20250417145426_AddRelationship.Designer.cs

@@ -14,7 +14,7 @@ using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 namespace DysonNetwork.Sphere.Migrations
 {
     [DbContext(typeof(AppDatabase))]
-    [Migration("20250415171044_AddRelationship")]
+    [Migration("20250417145426_AddRelationship")]
     partial class AddRelationship
     {
         /// <inheritdoc />
@@ -226,13 +226,13 @@ namespace DysonNetwork.Sphere.Migrations
 
             modelBuilder.Entity("DysonNetwork.Sphere.Account.Relationship", b =>
                 {
-                    b.Property<long>("FromAccountId")
+                    b.Property<long>("AccountId")
                         .HasColumnType("bigint")
-                        .HasColumnName("from_account_id");
+                        .HasColumnName("account_id");
 
-                    b.Property<long>("ToAccountId")
+                    b.Property<long>("RelatedId")
                         .HasColumnType("bigint")
-                        .HasColumnName("to_account_id");
+                        .HasColumnName("related_id");
 
                     b.Property<Instant>("CreatedAt")
                         .HasColumnType("timestamp with time zone")
@@ -242,19 +242,23 @@ namespace DysonNetwork.Sphere.Migrations
                         .HasColumnType("timestamp with time zone")
                         .HasColumnName("deleted_at");
 
-                    b.Property<int>("Type")
+                    b.Property<Instant?>("ExpiredAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expired_at");
+
+                    b.Property<int>("Status")
                         .HasColumnType("integer")
-                        .HasColumnName("type");
+                        .HasColumnName("status");
 
                     b.Property<Instant>("UpdatedAt")
                         .HasColumnType("timestamp with time zone")
                         .HasColumnName("updated_at");
 
-                    b.HasKey("FromAccountId", "ToAccountId")
+                    b.HasKey("AccountId", "RelatedId")
                         .HasName("pk_account_relationships");
 
-                    b.HasIndex("ToAccountId")
-                        .HasDatabaseName("ix_account_relationships_to_account_id");
+                    b.HasIndex("RelatedId")
+                        .HasDatabaseName("ix_account_relationships_related_id");
 
                     b.ToTable("account_relationships", (string)null);
                 });
@@ -514,23 +518,23 @@ namespace DysonNetwork.Sphere.Migrations
 
             modelBuilder.Entity("DysonNetwork.Sphere.Account.Relationship", b =>
                 {
-                    b.HasOne("DysonNetwork.Sphere.Account.Account", "FromAccount")
+                    b.HasOne("DysonNetwork.Sphere.Account.Account", "Account")
                         .WithMany("OutgoingRelationships")
-                        .HasForeignKey("FromAccountId")
+                        .HasForeignKey("AccountId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_account_relationships_accounts_from_account_id");
+                        .HasConstraintName("fk_account_relationships_accounts_account_id");
 
-                    b.HasOne("DysonNetwork.Sphere.Account.Account", "ToAccount")
+                    b.HasOne("DysonNetwork.Sphere.Account.Account", "Related")
                         .WithMany("IncomingRelationships")
-                        .HasForeignKey("ToAccountId")
+                        .HasForeignKey("RelatedId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_account_relationships_accounts_to_account_id");
+                        .HasConstraintName("fk_account_relationships_accounts_related_id");
 
-                    b.Navigation("FromAccount");
+                    b.Navigation("Account");
 
-                    b.Navigation("ToAccount");
+                    b.Navigation("Related");
                 });
 
             modelBuilder.Entity("DysonNetwork.Sphere.Auth.Challenge", b =>

DysonNetwork.Sphere/Migrations/20250417145426_AddRelationship.cs

@@ -15,34 +15,35 @@ namespace DysonNetwork.Sphere.Migrations
                 name: "account_relationships",
                 columns: table => new
                 {
-                    from_account_id = table.Column<long>(type: "bigint", nullable: false),
-                    to_account_id = table.Column<long>(type: "bigint", nullable: false),
-                    type = table.Column<int>(type: "integer", nullable: false),
+                    account_id = table.Column<long>(type: "bigint", nullable: false),
+                    related_id = table.Column<long>(type: "bigint", nullable: false),
+                    expired_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    status = table.Column<int>(type: "integer", nullable: false),
                     created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
                     updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
                     deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("pk_account_relationships", x => new { x.from_account_id, x.to_account_id });
+                    table.PrimaryKey("pk_account_relationships", x => new { x.account_id, x.related_id });
                     table.ForeignKey(
-                        name: "fk_account_relationships_accounts_from_account_id",
-                        column: x => x.from_account_id,
+                        name: "fk_account_relationships_accounts_account_id",
+                        column: x => x.account_id,
                         principalTable: "accounts",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Cascade);
                     table.ForeignKey(
-                        name: "fk_account_relationships_accounts_to_account_id",
-                        column: x => x.to_account_id,
+                        name: "fk_account_relationships_accounts_related_id",
+                        column: x => x.related_id,
                         principalTable: "accounts",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Cascade);
                 });
 
             migrationBuilder.CreateIndex(
-                name: "ix_account_relationships_to_account_id",
+                name: "ix_account_relationships_related_id",
                 table: "account_relationships",
-                column: "to_account_id");
+                column: "related_id");
         }
 
         /// <inheritdoc />

DysonNetwork.Sphere/Migrations/20250419115230_AddPost.cs

@@ -0,0 +1,451 @@
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+using NodaTime;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace DysonNetwork.Sphere.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPost : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<long>(
+                name: "post_id",
+                table: "files",
+                type: "bigint",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "post_categories",
+                columns: table => new
+                {
+                    id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    slug = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_post_categories", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "post_tags",
+                columns: table => new
+                {
+                    id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    slug = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_post_tags", x => x.id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "publishers",
+                columns: table => new
+                {
+                    id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    publisher_type = table.Column<int>(type: "integer", nullable: false),
+                    name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    nick = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    bio = table.Column<string>(type: "character varying(4096)", maxLength: 4096, nullable: true),
+                    picture_id = table.Column<string>(type: "text", nullable: true),
+                    background_id = table.Column<string>(type: "text", nullable: true),
+                    account_id = table.Column<long>(type: "bigint", nullable: true),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_publishers", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_publishers_accounts_account_id",
+                        column: x => x.account_id,
+                        principalTable: "accounts",
+                        principalColumn: "id");
+                    table.ForeignKey(
+                        name: "fk_publishers_files_background_id",
+                        column: x => x.background_id,
+                        principalTable: "files",
+                        principalColumn: "id");
+                    table.ForeignKey(
+                        name: "fk_publishers_files_picture_id",
+                        column: x => x.picture_id,
+                        principalTable: "files",
+                        principalColumn: "id");
+                });
+
+            migrationBuilder.CreateTable(
+                name: "post_collections",
+                columns: table => new
+                {
+                    id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    slug = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: false),
+                    name = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: true),
+                    description = table.Column<string>(type: "character varying(4096)", maxLength: 4096, nullable: true),
+                    publisher_id = table.Column<long>(type: "bigint", nullable: false),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_post_collections", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_post_collections_publishers_publisher_id",
+                        column: x => x.publisher_id,
+                        principalTable: "publishers",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "posts",
+                columns: table => new
+                {
+                    id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    title = table.Column<string>(type: "character varying(1024)", maxLength: 1024, nullable: true),
+                    description = table.Column<string>(type: "character varying(4096)", maxLength: 4096, nullable: true),
+                    language = table.Column<string>(type: "character varying(128)", maxLength: 128, nullable: true),
+                    edited_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    published_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    visibility = table.Column<int>(type: "integer", nullable: false),
+                    content = table.Column<string>(type: "text", nullable: true),
+                    type = table.Column<int>(type: "integer", nullable: false),
+                    meta = table.Column<Dictionary<string, object>>(type: "jsonb", nullable: true),
+                    views_unique = table.Column<int>(type: "integer", nullable: false),
+                    views_total = table.Column<int>(type: "integer", nullable: false),
+                    upvotes = table.Column<int>(type: "integer", nullable: false),
+                    downvotes = table.Column<int>(type: "integer", nullable: false),
+                    threaded_post_id = table.Column<long>(type: "bigint", nullable: true),
+                    replied_post_id = table.Column<long>(type: "bigint", nullable: true),
+                    forwarded_post_id = table.Column<long>(type: "bigint", nullable: true),
+                    publisher_id = table.Column<long>(type: "bigint", nullable: false),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_posts", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_posts_posts_forwarded_post_id",
+                        column: x => x.forwarded_post_id,
+                        principalTable: "posts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "fk_posts_posts_replied_post_id",
+                        column: x => x.replied_post_id,
+                        principalTable: "posts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "fk_posts_posts_threaded_post_id",
+                        column: x => x.threaded_post_id,
+                        principalTable: "posts",
+                        principalColumn: "id");
+                    table.ForeignKey(
+                        name: "fk_posts_publishers_publisher_id",
+                        column: x => x.publisher_id,
+                        principalTable: "publishers",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "publisher_members",
+                columns: table => new
+                {
+                    publisher_id = table.Column<long>(type: "bigint", nullable: false),
+                    account_id = table.Column<long>(type: "bigint", nullable: false),
+                    role = table.Column<int>(type: "integer", nullable: false),
+                    joined_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_publisher_members", x => new { x.publisher_id, x.account_id });
+                    table.ForeignKey(
+                        name: "fk_publisher_members_accounts_account_id",
+                        column: x => x.account_id,
+                        principalTable: "accounts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "fk_publisher_members_publishers_publisher_id",
+                        column: x => x.publisher_id,
+                        principalTable: "publishers",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "post_category_links",
+                columns: table => new
+                {
+                    categories_id = table.Column<long>(type: "bigint", nullable: false),
+                    posts_id = table.Column<long>(type: "bigint", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_post_category_links", x => new { x.categories_id, x.posts_id });
+                    table.ForeignKey(
+                        name: "fk_post_category_links_post_categories_categories_id",
+                        column: x => x.categories_id,
+                        principalTable: "post_categories",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "fk_post_category_links_posts_posts_id",
+                        column: x => x.posts_id,
+                        principalTable: "posts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "post_collection_links",
+                columns: table => new
+                {
+                    collections_id = table.Column<long>(type: "bigint", nullable: false),
+                    posts_id = table.Column<long>(type: "bigint", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_post_collection_links", x => new { x.collections_id, x.posts_id });
+                    table.ForeignKey(
+                        name: "fk_post_collection_links_post_collections_collections_id",
+                        column: x => x.collections_id,
+                        principalTable: "post_collections",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "fk_post_collection_links_posts_posts_id",
+                        column: x => x.posts_id,
+                        principalTable: "posts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "post_reactions",
+                columns: table => new
+                {
+                    id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    symbol = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    attitude = table.Column<int>(type: "integer", nullable: false),
+                    post_id = table.Column<long>(type: "bigint", nullable: false),
+                    account_id = table.Column<long>(type: "bigint", nullable: false),
+                    created_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    updated_at = table.Column<Instant>(type: "timestamp with time zone", nullable: false),
+                    deleted_at = table.Column<Instant>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_post_reactions", x => x.id);
+                    table.ForeignKey(
+                        name: "fk_post_reactions_accounts_account_id",
+                        column: x => x.account_id,
+                        principalTable: "accounts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "fk_post_reactions_posts_post_id",
+                        column: x => x.post_id,
+                        principalTable: "posts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "post_tag_links",
+                columns: table => new
+                {
+                    posts_id = table.Column<long>(type: "bigint", nullable: false),
+                    tags_id = table.Column<long>(type: "bigint", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_post_tag_links", x => new { x.posts_id, x.tags_id });
+                    table.ForeignKey(
+                        name: "fk_post_tag_links_post_tags_tags_id",
+                        column: x => x.tags_id,
+                        principalTable: "post_tags",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "fk_post_tag_links_posts_posts_id",
+                        column: x => x.posts_id,
+                        principalTable: "posts",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "ix_files_post_id",
+                table: "files",
+                column: "post_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_accounts_name",
+                table: "accounts",
+                column: "name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_post_category_links_posts_id",
+                table: "post_category_links",
+                column: "posts_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_post_collection_links_posts_id",
+                table: "post_collection_links",
+                column: "posts_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_post_collections_publisher_id",
+                table: "post_collections",
+                column: "publisher_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_post_reactions_account_id",
+                table: "post_reactions",
+                column: "account_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_post_reactions_post_id",
+                table: "post_reactions",
+                column: "post_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_post_tag_links_tags_id",
+                table: "post_tag_links",
+                column: "tags_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_posts_forwarded_post_id",
+                table: "posts",
+                column: "forwarded_post_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_posts_publisher_id",
+                table: "posts",
+                column: "publisher_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_posts_replied_post_id",
+                table: "posts",
+                column: "replied_post_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_posts_threaded_post_id",
+                table: "posts",
+                column: "threaded_post_id",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_publisher_members_account_id",
+                table: "publisher_members",
+                column: "account_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_publishers_account_id",
+                table: "publishers",
+                column: "account_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_publishers_background_id",
+                table: "publishers",
+                column: "background_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_publishers_name",
+                table: "publishers",
+                column: "name",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "ix_publishers_picture_id",
+                table: "publishers",
+                column: "picture_id");
+
+            migrationBuilder.AddForeignKey(
+                name: "fk_files_posts_post_id",
+                table: "files",
+                column: "post_id",
+                principalTable: "posts",
+                principalColumn: "id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "fk_files_posts_post_id",
+                table: "files");
+
+            migrationBuilder.DropTable(
+                name: "post_category_links");
+
+            migrationBuilder.DropTable(
+                name: "post_collection_links");
+
+            migrationBuilder.DropTable(
+                name: "post_reactions");
+
+            migrationBuilder.DropTable(
+                name: "post_tag_links");
+
+            migrationBuilder.DropTable(
+                name: "publisher_members");
+
+            migrationBuilder.DropTable(
+                name: "post_categories");
+
+            migrationBuilder.DropTable(
+                name: "post_collections");
+
+            migrationBuilder.DropTable(
+                name: "post_tags");
+
+            migrationBuilder.DropTable(
+                name: "posts");
+
+            migrationBuilder.DropTable(
+                name: "publishers");
+
+            migrationBuilder.DropIndex(
+                name: "ix_files_post_id",
+                table: "files");
+
+            migrationBuilder.DropIndex(
+                name: "ix_accounts_name",
+                table: "accounts");
+
+            migrationBuilder.DropColumn(
+                name: "post_id",
+                table: "files");
+        }
+    }
+}

DysonNetwork.Sphere/Migrations/AppDatabaseModelSnapshot.cs

@@ -70,6 +70,10 @@ namespace DysonNetwork.Sphere.Migrations
                     b.HasKey("Id")
                         .HasName("pk_accounts");
 
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_accounts_name");
+
                     b.ToTable("accounts", (string)null);
                 });
 
@@ -223,13 +227,13 @@ namespace DysonNetwork.Sphere.Migrations
 
             modelBuilder.Entity("DysonNetwork.Sphere.Account.Relationship", b =>
                 {
-                    b.Property<long>("FromAccountId")
+                    b.Property<long>("AccountId")
                         .HasColumnType("bigint")
-                        .HasColumnName("from_account_id");
+                        .HasColumnName("account_id");
 
-                    b.Property<long>("ToAccountId")
+                    b.Property<long>("RelatedId")
                         .HasColumnType("bigint")
-                        .HasColumnName("to_account_id");
+                        .HasColumnName("related_id");
 
                     b.Property<Instant>("CreatedAt")
                         .HasColumnType("timestamp with time zone")
@@ -239,19 +243,23 @@ namespace DysonNetwork.Sphere.Migrations
                         .HasColumnType("timestamp with time zone")
                         .HasColumnName("deleted_at");
 
-                    b.Property<int>("Type")
+                    b.Property<Instant?>("ExpiredAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expired_at");
+
+                    b.Property<int>("Status")
                         .HasColumnType("integer")
-                        .HasColumnName("type");
+                        .HasColumnName("status");
 
                     b.Property<Instant>("UpdatedAt")
                         .HasColumnType("timestamp with time zone")
                         .HasColumnName("updated_at");
 
-                    b.HasKey("FromAccountId", "ToAccountId")
+                    b.HasKey("AccountId", "RelatedId")
                         .HasName("pk_account_relationships");
 
-                    b.HasIndex("ToAccountId")
-                        .HasDatabaseName("ix_account_relationships_to_account_id");
+                    b.HasIndex("RelatedId")
+                        .HasDatabaseName("ix_account_relationships_related_id");
 
                     b.ToTable("account_relationships", (string)null);
                 });
@@ -382,6 +390,406 @@ namespace DysonNetwork.Sphere.Migrations
                     b.ToTable("auth_sessions", (string)null);
                 });
 
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.Post", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Content")
+                        .HasColumnType("text")
+                        .HasColumnName("content");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("description");
+
+                    b.Property<int>("Downvotes")
+                        .HasColumnType("integer")
+                        .HasColumnName("downvotes");
+
+                    b.Property<Instant?>("EditedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("edited_at");
+
+                    b.Property<long?>("ForwardedPostId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("forwarded_post_id");
+
+                    b.Property<string>("Language")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("language");
+
+                    b.Property<Dictionary<string, object>>("Meta")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("meta");
+
+                    b.Property<Instant?>("PublishedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("published_at");
+
+                    b.Property<long>("PublisherId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("publisher_id");
+
+                    b.Property<long?>("RepliedPostId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("replied_post_id");
+
+                    b.Property<long?>("ThreadedPostId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("threaded_post_id");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)")
+                        .HasColumnName("title");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasColumnName("type");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.Property<int>("Upvotes")
+                        .HasColumnType("integer")
+                        .HasColumnName("upvotes");
+
+                    b.Property<int>("ViewsTotal")
+                        .HasColumnType("integer")
+                        .HasColumnName("views_total");
+
+                    b.Property<int>("ViewsUnique")
+                        .HasColumnType("integer")
+                        .HasColumnName("views_unique");
+
+                    b.Property<int>("Visibility")
+                        .HasColumnType("integer")
+                        .HasColumnName("visibility");
+
+                    b.HasKey("Id")
+                        .HasName("pk_posts");
+
+                    b.HasIndex("ForwardedPostId")
+                        .HasDatabaseName("ix_posts_forwarded_post_id");
+
+                    b.HasIndex("PublisherId")
+                        .HasDatabaseName("ix_posts_publisher_id");
+
+                    b.HasIndex("RepliedPostId")
+                        .HasDatabaseName("ix_posts_replied_post_id");
+
+                    b.HasIndex("ThreadedPostId")
+                        .IsUnique()
+                        .HasDatabaseName("ix_posts_threaded_post_id");
+
+                    b.ToTable("posts", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PostCategory", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("slug");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id")
+                        .HasName("pk_post_categories");
+
+                    b.ToTable("post_categories", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PostCollection", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("description");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("name");
+
+                    b.Property<long>("PublisherId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("publisher_id");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("slug");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id")
+                        .HasName("pk_post_collections");
+
+                    b.HasIndex("PublisherId")
+                        .HasDatabaseName("ix_post_collections_publisher_id");
+
+                    b.ToTable("post_collections", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PostReaction", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("AccountId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("account_id");
+
+                    b.Property<int>("Attitude")
+                        .HasColumnType("integer")
+                        .HasColumnName("attitude");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<long>("PostId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("post_id");
+
+                    b.Property<string>("Symbol")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("symbol");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id")
+                        .HasName("pk_post_reactions");
+
+                    b.HasIndex("AccountId")
+                        .HasDatabaseName("ix_post_reactions_account_id");
+
+                    b.HasIndex("PostId")
+                        .HasDatabaseName("ix_post_reactions_post_id");
+
+                    b.ToTable("post_reactions", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PostTag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("slug");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id")
+                        .HasName("pk_post_tags");
+
+                    b.ToTable("post_tags", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.Publisher", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasColumnName("id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long?>("AccountId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("account_id");
+
+                    b.Property<string>("BackgroundId")
+                        .HasColumnType("text")
+                        .HasColumnName("background_id");
+
+                    b.Property<string>("Bio")
+                        .HasMaxLength(4096)
+                        .HasColumnType("character varying(4096)")
+                        .HasColumnName("bio");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Nick")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("nick");
+
+                    b.Property<string>("PictureId")
+                        .HasColumnType("text")
+                        .HasColumnName("picture_id");
+
+                    b.Property<int>("PublisherType")
+                        .HasColumnType("integer")
+                        .HasColumnName("publisher_type");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("Id")
+                        .HasName("pk_publishers");
+
+                    b.HasIndex("AccountId")
+                        .HasDatabaseName("ix_publishers_account_id");
+
+                    b.HasIndex("BackgroundId")
+                        .HasDatabaseName("ix_publishers_background_id");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasDatabaseName("ix_publishers_name");
+
+                    b.HasIndex("PictureId")
+                        .HasDatabaseName("ix_publishers_picture_id");
+
+                    b.ToTable("publishers", (string)null);
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PublisherMember", b =>
+                {
+                    b.Property<long>("PublisherId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("publisher_id");
+
+                    b.Property<long>("AccountId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("account_id");
+
+                    b.Property<Instant>("CreatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("created_at");
+
+                    b.Property<Instant?>("DeletedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("deleted_at");
+
+                    b.Property<Instant?>("JoinedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("joined_at");
+
+                    b.Property<int>("Role")
+                        .HasColumnType("integer")
+                        .HasColumnName("role");
+
+                    b.Property<Instant>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("updated_at");
+
+                    b.HasKey("PublisherId", "AccountId")
+                        .HasName("pk_publisher_members");
+
+                    b.HasIndex("AccountId")
+                        .HasDatabaseName("ix_publisher_members_account_id");
+
+                    b.ToTable("publisher_members", (string)null);
+                });
+
             modelBuilder.Entity("DysonNetwork.Sphere.Storage.CloudFile", b =>
                 {
                     b.Property<string>("Id")
@@ -425,6 +833,10 @@ namespace DysonNetwork.Sphere.Migrations
                         .HasColumnType("character varying(1024)")
                         .HasColumnName("name");
 
+                    b.Property<long?>("PostId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("post_id");
+
                     b.Property<long>("Size")
                         .HasColumnType("bigint")
                         .HasColumnName("size");
@@ -456,9 +868,69 @@ namespace DysonNetwork.Sphere.Migrations
                     b.HasIndex("AccountId")
                         .HasDatabaseName("ix_files_account_id");
 
+                    b.HasIndex("PostId")
+                        .HasDatabaseName("ix_files_post_id");
+
                     b.ToTable("files", (string)null);
                 });
 
+            modelBuilder.Entity("PostPostCategory", b =>
+                {
+                    b.Property<long>("CategoriesId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("categories_id");
+
+                    b.Property<long>("PostsId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("posts_id");
+
+                    b.HasKey("CategoriesId", "PostsId")
+                        .HasName("pk_post_category_links");
+
+                    b.HasIndex("PostsId")
+                        .HasDatabaseName("ix_post_category_links_posts_id");
+
+                    b.ToTable("post_category_links", (string)null);
+                });
+
+            modelBuilder.Entity("PostPostCollection", b =>
+                {
+                    b.Property<long>("CollectionsId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("collections_id");
+
+                    b.Property<long>("PostsId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("posts_id");
+
+                    b.HasKey("CollectionsId", "PostsId")
+                        .HasName("pk_post_collection_links");
+
+                    b.HasIndex("PostsId")
+                        .HasDatabaseName("ix_post_collection_links_posts_id");
+
+                    b.ToTable("post_collection_links", (string)null);
+                });
+
+            modelBuilder.Entity("PostPostTag", b =>
+                {
+                    b.Property<long>("PostsId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("posts_id");
+
+                    b.Property<long>("TagsId")
+                        .HasColumnType("bigint")
+                        .HasColumnName("tags_id");
+
+                    b.HasKey("PostsId", "TagsId")
+                        .HasName("pk_post_tag_links");
+
+                    b.HasIndex("TagsId")
+                        .HasDatabaseName("ix_post_tag_links_tags_id");
+
+                    b.ToTable("post_tag_links", (string)null);
+                });
+
             modelBuilder.Entity("DysonNetwork.Sphere.Account.AccountAuthFactor", b =>
                 {
                     b.HasOne("DysonNetwork.Sphere.Account.Account", "Account")
@@ -511,23 +983,23 @@ namespace DysonNetwork.Sphere.Migrations
 
             modelBuilder.Entity("DysonNetwork.Sphere.Account.Relationship", b =>
                 {
-                    b.HasOne("DysonNetwork.Sphere.Account.Account", "FromAccount")
+                    b.HasOne("DysonNetwork.Sphere.Account.Account", "Account")
                         .WithMany("OutgoingRelationships")
-                        .HasForeignKey("FromAccountId")
+                        .HasForeignKey("AccountId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_account_relationships_accounts_from_account_id");
+                        .HasConstraintName("fk_account_relationships_accounts_account_id");
 
-                    b.HasOne("DysonNetwork.Sphere.Account.Account", "ToAccount")
+                    b.HasOne("DysonNetwork.Sphere.Account.Account", "Related")
                         .WithMany("IncomingRelationships")
-                        .HasForeignKey("ToAccountId")
+                        .HasForeignKey("RelatedId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired()
-                        .HasConstraintName("fk_account_relationships_accounts_to_account_id");
+                        .HasConstraintName("fk_account_relationships_accounts_related_id");
 
-                    b.Navigation("FromAccount");
+                    b.Navigation("Account");
 
-                    b.Navigation("ToAccount");
+                    b.Navigation("Related");
                 });
 
             modelBuilder.Entity("DysonNetwork.Sphere.Auth.Challenge", b =>
@@ -563,6 +1035,119 @@ namespace DysonNetwork.Sphere.Migrations
                     b.Navigation("Challenge");
                 });
 
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.Post", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", "ForwardedPost")
+                        .WithMany()
+                        .HasForeignKey("ForwardedPostId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_posts_posts_forwarded_post_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.Publisher", "Publisher")
+                        .WithMany("Posts")
+                        .HasForeignKey("PublisherId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_posts_publishers_publisher_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", "RepliedPost")
+                        .WithMany()
+                        .HasForeignKey("RepliedPostId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .HasConstraintName("fk_posts_posts_replied_post_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", "ThreadedPost")
+                        .WithOne()
+                        .HasForeignKey("DysonNetwork.Sphere.Post.Post", "ThreadedPostId")
+                        .HasConstraintName("fk_posts_posts_threaded_post_id");
+
+                    b.Navigation("ForwardedPost");
+
+                    b.Navigation("Publisher");
+
+                    b.Navigation("RepliedPost");
+
+                    b.Navigation("ThreadedPost");
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PostCollection", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Post.Publisher", "Publisher")
+                        .WithMany("Collections")
+                        .HasForeignKey("PublisherId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_collections_publishers_publisher_id");
+
+                    b.Navigation("Publisher");
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PostReaction", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Account.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_reactions_accounts_account_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", "Post")
+                        .WithMany("Reactions")
+                        .HasForeignKey("PostId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_reactions_posts_post_id");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Post");
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.Publisher", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Account.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .HasConstraintName("fk_publishers_accounts_account_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Storage.CloudFile", "Background")
+                        .WithMany()
+                        .HasForeignKey("BackgroundId")
+                        .HasConstraintName("fk_publishers_files_background_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Storage.CloudFile", "Picture")
+                        .WithMany()
+                        .HasForeignKey("PictureId")
+                        .HasConstraintName("fk_publishers_files_picture_id");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Background");
+
+                    b.Navigation("Picture");
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.PublisherMember", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Account.Account", "Account")
+                        .WithMany()
+                        .HasForeignKey("AccountId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_publisher_members_accounts_account_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.Publisher", "Publisher")
+                        .WithMany("Members")
+                        .HasForeignKey("PublisherId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_publisher_members_publishers_publisher_id");
+
+                    b.Navigation("Account");
+
+                    b.Navigation("Publisher");
+                });
+
             modelBuilder.Entity("DysonNetwork.Sphere.Storage.CloudFile", b =>
                 {
                     b.HasOne("DysonNetwork.Sphere.Account.Account", "Account")
@@ -572,9 +1157,65 @@ namespace DysonNetwork.Sphere.Migrations
                         .IsRequired()
                         .HasConstraintName("fk_files_accounts_account_id");
 
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", null)
+                        .WithMany("Attachments")
+                        .HasForeignKey("PostId")
+                        .HasConstraintName("fk_files_posts_post_id");
+
                     b.Navigation("Account");
                 });
 
+            modelBuilder.Entity("PostPostCategory", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Post.PostCategory", null)
+                        .WithMany()
+                        .HasForeignKey("CategoriesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_category_links_post_categories_categories_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", null)
+                        .WithMany()
+                        .HasForeignKey("PostsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_category_links_posts_posts_id");
+                });
+
+            modelBuilder.Entity("PostPostCollection", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Post.PostCollection", null)
+                        .WithMany()
+                        .HasForeignKey("CollectionsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_collection_links_post_collections_collections_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", null)
+                        .WithMany()
+                        .HasForeignKey("PostsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_collection_links_posts_posts_id");
+                });
+
+            modelBuilder.Entity("PostPostTag", b =>
+                {
+                    b.HasOne("DysonNetwork.Sphere.Post.Post", null)
+                        .WithMany()
+                        .HasForeignKey("PostsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_tag_links_posts_posts_id");
+
+                    b.HasOne("DysonNetwork.Sphere.Post.PostTag", null)
+                        .WithMany()
+                        .HasForeignKey("TagsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("fk_post_tag_links_post_tags_tags_id");
+                });
+
             modelBuilder.Entity("DysonNetwork.Sphere.Account.Account", b =>
                 {
                     b.Navigation("AuthFactors");
@@ -592,6 +1233,22 @@ namespace DysonNetwork.Sphere.Migrations
 
                     b.Navigation("Sessions");
                 });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.Post", b =>
+                {
+                    b.Navigation("Attachments");
+
+                    b.Navigation("Reactions");
+                });
+
+            modelBuilder.Entity("DysonNetwork.Sphere.Post.Publisher", b =>
+                {
+                    b.Navigation("Collections");
+
+                    b.Navigation("Members");
+
+                    b.Navigation("Posts");
+                });
 #pragma warning restore 612, 618
         }
     }

DysonNetwork.Sphere/Post/Post.cs

@@ -0,0 +1,106 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text.Json.Serialization;
+using DysonNetwork.Sphere.Storage;
+using NodaTime;
+
+namespace DysonNetwork.Sphere.Post;
+
+public enum PostType
+{
+    Moment,
+    Article,
+    Video
+}
+
+public enum PostVisibility
+{
+    Public,
+    Friends,
+    Unlisted,
+    Private
+}
+
+public class Post : ModelBase
+{
+    public long Id { get; set; }
+    [MaxLength(1024)] public string? Title { get; set; }
+    [MaxLength(4096)] public string? Description { get; set; }
+    [MaxLength(128)] public string? Language { get; set; }
+    public Instant? EditedAt { get; set; }
+    public Instant? PublishedAt { get; set; }
+    public PostVisibility Visibility { get; set; } = PostVisibility.Public;
+
+    // ReSharper disable once EntityFramework.ModelValidation.UnlimitedStringLength
+    public string? Content { get; set; }
+
+    public PostType Type { get; set; }
+    [Column(TypeName = "jsonb")] public Dictionary<string, object>? Meta { get; set; }
+
+    public int ViewsUnique { get; set; }
+    public int ViewsTotal { get; set; }
+    public int Upvotes { get; set; }
+    public int Downvotes { get; set; }
+
+    public long? ThreadedPostId { get; set; }
+    public Post? ThreadedPost { get; set; }
+    public long? RepliedPostId { get; set; }
+    public Post? RepliedPost { get; set; }
+    public long? ForwardedPostId { get; set; }
+    public Post? ForwardedPost { get; set; }
+    public ICollection<CloudFile> Attachments { get; set; } = new List<CloudFile>();
+
+    public Publisher Publisher { get; set; } = null!;
+    public ICollection<PostReaction> Reactions { get; set; } = new List<PostReaction>();
+    public ICollection<PostTag> Tags { get; set; } = new List<PostTag>();
+    public ICollection<PostCategory> Categories { get; set; } = new List<PostCategory>();
+    public ICollection<PostCollection> Collections { get; set; } = new List<PostCollection>();
+
+    public bool Empty => Content?.Trim() is { Length: 0 } && Attachments.Count == 0 && ForwardedPostId == null;
+}
+
+public class PostTag : ModelBase
+{
+    public long Id { get; set; }
+    [MaxLength(128)] public string Slug { get; set; } = null!;
+    [MaxLength(256)] public string? Name { get; set; }
+    public ICollection<Post> Posts { get; set; } = new List<Post>();
+}
+
+public class PostCategory : ModelBase
+{
+    public long Id { get; set; }
+    [MaxLength(128)] public string Slug { get; set; } = null!;
+    [MaxLength(256)] public string? Name { get; set; }
+    public ICollection<Post> Posts { get; set; } = new List<Post>();
+}
+
+public class PostCollection : ModelBase
+{
+    public long Id { get; set; }
+    [MaxLength(128)] public string Slug { get; set; } = null!;
+    [MaxLength(256)] public string? Name { get; set; }
+    [MaxLength(4096)] public string? Description { get; set; }
+
+    public Publisher Publisher { get; set; } = null!;
+
+    public ICollection<Post> Posts { get; set; } = new List<Post>();
+}
+
+public enum PostReactionAttitude
+{
+    Positive,
+    Neutral,
+    Negative,
+}
+
+public class PostReaction : ModelBase
+{
+    public long Id { get; set; }
+    [MaxLength(256)] public string Symbol { get; set; } = null!;
+    public PostReactionAttitude Attitude { get; set; }
+
+    public long PostId { get; set; }
+    [JsonIgnore] public Post Post { get; set; } = null!;
+    public Account.Account Account { get; set; } = null!;
+}

DysonNetwork.Sphere/Post/PostController.cs

@@ -0,0 +1,225 @@
+using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace DysonNetwork.Sphere.Post;
+
+[ApiController]
+[Route("/posts")]
+public class PostController(AppDatabase db, PostService ps) : ControllerBase
+{
+    [HttpGet]
+    public async Task<ActionResult<List<Post>>> ListPosts([FromQuery] int offset = 0, [FromQuery] int take = 20)
+    {
+        HttpContext.Items.TryGetValue("CurrentUser", out var currentUserValue);
+        var currentUser = currentUserValue as Account.Account;
+
+        var totalCount = await db.Posts
+            .CountAsync();
+        var posts = await db.Posts
+            .Include(e => e.Publisher)
+            .Include(e => e.ThreadedPost)
+            .Include(e => e.ForwardedPost)
+            .Include(e => e.Attachments)
+            .Include(e => e.Categories)
+            .Include(e => e.Tags)
+            .FilterWithVisibility(currentUser, isListing: true)
+            .Skip(offset)
+            .Take(take)
+            .ToListAsync();
+
+        Response.Headers["X-Total"] = totalCount.ToString();
+
+        return Ok(posts);
+    }
+
+    [HttpGet("{id:long}")]
+    public async Task<ActionResult<Post>> GetPost(long id)
+    {
+        HttpContext.Items.TryGetValue("CurrentUser", out var currentUserValue);
+        var currentUser = currentUserValue as Account.Account;
+
+        var post = await db.Posts
+            .Where(e => e.Id == id)
+            .Include(e => e.Publisher)
+            .Include(e => e.RepliedPost)
+            .Include(e => e.ThreadedPost)
+            .Include(e => e.ForwardedPost)
+            .Include(e => e.Tags)
+            .Include(e => e.Categories)
+            .Include(e => e.Attachments)
+            .FilterWithVisibility(currentUser)
+            .FirstOrDefaultAsync();
+        if (post is null) return NotFound();
+
+        return Ok(post);
+    }
+
+    [HttpGet("{id:long}/replies")]
+    public async Task<ActionResult<List<Post>>> ListReplies(long id, [FromQuery] int offset = 0,
+        [FromQuery] int take = 20)
+    {
+        HttpContext.Items.TryGetValue("CurrentUser", out var currentUserValue);
+        var currentUser = currentUserValue as Account.Account;
+
+        var post = await db.Posts
+            .Where(e => e.Id == id)
+            .FirstOrDefaultAsync();
+        if (post is null) return NotFound();
+
+        var totalCount = await db.Posts
+            .Where(e => e.RepliedPostId == post.Id)
+            .CountAsync();
+        var posts = await db.Posts
+            .Where(e => e.RepliedPostId == id)
+            .Include(e => e.Publisher)
+            .Include(e => e.ThreadedPost)
+            .Include(e => e.ForwardedPost)
+            .Include(e => e.Attachments)
+            .Include(e => e.Categories)
+            .Include(e => e.Tags)
+            .FilterWithVisibility(currentUser, isListing: true)
+            .Skip(offset)
+            .Take(take)
+            .ToListAsync();
+
+        Response.Headers["X-Total"] = totalCount.ToString();
+
+        return Ok(posts);
+    }
+
+    public class PostRequest
+    {
+        [MaxLength(1024)] public string? Title { get; set; }
+        [MaxLength(4096)] public string? Description { get; set; }
+        public string? Content { get; set; }
+        public PostVisibility? Visibility { get; set; }
+        public PostType? Type { get; set; }
+        [MaxLength(16)] public List<string>? Tags { get; set; }
+        [MaxLength(8)] public List<string>? Categories { get; set; }
+        [MaxLength(32)] public List<string>? Attachments { get; set; }
+        public Dictionary<string, object>? Meta { get; set; }
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<Post>> CreatePost(
+        [FromBody] PostRequest request,
+        [FromHeader(Name = "X-Pub")] string? publisherName
+    )
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+
+        Publisher? publisher;
+        if (publisherName is null)
+        {
+            // Use the first personal publisher
+            publisher = await db.Publishers.FirstOrDefaultAsync(e =>
+                e.AccountId == currentUser.Id && e.PublisherType == PublisherType.Individual);
+        }
+        else
+        {
+            publisher = await db.Publishers.FirstOrDefaultAsync(e => e.Name == publisherName);
+            if (publisher is null) return BadRequest("Publisher was not found.");
+            var member =
+                await db.PublisherMembers.FirstOrDefaultAsync(e =>
+                    e.AccountId == currentUser.Id && e.PublisherId == publisher.Id);
+            if (member is null) return StatusCode(403, "You even wasn't a member of the publisher you specified.");
+            if (member.Role < PublisherMemberRole.Editor)
+                return StatusCode(403, "You need at least be an editor to post as this publisher.");
+        }
+
+        if (publisher is null) return BadRequest("Publisher was not found.");
+
+        var post = new Post
+        {
+            Title = request.Title,
+            Description = request.Description,
+            Content = request.Content,
+            Visibility = request.Visibility ?? PostVisibility.Public,
+            Type = request.Type ?? PostType.Moment,
+            Meta = request.Meta,
+        };
+
+        try
+        {
+            post = await ps.PostAsync(
+                post,
+                attachments: request.Attachments,
+                tags: request.Tags,
+                categories: request.Categories
+            );
+        }
+        catch (InvalidOperationException err)
+        {
+            return BadRequest(err.Message);
+        }
+
+        return post;
+    }
+
+    [HttpPatch("{id:long}")]
+    public async Task<ActionResult<Post>> UpdatePost(long id, [FromBody] PostRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+
+        var post = await db.Posts
+            .Where(e => e.Id == id)
+            .Include(e => e.Publisher)
+            .Include(e => e.Attachments)
+            .Include(e => e.Categories)
+            .Include(e => e.Tags)
+            .FirstOrDefaultAsync();
+        if (post is null) return NotFound();
+
+        var member = await db.PublisherMembers
+            .FirstOrDefaultAsync(e => e.AccountId == currentUser.Id && e.PublisherId == post.Publisher.Id);
+        if (member is null) return StatusCode(403, "You even wasn't a member of the publisher you specified.");
+        if (member.Role < PublisherMemberRole.Editor)
+            return StatusCode(403, "You need at least be an editor to edit this publisher's post.");
+
+        if (request.Title is not null) post.Title = request.Title;
+        if (request.Description is not null) post.Description = request.Description;
+        if (request.Content is not null) post.Content = request.Content;
+        if (request.Visibility is not null) post.Visibility = request.Visibility.Value;
+        if (request.Type is not null) post.Type = request.Type.Value;
+        if (request.Meta is not null) post.Meta = request.Meta;
+
+        try
+        {
+            post = await ps.UpdatePostAsync(
+                post,
+                attachments: request.Attachments,
+                tags: request.Tags,
+                categories: request.Categories
+            );
+        }
+        catch (InvalidOperationException err)
+        {
+            return BadRequest(err.Message);
+        }
+
+        return Ok(post);
+    }
+
+    [HttpDelete("{id:long}")]
+    public async Task<ActionResult<Post>> DeletePost(long id)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+
+        var post = await db.Posts
+            .Where(e => e.Id == id)
+            .Include(e => e.Attachments)
+            .FirstOrDefaultAsync();
+        if (post is null) return NotFound();
+
+        var member = await db.PublisherMembers
+            .FirstOrDefaultAsync(e => e.AccountId == currentUser.Id && e.PublisherId == post.Publisher.Id);
+        if (member is null) return StatusCode(403, "You even wasn't a member of the publisher you specified.");
+        if (member.Role < PublisherMemberRole.Editor)
+            return StatusCode(403, "You need at least be an editor to delete the publisher's post.");
+
+        await ps.DeletePostAsync(post);
+
+        return NoContent();
+    }
+}

DysonNetwork.Sphere/Post/PostService.cs

@@ -0,0 +1,157 @@
+using DysonNetwork.Sphere.Storage;
+using Microsoft.EntityFrameworkCore;
+using NodaTime;
+
+namespace DysonNetwork.Sphere.Post;
+
+public class PostService(AppDatabase db, FileService fs)
+{
+    public async Task<Post> PostAsync(
+        Post post,
+        List<string>? attachments = null,
+        List<string>? tags = null,
+        List<string>? categories = null
+    )
+    {
+        if (attachments is not null)
+        {
+            post.Attachments = await db.Files.Where(e => attachments.Contains(e.Id)).ToListAsync();
+            // Re-order the list to match the id list places
+            post.Attachments = attachments
+                .Select(id => post.Attachments.First(a => a.Id == id))
+                .ToList();
+        }
+
+        if (tags is not null)
+        {
+            var existingTags = await db.PostTags.Where(e => tags.Contains(e.Slug)).ToListAsync();
+
+            // Determine missing slugs
+            var existingSlugs = existingTags.Select(t => t.Slug).ToHashSet();
+            var missingSlugs = tags.Where(slug => !existingSlugs.Contains(slug)).ToList();
+
+            var newTags = missingSlugs.Select(slug => new PostTag { Slug = slug }).ToList();
+            if (newTags.Count > 0)
+            {
+                await db.PostTags.AddRangeAsync(newTags);
+                await db.SaveChangesAsync();
+            }
+
+            post.Tags = existingTags.Concat(newTags).ToList();
+        }
+
+        if (categories is not null)
+        {
+            post.Categories = await db.PostCategories.Where(e => categories.Contains(e.Slug)).ToListAsync();
+            if (post.Categories.Count != categories.Distinct().Count())
+                throw new InvalidOperationException("Categories contains one or more categories that wasn't exists.");
+        }
+        
+        if (post.Empty)
+            throw new InvalidOperationException("Cannot create a post with barely no content.");
+
+        // TODO Notify the subscribers
+
+        db.Posts.Add(post);
+        await db.SaveChangesAsync();
+        await fs.MarkUsageRangeAsync(post.Attachments, 1);
+
+        return post;
+    }
+
+    public async Task<Post> UpdatePostAsync(
+        Post post,
+        List<string>? attachments = null,
+        List<string>? tags = null,
+        List<string>? categories = null
+    )
+    {
+        post.EditedAt = Instant.FromDateTimeUtc(DateTime.UtcNow);
+
+        if (attachments is not null)
+        {
+            var records = await db.Files.Where(e => attachments.Contains(e.Id)).ToListAsync();
+
+            var previous = post.Attachments.ToDictionary(f => f.Id);
+            var current = records.ToDictionary(f => f.Id);
+
+            // Detect added files
+            var added = current.Keys.Except(previous.Keys).Select(id => current[id]).ToList();
+            // Detect removed files
+            var removed = previous.Keys.Except(current.Keys).Select(id => previous[id]).ToList();
+
+            // Update attachments
+            post.Attachments = attachments.Select(id => current[id]).ToList();
+
+            // Call mark usage
+            await fs.MarkUsageRangeAsync(added, 1);
+            await fs.MarkUsageRangeAsync(removed, -1);
+        }
+        
+        if (tags is not null)
+        {
+            var existingTags = await db.PostTags.Where(e => tags.Contains(e.Slug)).ToListAsync();
+
+            // Determine missing slugs
+            var existingSlugs = existingTags.Select(t => t.Slug).ToHashSet();
+            var missingSlugs = tags.Where(slug => !existingSlugs.Contains(slug)).ToList();
+
+            var newTags = missingSlugs.Select(slug => new PostTag { Slug = slug }).ToList();
+            if (newTags.Count > 0)
+            {
+                await db.PostTags.AddRangeAsync(newTags);
+                await db.SaveChangesAsync();
+            }
+
+            post.Tags = existingTags.Concat(newTags).ToList();
+        }
+
+        if (categories is not null)
+        {
+            post.Categories = await db.PostCategories.Where(e => categories.Contains(e.Slug)).ToListAsync();
+            if (post.Categories.Count != categories.Distinct().Count())
+                throw new InvalidOperationException("Categories contains one or more categories that wasn't exists.");
+        } 
+        
+        if (post.Empty)
+            throw new InvalidOperationException("Cannot edit a post to barely no content.");
+        
+        db.Update(post);
+        await db.SaveChangesAsync();
+        
+        return post;
+    }
+
+    public async Task DeletePostAsync(Post post)
+    {
+        db.Posts.Remove(post);
+        await db.SaveChangesAsync();
+        await fs.MarkUsageRangeAsync(post.Attachments, -1);
+    }
+}
+
+public static class PostQueryExtensions
+{
+    public static IQueryable<Post> FilterWithVisibility(this IQueryable<Post> source, Account.Account? currentUser,
+        bool isListing = false)
+    {
+        var now = Instant.FromDateTimeUtc(DateTime.UtcNow);
+
+        source = isListing switch
+        {
+            true when currentUser is not null => source.Where(e =>
+                e.Visibility != PostVisibility.Unlisted || e.Publisher.AccountId == currentUser.Id),
+            true => source.Where(e => e.Visibility != PostVisibility.Unlisted),
+            _ => source
+        };
+
+        if (currentUser is null)
+            return source
+                .Where(e => e.PublishedAt != null && now >= e.PublishedAt)
+                .Where(e => e.Visibility == PostVisibility.Public);
+
+        return source
+            .Where(e => e.PublishedAt != null && now >= e.PublishedAt && e.Publisher.AccountId == currentUser.Id)
+            .Where(e => e.Visibility != PostVisibility.Private || e.Publisher.AccountId == currentUser.Id);
+    }
+}

DysonNetwork.Sphere/Post/Publisher.cs

@@ -0,0 +1,53 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text.Json.Serialization;
+using DysonNetwork.Sphere.Storage;
+using Microsoft.EntityFrameworkCore;
+using NodaTime;
+
+namespace DysonNetwork.Sphere.Post;
+
+public enum PublisherType
+{
+    Individual,
+    Organizational
+}
+
+[Index(nameof(Name), IsUnique = true)]
+public class Publisher : ModelBase
+{
+    public long Id { get; set; }
+    public PublisherType PublisherType { get; set; }
+    [MaxLength(256)] public string Name { get; set; } = string.Empty;
+    [MaxLength(256)] public string Nick { get; set; } = string.Empty;
+    [MaxLength(4096)] public string? Bio { get; set; }
+
+    public CloudFile? Picture { get; set; }
+    public CloudFile? Background { get; set; }
+
+    [JsonIgnore] public ICollection<Post> Posts { get; set; } = new List<Post>();
+    [JsonIgnore] public ICollection<PostCollection> Collections { get; set; } = new List<PostCollection>();
+    [JsonIgnore] public ICollection<PublisherMember> Members { get; set; } = new List<PublisherMember>();
+    
+    public long? AccountId { get; set; }
+    [JsonIgnore] public Account.Account? Account { get; set; }
+}
+
+public enum PublisherMemberRole
+{
+    Owner = 100,
+    Manager = 75,
+    Editor = 50,
+    Viewer = 25
+}
+
+public class PublisherMember : ModelBase
+{
+    public long PublisherId { get; set; }
+    [JsonIgnore] public Publisher Publisher { get; set; } = null!;
+    public long AccountId { get; set; }
+    [JsonIgnore] public Account.Account Account { get; set; } = null!;
+
+    public PublisherMemberRole Role { get; set; }
+    public Instant? JoinedAt { get; set; }
+}

DysonNetwork.Sphere/Post/PublisherController.cs

@@ -0,0 +1,290 @@
+using System.ComponentModel.DataAnnotations;
+using Casbin;
+using DysonNetwork.Sphere.Storage;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using NodaTime;
+
+namespace DysonNetwork.Sphere.Post;
+
+[ApiController]
+[Route("/publishers")]
+public class PublisherController(AppDatabase db, PublisherService ps, FileService fs, IEnforcer enforcer)
+    : ControllerBase
+{
+    [HttpGet("{name}")]
+    public async Task<ActionResult<Publisher>> GetPublisher(string name)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+
+        var publisher = await db.Publishers
+            .Where(e => e.Name == name)
+            .FirstOrDefaultAsync();
+        if (publisher is null) return NotFound();
+
+        return Ok(publisher);
+    }
+
+    [HttpGet]
+    [Authorize]
+    public async Task<ActionResult<List<Publisher>>> ListManagedPublishers()
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var members = await db.PublisherMembers
+            .Where(m => m.AccountId == userId)
+            .Where(m => m.JoinedAt != null)
+            .Include(e => e.Publisher)
+            .ToListAsync();
+
+        return members.Select(m => m.Publisher).ToList();
+    }
+
+    [HttpGet("invites")]
+    [Authorize]
+    public async Task<ActionResult<List<PublisherMember>>> ListInvites()
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var members = await db.PublisherMembers
+            .Where(m => m.AccountId == userId)
+            .Where(m => m.JoinedAt == null)
+            .Include(e => e.Publisher)
+            .ToListAsync();
+
+        return members.ToList();
+    }
+
+    public class PublisherMemberRequest
+    {
+        [Required] public long RelatedUserId { get; set; }
+        [Required] public PublisherMemberRole Role { get; set; }
+    }
+
+    [HttpPost("invites/{name}")]
+    [Authorize]
+    public async Task<ActionResult<PublisherMember>> InviteMember(string name,
+        [FromBody] PublisherMemberRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var relatedUser = await db.Accounts.FindAsync(request.RelatedUserId);
+        if (relatedUser is null) return BadRequest("Related user was not found");
+
+        var publisher = await db.Publishers
+            .Where(p => p.Name == name)
+            .Include(publisher => publisher.Picture)
+            .Include(publisher => publisher.Background)
+            .FirstOrDefaultAsync();
+        if (publisher is null) return NotFound();
+
+        var member = await db.PublisherMembers
+            .Where(m => m.AccountId == userId)
+            .Where(m => m.PublisherId == publisher.Id)
+            .FirstOrDefaultAsync();
+        if (member is null) return StatusCode(403, "You are not even a member of the targeted publisher.");
+        if (member.Role < PublisherMemberRole.Manager)
+            return StatusCode(403,
+                "You need at least be a manager to invite other members to collaborate this publisher.");
+        if (member.Role < request.Role)
+            return StatusCode(403, "You cannot invite member has higher permission than yours.");
+
+        var newMember = new PublisherMember
+        {
+            Account = relatedUser,
+            AccountId = relatedUser.Id,
+            Publisher = publisher,
+            PublisherId = publisher.Id,
+            Role = request.Role,
+        };
+
+        db.PublisherMembers.Add(newMember);
+        await db.SaveChangesAsync();
+
+        return Ok(newMember);
+    }
+
+    [HttpPost("invites/{name}/accept")]
+    [Authorize]
+    public async Task<ActionResult<Publisher>> AcceptMemberInvite(string name)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var member = await db.PublisherMembers
+            .Where(m => m.AccountId == userId)
+            .Where(m => m.Publisher.Name == name)
+            .Where(m => m.JoinedAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null) return NotFound();
+
+        member.JoinedAt = Instant.FromDateTimeUtc(DateTime.UtcNow);
+        db.Update(member);
+        await db.SaveChangesAsync();
+
+        return Ok(member);
+    }
+
+    [HttpPost("invites/{name}/decline")]
+    [Authorize]
+    public async Task<ActionResult> DeclineMemberInvite(string name)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var member = await db.PublisherMembers
+            .Where(m => m.AccountId == userId)
+            .Where(m => m.Publisher.Name == name)
+            .Where(m => m.JoinedAt == null)
+            .FirstOrDefaultAsync();
+        if (member is null) return NotFound();
+
+        db.PublisherMembers.Remove(member);
+        await db.SaveChangesAsync();
+
+        return NoContent();
+    }
+
+    public class PublisherRequest
+    {
+        [MaxLength(256)] public string? Name { get; set; }
+        [MaxLength(256)] public string? Nick { get; set; }
+        [MaxLength(4096)] public string? Bio { get; set; }
+
+        public string? PictureId { get; set; }
+        public string? BackgroundId { get; set; }
+    }
+
+    [HttpPost("individual")]
+    [Authorize]
+    public async Task<ActionResult<Publisher>> CreatePublisherIndividual(PublisherRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        if (!await enforcer.EnforceAsync(currentUser.Id.ToString(), "global", "publishers", "create"))
+            return StatusCode(403);
+
+        var takenName = request.Name ?? currentUser.Name;
+        var duplicateNameCount = await db.Publishers
+            .Where(p => p.Name == takenName)
+            .CountAsync();
+        if (duplicateNameCount > 0)
+            return BadRequest(
+                "The name you requested has already be taken, " +
+                "if it is your account name, " +
+                "you can request a taken down to the publisher which created with " +
+                "your name firstly to get your name back."
+            );
+
+        CloudFile? picture = null, background = null;
+        if (request.PictureId is not null)
+        {
+            picture = await db.Files.Where(f => f.Id == request.PictureId).FirstOrDefaultAsync();
+            if (picture is null) return BadRequest("Invalid picture id, unable to find the file on cloud.");
+        }
+
+        if (request.BackgroundId is not null)
+        {
+            background = await db.Files.Where(f => f.Id == request.BackgroundId).FirstOrDefaultAsync();
+            if (background is null) return BadRequest("Invalid background id, unable to find the file on cloud.");
+        }
+
+        var publisher = await ps.CreateIndividualPublisher(
+            currentUser,
+            request.Name,
+            request.Nick,
+            request.Bio,
+            picture,
+            background
+        );
+
+        return Ok(publisher);
+    }
+
+    [HttpPatch("{name}")]
+    [Authorize]
+    public async Task<ActionResult<Publisher>> UpdatePublisher(string name, PublisherRequest request)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var publisher = await db.Publishers
+            .Where(p => p.Name == name)
+            .Include(publisher => publisher.Picture)
+            .Include(publisher => publisher.Background)
+            .FirstOrDefaultAsync();
+        if (publisher is null) return NotFound();
+
+        var member = await db.PublisherMembers
+            .Where(m => m.AccountId == userId)
+            .Where(m => m.PublisherId == publisher.Id)
+            .FirstOrDefaultAsync();
+        if (member is null) return StatusCode(403, "You are not even a member of the targeted publisher.");
+        if (member.Role < PublisherMemberRole.Manager)
+            return StatusCode(403, "You need at least be the manager to update the publisher profile.");
+
+        if (request.Name is not null) publisher.Name = request.Name;
+        if (request.Nick is not null) publisher.Nick = request.Nick;
+        if (request.Bio is not null) publisher.Bio = request.Bio;
+        if (request.PictureId is not null)
+        {
+            var picture = await db.Files.Where(f => f.Id == request.PictureId).FirstOrDefaultAsync();
+            if (picture is null) return BadRequest("Invalid picture id.");
+            if (publisher.Picture is not null) await fs.MarkUsageAsync(publisher.Picture, -1);
+
+            publisher.Picture = picture;
+            await fs.MarkUsageAsync(picture, 1);
+        }
+
+        if (request.BackgroundId is not null)
+        {
+            var background = await db.Files.Where(f => f.Id == request.BackgroundId).FirstOrDefaultAsync();
+            if (background is null) return BadRequest("Invalid background id.");
+            if (publisher.Background is not null) await fs.MarkUsageAsync(publisher.Background, -1);
+
+            publisher.Background = background;
+            await fs.MarkUsageAsync(background, 1);
+        }
+
+        db.Update(publisher);
+        await db.SaveChangesAsync();
+
+        return Ok(publisher);
+    }
+
+    [HttpDelete("{name}")]
+    [Authorize]
+    public async Task<ActionResult<Publisher>> DeletePublisher(string name)
+    {
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
+
+        var publisher = await db.Publishers
+            .Where(p => p.Name == name)
+            .Include(publisher => publisher.Picture)
+            .Include(publisher => publisher.Background)
+            .FirstOrDefaultAsync();
+        if (publisher is null) return NotFound();
+
+        var member = await db.PublisherMembers
+            .Where(m => m.AccountId == userId)
+            .Where(m => m.PublisherId == publisher.Id)
+            .FirstOrDefaultAsync();
+        if (member is null) return StatusCode(403, "You are not even a member of the targeted publisher.");
+        if (member.Role < PublisherMemberRole.Owner)
+            return StatusCode(403, "You need to be the owner to delete the publisher.");
+
+        if (publisher.Picture is not null)
+            await fs.MarkUsageAsync(publisher.Picture, -1);
+        if (publisher.Background is not null)
+            await fs.MarkUsageAsync(publisher.Background, -1);
+
+        db.Publishers.Remove(publisher);
+        await db.SaveChangesAsync();
+
+        return NoContent();
+    }
+}

DysonNetwork.Sphere/Post/PublisherService.cs

@@ -0,0 +1,48 @@
+using DysonNetwork.Sphere.Storage;
+using NodaTime;
+
+namespace DysonNetwork.Sphere.Post;
+
+public class PublisherService(AppDatabase db, FileService fs)
+{
+    public async Task<Publisher> CreateIndividualPublisher(
+        Account.Account account,
+        string? name,
+        string? nick,
+        string? bio,
+        CloudFile? picture,
+        CloudFile? background
+    )
+    {
+        var publisher = new Publisher
+        {
+            PublisherType = PublisherType.Individual,
+            Name = name ?? account.Name,
+            Nick = nick ?? account.Nick,
+            Bio = bio ?? account.Profile.Bio,
+            Picture = picture ?? account.Profile.Picture,
+            Background = background ?? account.Profile.Background,
+            Account = account,
+            Members = new List<PublisherMember>
+            {
+                new()
+                {
+                    AccountId = account.Id,
+                    Account = account,
+                    Role = PublisherMemberRole.Owner,
+                    JoinedAt = Instant.FromDateTimeUtc(DateTime.UtcNow)
+                }
+            }
+        };
+
+        db.Publishers.Add(publisher);
+        await db.SaveChangesAsync();
+
+        if (publisher.Picture is not null) await fs.MarkUsageAsync(publisher.Picture, 1);
+        if (publisher.Background is not null) await fs.MarkUsageAsync(publisher.Background, 1);
+
+        return publisher;
+    }
+
+    // TODO Able to create organizational publisher when the realm system is completed
+}

DysonNetwork.Sphere/Program.cs

@@ -7,6 +7,7 @@ using Casbin.Persist.Adapter.EFCore;
 using DysonNetwork.Sphere;
 using DysonNetwork.Sphere.Account;
 using DysonNetwork.Sphere.Auth;
+using DysonNetwork.Sphere.Post;
 using DysonNetwork.Sphere.Storage;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.HttpOverrides;
@@ -29,6 +30,8 @@ builder.Host.UseContentRoot(Directory.GetCurrentDirectory());
 // Add services to the container.
 
 builder.Services.AddDbContext<AppDatabase>();
+builder.Services.AddMemoryCache();
+
 builder.Services.AddControllers().AddJsonOptions(options =>
 {
     options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower;
@@ -117,6 +120,8 @@ builder.Services.AddOpenApi();
 builder.Services.AddScoped<AccountService>();
 builder.Services.AddScoped<AuthService>();
 builder.Services.AddScoped<FileService>();
+builder.Services.AddScoped<PublisherService>();
+builder.Services.AddScoped<PostService>();
 
 // Timed task
 
@@ -167,6 +172,7 @@ app.UseCors(opts =>
 
 app.UseHttpsRedirection();
 app.UseAuthorization();
+app.UseMiddleware<UserInfoMiddleware>();
 
 app.MapControllers();
 

DysonNetwork.Sphere/Storage/FileController.cs

@@ -83,9 +83,8 @@ public class FileController(
     [HttpDelete("{id}")]
     public async Task<ActionResult> DeleteFile(string id)
     {
-        var userIdClaim = User.FindFirst("user_id")?.Value;
-        if (userIdClaim is null) return Unauthorized();
-        var userId = long.Parse(userIdClaim);
+        if (HttpContext.Items["CurrentUser"] is not Account.Account currentUser) return Unauthorized();
+        var userId = currentUser.Id;
 
         var file = await db.Files
             .Where(e => e.Id == id)

DysonNetwork.Sphere/Storage/FileService.cs

@@ -158,10 +158,9 @@ public class FileService(AppDatabase db, IConfiguration configuration)
         );
 
         file.UploadedAt = Instant.FromDateTimeUtc(DateTime.UtcNow);
-        await db.Files.Where(f => f.Id == file.Id).ExecuteUpdateAsync(
-            setter => setter
-                .SetProperty(f => f.UploadedAt, file.UploadedAt)
-                .SetProperty(f => f.UploadedTo, file.UploadedTo)
+        await db.Files.Where(f => f.Id == file.Id).ExecuteUpdateAsync(setter => setter
+            .SetProperty(f => f.UploadedAt, file.UploadedAt)
+            .SetProperty(f => f.UploadedTo, file.UploadedTo)
         );
         return file;
     }
@@ -215,8 +214,18 @@ public class FileService(AppDatabase db, IConfiguration configuration)
     public async Task MarkUsageAsync(CloudFile file, int delta)
     {
         await db.Files.Where(o => o.Id == file.Id)
-            .ExecuteUpdateAsync(
-                setter => setter.SetProperty(
+            .ExecuteUpdateAsync(setter => setter.SetProperty(
+                    b => b.UsedCount,
+                    b => b.UsedCount + delta
+                )
+            );
+    }
+
+    public async Task MarkUsageRangeAsync(ICollection<CloudFile> files, int delta)
+    {
+        var ids = files.Select(f => f.Id).ToArray();
+        await db.Files.Where(o => ids.Contains(o.Id))
+            .ExecuteUpdateAsync(setter => setter.SetProperty(
                     b => b.UsedCount,
                     b => b.UsedCount + delta
                 )

DysonNetwork.sln.DotSettings.user

@@ -1,4 +1,5 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AAuthenticationMiddleware_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003Fe49de78932194d52a02b07486c6d023a24600_003F2f_003F7ab1cc57_003FAuthenticationMiddleware_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AAuthorizationAppBuilderExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F2ff26593f91746d7a53418a46dc419d1f200_003F4b_003F56550da2_003FAuthorizationAppBuilderExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ABucketArgs_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FSourcesCache_003Fd515fb889657fcdcace3fed90735057b458ff9e0bb60bded7c8fe8b3a4673c_003FBucketArgs_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AChapterData_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003Ffef366b36a224d469ff150d30f9a866d23c00_003Fe6_003F64a6c0f7_003FChapterData_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
@@ -9,7 +10,9 @@
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ADbContext_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FSourcesCache_003Fa0b45f29f34f594814a7b1fbc25fe5ef3c18257956ed4f4fbfa68717db58_003FDbContext_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ADirectory_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003Fb6f0571a6bc744b0b551fd4578292582e54c00_003Fde_003F94973e27_003FDirectory_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEndpointConventionBuilderExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F8bb08a178b5b43c5bac20a5a54159a5b2a800_003F8a_003F101938e3_003FEndpointConventionBuilderExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEnforcerExtension_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003Fbb4a120e56464fc6abd8c30969ef70864ba00_003Fb5_003F180850e0_003FEnforcerExtension_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEntityFrameworkQueryableExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FSourcesCache_003Fe096e6f12c5d6b49356bc34ff1ea08738f910c0929c9d717c9cba7f44288_003FEntityFrameworkQueryableExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEntityFrameworkQueryableExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003Fcb0587797ea44bd6915ede69888c6766291038_003F55_003F277f2d4c_003FEntityFrameworkQueryableExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEntityFrameworkServiceCollectionExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FSourcesCache_003F4a28847852ee9ba45fd3107526c0a749a733bd4f4ebf33aa3c9a59737a3f758_003FEntityFrameworkServiceCollectionExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEnumerable_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F832399abc13b45b6bdbabfa022e4a28487e00_003F7f_003F7aece4dd_003FEnumerable_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AEvents_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F8bb08a178b5b43c5bac20a5a54159a5b2a800_003F20_003F86914b63_003FEvents_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
@@ -29,6 +32,7 @@
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AOptionsConfigurationServiceCollectionExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F6622dea924b14dc7aa3ee69d7c84e5735000_003Fe0_003F024ba0b7_003FOptionsConfigurationServiceCollectionExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003APath_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003Fb6f0571a6bc744b0b551fd4578292582e54c00_003Fd3_003F7b05b2bd_003FPath_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003APresignedGetObjectArgs_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FSourcesCache_003F0df26a9d89e29319e9efcaea0a8489db9e97bc1aedcca3f7e360cc50f8f4ea_003FPresignedGetObjectArgs_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
+	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AQueryable_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2025_002E1_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003F42d8f09d6a294d00a6f49efc989927492fe00_003F4e_003F26d1ee34_003FQueryable_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ASecuritySchemeType_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FSourcesCache_003F29898ce74e3763a786ac1bd9a6db2152e1af75769440b1e53b9cbdf1dda1bd99_003FSecuritySchemeType_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003AServiceCollectionContainerBuilderExtensions_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FDecompilerCache_003Fdecompiler_003Fc0e30e11d8f5456cb7a11b21ebee6c5a35c00_003F60_003F78b485f5_003FServiceCollectionContainerBuilderExtensions_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>
 	<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=7020124F_002D9FFC_002D4AC3_002D8F3D_002DAAB8E0240759_002Ff_003ASetPropertyCalls_002Ecs_002Fl_003A_002E_002E_003F_002E_002E_003F_002E_002E_003FLibrary_003FApplication_0020Support_003FJetBrains_003FRider2024_002E3_003Fresharper_002Dhost_003FSourcesCache_003F458b5f22476b4599b87176214d5e4026c2327b148f4d3f885ee92362b4dac3_003FSetPropertyCalls_002Ecs/@EntryIndexedValue">ForceIncluded</s:String>