God bloody christ. There's like three layers of shit here.
So firstly, apparently we were still using Npgsql.EnableLegacyTimestampBehavior. This means that time values (which are stored UTC in the database) were converted to local time when read out. This meant they were passed around as kind Local to clients (instead of UTC in the case of SQLite). That's easy enough to fix just turn off the flag and fix the couple spots we're passing a local DateTime ez.
Oh but it turns out there's a DIFFERENT problem with SQLite: See SQLite we definitely store the DateTimes as UTC, but when Microsoft.Data.Sqlite reads them it reads them as Kind Unspecified instead of Utc.
Why are these so bad? Because the admin notes system passes DateTime instances from EF Core straight to the rest of the game code. And that means it's a PAIN IN THE ASS to run the necessary conversions to fix the DateTime instances. GOD DAMNIT now I have to make a whole new set of "Record" entities so we avoid leaking the EF Core model entities. WAAAAAAA.
Fixes #19897
SeverityRect.Texture = _sprites.Frame0(new SpriteSpecifier.Texture(new ResPath(iconPath)));
}
- TimeLabel.Text = Note.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss");
+ TimeLabel.Text = Note.CreatedAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
ServerLabel.Text = Note.ServerName ?? "Unknown";
RoundLabel.Text = Note.Round == null ? "Unknown round" : "Round " + Note.Round;
AdminLabel.Text = Note.CreatedByName;
if (Note.ExpiryTime.Value > DateTime.UtcNow)
{
ExpiresLabel.Text = Loc.GetString("admin-note-editor-expiry-label-params",
- ("date", Note.ExpiryTime.Value.ToString("yyyy-MM-dd HH:mm:ss")),
+ ("date", Note.ExpiryTime.Value.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss")),
("expiresIn", (Note.ExpiryTime.Value - DateTime.UtcNow).ToString("d'd 'hh':'mm")));
ExpiresLabel.Modulate = Color.FromHex("#86DC3D");
}
if (Note.LastEditedAt > Note.CreatedAt)
{
- EditedLabel.Text = Loc.GetString("admin-notes-edited", ("author", Note.EditedByName), ("date", Note.LastEditedAt));
+ EditedLabel.Text = Loc.GetString("admin-notes-edited", ("author", Note.EditedByName), ("date", Note.LastEditedAt.Value.ToLocalTime()));
EditedLabel.Visible = true;
}
? Loc.GetString("admin-notes-round-id-unknown")
: Loc.GetString("admin-notes-round-id", ("id", note.Round));
CreatedByLabel.Text = Loc.GetString("admin-notes-created-by", ("author", note.CreatedByName));
- CreatedAtLabel.Text = Loc.GetString("admin-notes-created-at", ("date", note.CreatedAt.ToString("yyyy-MM-dd HH:mm:ss")));
+ CreatedAtLabel.Text = Loc.GetString("admin-notes-created-at", ("date", note.CreatedAt.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss")));
EditedByLabel.Text = Loc.GetString("admin-notes-last-edited-by", ("author", note.EditedByName));
- EditedAtLabel.Text = Loc.GetString("admin-notes-last-edited-at", ("date", note.LastEditedAt?.ToString("yyyy-MM-dd HH:mm:ss") ?? Loc.GetString("admin-notes-edited-never")));
+ EditedAtLabel.Text = Loc.GetString("admin-notes-last-edited-at", ("date", note.LastEditedAt?.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss") ?? Loc.GetString("admin-notes-edited-never")));
ExpiryTimeLabel.Text = note.ExpiryTime == null
? Loc.GetString("admin-notes-expires-never")
- : Loc.GetString("admin-notes-expires", ("expires", note.ExpiryTime.Value.ToString("yyyy-MM-dd HH:mm:ss")));
+ : Loc.GetString("admin-notes-expires", ("expires", note.ExpiryTime.Value.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss")));
NoteTextEdit.InsertAtCursor(note.Message);
if (note.NoteType is NoteType.ServerBan or NoteType.RoleBan)
{
PermanentCheckBox.Pressed = false;
UpdatePermanentCheckboxFields();
- ExpiryLineEdit.Text = ExpiryTime.Value.ToString("yyyy-MM-dd HH:mm:ss");
+ ExpiryLineEdit.Text = ExpiryTime.Value.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
}
}
ExpiryLabel.Visible = !PermanentCheckBox.Pressed;
ExpiryLineEdit.Visible = !PermanentCheckBox.Pressed;
- ExpiryLineEdit.Text = !PermanentCheckBox.Pressed ? DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss") : string.Empty;
+ ExpiryLineEdit.Text = !PermanentCheckBox.Pressed ? DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") : string.Empty;
}
private void OnSecretPressed(BaseButton.ButtonEventArgs _)
return false;
}
- ExpiryTime = result;
+ ExpiryTime = result.ToUniversalTime();
ExpiryLineEdit.ModulateSelfOverride = null;
return true;
}
public byte[] Data { get; set; } = default!;
}
- public interface IAdminRemarksCommon
- {
- public int Id { get; }
-
- public int? RoundId { get; }
- public Round? Round { get; }
-
- public Guid? PlayerUserId { get; }
- public Player? Player { get; }
- public TimeSpan PlaytimeAtNote { get; }
-
- public string Message { get; }
-
- public Player? CreatedBy { get; }
-
- public DateTime CreatedAt { get; }
-
- public Player? LastEditedBy { get; }
-
- public DateTime? LastEditedAt { get; }
- public DateTime? ExpirationTime { get; }
-
- public bool Deleted { get; }
- }
-
[Index(nameof(PlayerUserId))]
- public class AdminNote : IAdminRemarksCommon
+ public class AdminNote
{
[Required, Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id { get; set; }
}
[Index(nameof(PlayerUserId))]
- public class AdminWatchlist : IAdminRemarksCommon
+ public class AdminWatchlist
{
[Required, Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id { get; set; }
}
[Index(nameof(PlayerUserId))]
- public class AdminMessage : IAdminRemarksCommon
+ public class AdminMessage
{
[Required, Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)] public int Id { get; set; }
{
public sealed class PostgresServerDbContext : ServerDbContext
{
- static PostgresServerDbContext()
- {
- AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
- }
-
public PostgresServerDbContext(DbContextOptions<PostgresServerDbContext> options) : base(options)
{
}
[Dependency] private readonly IAdminNotesManager _notesMan = default!;
[Dependency] private readonly IConfigurationManager _cfg = default!;
private readonly float _closeWait;
- private AdminMessage? _message;
+ private AdminMessageRecord? _message;
private DateTime _startTime;
public AdminMessageEui()
_closeWait = _cfg.GetCVar(CCVars.MessageWaitTime);
}
- public void SetMessage(AdminMessage message)
+ public void SetMessage(AdminMessageRecord message)
{
_message = message;
_startTime = DateTime.UtcNow;
_closeWait,
_message.Message,
_message.CreatedBy?.LastSeenUserName ?? "[System]",
- _message.CreatedAt
+ _message.CreatedAt.UtcDateTime
);
}
-using System.Diagnostics;
using Content.Server.Database;
using Content.Shared.Administration.Notes;
using Content.Shared.Database;
public static class AdminNotesExtensions
{
- public static SharedAdminNote ToShared(this IAdminRemarksCommon note)
+ public static SharedAdminNote ToShared(this IAdminRemarksRecord note)
{
NoteSeverity? severity = null;
var secret = false;
bool? seen = null;
switch (note)
{
- case AdminNote adminNote:
+ case AdminNoteRecord adminNote:
type = NoteType.Note;
severity = adminNote.Severity;
secret = adminNote.Secret;
break;
- case AdminWatchlist:
+ case AdminWatchlistRecord:
type = NoteType.Watchlist;
secret = true;
break;
- case AdminMessage adminMessage:
+ case AdminMessageRecord adminMessage:
type = NoteType.Message;
seen = adminMessage.Seen;
break;
- case ServerBanNote ban:
+ case ServerBanNoteRecord ban:
type = NoteType.ServerBan;
severity = ban.Severity;
unbannedTime = ban.UnbanTime;
unbannedByName = ban.UnbanningAdmin?.LastSeenUserName ?? Loc.GetString("system-user");
break;
- case ServerRoleBanNote roleBan:
+ case ServerRoleBanNoteRecord roleBan:
type = NoteType.RoleBan;
severity = roleBan.Severity;
bannedRoles = roleBan.Roles;
}
// There may be bans without a user, but why would we ever be converting them to shared notes?
- if (note.PlayerUserId is null)
- throw new ArgumentNullException(nameof(note.PlayerUserId), "Player user ID cannot be null for a note");
+ if (note.Player is null)
+ throw new ArgumentNullException(nameof(note), "Player user ID cannot be null for a note");
+
return new SharedAdminNote(
note.Id,
- note.PlayerUserId.Value,
- note.RoundId,
+ note.Player!.UserId,
+ note.Round?.Id,
note.Round?.Server.Name,
note.PlaytimeAtNote,
type,
secret,
note.CreatedBy?.LastSeenUserName ?? Loc.GetString("system-user"),
note.LastEditedBy?.LastSeenUserName ?? string.Empty,
- note.CreatedAt,
- note.LastEditedAt,
- note.ExpirationTime,
+ note.CreatedAt.UtcDateTime,
+ note.LastEditedAt?.UtcDateTime,
+ note.ExpirationTime?.UtcDateTime,
bannedRoles,
unbannedTime,
unbannedByName,
var note = new SharedAdminNote(
noteId,
- player,
+ (NetUserId) player,
roundId,
serverName,
playtime,
NoteModified?.Invoke(newNote);
}
- public async Task<List<IAdminRemarksCommon>> GetAllAdminRemarks(Guid player)
+ public async Task<List<IAdminRemarksRecord>> GetAllAdminRemarks(Guid player)
{
return await _db.GetAllAdminRemarks(player);
}
- public async Task<List<IAdminRemarksCommon>> GetVisibleRemarks(Guid player)
+ public async Task<List<IAdminRemarksRecord>> GetVisibleRemarks(Guid player)
{
if (_config.GetCVar(CCVars.SeeOwnNotes))
{
return await _db.GetVisibleAdminNotes(player);
}
_sawmill.Warning($"Someone tried to call GetVisibleNotes for {player} when see_own_notes was false");
- return new List<IAdminRemarksCommon>();
+ return new List<IAdminRemarksRecord>();
}
- public async Task<List<AdminWatchlist>> GetActiveWatchlists(Guid player)
+ public async Task<List<AdminWatchlistRecord>> GetActiveWatchlists(Guid player)
{
return await _db.GetActiveWatchlists(player);
}
- public async Task<List<AdminMessage>> GetNewMessages(Guid player)
+ public async Task<List<AdminMessageRecord>> GetNewMessages(Guid player)
{
return await _db.GetMessages(player);
}
/// </summary>
/// <param name="player">Desired player's <see cref="Guid"/></param>
/// <returns>ALL non-deleted notes, secret or not</returns>
- Task<List<IAdminRemarksCommon>> GetAllAdminRemarks(Guid player);
+ Task<List<IAdminRemarksRecord>> GetAllAdminRemarks(Guid player);
/// <summary>
/// Queries the database and retrieves the notes a player should see
/// </summary>
/// <param name="player">Desired player's <see cref="Guid"/></param>
/// <returns>All player-visible notes</returns>
- Task<List<IAdminRemarksCommon>> GetVisibleRemarks(Guid player);
+ Task<List<IAdminRemarksRecord>> GetVisibleRemarks(Guid player);
/// <summary>
/// Queries the database and retrieves watchlists that may have been placed on the player
/// </summary>
/// <param name="player">Desired player's <see cref="Guid"/></param>
/// <returns>Active watchlists</returns>
- Task<List<AdminWatchlist>> GetActiveWatchlists(Guid player);
+ Task<List<AdminWatchlistRecord>> GetActiveWatchlists(Guid player);
/// <summary>
/// Queries the database and retrieves new messages a player has gotten
/// </summary>
/// <param name="player">Desired player's <see cref="Guid"/></param>
/// <returns>All unread messages</returns>
- Task<List<AdminMessage>> GetNewMessages(Guid player);
+ Task<List<AdminMessageRecord>> GetNewMessages(Guid player);
Task MarkMessageAsSeen(int id);
}
--- /dev/null
+using System.Collections.Immutable;
+using System.Net;
+using Content.Shared.Database;
+using Robust.Shared.Network;
+
+namespace Content.Server.Database;
+
+// This file contains copies of records returned from the database.
+// We can't return the raw EF Core entities as they are often unsuited.
+// (e.g. datetime handling of Microsoft.Data.Sqlite)
+
+public interface IAdminRemarksRecord
+{
+ public int Id { get; }
+
+ public RoundRecord? Round { get; }
+
+ public PlayerRecord? Player { get; }
+ public TimeSpan PlaytimeAtNote { get; }
+
+ public string Message { get; }
+
+ public PlayerRecord? CreatedBy { get; }
+
+ public DateTimeOffset CreatedAt { get; }
+
+ public PlayerRecord? LastEditedBy { get; }
+
+ public DateTimeOffset? LastEditedAt { get; }
+ public DateTimeOffset? ExpirationTime { get; }
+
+ public bool Deleted { get; }
+}
+
+public sealed record ServerRoleBanNoteRecord(
+ int Id,
+ RoundRecord? Round,
+ PlayerRecord? Player,
+ TimeSpan PlaytimeAtNote,
+ string Message,
+ NoteSeverity Severity,
+ PlayerRecord? CreatedBy,
+ DateTimeOffset CreatedAt,
+ PlayerRecord? LastEditedBy,
+ DateTimeOffset? LastEditedAt,
+ DateTimeOffset? ExpirationTime,
+ bool Deleted,
+ string[] Roles,
+ PlayerRecord? UnbanningAdmin,
+ DateTime? UnbanTime) : IAdminRemarksRecord;
+
+public sealed record ServerBanNoteRecord(
+ int Id,
+ RoundRecord? Round,
+ PlayerRecord? Player,
+ TimeSpan PlaytimeAtNote,
+ string Message,
+ NoteSeverity Severity,
+ PlayerRecord? CreatedBy,
+ DateTimeOffset CreatedAt,
+ PlayerRecord? LastEditedBy,
+ DateTimeOffset? LastEditedAt,
+ DateTimeOffset? ExpirationTime,
+ bool Deleted,
+ PlayerRecord? UnbanningAdmin,
+ DateTime? UnbanTime) : IAdminRemarksRecord;
+
+public sealed record AdminNoteRecord(
+ int Id,
+ RoundRecord? Round,
+ PlayerRecord? Player,
+ TimeSpan PlaytimeAtNote,
+ string Message,
+ NoteSeverity Severity,
+ PlayerRecord? CreatedBy,
+ DateTimeOffset CreatedAt,
+ PlayerRecord? LastEditedBy,
+ DateTimeOffset? LastEditedAt,
+ DateTimeOffset? ExpirationTime,
+ bool Deleted,
+ PlayerRecord? DeletedBy,
+ DateTimeOffset? DeletedAt,
+ bool Secret) : IAdminRemarksRecord;
+
+public sealed record AdminWatchlistRecord(
+ int Id,
+ RoundRecord? Round,
+ PlayerRecord? Player,
+ TimeSpan PlaytimeAtNote,
+ string Message,
+ PlayerRecord? CreatedBy,
+ DateTimeOffset CreatedAt,
+ PlayerRecord? LastEditedBy,
+ DateTimeOffset? LastEditedAt,
+ DateTimeOffset? ExpirationTime,
+ bool Deleted,
+ PlayerRecord? DeletedBy,
+ DateTimeOffset? DeletedAt) : IAdminRemarksRecord;
+
+public sealed record AdminMessageRecord(
+ int Id,
+ RoundRecord? Round,
+ PlayerRecord? Player,
+ TimeSpan PlaytimeAtNote,
+ string Message,
+ PlayerRecord? CreatedBy,
+ DateTimeOffset CreatedAt,
+ PlayerRecord? LastEditedBy,
+ DateTimeOffset? LastEditedAt,
+ DateTimeOffset? ExpirationTime,
+ bool Deleted,
+ PlayerRecord? DeletedBy,
+ DateTimeOffset? DeletedAt,
+ bool Seen) : IAdminRemarksRecord;
+
+
+public sealed record PlayerRecord(
+ NetUserId UserId,
+ DateTimeOffset FirstSeenTime,
+ string LastSeenUserName,
+ DateTimeOffset LastSeenTime,
+ IPAddress LastSeenAddress,
+ ImmutableArray<byte>? HWId);
+
+public sealed record RoundRecord(int Id, DateTimeOffset StartDate, ServerRecord Server);
+
+public sealed record ServerRecord(int Id, string Name);
+++ /dev/null
-using System.Collections.Immutable;
-using System.Net;
-using Robust.Shared.Network;
-
-namespace Content.Server.Database
-{
- public sealed class PlayerRecord
- {
- public NetUserId UserId { get; }
- public ImmutableArray<byte>? HWId { get; }
- public DateTimeOffset FirstSeenTime { get; }
- public string LastSeenUserName { get; }
- public DateTimeOffset LastSeenTime { get; }
- public IPAddress LastSeenAddress { get; }
-
- public PlayerRecord(
- NetUserId userId,
- DateTimeOffset firstSeenTime,
- string lastSeenUserName,
- DateTimeOffset lastSeenTime,
- IPAddress lastSeenAddress,
- ImmutableArray<byte>? hwId)
- {
- UserId = userId;
- FirstSeenTime = firstSeenTime;
- LastSeenUserName = lastSeenUserName;
- LastSeenTime = lastSeenTime;
- LastSeenAddress = lastSeenAddress;
- HWId = hwId;
- }
- }
-}
+++ /dev/null
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Content.Shared.Database;
-
-namespace Content.Server.Database
-{
- public record ServerBanNote(int Id, int? RoundId, Round? Round, Guid? PlayerUserId, Player? Player,
- TimeSpan PlaytimeAtNote, string Message, NoteSeverity Severity, Player? CreatedBy, DateTime CreatedAt,
- Player? LastEditedBy, DateTime? LastEditedAt, DateTime? ExpirationTime, bool Deleted, Player? UnbanningAdmin,
- DateTime? UnbanTime) : IAdminRemarksCommon;
-}
using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net;
using System.Runtime.CompilerServices;
public abstract Task AddServerBanAsync(ServerBanDef serverBan);
public abstract Task AddServerUnbanAsync(ServerUnbanDef serverUnban);
- public async Task EditServerBan(int id, string reason, NoteSeverity severity, DateTime? expiration, Guid editedBy, DateTime editedAt)
+ public async Task EditServerBan(int id, string reason, NoteSeverity severity, DateTimeOffset? expiration, Guid editedBy, DateTimeOffset editedAt)
{
await using var db = await GetDb();
return;
ban.Severity = severity;
ban.Reason = reason;
- ban.ExpirationTime = expiration;
+ ban.ExpirationTime = expiration?.UtcDateTime;
ban.LastEditedById = editedBy;
- ban.LastEditedAt = editedAt;
+ ban.LastEditedAt = editedAt.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
public abstract Task<ServerRoleBanDef> AddServerRoleBanAsync(ServerRoleBanDef serverRoleBan);
public abstract Task AddServerRoleUnbanAsync(ServerRoleUnbanDef serverRoleUnban);
- public async Task EditServerRoleBan(int id, string reason, NoteSeverity severity, DateTime? expiration, Guid editedBy, DateTime editedAt)
+ public async Task EditServerRoleBan(int id, string reason, NoteSeverity severity, DateTimeOffset? expiration, Guid editedBy, DateTimeOffset editedAt)
{
await using var db = await GetDb();
return;
ban.Severity = severity;
ban.Reason = reason;
- ban.ExpirationTime = expiration;
+ ban.ExpirationTime = expiration?.UtcDateTime;
ban.LastEditedById = editedBy;
- ban.LastEditedAt = editedAt;
+ ban.LastEditedAt = editedAt.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
#endregion
return record == null ? null : MakePlayerRecord(record);
}
- protected abstract PlayerRecord MakePlayerRecord(Player player);
+ [return: NotNullIfNotNull(nameof(player))]
+ protected PlayerRecord? MakePlayerRecord(Player? player)
+ {
+ if (player == null)
+ return null;
+
+ return new PlayerRecord(
+ new NetUserId(player.UserId),
+ new DateTimeOffset(NormalizeDatabaseTime(player.FirstSeenTime)),
+ player.LastSeenUserName,
+ new DateTimeOffset(NormalizeDatabaseTime(player.LastSeenTime)),
+ player.LastSeenAddress,
+ player.LastSeenHWId?.ToImmutableArray());
+ }
+
#endregion
#region Connection Logs
await db.DbContext.SaveChangesAsync();
}
+ [return: NotNullIfNotNull(nameof(round))]
+ protected RoundRecord? MakeRoundRecord(Round? round)
+ {
+ if (round == null)
+ return null;
+
+ return new RoundRecord(
+ round.Id,
+ NormalizeDatabaseTime(round.StartDate),
+ MakeServerRecord(round.Server));
+ }
+
public async Task UpdateAdminRankAsync(AdminRank rank, CancellationToken cancel)
{
await using var db = await GetDb();
return (server, false);
}
+ [return: NotNullIfNotNull(nameof(server))]
+ protected ServerRecord? MakeServerRecord(Server? server)
+ {
+ if (server == null)
+ return null;
+
+ return new ServerRecord(server.Id, server.Name);
+ }
+
public async Task AddAdminLogs(List<AdminLog> logs)
{
DebugTools.Assert(logs.All(x => x.RoundId > 0), "Adding logs with invalid round ids.");
await db.DbContext.SaveChangesAsync();
}
- public async Task<DateTime?> GetLastReadRules(NetUserId player)
+ public async Task<DateTimeOffset?> GetLastReadRules(NetUserId player)
{
await using var db = await GetDb();
- return await db.DbContext.Player
+ return NormalizeDatabaseTime(await db.DbContext.Player
.Where(dbPlayer => dbPlayer.UserId == player)
.Select(dbPlayer => dbPlayer.LastReadRules)
- .SingleOrDefaultAsync();
+ .SingleOrDefaultAsync());
}
- public async Task SetLastReadRules(NetUserId player, DateTime date)
+ public async Task SetLastReadRules(NetUserId player, DateTimeOffset date)
{
await using var db = await GetDb();
return;
}
- dbPlayer.LastReadRules = date;
+ dbPlayer.LastReadRules = date.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
#region Uploaded Resources Logs
- public async Task AddUploadedResourceLogAsync(NetUserId user, DateTime date, string path, byte[] data)
+ public async Task AddUploadedResourceLogAsync(NetUserId user, DateTimeOffset date, string path, byte[] data)
{
await using var db = await GetDb();
- db.DbContext.UploadedResourceLog.Add(new UploadedResourceLog() { UserId = user, Date = date, Path = path, Data = data });
+ db.DbContext.UploadedResourceLog.Add(new UploadedResourceLog() { UserId = user, Date = date.UtcDateTime, Path = path, Data = data });
await db.DbContext.SaveChangesAsync();
}
{
await using var db = await GetDb();
- var date = DateTime.Now.Subtract(TimeSpan.FromDays(days));
+ var date = DateTime.UtcNow.Subtract(TimeSpan.FromDays(days));
await foreach (var log in db.DbContext.UploadedResourceLog
.Where(l => date > l.Date)
return message.Id;
}
- public async Task<AdminNote?> GetAdminNote(int id)
+ public async Task<AdminNoteRecord?> GetAdminNote(int id)
{
await using var db = await GetDb();
- return await db.DbContext.AdminNotes
+ var entity = await db.DbContext.AdminNotes
.Where(note => note.Id == id)
.Include(note => note.Round)
.ThenInclude(r => r!.Server)
.Include(note => note.DeletedBy)
.Include(note => note.Player)
.SingleOrDefaultAsync();
+
+ return entity == null ? null : MakeAdminNoteRecord(entity);
}
- public async Task<AdminWatchlist?> GetAdminWatchlist(int id)
+ private AdminNoteRecord MakeAdminNoteRecord(AdminNote entity)
+ {
+ return new AdminNoteRecord(
+ entity.Id,
+ MakeRoundRecord(entity.Round),
+ MakePlayerRecord(entity.Player),
+ entity.PlaytimeAtNote,
+ entity.Message,
+ entity.Severity,
+ MakePlayerRecord(entity.CreatedBy),
+ NormalizeDatabaseTime(entity.CreatedAt),
+ MakePlayerRecord(entity.LastEditedBy),
+ NormalizeDatabaseTime(entity.LastEditedAt),
+ NormalizeDatabaseTime(entity.ExpirationTime),
+ entity.Deleted,
+ MakePlayerRecord(entity.DeletedBy),
+ NormalizeDatabaseTime(entity.DeletedAt),
+ entity.Secret);
+ }
+
+ public async Task<AdminWatchlistRecord?> GetAdminWatchlist(int id)
{
await using var db = await GetDb();
- return await db.DbContext.AdminWatchlists
+ var entity = await db.DbContext.AdminWatchlists
.Where(note => note.Id == id)
.Include(note => note.Round)
.ThenInclude(r => r!.Server)
.Include(note => note.DeletedBy)
.Include(note => note.Player)
.SingleOrDefaultAsync();
+
+ return entity == null ? null : MakeAdminWatchlistRecord(entity);
}
- public async Task<AdminMessage?> GetAdminMessage(int id)
+ public async Task<AdminMessageRecord?> GetAdminMessage(int id)
{
await using var db = await GetDb();
- return await db.DbContext.AdminMessages
+ var entity = await db.DbContext.AdminMessages
.Where(note => note.Id == id)
.Include(note => note.Round)
.ThenInclude(r => r!.Server)
.Include(note => note.DeletedBy)
.Include(note => note.Player)
.SingleOrDefaultAsync();
+
+ return entity == null ? null : MakeAdminMessageRecord(entity);
}
- public async Task<ServerBanNote?> GetServerBanAsNoteAsync(int id)
+ private AdminMessageRecord MakeAdminMessageRecord(AdminMessage entity)
+ {
+ return new AdminMessageRecord(
+ entity.Id,
+ MakeRoundRecord(entity.Round),
+ MakePlayerRecord(entity.Player),
+ entity.PlaytimeAtNote,
+ entity.Message,
+ MakePlayerRecord(entity.CreatedBy),
+ NormalizeDatabaseTime(entity.CreatedAt),
+ MakePlayerRecord(entity.LastEditedBy),
+ NormalizeDatabaseTime(entity.LastEditedAt),
+ NormalizeDatabaseTime(entity.ExpirationTime),
+ entity.Deleted,
+ MakePlayerRecord(entity.DeletedBy),
+ NormalizeDatabaseTime(entity.DeletedAt),
+ entity.Seen);
+ }
+
+ public async Task<ServerBanNoteRecord?> GetServerBanAsNoteAsync(int id)
{
await using var db = await GetDb();
return null;
var player = await db.DbContext.Player.SingleOrDefaultAsync(p => p.UserId == ban.PlayerUserId);
- return new ServerBanNote(ban.Id, ban.RoundId, ban.Round, ban.PlayerUserId, player,
- ban.PlaytimeAtNote, ban.Reason, ban.Severity, ban.CreatedBy, ban.BanTime,
- ban.LastEditedBy, ban.LastEditedAt, ban.ExpirationTime, ban.Hidden,
- ban.Unban?.UnbanningAdmin == null
+ return new ServerBanNoteRecord(
+ ban.Id,
+ MakeRoundRecord(ban.Round),
+ MakePlayerRecord(player),
+ ban.PlaytimeAtNote,
+ ban.Reason,
+ ban.Severity,
+ MakePlayerRecord(ban.CreatedBy),
+ ban.BanTime,
+ MakePlayerRecord(ban.LastEditedBy),
+ ban.LastEditedAt,
+ ban.ExpirationTime,
+ ban.Hidden,
+ MakePlayerRecord(ban.Unban?.UnbanningAdmin == null
? null
: await db.DbContext.Player.SingleOrDefaultAsync(p =>
- p.UserId == ban.Unban.UnbanningAdmin.Value),
+ p.UserId == ban.Unban.UnbanningAdmin.Value)),
ban.Unban?.UnbanTime);
}
- public async Task<ServerRoleBanNote?> GetServerRoleBanAsNoteAsync(int id)
+ public async Task<ServerRoleBanNoteRecord?> GetServerRoleBanAsNoteAsync(int id)
{
await using var db = await GetDb();
var ban = await db.DbContext.RoleBan
- .Include(b => b.Unban)
+ .Include(ban => ban.Unban)
+ .Include(ban => ban.Round)
+ .ThenInclude(r => r!.Server)
+ .Include(ban => ban.CreatedBy)
+ .Include(ban => ban.LastEditedBy)
+ .Include(ban => ban.Unban)
.SingleOrDefaultAsync(b => b.Id == id);
if (ban is null)
ban.Unban is null
? null
: await db.DbContext.Player.SingleOrDefaultAsync(b => b.UserId == ban.Unban.UnbanningAdmin);
- return new ServerRoleBanNote(ban.Id, ban.RoundId, ban.Round, ban.PlayerUserId,
- player, ban.PlaytimeAtNote, ban.Reason, ban.Severity, ban.CreatedBy,
- ban.BanTime, ban.LastEditedBy, ban.LastEditedAt, ban.ExpirationTime,
- ban.Hidden, new [] { ban.RoleId.Replace(BanManager.JobPrefix, null) },
- unbanningAdmin, ban.Unban?.UnbanTime);
+
+ return new ServerRoleBanNoteRecord(
+ ban.Id,
+ MakeRoundRecord(ban.Round),
+ MakePlayerRecord(player),
+ ban.PlaytimeAtNote,
+ ban.Reason,
+ ban.Severity,
+ MakePlayerRecord(ban.CreatedBy),
+ ban.BanTime,
+ MakePlayerRecord(ban.LastEditedBy),
+ ban.LastEditedAt,
+ ban.ExpirationTime,
+ ban.Hidden,
+ new [] { ban.RoleId.Replace(BanManager.JobPrefix, null) },
+ MakePlayerRecord(unbanningAdmin),
+ ban.Unban?.UnbanTime);
}
- public async Task<List<IAdminRemarksCommon>> GetAllAdminRemarks(Guid player)
+ public async Task<List<IAdminRemarksRecord>> GetAllAdminRemarks(Guid player)
{
await using var db = await GetDb();
- List<IAdminRemarksCommon> notes = new();
+ List<IAdminRemarksRecord> notes = new();
notes.AddRange(
- await (from note in db.DbContext.AdminNotes
- where note.PlayerUserId == player &&
- !note.Deleted &&
- (note.ExpirationTime == null || DateTime.UtcNow < note.ExpirationTime)
- select note)
- .Include(note => note.Round)
- .ThenInclude(r => r!.Server)
- .Include(note => note.CreatedBy)
- .Include(note => note.LastEditedBy)
- .Include(note => note.Player)
- .ToListAsync());
+ (await (from note in db.DbContext.AdminNotes
+ where note.PlayerUserId == player &&
+ !note.Deleted &&
+ (note.ExpirationTime == null || DateTime.UtcNow < note.ExpirationTime)
+ select note)
+ .Include(note => note.Round)
+ .ThenInclude(r => r!.Server)
+ .Include(note => note.CreatedBy)
+ .Include(note => note.LastEditedBy)
+ .Include(note => note.Player)
+ .ToListAsync()).Select(MakeAdminNoteRecord));
notes.AddRange(await GetActiveWatchlistsImpl(db, player));
notes.AddRange(await GetMessagesImpl(db, player));
notes.AddRange(await GetServerBansAsNotesForUser(db, player));
notes.AddRange(await GetGroupedServerRoleBansAsNotesForUser(db, player));
return notes;
}
- public async Task EditAdminNote(int id, string message, NoteSeverity severity, bool secret, Guid editedBy, DateTime editedAt, DateTime? expiryTime)
+ public async Task EditAdminNote(int id, string message, NoteSeverity severity, bool secret, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime)
{
await using var db = await GetDb();
note.Severity = severity;
note.Secret = secret;
note.LastEditedById = editedBy;
- note.LastEditedAt = editedAt;
- note.ExpirationTime = expiryTime;
+ note.LastEditedAt = editedAt.UtcDateTime;
+ note.ExpirationTime = expiryTime?.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task EditAdminWatchlist(int id, string message, Guid editedBy, DateTime editedAt, DateTime? expiryTime)
+ public async Task EditAdminWatchlist(int id, string message, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime)
{
await using var db = await GetDb();
var note = await db.DbContext.AdminWatchlists.Where(note => note.Id == id).SingleAsync();
note.Message = message;
note.LastEditedById = editedBy;
- note.LastEditedAt = editedAt;
- note.ExpirationTime = expiryTime;
+ note.LastEditedAt = editedAt.UtcDateTime;
+ note.ExpirationTime = expiryTime?.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task EditAdminMessage(int id, string message, Guid editedBy, DateTime editedAt, DateTime? expiryTime)
+ public async Task EditAdminMessage(int id, string message, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime)
{
await using var db = await GetDb();
var note = await db.DbContext.AdminMessages.Where(note => note.Id == id).SingleAsync();
note.Message = message;
note.LastEditedById = editedBy;
- note.LastEditedAt = editedAt;
- note.ExpirationTime = expiryTime;
+ note.LastEditedAt = editedAt.UtcDateTime;
+ note.ExpirationTime = expiryTime?.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task DeleteAdminNote(int id, Guid deletedBy, DateTime deletedAt)
+ public async Task DeleteAdminNote(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
await using var db = await GetDb();
note.Deleted = true;
note.DeletedById = deletedBy;
- note.DeletedAt = deletedAt;
+ note.DeletedAt = deletedAt.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task DeleteAdminWatchlist(int id, Guid deletedBy, DateTime deletedAt)
+ public async Task DeleteAdminWatchlist(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
await using var db = await GetDb();
watchlist.Deleted = true;
watchlist.DeletedById = deletedBy;
- watchlist.DeletedAt = deletedAt;
+ watchlist.DeletedAt = deletedAt.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task DeleteAdminMessage(int id, Guid deletedBy, DateTime deletedAt)
+ public async Task DeleteAdminMessage(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
await using var db = await GetDb();
message.Deleted = true;
message.DeletedById = deletedBy;
- message.DeletedAt = deletedAt;
+ message.DeletedAt = deletedAt.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task HideServerBanFromNotes(int id, Guid deletedBy, DateTime deletedAt)
+ public async Task HideServerBanFromNotes(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
await using var db = await GetDb();
ban.Hidden = true;
ban.LastEditedById = deletedBy;
- ban.LastEditedAt = deletedAt;
+ ban.LastEditedAt = deletedAt.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task HideServerRoleBanFromNotes(int id, Guid deletedBy, DateTime deletedAt)
+ public async Task HideServerRoleBanFromNotes(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
await using var db = await GetDb();
roleBan.Hidden = true;
roleBan.LastEditedById = deletedBy;
- roleBan.LastEditedAt = deletedAt;
+ roleBan.LastEditedAt = deletedAt.UtcDateTime;
await db.DbContext.SaveChangesAsync();
}
- public async Task<List<IAdminRemarksCommon>> GetVisibleAdminRemarks(Guid player)
+ public async Task<List<IAdminRemarksRecord>> GetVisibleAdminRemarks(Guid player)
{
await using var db = await GetDb();
- List<IAdminRemarksCommon> notesCol = new();
+ List<IAdminRemarksRecord> notesCol = new();
notesCol.AddRange(
- await (from note in db.DbContext.AdminNotes
- where note.PlayerUserId == player &&
- !note.Secret &&
- !note.Deleted &&
- (note.ExpirationTime == null || DateTime.UtcNow < note.ExpirationTime)
- select note)
- .Include(note => note.Round)
- .ThenInclude(r => r!.Server)
- .Include(note => note.CreatedBy)
- .Include(note => note.Player)
- .ToListAsync());
+ (await (from note in db.DbContext.AdminNotes
+ where note.PlayerUserId == player &&
+ !note.Secret &&
+ !note.Deleted &&
+ (note.ExpirationTime == null || DateTime.UtcNow < note.ExpirationTime)
+ select note)
+ .Include(note => note.Round)
+ .ThenInclude(r => r!.Server)
+ .Include(note => note.CreatedBy)
+ .Include(note => note.Player)
+ .ToListAsync()).Select(MakeAdminNoteRecord));
notesCol.AddRange(await GetMessagesImpl(db, player));
return notesCol;
}
- public async Task<List<AdminWatchlist>> GetActiveWatchlists(Guid player)
+ public async Task<List<AdminWatchlistRecord>> GetActiveWatchlists(Guid player)
{
await using var db = await GetDb();
return await GetActiveWatchlistsImpl(db, player);
}
- protected async Task<List<AdminWatchlist>> GetActiveWatchlistsImpl(DbGuard db, Guid player)
+ protected async Task<List<AdminWatchlistRecord>> GetActiveWatchlistsImpl(DbGuard db, Guid player)
{
- return await (from watchlist in db.DbContext.AdminWatchlists
+ var entities = await (from watchlist in db.DbContext.AdminWatchlists
where watchlist.PlayerUserId == player &&
!watchlist.Deleted &&
(watchlist.ExpirationTime == null || DateTime.UtcNow < watchlist.ExpirationTime)
.Include(note => note.LastEditedBy)
.Include(note => note.Player)
.ToListAsync();
+
+ return entities.Select(MakeAdminWatchlistRecord).ToList();
}
- public async Task<List<AdminMessage>> GetMessages(Guid player)
+ private AdminWatchlistRecord MakeAdminWatchlistRecord(AdminWatchlist entity)
+ {
+ return new AdminWatchlistRecord(entity.Id, MakeRoundRecord(entity.Round), MakePlayerRecord(entity.Player), entity.PlaytimeAtNote, entity.Message, MakePlayerRecord(entity.CreatedBy), NormalizeDatabaseTime(entity.CreatedAt), MakePlayerRecord(entity.LastEditedBy), NormalizeDatabaseTime(entity.LastEditedAt), NormalizeDatabaseTime(entity.ExpirationTime), entity.Deleted, MakePlayerRecord(entity.DeletedBy), NormalizeDatabaseTime(entity.DeletedAt));
+ }
+
+ public async Task<List<AdminMessageRecord>> GetMessages(Guid player)
{
await using var db = await GetDb();
return await GetMessagesImpl(db, player);
}
- protected async Task<List<AdminMessage>> GetMessagesImpl(DbGuard db, Guid player)
+ protected async Task<List<AdminMessageRecord>> GetMessagesImpl(DbGuard db, Guid player)
{
- return await (from message in db.DbContext.AdminMessages
- where message.PlayerUserId == player &&
- !message.Deleted &&
- (message.ExpirationTime == null || DateTime.UtcNow < message.ExpirationTime)
- select message)
- .Include(note => note.Round)
- .ThenInclude(r => r!.Server)
- .Include(note => note.CreatedBy)
- .Include(note => note.LastEditedBy)
- .Include(note => note.Player)
- .ToListAsync();
+ var entities = await (from message in db.DbContext.AdminMessages
+ where message.PlayerUserId == player && !message.Deleted &&
+ (message.ExpirationTime == null || DateTime.UtcNow < message.ExpirationTime)
+ select message).Include(note => note.Round)
+ .ThenInclude(r => r!.Server)
+ .Include(note => note.CreatedBy)
+ .Include(note => note.LastEditedBy)
+ .Include(note => note.Player)
+ .ToListAsync();
+
+ return entities.Select(MakeAdminMessageRecord).ToList();
}
public async Task MarkMessageAsSeen(int id)
}
// These two are here because they get converted into notes later
- protected async Task<List<ServerBanNote>> GetServerBansAsNotesForUser(DbGuard db, Guid user)
+ protected async Task<List<ServerBanNoteRecord>> GetServerBansAsNotesForUser(DbGuard db, Guid user)
{
// You can't group queries, as player will not always exist. When it doesn't, the
// whole query returns nothing
.Include(ban => ban.Unban)
.ToArrayAsync();
- var banNotes = new List<ServerBanNote>();
+ var banNotes = new List<ServerBanNoteRecord>();
foreach (var ban in bans)
{
- var banNote = new ServerBanNote(ban.Id, ban.RoundId, ban.Round, ban.PlayerUserId, player,
- ban.PlaytimeAtNote, ban.Reason, ban.Severity, ban.CreatedBy, ban.BanTime,
- ban.LastEditedBy, ban.LastEditedAt, ban.ExpirationTime, ban.Hidden,
- ban.Unban?.UnbanningAdmin == null
+ var banNote = new ServerBanNoteRecord(
+ ban.Id,
+ MakeRoundRecord(ban.Round),
+ MakePlayerRecord(player),
+ ban.PlaytimeAtNote,
+ ban.Reason,
+ ban.Severity,
+ MakePlayerRecord(ban.CreatedBy),
+ NormalizeDatabaseTime(ban.BanTime),
+ MakePlayerRecord(ban.LastEditedBy),
+ NormalizeDatabaseTime(ban.LastEditedAt),
+ NormalizeDatabaseTime(ban.ExpirationTime),
+ ban.Hidden,
+ MakePlayerRecord(ban.Unban?.UnbanningAdmin == null
? null
: await db.DbContext.Player.SingleOrDefaultAsync(
- p => p.UserId == ban.Unban.UnbanningAdmin.Value),
- ban.Unban?.UnbanTime);
+ p => p.UserId == ban.Unban.UnbanningAdmin.Value)),
+ NormalizeDatabaseTime(ban.Unban?.UnbanTime));
banNotes.Add(banNote);
}
return banNotes;
}
- protected async Task<List<ServerRoleBanNote>> GetGroupedServerRoleBansAsNotesForUser(DbGuard db, Guid user)
+ protected async Task<List<ServerRoleBanNoteRecord>> GetGroupedServerRoleBansAsNotesForUser(DbGuard db, Guid user)
{
// Server side query
var bansQuery = await db.DbContext.RoleBan
.Select(banGroup => banGroup)
.ToArray();
- List<ServerRoleBanNote> bans = new();
+ List<ServerRoleBanNoteRecord> bans = new();
var player = await db.DbContext.Player.SingleOrDefaultAsync(p => p.UserId == user);
foreach (var banGroup in bansEnumerable)
{
if (firstBan.Unban?.UnbanningAdmin is not null)
unbanningAdmin = await db.DbContext.Player.SingleOrDefaultAsync(p => p.UserId == firstBan.Unban.UnbanningAdmin.Value);
- bans.Add(new ServerRoleBanNote(firstBan.Id, firstBan.RoundId, firstBan.Round, firstBan.PlayerUserId,
- player, firstBan.PlaytimeAtNote, firstBan.Reason, firstBan.Severity, firstBan.CreatedBy,
- firstBan.BanTime, firstBan.LastEditedBy, firstBan.LastEditedAt, firstBan.ExpirationTime,
- firstBan.Hidden, banGroup.Select(ban => ban.RoleId.Replace(BanManager.JobPrefix, null)).ToArray(),
- unbanningAdmin, firstBan.Unban?.UnbanTime));
+ bans.Add(new ServerRoleBanNoteRecord(
+ firstBan.Id,
+ MakeRoundRecord(firstBan.Round),
+ MakePlayerRecord(player),
+ firstBan.PlaytimeAtNote,
+ firstBan.Reason,
+ firstBan.Severity,
+ MakePlayerRecord(firstBan.CreatedBy),
+ NormalizeDatabaseTime(firstBan.BanTime),
+ MakePlayerRecord(firstBan.LastEditedBy),
+ NormalizeDatabaseTime(firstBan.LastEditedAt),
+ NormalizeDatabaseTime(firstBan.ExpirationTime),
+ firstBan.Hidden,
+ banGroup.Select(ban => ban.RoleId.Replace(BanManager.JobPrefix, null)).ToArray(),
+ MakePlayerRecord(unbanningAdmin),
+ NormalizeDatabaseTime(firstBan.Unban?.UnbanTime)));
}
return bans;
#endregion
+ // SQLite returns DateTime as Kind=Unspecified, Npgsql actually knows for sure it's Kind=Utc.
+ // Normalize DateTimes here so they're always Utc. Thanks.
+ protected abstract DateTime NormalizeDatabaseTime(DateTime time);
+
+ [return: NotNullIfNotNull(nameof(time))]
+ protected DateTime? NormalizeDatabaseTime(DateTime? time)
+ {
+ return time != null ? NormalizeDatabaseTime(time.Value) : time;
+ }
+
protected abstract Task<DbGuard> GetDb([CallerMemberName] string? name = null);
protected void LogDbOp(string? name)
int id,
string reason,
NoteSeverity severity,
- DateTime? expiration,
+ DateTimeOffset? expiration,
Guid editedBy,
- DateTime editedAt);
+ DateTimeOffset editedAt);
/// <summary>
/// Update ban exemption information for a player.
int id,
string reason,
NoteSeverity severity,
- DateTime? expiration,
+ DateTimeOffset? expiration,
Guid editedBy,
- DateTime editedAt);
+ DateTimeOffset editedAt);
#endregion
#region Playtime
#region Uploaded Resources Logs
- Task AddUploadedResourceLogAsync(NetUserId user, DateTime date, string path, byte[] data);
+ Task AddUploadedResourceLogAsync(NetUserId user, DateTimeOffset date, string path, byte[] data);
Task PurgeUploadedResourceLogAsync(int days);
#region Rules
- Task<DateTime?> GetLastReadRules(NetUserId player);
- Task SetLastReadRules(NetUserId player, DateTime time);
+ Task<DateTimeOffset?> GetLastReadRules(NetUserId player);
+ Task SetLastReadRules(NetUserId player, DateTimeOffset time);
#endregion
#region Admin Notes
- Task<int> AddAdminNote(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, NoteSeverity severity, bool secret, Guid createdBy, DateTime createdAt, DateTime? expiryTime);
- Task<int> AddAdminWatchlist(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTime createdAt, DateTime? expiryTime);
- Task<int> AddAdminMessage(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTime createdAt, DateTime? expiryTime);
- Task<AdminNote?> GetAdminNote(int id);
- Task<AdminWatchlist?> GetAdminWatchlist(int id);
- Task<AdminMessage?> GetAdminMessage(int id);
- Task<ServerBanNote?> GetServerBanAsNoteAsync(int id);
- Task<ServerRoleBanNote?> GetServerRoleBanAsNoteAsync(int id);
- Task<List<IAdminRemarksCommon>> GetAllAdminRemarks(Guid player);
- Task<List<IAdminRemarksCommon>> GetVisibleAdminNotes(Guid player);
- Task<List<AdminWatchlist>> GetActiveWatchlists(Guid player);
- Task<List<AdminMessage>> GetMessages(Guid player);
- Task EditAdminNote(int id, string message, NoteSeverity severity, bool secret, Guid editedBy, DateTime editedAt, DateTime? expiryTime);
- Task EditAdminWatchlist(int id, string message, Guid editedBy, DateTime editedAt, DateTime? expiryTime);
- Task EditAdminMessage(int id, string message, Guid editedBy, DateTime editedAt, DateTime? expiryTime);
- Task DeleteAdminNote(int id, Guid deletedBy, DateTime deletedAt);
- Task DeleteAdminWatchlist(int id, Guid deletedBy, DateTime deletedAt);
- Task DeleteAdminMessage(int id, Guid deletedBy, DateTime deletedAt);
- Task HideServerBanFromNotes(int id, Guid deletedBy, DateTime deletedAt);
- Task HideServerRoleBanFromNotes(int id, Guid deletedBy, DateTime deletedAt);
+ Task<int> AddAdminNote(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, NoteSeverity severity, bool secret, Guid createdBy, DateTimeOffset createdAt, DateTimeOffset? expiryTime);
+ Task<int> AddAdminWatchlist(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTimeOffset createdAt, DateTimeOffset? expiryTime);
+ Task<int> AddAdminMessage(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTimeOffset createdAt, DateTimeOffset? expiryTime);
+ Task<AdminNoteRecord?> GetAdminNote(int id);
+ Task<AdminWatchlistRecord?> GetAdminWatchlist(int id);
+ Task<AdminMessageRecord?> GetAdminMessage(int id);
+ Task<ServerBanNoteRecord?> GetServerBanAsNoteAsync(int id);
+ Task<ServerRoleBanNoteRecord?> GetServerRoleBanAsNoteAsync(int id);
+ Task<List<IAdminRemarksRecord>> GetAllAdminRemarks(Guid player);
+ Task<List<IAdminRemarksRecord>> GetVisibleAdminNotes(Guid player);
+ Task<List<AdminWatchlistRecord>> GetActiveWatchlists(Guid player);
+ Task<List<AdminMessageRecord>> GetMessages(Guid player);
+ Task EditAdminNote(int id, string message, NoteSeverity severity, bool secret, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime);
+ Task EditAdminWatchlist(int id, string message, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime);
+ Task EditAdminMessage(int id, string message, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime);
+ Task DeleteAdminNote(int id, Guid deletedBy, DateTimeOffset deletedAt);
+ Task DeleteAdminWatchlist(int id, Guid deletedBy, DateTimeOffset deletedAt);
+ Task DeleteAdminMessage(int id, Guid deletedBy, DateTimeOffset deletedAt);
+ Task HideServerBanFromNotes(int id, Guid deletedBy, DateTimeOffset deletedAt);
+ Task HideServerRoleBanFromNotes(int id, Guid deletedBy, DateTimeOffset deletedAt);
Task MarkMessageAsSeen(int id);
#endregion
return RunDbCommand(() => _db.AddServerUnbanAsync(serverUnban));
}
- public Task EditServerBan(int id, string reason, NoteSeverity severity, DateTime? expiration, Guid editedBy, DateTime editedAt)
+ public Task EditServerBan(int id, string reason, NoteSeverity severity, DateTimeOffset? expiration, Guid editedBy, DateTimeOffset editedAt)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.EditServerBan(id, reason, severity, expiration, editedBy, editedAt));
return RunDbCommand(() => _db.AddServerRoleUnbanAsync(serverRoleUnban));
}
- public Task EditServerRoleBan(int id, string reason, NoteSeverity severity, DateTime? expiration, Guid editedBy, DateTime editedAt)
+ public Task EditServerRoleBan(int id, string reason, NoteSeverity severity, DateTimeOffset? expiration, Guid editedBy, DateTimeOffset editedAt)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.EditServerRoleBan(id, reason, severity, expiration, editedBy, editedAt));
return RunDbCommand(() => _db.RemoveFromWhitelistAsync(player));
}
- public Task AddUploadedResourceLogAsync(NetUserId user, DateTime date, string path, byte[] data)
+ public Task AddUploadedResourceLogAsync(NetUserId user, DateTimeOffset date, string path, byte[] data)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.AddUploadedResourceLogAsync(user, date, path, data));
return RunDbCommand(() => _db.PurgeUploadedResourceLogAsync(days));
}
- public Task<DateTime?> GetLastReadRules(NetUserId player)
+ public Task<DateTimeOffset?> GetLastReadRules(NetUserId player)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetLastReadRules(player));
}
- public Task SetLastReadRules(NetUserId player, DateTime time)
+ public Task SetLastReadRules(NetUserId player, DateTimeOffset time)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.SetLastReadRules(player, time));
}
- public Task<int> AddAdminNote(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, NoteSeverity severity, bool secret, Guid createdBy, DateTime createdAt, DateTime? expiryTime)
+ public Task<int> AddAdminNote(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, NoteSeverity severity, bool secret, Guid createdBy, DateTimeOffset createdAt, DateTimeOffset? expiryTime)
{
DbWriteOpsMetric.Inc();
var note = new AdminNote
Message = message,
Severity = severity,
Secret = secret,
- CreatedAt = createdAt,
- LastEditedAt = createdAt,
- ExpirationTime = expiryTime
+ CreatedAt = createdAt.UtcDateTime,
+ LastEditedAt = createdAt.UtcDateTime,
+ ExpirationTime = expiryTime?.UtcDateTime
};
return RunDbCommand(() => _db.AddAdminNote(note));
}
- public Task<int> AddAdminWatchlist(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTime createdAt, DateTime? expiryTime)
+ public Task<int> AddAdminWatchlist(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTimeOffset createdAt, DateTimeOffset? expiryTime)
{
DbWriteOpsMetric.Inc();
var note = new AdminWatchlist
PlayerUserId = player,
PlaytimeAtNote = playtimeAtNote,
Message = message,
- CreatedAt = createdAt,
- LastEditedAt = createdAt,
- ExpirationTime = expiryTime
+ CreatedAt = createdAt.UtcDateTime,
+ LastEditedAt = createdAt.UtcDateTime,
+ ExpirationTime = expiryTime?.UtcDateTime
};
return RunDbCommand(() => _db.AddAdminWatchlist(note));
}
- public Task<int> AddAdminMessage(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTime createdAt, DateTime? expiryTime)
+ public Task<int> AddAdminMessage(int? roundId, Guid player, TimeSpan playtimeAtNote, string message, Guid createdBy, DateTimeOffset createdAt, DateTimeOffset? expiryTime)
{
DbWriteOpsMetric.Inc();
var note = new AdminMessage
PlayerUserId = player,
PlaytimeAtNote = playtimeAtNote,
Message = message,
- CreatedAt = createdAt,
- LastEditedAt = createdAt,
- ExpirationTime = expiryTime
+ CreatedAt = createdAt.UtcDateTime,
+ LastEditedAt = createdAt.UtcDateTime,
+ ExpirationTime = expiryTime?.UtcDateTime
};
return RunDbCommand(() => _db.AddAdminMessage(note));
}
- public Task<AdminNote?> GetAdminNote(int id)
+ public Task<AdminNoteRecord?> GetAdminNote(int id)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetAdminNote(id));
}
- public Task<AdminWatchlist?> GetAdminWatchlist(int id)
+ public Task<AdminWatchlistRecord?> GetAdminWatchlist(int id)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetAdminWatchlist(id));
}
- public Task<AdminMessage?> GetAdminMessage(int id)
+ public Task<AdminMessageRecord?> GetAdminMessage(int id)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetAdminMessage(id));
}
- public Task<ServerBanNote?> GetServerBanAsNoteAsync(int id)
+ public Task<ServerBanNoteRecord?> GetServerBanAsNoteAsync(int id)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetServerBanAsNoteAsync(id));
}
- public Task<ServerRoleBanNote?> GetServerRoleBanAsNoteAsync(int id)
+ public Task<ServerRoleBanNoteRecord?> GetServerRoleBanAsNoteAsync(int id)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetServerRoleBanAsNoteAsync(id));
}
- public Task<List<IAdminRemarksCommon>> GetAllAdminRemarks(Guid player)
+ public Task<List<IAdminRemarksRecord>> GetAllAdminRemarks(Guid player)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetAllAdminRemarks(player));
}
- public Task<List<IAdminRemarksCommon>> GetVisibleAdminNotes(Guid player)
+ public Task<List<IAdminRemarksRecord>> GetVisibleAdminNotes(Guid player)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetVisibleAdminRemarks(player));
}
- public Task<List<AdminWatchlist>> GetActiveWatchlists(Guid player)
+ public Task<List<AdminWatchlistRecord>> GetActiveWatchlists(Guid player)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetActiveWatchlists(player));
}
- public Task<List<AdminMessage>> GetMessages(Guid player)
+ public Task<List<AdminMessageRecord>> GetMessages(Guid player)
{
DbReadOpsMetric.Inc();
return RunDbCommand(() => _db.GetMessages(player));
}
- public Task EditAdminNote(int id, string message, NoteSeverity severity, bool secret, Guid editedBy, DateTime editedAt, DateTime? expiryTime)
+ public Task EditAdminNote(int id, string message, NoteSeverity severity, bool secret, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.EditAdminNote(id, message, severity, secret, editedBy, editedAt, expiryTime));
}
- public Task EditAdminWatchlist(int id, string message, Guid editedBy, DateTime editedAt, DateTime? expiryTime)
+ public Task EditAdminWatchlist(int id, string message, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.EditAdminWatchlist(id, message, editedBy, editedAt, expiryTime));
}
- public Task EditAdminMessage(int id, string message, Guid editedBy, DateTime editedAt, DateTime? expiryTime)
+ public Task EditAdminMessage(int id, string message, Guid editedBy, DateTimeOffset editedAt, DateTimeOffset? expiryTime)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.EditAdminMessage(id, message, editedBy, editedAt, expiryTime));
}
- public Task DeleteAdminNote(int id, Guid deletedBy, DateTime deletedAt)
+ public Task DeleteAdminNote(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.DeleteAdminNote(id, deletedBy, deletedAt));
}
- public Task DeleteAdminWatchlist(int id, Guid deletedBy, DateTime deletedAt)
+ public Task DeleteAdminWatchlist(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.DeleteAdminWatchlist(id, deletedBy, deletedAt));
}
- public Task DeleteAdminMessage(int id, Guid deletedBy, DateTime deletedAt)
+ public Task DeleteAdminMessage(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.DeleteAdminMessage(id, deletedBy, deletedAt));
}
- public Task HideServerBanFromNotes(int id, Guid deletedBy, DateTime deletedAt)
+ public Task HideServerBanFromNotes(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.HideServerBanFromNotes(id, deletedBy, deletedAt));
}
- public Task HideServerRoleBanFromNotes(int id, Guid deletedBy, DateTime deletedAt)
+ public Task HideServerRoleBanFromNotes(int id, Guid deletedBy, DateTimeOffset deletedAt)
{
DbWriteOpsMetric.Inc();
return RunDbCommand(() => _db.HideServerRoleBanFromNotes(id, deletedBy, deletedAt));
if (!includeUnbanned)
{
query = query.Where(p =>
- p.Unban == null && (p.ExpirationTime == null || p.ExpirationTime.Value > DateTime.Now));
+ p.Unban == null && (p.ExpirationTime == null || p.ExpirationTime.Value > DateTime.UtcNow));
}
if (exemptFlags is { } exempt)
if (!includeUnbanned)
{
query = query?.Where(p =>
- p.Unban == null && (p.ExpirationTime == null || p.ExpirationTime.Value > DateTime.Now));
+ p.Unban == null && (p.ExpirationTime == null || p.ExpirationTime.Value > DateTime.UtcNow));
}
query = query!.Distinct();
}
#endregion
- protected override PlayerRecord MakePlayerRecord(Player record)
- {
- return new PlayerRecord(
- new NetUserId(record.UserId),
- new DateTimeOffset(record.FirstSeenTime),
- record.LastSeenUserName,
- new DateTimeOffset(record.LastSeenTime),
- record.LastSeenAddress,
- record.LastSeenHWId?.ToImmutableArray());
- }
-
public override async Task<int> AddConnectionLogAsync(
NetUserId userId,
string userName,
return db.AdminLog;
}
+ protected override DateTime NormalizeDatabaseTime(DateTime time)
+ {
+ DebugTools.Assert(time.Kind == DateTimeKind.Utc);
+ return time;
+ }
+
private async Task<DbGuardImpl> GetDbImpl([CallerMemberName] string? name = null)
{
LogDbOp(name);
using Microsoft.EntityFrameworkCore;
using Robust.Shared.Configuration;
using Robust.Shared.Network;
+using Robust.Shared.Utility;
namespace Content.Server.Database
{
}
#endregion
- protected override PlayerRecord MakePlayerRecord(Player record)
- {
- return new PlayerRecord(
- new NetUserId(record.UserId),
- new DateTimeOffset(record.FirstSeenTime, TimeSpan.Zero),
- record.LastSeenUserName,
- new DateTimeOffset(record.LastSeenTime, TimeSpan.Zero),
- record.LastSeenAddress,
- record.LastSeenHWId?.ToImmutableArray());
- }
-
private static ServerBanDef? ConvertBan(ServerBan? ban)
{
if (ban == null)
return await base.AddAdminMessage(message);
}
+ protected override DateTime NormalizeDatabaseTime(DateTime time)
+ {
+ DebugTools.Assert(time.Kind == DateTimeKind.Unspecified);
+ return DateTime.SpecifyKind(time, DateTimeKind.Utc);
+ }
+
private async Task<DbGuardImpl> GetDbImpl([CallerMemberName] string? name = null)
{
LogDbOp(name);
+++ /dev/null
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Content.Shared.Database;
-
-namespace Content.Server.Database
-{
- public record ServerRoleBanNote(int Id, int? RoundId, Round? Round, Guid? PlayerUserId, Player? Player,
- TimeSpan PlaytimeAtNote, string Message, NoteSeverity Severity, Player? CreatedBy, DateTime CreatedAt,
- Player? LastEditedBy, DateTime? LastEditedAt, DateTime? ExpirationTime, bool Deleted, string[] Roles,
- Player? UnbanningAdmin, DateTime? UnbanTime) : IAdminRemarksCommon;
-}
using Content.Shared.Database;
+using Robust.Shared.Network;
using Robust.Shared.Serialization;
namespace Content.Shared.Administration.Notes;
[Serializable, NetSerializable]
public sealed record SharedAdminNote(
int Id, // Id of note, message, watchlist, ban or role ban. Should be paired with NoteType to uniquely identify a shared admin note.
- Guid Player, // Notes player
+ NetUserId Player, // Notes player
int? Round, // Which round was it added in?
string? ServerName, // Which server was this added on?
TimeSpan PlaytimeAtNote, // Playtime at the time of getting the note
/// Default severity for server bans
/// </summary>
public static readonly CVarDef<string> ServerBanDefaultSeverity =
- CVarDef.Create("admin.server_ban_default_severity", "high", CVar.ARCHIVE | CVar.SERVER);
+ CVarDef.Create("admin.server_ban_default_severity", "High", CVar.ARCHIVE | CVar.SERVER);
/// <summary>
/// Minimum explosion intensity to create an admin alert message. -1 to disable the alert.
projects / space-station-14.git / commitdiff