Rename audit log classes and entities

Server/Phantom.Server.Database.Postgres/Migrations/20230213040522_AuditLogRename.Designer.cs

@@ -0,0 +1,466 @@
+// <auto-generated />
+using System;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Phantom.Server.Database;
+
+#nullable disable
+
+namespace Phantom.Server.Database.Postgres.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20230213040522_AuditLogRename")]
+    partial class AuditLogRename
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "7.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("Roles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("RoleClaims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.ToTable("Users", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserLogins", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("UserRoles", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("UserTokens", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AgentEntity", b =>
+                {
+                    b.Property<Guid>("AgentGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BuildVersion")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("MaxInstances")
+                        .HasColumnType("integer");
+
+                    b.Property<ushort>("MaxMemory")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ProtocolVersion")
+                        .HasColumnType("integer");
+
+                    b.HasKey("AgentGuid");
+
+                    b.ToTable("Agents", "agents");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<JsonDocument>("Data")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("EventType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("UtcTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AuditLog", "system");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.InstanceEntity", b =>
+                {
+                    b.Property<Guid>("InstanceGuid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AgentGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("JavaRuntimeGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("JvmArguments")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("LaunchAutomatically")
+                        .HasColumnType("boolean");
+
+                    b.Property<ushort>("MemoryAllocation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MinecraftServerKind")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MinecraftVersion")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("RconPort")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ServerPort")
+                        .HasColumnType("integer");
+
+                    b.HasKey("InstanceGuid");
+
+                    b.ToTable("Instances", "agents");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.PermissionEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Permissions", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.RolePermissionEntity", b =>
+                {
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionId")
+                        .HasColumnType("text");
+
+                    b.HasKey("RoleId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("RolePermissions", "identity");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.UserPermissionEntity", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PermissionId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "PermissionId");
+
+                    b.HasIndex("PermissionId");
+
+                    b.ToTable("UserPermissions", "identity");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.RolePermissionEntity", b =>
+                {
+                    b.HasOne("Phantom.Server.Database.Entities.PermissionEntity", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Phantom.Server.Database.Entities.UserPermissionEntity", b =>
+                {
+                    b.HasOne("Phantom.Server.Database.Entities.PermissionEntity", null)
+                        .WithMany()
+                        .HasForeignKey("PermissionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Server/Phantom.Server.Database.Postgres/Migrations/20230213040522_AuditLogRename.cs

@@ -0,0 +1,92 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Phantom.Server.Database.Postgres.Migrations
+{
+    /// <inheritdoc />
+    public partial class AuditLogRename : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditEvents_Users_UserId",
+                schema: "system",
+                table: "AuditEvents");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AuditEvents",
+                schema: "system",
+                table: "AuditEvents");
+
+            migrationBuilder.RenameTable(
+                name: "AuditEvents",
+                schema: "system",
+                newName: "AuditLog",
+                newSchema: "system");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AuditEvents_UserId",
+                schema: "system",
+                table: "AuditLog",
+                newName: "IX_AuditLog_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AuditLog",
+                schema: "system",
+                table: "AuditLog",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditLog_Users_UserId",
+                schema: "system",
+                table: "AuditLog",
+                column: "UserId",
+                principalSchema: "identity",
+                principalTable: "Users",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_AuditLog_Users_UserId",
+                schema: "system",
+                table: "AuditLog");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_AuditLog",
+                schema: "system",
+                table: "AuditLog");
+
+            migrationBuilder.RenameTable(
+                name: "AuditLog",
+                schema: "system",
+                newName: "AuditEvents",
+                newSchema: "system");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_AuditLog_UserId",
+                schema: "system",
+                table: "AuditEvents",
+                newName: "IX_AuditEvents_UserId");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_AuditEvents",
+                schema: "system",
+                table: "AuditEvents",
+                column: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_AuditEvents_Users_UserId",
+                schema: "system",
+                table: "AuditEvents",
+                column: "UserId",
+                principalSchema: "identity",
+                principalTable: "Users",
+                principalColumn: "Id");
+        }
+    }
+}

Server/Phantom.Server.Database.Postgres/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -18,7 +18,7 @@ namespace Phantom.Server.Database.Postgres.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "7.0.0-rc.1.22426.7")
+                .HasAnnotation("ProductVersion", "7.0.1")
                 .HasAnnotation("Relational:MaxIdentifierLength", 63);
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
@@ -247,7 +247,7 @@ namespace Phantom.Server.Database.Postgres.Migrations
                     b.ToTable("Agents", "agents");
                 });
 
-            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditLogEntity", b =>
                 {
                     b.Property<long>("Id")
                         .ValueGeneratedOnAdd()
@@ -280,7 +280,7 @@ namespace Phantom.Server.Database.Postgres.Migrations
 
                     b.HasIndex("UserId");
 
-                    b.ToTable("AuditEvents", "system");
+                    b.ToTable("AuditLog", "system");
                 });
 
             modelBuilder.Entity("Phantom.Server.Database.Entities.InstanceEntity", b =>
@@ -419,7 +419,7 @@ namespace Phantom.Server.Database.Postgres.Migrations
                         .IsRequired();
                 });
 
-            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditEventEntity", b =>
+            modelBuilder.Entity("Phantom.Server.Database.Entities.AuditLogEntity", b =>
                 {
                     b.HasOne("Microsoft.AspNetCore.Identity.IdentityUser", "User")
                         .WithMany()

Server/Phantom.Server.Database/ApplicationDbContext.cs

@@ -20,7 +20,7 @@ public class ApplicationDbContext : IdentityDbContext {
 	
 	public DbSet<AgentEntity> Agents { get; set; } = null!;
 	public DbSet<InstanceEntity> Instances { get; set; } = null!;
-	public DbSet<AuditEventEntity> AuditEvents { get; set; } = null!;
+	public DbSet<AuditLogEntity> AuditLog { get; set; } = null!;
 
 	public AgentEntityUpsert AgentUpsert { get; }
 	public InstanceEntityUpsert InstanceUpsert { get; }
@@ -60,8 +60,8 @@ public class ApplicationDbContext : IdentityDbContext {
 	protected override void ConfigureConventions(ModelConfigurationBuilder builder) {
 		base.ConfigureConventions(builder);
 
-		builder.Properties<AuditEventType>().HaveConversion<EnumToStringConverter<AuditEventType>>();
-		builder.Properties<AuditSubjectType>().HaveConversion<EnumToStringConverter<AuditSubjectType>>();
+		builder.Properties<AuditLogEventType>().HaveConversion<EnumToStringConverter<AuditLogEventType>>();
+		builder.Properties<AuditLogSubjectType>().HaveConversion<EnumToStringConverter<AuditLogSubjectType>>();
 		builder.Properties<MinecraftServerKind>().HaveConversion<EnumToStringConverter<MinecraftServerKind>>();
 		builder.Properties<RamAllocationUnits>().HaveConversion<RamAllocationUnitsConverter>();
 	}

Server/Phantom.Server.Database/Entities/AuditLogEntity.cs

@@ -7,10 +7,10 @@ using Phantom.Server.Database.Enums;
 
 namespace Phantom.Server.Database.Entities; 
 
-[Table("AuditEvents", Schema = "system")]
+[Table("AuditLog", Schema = "system")]
 [SuppressMessage("ReSharper", "AutoPropertyCanBeMadeGetOnly.Global")]
 [SuppressMessage("ReSharper", "ClassWithVirtualMembersNeverInherited.Global")]
-public class AuditEventEntity : IDisposable {
+public class AuditLogEntity : IDisposable {
 	[Key]
 	[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
 	[SuppressMessage("ReSharper", "UnusedMember.Global")]
@@ -18,19 +18,19 @@ public class AuditEventEntity : IDisposable {
 
 	public string? UserId { get; set; }
 	public DateTime UtcTime { get; set; } // Note: Converting to UTC is not best practice, but for historical records it's good enough.
-	public AuditEventType EventType { get; set; }
-	public AuditSubjectType SubjectType { get; set; }
+	public AuditLogEventType EventType { get; set; }
+	public AuditLogSubjectType SubjectType { get; set; }
 	public string SubjectId { get; set; }
 	public JsonDocument? Data { get; set; }
 
 	public virtual IdentityUser? User { get; set; }
 	
 	[SuppressMessage("ReSharper", "UnusedMember.Global")]
-	internal AuditEventEntity() {
+	internal AuditLogEntity() {
 		SubjectId = string.Empty;
 	}
 
-	public AuditEventEntity(string? userId, AuditEventType eventType, string subjectId, Dictionary<string, object?>? data) {
+	public AuditLogEntity(string? userId, AuditLogEventType eventType, string subjectId, Dictionary<string, object?>? data) {
 		UserId = userId;
 		UtcTime = DateTime.UtcNow;
 		EventType = eventType;

Server/Phantom.Server.Database/Enums/AuditEventType.cs

@@ -1,54 +0,0 @@
-using System.Text.RegularExpressions;
-
-namespace Phantom.Server.Database.Enums;
-
-public enum AuditEventType {
-	AdministratorUserCreated,
-	AdministratorUserModified,
-	UserLoggedIn,
-	UserLoggedOut,
-	UserCreated,
-	UserRolesChanged,
-	UserDeleted,
-	InstanceCreated,
-	InstanceEdited,
-	InstanceLaunched,
-	InstanceStopped,
-	InstanceCommandExecuted
-}
-
-public static partial class AuditEventCategoryExtensions {
-	private static readonly Dictionary<AuditEventType, AuditSubjectType> SubjectTypes = new () {
-		{ AuditEventType.AdministratorUserCreated,  AuditSubjectType.User },
-		{ AuditEventType.AdministratorUserModified, AuditSubjectType.User },
-		{ AuditEventType.UserLoggedIn,              AuditSubjectType.User },
-		{ AuditEventType.UserLoggedOut,             AuditSubjectType.User },
-		{ AuditEventType.UserCreated,               AuditSubjectType.User },
-		{ AuditEventType.UserRolesChanged,          AuditSubjectType.User },
-		{ AuditEventType.UserDeleted,               AuditSubjectType.User },
-		{ AuditEventType.InstanceCreated,           AuditSubjectType.Instance },
-		{ AuditEventType.InstanceEdited,            AuditSubjectType.Instance },
-		{ AuditEventType.InstanceLaunched,          AuditSubjectType.Instance },
-		{ AuditEventType.InstanceStopped,           AuditSubjectType.Instance },
-		{ AuditEventType.InstanceCommandExecuted,   AuditSubjectType.Instance }
-	};
-
-	static AuditEventCategoryExtensions() {
-		foreach (var eventType in Enum.GetValues<AuditEventType>()) {
-			if (!SubjectTypes.ContainsKey(eventType)) {
-				throw new Exception("Missing mapping from " + eventType + " to a subject type.");
-			}
-		}
-	}
-
-	internal static AuditSubjectType GetSubjectType(this AuditEventType type) {
-		return SubjectTypes[type];
-	}
-	
-	[GeneratedRegex(@"\B([A-Z])", RegexOptions.NonBacktracking)]
-	private static partial Regex FindCapitalLettersRegex();
-
-	public static string ToNiceString(this AuditEventType type) {
-		return FindCapitalLettersRegex().Replace(type.ToString(), static match => " " + match.Groups[1].Value.ToLowerInvariant());
-	}
-}

Server/Phantom.Server.Database/Enums/AuditLogEventType.cs

@@ -0,0 +1,54 @@
+using System.Text.RegularExpressions;
+
+namespace Phantom.Server.Database.Enums;
+
+public enum AuditLogEventType {
+	AdministratorUserCreated,
+	AdministratorUserModified,
+	UserLoggedIn,
+	UserLoggedOut,
+	UserCreated,
+	UserRolesChanged,
+	UserDeleted,
+	InstanceCreated,
+	InstanceEdited,
+	InstanceLaunched,
+	InstanceStopped,
+	InstanceCommandExecuted
+}
+
+public static partial class AuditLogEventTypeExtensions {
+	private static readonly Dictionary<AuditLogEventType, AuditLogSubjectType> SubjectTypes = new () {
+		{ AuditLogEventType.AdministratorUserCreated,  AuditLogSubjectType.User },
+		{ AuditLogEventType.AdministratorUserModified, AuditLogSubjectType.User },
+		{ AuditLogEventType.UserLoggedIn,              AuditLogSubjectType.User },
+		{ AuditLogEventType.UserLoggedOut,             AuditLogSubjectType.User },
+		{ AuditLogEventType.UserCreated,               AuditLogSubjectType.User },
+		{ AuditLogEventType.UserRolesChanged,          AuditLogSubjectType.User },
+		{ AuditLogEventType.UserDeleted,               AuditLogSubjectType.User },
+		{ AuditLogEventType.InstanceCreated,           AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceEdited,            AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceLaunched,          AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceStopped,           AuditLogSubjectType.Instance },
+		{ AuditLogEventType.InstanceCommandExecuted,   AuditLogSubjectType.Instance }
+	};
+
+	static AuditLogEventTypeExtensions() {
+		foreach (var eventType in Enum.GetValues<AuditLogEventType>()) {
+			if (!SubjectTypes.ContainsKey(eventType)) {
+				throw new Exception("Missing mapping from " + eventType + " to a subject type.");
+			}
+		}
+	}
+
+	internal static AuditLogSubjectType GetSubjectType(this AuditLogEventType type) {
+		return SubjectTypes[type];
+	}
+	
+	[GeneratedRegex(@"\B([A-Z])", RegexOptions.NonBacktracking)]
+	private static partial Regex FindCapitalLettersRegex();
+
+	public static string ToNiceString(this AuditLogEventType type) {
+		return FindCapitalLettersRegex().Replace(type.ToString(), static match => " " + match.Groups[1].Value.ToLowerInvariant());
+	}
+}

Server/Phantom.Server.Database/Enums/AuditLogSubjectType.cs

@@ -1,6 +1,6 @@
 namespace Phantom.Server.Database.Enums; 
 
-public enum AuditSubjectType {
+public enum AuditLogSubjectType {
 	User,
 	Instance
 }

Server/Phantom.Server.Services/Audit/AuditEvent.cs

@@ -1,6 +0,0 @@
-using System.Text.Json;
-using Phantom.Server.Database.Enums;
-
-namespace Phantom.Server.Services.Audit; 
-
-public sealed record AuditEvent(DateTime UtcTime, string? UserId, string? UserName, AuditEventType EventType, AuditSubjectType SubjectType, string? SubjectId, JsonDocument? Data);

Server/Phantom.Server.Services/Audit/AuditLog.EventTypes.cs

@@ -5,23 +5,23 @@ namespace Phantom.Server.Services.Audit;
 
 public sealed partial class AuditLog {
 	public Task AddAdministratorUserCreatedEvent(IdentityUser administratorUser) {
-		return AddEvent(AuditEventType.AdministratorUserCreated, administratorUser.Id);
+		return AddItem(AuditLogEventType.AdministratorUserCreated, administratorUser.Id);
 	}
 
 	public Task AddAdministratorUserModifiedEvent(IdentityUser administratorUser) {
-		return AddEvent(AuditEventType.AdministratorUserModified, administratorUser.Id);
+		return AddItem(AuditLogEventType.AdministratorUserModified, administratorUser.Id);
 	}
 
 	public void AddUserLoggedInEvent(string userId) {
-		AddEvent(userId, AuditEventType.UserLoggedIn, userId);
+		AddItem(userId, AuditLogEventType.UserLoggedIn, userId);
 	}
 
 	public void AddUserLoggedOutEvent(string userId) {
-		AddEvent(userId, AuditEventType.UserLoggedOut, userId);
+		AddItem(userId, AuditLogEventType.UserLoggedOut, userId);
 	}
 	
 	public Task AddUserCreatedEvent(IdentityUser user) {
-		return AddEvent(AuditEventType.UserCreated, user.Id);
+		return AddItem(AuditLogEventType.UserCreated, user.Id);
 	}
 
 	public Task AddUserRolesChangedEvent(IdentityUser user, List<string> addedToRoles, List<string> removedFromRoles) {
@@ -37,35 +37,35 @@ public sealed partial class AuditLog {
 			extra["removedFromRoles"] = removedFromRoles;
 		}
 		
-		return AddEvent(AuditEventType.UserDeleted, user.Id, extra);
+		return AddItem(AuditLogEventType.UserDeleted, user.Id, extra);
 	}
 	
 	public Task AddUserDeletedEvent(IdentityUser user) {
-		return AddEvent(AuditEventType.UserDeleted, user.Id, new Dictionary<string, object?> {
+		return AddItem(AuditLogEventType.UserDeleted, user.Id, new Dictionary<string, object?> {
 			{ "username", user.UserName }
 		});
 	}
 
 	public Task AddInstanceCreatedEvent(Guid instanceGuid) {
-		return AddEvent(AuditEventType.InstanceCreated, instanceGuid.ToString());
+		return AddItem(AuditLogEventType.InstanceCreated, instanceGuid.ToString());
 	}
 
 	public Task AddInstanceEditedEvent(Guid instanceGuid) {
-		return AddEvent(AuditEventType.InstanceEdited, instanceGuid.ToString());
+		return AddItem(AuditLogEventType.InstanceEdited, instanceGuid.ToString());
 	}
 	
 	public Task AddInstanceLaunchedEvent(Guid instanceGuid) {
-		return AddEvent(AuditEventType.InstanceLaunched, instanceGuid.ToString());
+		return AddItem(AuditLogEventType.InstanceLaunched, instanceGuid.ToString());
 	}
 
 	public Task AddInstanceCommandExecutedEvent(Guid instanceGuid, string command) {
-		return AddEvent(AuditEventType.InstanceCommandExecuted, instanceGuid.ToString(), new Dictionary<string, object?> {
+		return AddItem(AuditLogEventType.InstanceCommandExecuted, instanceGuid.ToString(), new Dictionary<string, object?> {
 			{ "command", command }
 		});
 	}
 
 	public Task AddInstanceStoppedEvent(Guid instanceGuid, int stopInSeconds) {
-		return AddEvent(AuditEventType.InstanceStopped, instanceGuid.ToString(), new Dictionary<string, object?> {
+		return AddItem(AuditLogEventType.InstanceStopped, instanceGuid.ToString(), new Dictionary<string, object?> {
 			{ "stop_in_seconds", stopInSeconds.ToString() }
 		});
 	}

Server/Phantom.Server.Services/Audit/AuditLog.cs

@@ -28,29 +28,29 @@ public sealed partial class AuditLog {
 		return identityLookup.GetAuthenticatedUserId(authenticationState.User);
 	}
 
-	private async Task AddEventToDatabase(AuditEventEntity eventEntity) {
+	private async Task AddEntityToDatabase(AuditLogEntity logEntity) {
 		using var scope = databaseProvider.CreateScope();
-		scope.Ctx.AuditEvents.Add(eventEntity);
+		scope.Ctx.AuditLog.Add(logEntity);
 		await scope.Ctx.SaveChangesAsync(cancellationToken);
 	}
 
-	private void AddEvent(string? userId, AuditEventType eventType, string subjectId, Dictionary<string, object?>? extra = null) {
-		var eventEntity = new AuditEventEntity(userId, eventType, subjectId, extra);
-		taskManager.Run("Store audit log event", () => AddEventToDatabase(eventEntity));
+	private void AddItem(string? userId, AuditLogEventType eventType, string subjectId, Dictionary<string, object?>? extra = null) {
+		var logEntity = new AuditLogEntity(userId, eventType, subjectId, extra);
+		taskManager.Run("Store audit log item to database", () => AddEntityToDatabase(logEntity));
 	}
 
-	private async Task AddEvent(AuditEventType eventType, string subjectId, Dictionary<string, object?>? extra = null) {
-		AddEvent(await GetCurrentAuthenticatedUserId(), eventType, subjectId, extra);
+	private async Task AddItem(AuditLogEventType eventType, string subjectId, Dictionary<string, object?>? extra = null) {
+		AddItem(await GetCurrentAuthenticatedUserId(), eventType, subjectId, extra);
 	}
 
-	public async Task<AuditEvent[]> GetEvents(int count, CancellationToken cancellationToken) {
+	public async Task<AuditLogItem[]> GetItems(int count, CancellationToken cancellationToken) {
 		using var scope = databaseProvider.CreateScope();
-		return await scope.Ctx.AuditEvents
+		return await scope.Ctx.AuditLog
 		                  .Include(static entity => entity.User)
 		                  .AsQueryable()
 		                  .OrderByDescending(static entity => entity.UtcTime)
 		                  .Take(count)
-		                  .Select(static entity => new AuditEvent(entity.UtcTime, entity.UserId, entity.User == null ? null : entity.User.UserName, entity.EventType, entity.SubjectType, entity.SubjectId, entity.Data))
+		                  .Select(static entity => new AuditLogItem(entity.UtcTime, entity.UserId, entity.User == null ? null : entity.User.UserName, entity.EventType, entity.SubjectType, entity.SubjectId, entity.Data))
 		                  .ToArrayAsync(cancellationToken);
 	}
 }

Server/Phantom.Server.Services/Audit/AuditLogItem.cs

@@ -0,0 +1,6 @@
+using System.Text.Json;
+using Phantom.Server.Database.Enums;
+
+namespace Phantom.Server.Services.Audit; 
+
+public sealed record AuditLogItem(DateTime UtcTime, string? UserId, string? UserName, AuditLogEventType EventType, AuditLogSubjectType SubjectType, string? SubjectId, JsonDocument? Data);

Server/Phantom.Server.Web/Pages/Audit.razor

@@ -24,27 +24,27 @@
     </tr>
   </thead>
   <tbody>
-    @foreach (var eventEntity in events) {
-      DateTimeOffset time = eventEntity.UtcTime.ToLocalTime();
+    @foreach (var logItem in logItems) {
+      DateTimeOffset time = logItem.UtcTime.ToLocalTime();
       <tr>
         <td class="text-end">
           <time datetime="@time.ToString("o")">@time.ToString()</time>
         </td>
         <td>
-          @(eventEntity.UserName ?? "-")
+          @(logItem.UserName ?? "-")
           <br>
-          <code class="text-uppercase">@eventEntity.UserId</code>
+          <code class="text-uppercase">@logItem.UserId</code>
         </td>
-        <td>@eventEntity.EventType.ToNiceString()</td>
+        <td>@logItem.EventType.ToNiceString()</td>
         <td>
-          @if (eventEntity.SubjectId is {} subjectId && GetSubjectName(eventEntity.SubjectType, subjectId) is {} subjectName) {
+          @if (logItem.SubjectId is {} subjectId && GetSubjectName(logItem.SubjectType, subjectId) is {} subjectName) {
             @subjectName
             <br>
           }
-          <code class="text-uppercase">@(eventEntity.SubjectId ?? "-")</code>
+          <code class="text-uppercase">@(logItem.SubjectId ?? "-")</code>
         </td>
         <td>
-          <code>@eventEntity.Data?.RootElement.ToString()</code>
+          <code>@logItem.Data?.RootElement.ToString()</code>
         </td>
       </tr>
     }
@@ -54,7 +54,7 @@
 @code {
 
   private CancellationTokenSource? initializationCancellationTokenSource;
-  private AuditEvent[] events = Array.Empty<AuditEvent>();
+  private AuditLogItem[] logItems = Array.Empty<AuditLogItem>();
   private Dictionary<string, string>? userNamesById;
   private ImmutableDictionary<Guid, string> instanceNamesByGuid = ImmutableDictionary<Guid, string>.Empty;
 
@@ -63,7 +63,7 @@
     var cancellationToken = initializationCancellationTokenSource.Token;
 
     try {
-      events = await AuditLog.GetEvents(50, cancellationToken);
+      logItems = await AuditLog.GetItems(50, cancellationToken);
       userNamesById = await UserManager.Users.ToDictionaryAsync(static user => user.Id, static user => user.UserName ?? user.Id, cancellationToken);
       instanceNamesByGuid = InstanceManager.GetInstanceNames();
     } finally {
@@ -71,12 +71,12 @@
     }
   }
   
-  private string? GetSubjectName(AuditSubjectType type, string id) {
+  private string? GetSubjectName(AuditLogSubjectType type, string id) {
     return type switch {
-           AuditSubjectType.Instance => instanceNamesByGuid.TryGetValue(Guid.Parse(id), out var name) ? name : null,
-           AuditSubjectType.User     => userNamesById != null && userNamesById.TryGetValue(id, out var name) ? name : null,
-           _                         => null
-   };
+           AuditLogSubjectType.Instance => instanceNamesByGuid.TryGetValue(Guid.Parse(id), out var name) ? name : null,
+           AuditLogSubjectType.User     => userNamesById != null && userNamesById.TryGetValue(id, out var name) ? name : null,
+           _                            => null
+    };
   }
 
   public void Dispose() {