SocialPub/PrivaPub/Domain/Moderation/ModerationLog.cs

using MongoDB.Entities;

using PrivaPub.Models;
using PrivaPub.Models.User;

namespace PrivaPub.Domain.Moderation
{
	public interface IModerationLog
	{
		/// <summary>Keeps one act of the staff (Models/AdminAction.cs). Never throws: an act that was done stays done when
		/// its entry can't be written, and the failure is logged.</summary>
		Task Write(string byRootId, string action, string targetKind, string targetId, string targetLabel, string reportId = default, string note = default,
			CancellationToken token = default);
	}

	// The staff's log (completion program R5): administrators read all of it, moderators what isn't about a login
	// (ModeratorController's /clientapi/moderator/log). An entry never holds an IP address, and never pairs a root with its
	// own personas: an act on a persona that the acting root owns, on a post of it, a group it owns or a report about it
	// (R6), is kept without who acted.
	public class ModerationLog : IModerationLog
	{
		const int MaxLabel = 200;
		const int MaxNote = 1000;

		readonly ILogger<ModerationLog> _logger;

		public ModerationLog(ILogger<ModerationLog> logger)
		{
			_logger = logger;
		}

		public async Task Write(string byRootId, string action, string targetKind, string targetId, string targetLabel, string reportId = default,
			string note = default, CancellationToken token = default)
		{
			try
			{
				if (byRootId != default && byRootId != AdminAction.Cli && await OwnPersona(byRootId, targetKind, targetId, reportId, token))
					byRootId = default;
				await DB.Default.SaveAsync(new AdminAction
				{
					ByRootId = byRootId,
					Action = action,
					TargetKind = targetKind,
					TargetId = targetId,
					TargetLabel = Cut(targetLabel, MaxLabel),
					ReportId = reportId,
					Note = Cut(note, MaxNote)
				}, CancellationToken.None);//an act that was done is logged even when its request went away
			}
			catch (Exception ex)
			{
				_logger.LogWarning(ex, "The staff's log could not keep a {Action}", action);
			}
		}

		// whether what an entry is about is a persona of the acting login: the persona itself, a post of it, a group it owns,
		// or a report about it (R6) — any of them would pair the login with that persona
		static async Task<bool> OwnPersona(string rootId, string targetKind, string targetId, string reportId, CancellationToken token)
		{
			var personas = new List<string>();
			if (targetId != default)
				switch (targetKind)
				{
					case AdminTargets.Persona:
						personas.Add(targetId);
						break;
					case AdminTargets.Post when MongoDB.Bson.ObjectId.TryParse(targetId, out _):
						if (await DB.Default.Find<Models.Post.Post>().MatchID(targetId).Match(p => !p.IsFederatedCopy)
							.Project(p => p.Include(x => x.GroupUserId)).ExecuteFirstAsync(token) is { GroupUserId: { } author })
							personas.Add(author);
						break;
					case AdminTargets.Group when MongoDB.Bson.ObjectId.TryParse(targetId, out _):
						if (await DB.Default.Find<Models.Group.Group>().MatchID(targetId).Project(g => g.Include(x => x.OwnerAvatarId))
							.ExecuteFirstAsync(token) is { OwnerAvatarId: { } owner })
							personas.Add(owner);
						break;
				}
			var report = reportId ?? (targetKind == AdminTargets.Report ? targetId : default);
			if (report != default && MongoDB.Bson.ObjectId.TryParse(report, out _)
				&& await DB.Default.Find<Models.Social.Report>().MatchID(report).Project(r => r.Include(x => x.TargetAccountId)).ExecuteFirstAsync(token)
					is { TargetAccountId: { } reported })
				personas.Add(reported);
			return personas.Count > 0
				&& await DB.Default.Find<RootToAvatar>().Match(r => r.RootId == rootId && personas.Contains(r.AvatarId)).ExecuteAnyAsync(token);
		}

		static string Cut(string text, int max) =>
			string.IsNullOrEmpty(text) ? text : text.Length <= max ? text : text[..(max - 1)] + "…";
	}
}