Refactor user role and profile property naming

XIYUEKONGLING · XIYUEKONGLING · commit d4de743c768a · 2025-12-23T11:19:45.000+08:00
diff --git a/OpenBioCardServer/Controllers/AdminController.cs b/OpenBioCardServer/Controllers/AdminController.cs
@@ -49,7 +49,7 @@ public async Task<IActionResult> CheckPermission()
         return Ok(new 
         { 
             Success = true, 
-            Type = account.Type.ToString().ToLower() 
+            Type = account.Role.ToString().ToLower() 
         });
     }
 
@@ -67,11 +67,11 @@ public async Task<ActionResult<UserListResponse>> GetUsers()
         }
 
         var users = await _context.Accounts
-            .Where(a => a.Type != UserType.Root)
+            .Where(a => a.Role != UserRole.Root)
             .Select(a => new UserInfoDto
             {
                 Username = a.UserName,
-                Type = a.Type.ToString().ToLower()
+                Type = a.Role.ToString().ToLower()
             })
             .ToListAsync();
 
@@ -96,7 +96,7 @@ public async Task<ActionResult<TokenResponse>> CreateUser([FromBody] CreateUserR
                 return Unauthorized(new { Error = "Invalid token or insufficient permissions" });
             }
 
-            if (!Enum.TryParse<UserType>(request.Type, true, out var userType) || userType == UserType.Root)
+            if (!Enum.TryParse<UserRole>(request.Type, true, out var userType) || userType == UserRole.Root)
             {
                 return BadRequest(new { Error = "Invalid user type" });
             }
@@ -151,7 +151,7 @@ public async Task<IActionResult> DeleteUser(string username)
             return NotFound(new { Error = "User not found" });
         }
 
-        if (targetAccount.Type == UserType.Root)
+        if (targetAccount.Role == UserRole.Root)
         {
             return Forbid("Cannot delete root account");
         }
diff --git a/OpenBioCardServer/Controllers/AuthController.cs b/OpenBioCardServer/Controllers/AuthController.cs
@@ -47,12 +47,12 @@ public async Task<ActionResult<TokenResponse>> SignUp([FromBody] SignUpRequest r
                 return BadRequest(new { Error = "Missing required fields" });
             }
 
-            if (!Enum.TryParse<UserType>(request.UserType, true, out var userType))
+            if (!Enum.TryParse<UserRole>(request.UserType, true, out var userType))
             {
                 return BadRequest(new { Error = "Invalid user type" });
             }
 
-            if (userType == UserType.Root)
+            if (userType == UserRole.Root)
             {
                 return Forbid("Cannot create root users");
             }
@@ -123,7 +123,7 @@ public async Task<IActionResult> DeleteAccount([FromBody] DeleteRequest request)
             return Unauthorized(new { Error = "Invalid token or token does not match username" });
         }
 
-        if (account.Type == UserType.Root)
+        if (account.Role == UserRole.Root)
         {
             return Forbid("Cannot delete root account");
         }
diff --git a/OpenBioCardServer/Controllers/Classic/ClassicAdminController.cs b/OpenBioCardServer/Controllers/Classic/ClassicAdminController.cs
@@ -62,7 +62,7 @@ public async Task<IActionResult> CheckPermission([FromBody] ClassicAdminRequest
             return Ok(new ClassicCheckPermissionResponse
             { 
                 Success = true, 
-                Type = account.Type.ToString().ToLower() 
+                Type = account.Role.ToString().ToLower() 
             });
         }
         catch (Exception ex)
@@ -118,11 +118,11 @@ private async Task<IActionResult> GetUsersInternal(string token, string username
 
             // Get all non-root users
             var users = await _context.Accounts
-                .Where(a => a.Type != UserType.Root)
+                .Where(a => a.Role != UserRole.Root)
                 .Select(a => new ClassicUserInfo
                 {
                     Username = a.UserName,
-                    Type = a.Type.ToString().ToLower()
+                    Type = a.Role.ToString().ToLower()
                 })
                 .ToListAsync();
 
@@ -163,13 +163,13 @@ public async Task<IActionResult> CreateUser([FromBody] ClassicCreateUserRequest
             }
 
             // Validate new user type
-            if (!Enum.TryParse<UserType>(request.Type, true, out var userType))
+            if (!Enum.TryParse<UserRole>(request.Type, true, out var userType))
             {
                 return BadRequest(new ClassicErrorResponse("Invalid user type"));
             }
 
             // Cannot create root users
-            if (userType == UserType.Root)
+            if (userType == UserRole.Root)
             {
                 return StatusCode(403, new ClassicErrorResponse("Cannot create root users"));
             }
@@ -187,7 +187,7 @@ public async Task<IActionResult> CreateUser([FromBody] ClassicCreateUserRequest
                 UserName = request.NewUsername,
                 PasswordHash = hash,
                 PasswordSalt = salt,
-                Type = userType
+                Role = userType
             };
 
             _context.Accounts.Add(newAccount);
@@ -197,7 +197,7 @@ public async Task<IActionResult> CreateUser([FromBody] ClassicCreateUserRequest
             var profile = new ProfileEntity
             {
                 AccountId = newAccount.Id,
-                Username = request.NewUsername,
+                UserName = request.NewUsername,
                 AvatarType = AssetType.Text,
                 AvatarText = "👤"
             };
@@ -267,7 +267,7 @@ public async Task<IActionResult> DeleteUser(string targetUsername, [FromBody] Cl
             }
 
             // Cannot delete root account
-            if (targetAccount.Type == UserType.Root)
+            if (targetAccount.Role == UserRole.Root)
             {
                 return StatusCode(403, new ClassicErrorResponse("Cannot delete root account"));
             }
diff --git a/OpenBioCardServer/Controllers/Classic/ClassicAuthController.cs b/OpenBioCardServer/Controllers/Classic/ClassicAuthController.cs
@@ -58,13 +58,13 @@ public async Task<IActionResult> SignUp([FromBody] ClassicSignUpRequest request)
             }
 
             // Validate and parse user type
-            if (!Enum.TryParse<UserType>(request.Type, true, out var userType))
+            if (!Enum.TryParse<UserRole>(request.Type, true, out var userType))
             {
                 return BadRequest(new ClassicErrorResponse("Invalid user type"));
             }
 
             // Cannot create root users via signup
-            if (userType == UserType.Root)
+            if (userType == UserRole.Root)
             {
                 return StatusCode(403, new ClassicErrorResponse("Cannot create root users"));
             }
@@ -76,7 +76,7 @@ public async Task<IActionResult> SignUp([FromBody] ClassicSignUpRequest request)
                 UserName = request.Username,
                 PasswordHash = hash,
                 PasswordSalt = salt,
-                Type = userType
+                Role = userType
             };
 
             _context.Accounts.Add(account);
@@ -86,7 +86,7 @@ public async Task<IActionResult> SignUp([FromBody] ClassicSignUpRequest request)
             var profile = new ProfileEntity
             {
                 AccountId = account.Id,
-                Username = request.Username,
+                UserName = request.Username,
                 AvatarType = AssetType.Text,
                 AvatarText = "👤"
             };
@@ -167,14 +167,14 @@ private async Task<IActionResult> HandleSignInAsync(ClassicSignInRequest request
             await _context.SaveChangesAsync();
 
             // 记录日志（区分Root和普通用户）
-            if (account.Type == UserType.Root)
+            if (account.Role == UserRole.Root)
             {
                 _logger.LogInformation("Root user logged in");
             }
             else
             {
                 _logger.LogInformation("User logged in: {Username} (Type: {Type})", 
-                    request.Username, account.Type);
+                    request.Username, account.Role);
             }
 
             return Ok(new ClassicTokenResponse { Token = token });
@@ -207,7 +207,7 @@ public async Task<IActionResult> DeleteAccount([FromBody] ClassicDeleteRequest r
             }
 
             // Root account cannot be deleted
-            if (account.Type == UserType.Root)
+            if (account.Role == UserRole.Root)
             {
                 return StatusCode(403, new ClassicErrorResponse("Cannot delete root account"));
             }
diff --git a/OpenBioCardServer/Data/AppDbContext.cs b/OpenBioCardServer/Data/AppDbContext.cs
@@ -64,7 +64,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         modelBuilder.Entity<ProfileEntity>(entity =>
         {
             // Unique index on Username (redundant with Account but useful)
-            entity.HasIndex(e => e.Username).IsUnique();
+            entity.HasIndex(e => e.UserName).IsUnique();
             
             // One-to-Many relationships with all child entities
             entity.HasMany(e => e.Contacts)
diff --git a/OpenBioCardServer/Models/Asset.cs b/OpenBioCardServer/Models/Asset.cs
@@ -6,5 +6,6 @@ public class Asset
 {
     public AssetType Type { get; set; }
     public string? Text { get; set; } // Text & Emoji & Remote Uri
+    public string? Tag { get; set; } // MIME Type
     public byte[]? Data { get; set; } // Embedded Base64
 }
diff --git a/OpenBioCardServer/Models/Entities/Account.cs b/OpenBioCardServer/Models/Entities/Account.cs
@@ -21,7 +21,8 @@ public class Account
     [MaxLength(256)]
     public string PasswordSalt { get; set; } = string.Empty;
 
-    public UserType Type { get; set; } = UserType.User;
+    public UserRole Role { get; set; } = UserRole.User;
+    public AccountType Type { get; set; } = AccountType.Personal;
     
     public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
     public DateTime LastLogin { get; set; } = DateTime.UtcNow;
diff --git a/OpenBioCardServer/Models/Entities/ContactItemEntity.cs b/OpenBioCardServer/Models/Entities/ContactItemEntity.cs
@@ -20,8 +20,8 @@ public class ContactItemEntity
     
     // Image Asset (optional) - 扁平化存储
     public AssetType? ImageType { get; set; }
-    [MaxLength(512)]
-    public string? ImageText { get; set; }
+    [MaxLength(64)] public string? ImageTag { get; set; }
+    [MaxLength(512)] public string? ImageText { get; set; }
     public byte[]? ImageData { get; set; }
     
     // Navigation property
diff --git a/OpenBioCardServer/Models/Entities/GalleryItemEntity.cs b/OpenBioCardServer/Models/Entities/GalleryItemEntity.cs
@@ -13,8 +13,8 @@ public class GalleryItemEntity
     
     // Image Asset (optional but expected)
     public AssetType? ImageType { get; set; }
-    [MaxLength(512)]
-    public string? ImageText { get; set; }
+    [MaxLength(64)] public string? ImageTag { get; set; }
+    [MaxLength(512)] public string? ImageText { get; set; }
     public byte[]? ImageData { get; set; }
     
     [MaxLength(500)]
diff --git a/OpenBioCardServer/Models/Entities/ProfileEntity.cs b/OpenBioCardServer/Models/Entities/ProfileEntity.cs
@@ -16,22 +16,22 @@ public class ProfileEntity
     
     [Required]
     [MaxLength(64)]
-    public string Username { get; set; } = string.Empty;
+    public string UserName { get; set; } = string.Empty;
     
     // Avatar (required Asset) - 扁平化存储
     public AssetType AvatarType { get; set; } = AssetType.Text;
-    [MaxLength(512)]
-    public string? AvatarText { get; set; }
+    [MaxLength(512)] public string? AvatarTag { get; set; }
+    [MaxLength(512)] public string? AvatarText { get; set; }
     public byte[]? AvatarData { get; set; }
     
     [MaxLength(128)]
-    public string? NickName { get; set; }
+    public string? Nickname { get; set; }
     
     [MaxLength(64)]
     public string? Pronouns { get; set; }
     
     [MaxLength(2000)]
-    public string? Description { get; set; } // Bio
+    public string? Biography { get; set; } // Bio
     
     [MaxLength(256)]
     public string? Location { get; set; }
@@ -41,8 +41,8 @@ public class ProfileEntity
     
     // Background (optional Asset)
     public AssetType? BackgroundType { get; set; }
-    [MaxLength(512)]
-    public string? BackgroundText { get; set; }
+    [MaxLength(64)] public string? BackgroundTag { get; set; }
+    [MaxLength(512)] public string? BackgroundText { get; set; }
     public byte[]? BackgroundData { get; set; }
     
     [MaxLength(256)]
diff --git a/OpenBioCardServer/Models/Entities/ProjectItemEntity.cs b/OpenBioCardServer/Models/Entities/ProjectItemEntity.cs
@@ -23,8 +23,8 @@ public class ProjectItemEntity
     
     // Logo Asset (optional)
     public AssetType? LogoType { get; set; }
-    [MaxLength(512)]
-    public string? LogoText { get; set; }
+    [MaxLength(64)] public string? LogoTag { get; set; }
+    [MaxLength(512)] public string? LogoText { get; set; }
     public byte[]? LogoData { get; set; }
     
     // Navigation property
diff --git a/OpenBioCardServer/Models/Entities/SchoolExperienceItemEntity.cs b/OpenBioCardServer/Models/Entities/SchoolExperienceItemEntity.cs
@@ -32,8 +32,8 @@ public class SchoolExperienceItemEntity
     
     // Logo Asset (optional)
     public AssetType? LogoType { get; set; }
-    [MaxLength(512)]
-    public string? LogoText { get; set; }
+    [MaxLength(64)] public string? LogoTag { get; set; }
+    [MaxLength(512)] public string? LogoText { get; set; }
     public byte[]? LogoData { get; set; }
     
     // Navigation property
diff --git a/OpenBioCardServer/Models/Entities/SystemSettingsEntity.cs b/OpenBioCardServer/Models/Entities/SystemSettingsEntity.cs
@@ -17,7 +17,7 @@ public class SystemSettingsEntity
     
     // Logo Asset (optional)
     public AssetType? LogoType { get; set; }
-    [MaxLength(512)]
-    public string? LogoText { get; set; }
+    [MaxLength(64)] public string? LogoTag { get; set; }
+    [MaxLength(512)] public string? LogoText { get; set; }
     public byte[]? LogoData { get; set; }
 }
diff --git a/OpenBioCardServer/Models/Entities/WorkExperienceItemEntity.cs b/OpenBioCardServer/Models/Entities/WorkExperienceItemEntity.cs
@@ -29,8 +29,13 @@ public class WorkExperienceItemEntity
     
     // Logo Asset (optional)
     public AssetType? LogoType { get; set; }
+    
+    [MaxLength(64)]
+    public string? LogoTag { get; set; }
+    
     [MaxLength(512)]
     public string? LogoText { get; set; }
+    
     public byte[]? LogoData { get; set; }
     
     // Navigation property
diff --git a/OpenBioCardServer/Models/Enums/AccountType.cs b/OpenBioCardServer/Models/Enums/AccountType.cs
@@ -0,0 +1,8 @@
+namespace OpenBioCardServer.Models.Enums;
+
+public enum AccountType
+{
+    Personal,
+    Company,
+    Organization,
+}
diff --git a/OpenBioCardServer/Models/Enums/UserRole.cs b/OpenBioCardServer/Models/Enums/UserRole.cs
@@ -1,6 +1,6 @@
 namespace OpenBioCardServer.Models.Enums;
 
-public enum UserType
+public enum UserRole
 {
     User,
     Admin,
diff --git a/OpenBioCardServer/Models/Profile.cs b/OpenBioCardServer/Models/Profile.cs
@@ -1,13 +1,17 @@
+using OpenBioCardServer.Models.Enums;
+
 namespace OpenBioCardServer.Models;
 
 public class Profile
 {
     public string UserName { get; set; } = string.Empty;
+    public UserRole  UserRole { get; set; } =  UserRole.User;
+    public AccountType UserType { get; set; } = AccountType.Personal;
     
     public Asset Avatar { get; set; } = new();
-    public string? NickName { get; set; }
+    public string? Nickname { get; set; }
     public string? Pronouns { get; set; }
-    public string? Description { get; set; } // BIO
+    public string? Biography { get; set; } // BIO
     public string? Location { get; set; }
     public string? Website { get; set; }
     public Asset? Background { get; set; }
diff --git a/OpenBioCardServer/Program.cs b/OpenBioCardServer/Program.cs
@@ -423,7 +423,7 @@ private static async Task InitializeRootUserAsync(AppDbContext context, AuthSett
                     UserName = authSettings.RootUsername,
                     PasswordHash = hash,
                     PasswordSalt = salt,
-                    Type = UserType.Root
+                    Role = UserRole.Root
                 };
                 context.Accounts.Add(rootAccount);
                 await context.SaveChangesAsync();
diff --git a/OpenBioCardServer/Services/AuthService.cs b/OpenBioCardServer/Services/AuthService.cs
diff --git a/OpenBioCardServer/Services/ClassicAuthService.cs b/OpenBioCardServer/Services/ClassicAuthService.cs
diff --git a/OpenBioCardServer/Services/ClassicProfileService.cs b/OpenBioCardServer/Services/ClassicProfileService.cs
diff --git a/OpenBioCardServer/Services/ProfileService.cs b/OpenBioCardServer/Services/ProfileService.cs
diff --git a/OpenBioCardServer/Utilities/Mappers/ClassicMapper.cs b/OpenBioCardServer/Utilities/Mappers/ClassicMapper.cs
diff --git a/OpenBioCardServer/Utilities/Mappers/DataMapper.cs b/OpenBioCardServer/Utilities/Mappers/DataMapper.cs

Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public async Task<IActionResult> CheckPermission()`
`49`	`49`	`return Ok(new`
`50`	`50`	`{`
`51`	`51`	`Success = true,`
`52`		`- Type = account.Type.ToString().ToLower()`
	`52`	`+ Type = account.Role.ToString().ToLower()`
`53`	`53`	`});`
`54`	`54`	`}`
`55`	`55`
`@@ -67,11 +67,11 @@ public async Task<ActionResult<UserListResponse>> GetUsers()`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`var users = await _context.Accounts`
`70`		`- .Where(a => a.Type != UserType.Root)`
	`70`	`+ .Where(a => a.Role != UserRole.Root)`
`71`	`71`	`.Select(a => new UserInfoDto`
`72`	`72`	`{`
`73`	`73`	`Username = a.UserName,`
`74`		`- Type = a.Type.ToString().ToLower()`
	`74`	`+ Type = a.Role.ToString().ToLower()`
`75`	`75`	`})`
`76`	`76`	`.ToListAsync();`
`77`	`77`
`@@ -96,7 +96,7 @@ public async Task<ActionResult<TokenResponse>> CreateUser([FromBody] CreateUserR`
`96`	`96`	`return Unauthorized(new { Error = "Invalid token or insufficient permissions" });`
`97`	`97`	`}`
`98`	`98`
`99`		`- if (!Enum.TryParse<UserType>(request.Type, true, out var userType) \|\| userType == UserType.Root)`
	`99`	`+ if (!Enum.TryParse<UserRole>(request.Type, true, out var userType) \|\| userType == UserRole.Root)`
`100`	`100`	`{`
`101`	`101`	`return BadRequest(new { Error = "Invalid user type" });`
`102`	`102`	`}`
`@@ -151,7 +151,7 @@ public async Task<IActionResult> DeleteUser(string username)`
`151`	`151`	`return NotFound(new { Error = "User not found" });`
`152`	`152`	`}`
`153`	`153`
`154`		`- if (targetAccount.Type == UserType.Root)`
	`154`	`+ if (targetAccount.Role == UserRole.Root)`
`155`	`155`	`{`
`156`	`156`	`return Forbid("Cannot delete root account");`
`157`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,12 +47,12 @@ public async Task<ActionResult<TokenResponse>> SignUp([FromBody] SignUpRequest r`
`47`	`47`	`return BadRequest(new { Error = "Missing required fields" });`
`48`	`48`	`}`
`49`	`49`
`50`		`- if (!Enum.TryParse<UserType>(request.UserType, true, out var userType))`
	`50`	`+ if (!Enum.TryParse<UserRole>(request.UserType, true, out var userType))`
`51`	`51`	`{`
`52`	`52`	`return BadRequest(new { Error = "Invalid user type" });`
`53`	`53`	`}`
`54`	`54`
`55`		`- if (userType == UserType.Root)`
	`55`	`+ if (userType == UserRole.Root)`
`56`	`56`	`{`
`57`	`57`	`return Forbid("Cannot create root users");`
`58`	`58`	`}`
`@@ -123,7 +123,7 @@ public async Task<IActionResult> DeleteAccount([FromBody] DeleteRequest request)`
`123`	`123`	`return Unauthorized(new { Error = "Invalid token or token does not match username" });`
`124`	`124`	`}`
`125`	`125`
`126`		`- if (account.Type == UserType.Root)`
	`126`	`+ if (account.Role == UserRole.Root)`
`127`	`127`	`{`
`128`	`128`	`return Forbid("Cannot delete root account");`
`129`	`129`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ public async Task<IActionResult> CheckPermission([FromBody] ClassicAdminRequest`
`62`	`62`	`return Ok(new ClassicCheckPermissionResponse`
`63`	`63`	`{`
`64`	`64`	`Success = true,`
`65`		`- Type = account.Type.ToString().ToLower()`
	`65`	`+ Type = account.Role.ToString().ToLower()`
`66`	`66`	`});`
`67`	`67`	`}`
`68`	`68`	`catch (Exception ex)`
`@@ -118,11 +118,11 @@ private async Task<IActionResult> GetUsersInternal(string token, string username`
`118`	`118`
`119`	`119`	`// Get all non-root users`
`120`	`120`	`var users = await _context.Accounts`
`121`		`- .Where(a => a.Type != UserType.Root)`
	`121`	`+ .Where(a => a.Role != UserRole.Root)`
`122`	`122`	`.Select(a => new ClassicUserInfo`
`123`	`123`	`{`
`124`	`124`	`Username = a.UserName,`
`125`		`- Type = a.Type.ToString().ToLower()`
	`125`	`+ Type = a.Role.ToString().ToLower()`
`126`	`126`	`})`
`127`	`127`	`.ToListAsync();`
`128`	`128`
`@@ -163,13 +163,13 @@ public async Task<IActionResult> CreateUser([FromBody] ClassicCreateUserRequest`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`// Validate new user type`
`166`		`- if (!Enum.TryParse<UserType>(request.Type, true, out var userType))`
	`166`	`+ if (!Enum.TryParse<UserRole>(request.Type, true, out var userType))`
`167`	`167`	`{`
`168`	`168`	`return BadRequest(new ClassicErrorResponse("Invalid user type"));`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`// Cannot create root users`
`172`		`- if (userType == UserType.Root)`
	`172`	`+ if (userType == UserRole.Root)`
`173`	`173`	`{`
`174`	`174`	`return StatusCode(403, new ClassicErrorResponse("Cannot create root users"));`
`175`	`175`	`}`
`@@ -187,7 +187,7 @@ public async Task<IActionResult> CreateUser([FromBody] ClassicCreateUserRequest`
`187`	`187`	`UserName = request.NewUsername,`
`188`	`188`	`PasswordHash = hash,`
`189`	`189`	`PasswordSalt = salt,`
`190`		`- Type = userType`
	`190`	`+ Role = userType`
`191`	`191`	`};`
`192`	`192`
`193`	`193`	`_context.Accounts.Add(newAccount);`
`@@ -197,7 +197,7 @@ public async Task<IActionResult> CreateUser([FromBody] ClassicCreateUserRequest`
`197`	`197`	`var profile = new ProfileEntity`
`198`	`198`	`{`
`199`	`199`	`AccountId = newAccount.Id,`
`200`		`- Username = request.NewUsername,`
	`200`	`+ UserName = request.NewUsername,`
`201`	`201`	`AvatarType = AssetType.Text,`
`202`	`202`	`AvatarText = "👤"`
`203`	`203`	`};`
`@@ -267,7 +267,7 @@ public async Task<IActionResult> DeleteUser(string targetUsername, [FromBody] Cl`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`// Cannot delete root account`
`270`		`- if (targetAccount.Type == UserType.Root)`
	`270`	`+ if (targetAccount.Role == UserRole.Root)`
`271`	`271`	`{`
`272`	`272`	`return StatusCode(403, new ClassicErrorResponse("Cannot delete root account"));`
`273`	`273`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,13 +58,13 @@ public async Task<IActionResult> SignUp([FromBody] ClassicSignUpRequest request)`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`// Validate and parse user type`
`61`		`- if (!Enum.TryParse<UserType>(request.Type, true, out var userType))`
	`61`	`+ if (!Enum.TryParse<UserRole>(request.Type, true, out var userType))`
`62`	`62`	`{`
`63`	`63`	`return BadRequest(new ClassicErrorResponse("Invalid user type"));`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`// Cannot create root users via signup`
`67`		`- if (userType == UserType.Root)`
	`67`	`+ if (userType == UserRole.Root)`
`68`	`68`	`{`
`69`	`69`	`return StatusCode(403, new ClassicErrorResponse("Cannot create root users"));`
`70`	`70`	`}`
`@@ -76,7 +76,7 @@ public async Task<IActionResult> SignUp([FromBody] ClassicSignUpRequest request)`
`76`	`76`	`UserName = request.Username,`
`77`	`77`	`PasswordHash = hash,`
`78`	`78`	`PasswordSalt = salt,`
`79`		`- Type = userType`
	`79`	`+ Role = userType`
`80`	`80`	`};`
`81`	`81`
`82`	`82`	`_context.Accounts.Add(account);`
`@@ -86,7 +86,7 @@ public async Task<IActionResult> SignUp([FromBody] ClassicSignUpRequest request)`
`86`	`86`	`var profile = new ProfileEntity`
`87`	`87`	`{`
`88`	`88`	`AccountId = account.Id,`
`89`		`- Username = request.Username,`
	`89`	`+ UserName = request.Username,`
`90`	`90`	`AvatarType = AssetType.Text,`
`91`	`91`	`AvatarText = "👤"`
`92`	`92`	`};`
`@@ -167,14 +167,14 @@ private async Task<IActionResult> HandleSignInAsync(ClassicSignInRequest request`
`167`	`167`	`await _context.SaveChangesAsync();`
`168`	`168`
`169`	`169`	`// 记录日志（区分Root和普通用户）`
`170`		`- if (account.Type == UserType.Root)`
	`170`	`+ if (account.Role == UserRole.Root)`
`171`	`171`	`{`
`172`	`172`	`_logger.LogInformation("Root user logged in");`
`173`	`173`	`}`
`174`	`174`	`else`
`175`	`175`	`{`
`176`	`176`	`_logger.LogInformation("User logged in: {Username} (Type: {Type})",`
`177`		`- request.Username, account.Type);`
	`177`	`+ request.Username, account.Role);`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`return Ok(new ClassicTokenResponse { Token = token });`
`@@ -207,7 +207,7 @@ public async Task<IActionResult> DeleteAccount([FromBody] ClassicDeleteRequest r`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`// Root account cannot be deleted`
`210`		`- if (account.Type == UserType.Root)`
	`210`	`+ if (account.Role == UserRole.Root)`
`211`	`211`	`{`
`212`	`212`	`return StatusCode(403, new ClassicErrorResponse("Cannot delete root account"));`
`213`	`213`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)`
`64`	`64`	`modelBuilder.Entity<ProfileEntity>(entity =>`
`65`	`65`	`{`
`66`	`66`	`// Unique index on Username (redundant with Account but useful)`
`67`		`- entity.HasIndex(e => e.Username).IsUnique();`
	`67`	`+ entity.HasIndex(e => e.UserName).IsUnique();`
`68`	`68`
`69`	`69`	`// One-to-Many relationships with all child entities`
`70`	`70`	`entity.HasMany(e => e.Contacts)`
Original file line number	Diff line number	Diff line change
`@@ -6,5 +6,6 @@ public class Asset`
`6`	`6`	`{`
`7`	`7`	`public AssetType Type { get; set; }`
`8`	`8`	`public string? Text { get; set; } // Text & Emoji & Remote Uri`
	`9`	`+ public string? Tag { get; set; } // MIME Type`
`9`	`10`	`public byte[]? Data { get; set; } // Embedded Base64`
`10`	`11`	`}`