How to make a Rust team-only sleeping bag plugin (CanAssignBed)

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

namespace Oxide.Plugins
{
    [Info("TeamOnlyBags", "RustPluginGenerator", "1.0.0")]
    [Description("Only allows sleeping bags and beds to be assigned to members of the assigning player's team.")]
    public class TeamOnlyBags : RustPlugin
    {
        private const string PermUse = "teamonlybags.use";
        private const string PermAdmin = "teamonlybags.admin";

        private PluginConfig config;
        private StoredData data;
        private Timer revokeTimer;

        private class PluginConfig
        {
            [JsonProperty("Allow self assignment")]
            public bool AllowSelfAssignment { get; set; } = true;

            [JsonProperty("Require same team")]
            public bool RequireSameTeam { get; set; } = true;

            [JsonProperty("Revoke on team change")]
            public bool RevokeOnTeamChange { get; set; } = true;

            [JsonProperty("Revoke check interval (seconds)")]
            public float RevokeInterval { get; set; } = 60f;
        }

        private class BagEntry
        {
            [JsonProperty("Owner id")]
            public ulong OwnerId { get; set; }

            [JsonProperty("Assigned id")]
            public ulong AssignedId { get; set; }
        }

        private class StoredData
        {
            [JsonProperty("Assignments")]
            public Dictionary<ulong, BagEntry> Assignments { get; set; } = new Dictionary<ulong, BagEntry>();
        }

        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>
            {
                ["Status"] = "Team-only bags: self={0}, sameTeam={1}, revoke={2}, interval={3}s",
                ["CheckOwned"] = "{0} owns {1} stored assignment(s).",
                ["CheckNone"] = "{0} has no stored assignments.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Revoked"] = "Revoked {0} assignment(s) that no longer match a team.",
                ["ConsoleOnly"] = "This command must be run from the server console or RCON."
            }, 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(PermUse, this);
            permission.RegisterPermission(PermAdmin, this);
        }

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name);
            if (data == null) data = new StoredData();
            if (data.Assignments == null) data.Assignments = new Dictionary<ulong, BagEntry>();

            revokeTimer = timer.Every(Mathf.Max(10f, config.RevokeInterval), RevokeStale);
        }

        private void Unload()
        {
            revokeTimer?.Destroy();
            revokeTimer = null;
            SaveData();
        }

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

        private object CanAssignBed(BasePlayer player, SleepingBag sleepingBag, ulong num)
        {
            if (player == null || sleepingBag == null || sleepingBag.net == null) return null;

            if (config.AllowSelfAssignment && num == player.userID.Get()) return null;

            if (!config.RequireSameTeam) return null;

            BasePlayer target = BasePlayer.FindAwakeOrSleeping(num.ToString());
            ulong targetTeam = target != null ? target.currentTeam : 0UL;
            ulong ownTeam = player.currentTeam;

            if (ownTeam == 0 || targetTeam == 0 || ownTeam != targetTeam)
                return false;

            data.Assignments[sleepingBag.net.ID.Value] = new BagEntry
            {
                OwnerId = player.userID.Get(),
                AssignedId = num
            };
            return null;
        }

        private void RevokeStale()
        {
            if (data == null || data.Assignments == null || !config.RevokeOnTeamChange || data.Assignments.Count == 0)
                return;

            int revoked = 0;
            List<ulong> remove = new List<ulong>();

            foreach (KeyValuePair<ulong, BagEntry> pair in data.Assignments)
            {
                SleepingBag bag = FindBag(pair.Key);
                if (bag == null)
                {
                    remove.Add(pair.Key);
                    continue;
                }

                BasePlayer owner = BasePlayer.FindAwakeOrSleeping(pair.Value.OwnerId.ToString());
                BasePlayer assigned = BasePlayer.FindAwakeOrSleeping(pair.Value.AssignedId.ToString());

                bool sameTeam = owner != null && assigned != null && owner.currentTeam != 0 && owner.currentTeam == assigned.currentTeam;
                if (sameTeam || pair.Value.OwnerId == pair.Value.AssignedId) continue;

                remove.Add(pair.Key);
                revoked++;
            }

            for (int i = 0; i < remove.Count; i++) data.Assignments.Remove(remove[i]);
            if (revoked > 0) SaveData();
        }

        private SleepingBag FindBag(ulong netId)
        {
            foreach (BaseNetworkable entity in BaseNetworkable.serverEntities)
            {
                if (entity == null || entity.net == null || entity.net.ID.Value != netId) continue;
                return entity as SleepingBag;
            }
            return null;
        }

        [ChatCommand("teambags")]
        private void CmdTeamBags(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;

            if (args == null || args.Length == 0 || args[0].ToLower() == "status")
            {
                if (!permission.UserHasPermission(player.UserIDString, PermUse))
                {
                    SendReply(player, Msg("NoPermission", player.UserIDString));
                    return;
                }
                SendReply(player, Msg("Status", player.UserIDString, config.AllowSelfAssignment, config.RequireSameTeam, config.RevokeOnTeamChange, config.RevokeInterval));
                return;
            }

            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (args[0].ToLower() == "check" && args.Length >= 2)
            {
                int count = 0;
                if (data != null && data.Assignments != null)
                {
                    foreach (BagEntry entry in data.Assignments.Values)
                        if (entry.OwnerId.ToString() == args[1] || entry.AssignedId.ToString() == args[1]) count++;
                }
                SendReply(player, count == 0 ? Msg("CheckNone", player.UserIDString, args[1]) : Msg("CheckOwned", player.UserIDString, args[1], count));
            }
        }

        [ConsoleCommand("teambags.revokeall")]
        private void CcmdRevokeAll(ConsoleSystem.Arg arg)
        {
            BasePlayer player = arg?.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            int before = data?.Assignments?.Count ?? 0;
            RevokeStale();
            int after = data?.Assignments?.Count ?? 0;
            arg?.ReplyWith(string.Format(lang.GetMessage("Revoked", this, player?.UserIDString), before - after));
        }
    }
}