OnServerUserSet

using System.Linq;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("ServerUserAudit", "RustPluginGenerator", "1.0.0")]
    [Description("Records every server user entry (ban, whitelist, owner) written to the users file.")]
    public class ServerUserAudit : RustPlugin
    {
        private const string PermShow = "serveruseraudit.show";

        private PluginConfig config;
        private AuditData data;
        private Timer flushTimer;

        private class PluginConfig
        {
            [JsonProperty("Maximum stored entries")]
            public int MaxEntries = 500;
        }

        private class AuditEntry
        {
            [JsonProperty("Time (UTC)")]
            public string Time;

            [JsonProperty("Steam ID")]
            public string Uid;

            [JsonProperty("Group")]
            public string Group;

            [JsonProperty("Username")]
            public string Username;

            [JsonProperty("Notes")]
            public string Notes;

            [JsonProperty("Expiry")]
            public string Expiry;
        }

        private class AuditData
        {
            [JsonProperty("Entries")]
            public List<AuditEntry> Entries = new List<AuditEntry>();
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Empty"] = "No server user entries have been recorded yet.",
                ["Header"] = "{0} recent server user entries:",
                ["Line"] = "{0} | {1} | {2} | expires {3} | {4}"
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) => string.Format(lang.GetMessage(key, this, userId), args);

        private void Init()
        {
            permission.RegisterPermission(PermShow, this);
            data = Interface.Oxide.DataFileSystem.ReadObject<AuditData>(Name) ?? new AuditData();
        }

        private void Unload()
        {
            SaveData();
            flushTimer?.Destroy();
        }

        private void OnServerUserSet(ulong uid, ServerUsers.UserGroup group, string username, string notes, long expiry)
        {
            string expiryText = expiry == 0 ? "never" : DateTimeOffset.FromUnixTimeSeconds(expiry).UtcDateTime.ToString("yyyy-MM-dd HH:mm");

            data.Entries.Add(new AuditEntry
            {
                Time = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"),
                Uid = uid.ToString(),
                Group = group.ToString(),
                Username = string.IsNullOrEmpty(username) ? "-" : username,
                Notes = string.IsNullOrEmpty(notes) ? "-" : notes,
                Expiry = expiryText
            });

            while (data.Entries.Count > config.MaxEntries)
                data.Entries.RemoveAt(0);

            flushTimer?.Destroy();
            flushTimer = timer.Once(1f, SaveData);
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }

        [ChatCommand("useraudit")]
        private void CmdUserAudit(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermShow))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            SendLog(player, player.UserIDString);
        }

        [ConsoleCommand("useraudit.print")]
        private void CcmdUserAuditPrint(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermShow))
            {
                arg.ReplyWith(Msg("NoPermission", player.UserIDString));
                return;
            }

            SendLog(player, player?.UserIDString);
        }

        private void SendLog(BasePlayer player, string userId)
        {
            if (data.Entries.Count == 0)
            {
                Reply(player, Msg("Empty", userId));
                return;
            }

            Reply(player, Msg("Header", userId, data.Entries.Count));
            int start = Math.Max(0, data.Entries.Count - 10);
            for (int i = start; i < data.Entries.Count; i++)
            {
                var e = data.Entries[i];
                Reply(player, Msg("Line", userId, e.Time, e.Uid, e.Group, e.Expiry, e.Notes));
            }
        }

        private void Reply(BasePlayer player, string message)
        {
            if (player != null) player.ChatMessage(message);
            else Puts(message);
        }
    }
}