How to make a Rust team auto authorization plugin (TC, locks, turrets)

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

namespace Oxide.Plugins
{
    [Info("Team Auto Auth", "RustPluginGenerator", "1.0.0")]
    [Description("Authorizes teammates on tool cupboards, code locks and auto turrets when they join a team, and removes them on leave.")]
    public class TeamAutoAuth : RustPlugin
    {
        private const string PermUse = "teamautoauth.use";
        private const string PermAdmin = "teamautoauth.admin";

        private class PluginConfig
        {
            [JsonProperty("Enabled by default")]
            public bool Enabled { get; set; } = true;

            [JsonProperty("Authorize tool cupboards")]
            public bool AuthCupboards { get; set; } = true;

            [JsonProperty("Authorize code locks")]
            public bool AuthLocks { get; set; } = true;

            [JsonProperty("Authorize auto turrets")]
            public bool AuthTurrets { get; set; } = true;
        }

        private class StoredData
        {
            [JsonProperty("Player opt-outs")]
            public HashSet<ulong> OptOut { get; set; } = new HashSet<ulong>();
        }

        private PluginConfig config;
        private StoredData data;
        private readonly HashSet<ulong> syncedTeams = new HashSet<ulong>();

        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);

        private void LoadData()
        {
            try
            {
                data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name);
            }
            catch
            {
                data = null;
            }
            if (data == null) data = new StoredData();
        }

        private void SaveData() => Interface.Oxide.DataFileSystem.WriteObject(Name, data);

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
            permission.RegisterPermission(PermAdmin, this);
            LoadData();
        }

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["OptedOut"] = "Team auto authorization is now off for you.",
                ["OptedIn"] = "Team auto authorization is now on for you.",
                ["StatusOn"] = "Team auto authorization is currently on.",
                ["StatusOff"] = "Team auto authorization is currently off.",
                ["Usage"] = "Usage: /teamauth <on|off|status> or teamauth.sync <on|off>",
                ["Synced"] = "Rescanned {0} team(s) and applied authorization to online members.",
                ["SyncDefault"] = "Server default is now {0}."
            }, this);
        }

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

        private bool IsOptedOut(BasePlayer player) =>
            data != null && data.OptOut.Contains(player.userID.Get());

        private bool WantsAutoAuth(BasePlayer player) => config.Enabled ? !IsOptedOut(player) : IsOptedOut(player);

        private object OnTeamAcceptInvite(RelationshipManager.PlayerTeam playerTeam, BasePlayer player)
        {
            if (player == null || playerTeam == null) return null;
            if (!WantsAutoAuth(player)) return null;

            AuthorizePlayer(player, playerTeam);
            syncedTeams.Add(playerTeam.teamID);
            return null;
        }

        private object OnTeamLeave(RelationshipManager.PlayerTeam playerTeam, BasePlayer player)
        {
            if (player == null || playerTeam == null) return null;
            DeauthorizePlayer(player, playerTeam);
            return null;
        }

        private object OnTeamKick(RelationshipManager.PlayerTeam playerTeam, BasePlayer player, ulong uLong)
        {
            if (player == null || playerTeam == null) return null;
            DeauthorizePlayer(player, playerTeam);
            return null;
        }

        private void OnTeamDisbanded(RelationshipManager.PlayerTeam playerTeam)
        {
            if (playerTeam == null) return;
            foreach (ulong id in new List<ulong>(playerTeam.members))
            {
                BasePlayer member = BasePlayer.FindByID(id);
                if (member != null) DeauthorizePlayer(member, playerTeam);
            }
            syncedTeams.Remove(playerTeam.teamID);
        }

        private void AuthorizePlayer(BasePlayer player, RelationshipManager.PlayerTeam team)
        {
            ApplyToEntities(player, team, true);
        }

        private void DeauthorizePlayer(BasePlayer player, RelationshipManager.PlayerTeam team)
        {
            ApplyToEntities(player, team, false);
        }

        private void ApplyToEntities(BasePlayer player, RelationshipManager.PlayerTeam team, bool grant)
        {
            if (player == null || team == null || team.members == null || team.members.Count == 0) return;
            HashSet<ulong> memberIds = new HashSet<ulong>(team.members);

            foreach (BaseNetworkable networkable in BaseNetworkable.serverEntities)
            {
                BaseEntity entity = networkable as BaseEntity;
                if (entity == null || entity.IsDestroyed) continue;
                if (!memberIds.Contains(entity.OwnerID)) continue;

                if (config.AuthCupboards && entity is BuildingPrivlidge privlidge)
                {
                    if (!grant && privlidge.OwnerID == player.userID.Get()) continue;
                    if (!grant) privlidge.authorizedPlayers.Remove(player.userID);
                    else if (!privlidge.IsAuthed(player)) privlidge.authorizedPlayers.Add(player.userID);
                    privlidge.SendNetworkUpdate();
                }
                else if (config.AuthLocks && entity is CodeLock codeLock)
                {
                    if (!grant && codeLock.OwnerID == player.userID.Get()) continue;
                    if (!grant) codeLock.whitelistPlayers.Remove(player.userID);
                    else if (!codeLock.whitelistPlayers.Contains(player.userID)) codeLock.whitelistPlayers.Add(player.userID);
                    codeLock.SendNetworkUpdate();
                }
                else if (config.AuthTurrets && entity is AutoTurret turret)
                {
                    if (!grant && turret.OwnerID == player.userID.Get()) continue;
                    if (!grant) turret.authorizedPlayers.Remove(player.userID);
                    else if (!turret.authorizedPlayers.Contains(player.userID)) turret.authorizedPlayers.Add(player.userID);
                    turret.SendNetworkUpdate();
                }
            }
        }

        [ChatCommand("teamauth")]
        private void CmdTeamAuth(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            string arg = args != null && args.Length > 0 ? args[0].ToLower() : "status";
            if (arg == "on")
            {
                data.OptOut.Remove(player.userID.Get());
                SaveData();
                SendReply(player, Msg("OptedIn", player.UserIDString));
            }
            else if (arg == "off")
            {
                data.OptOut.Add(player.userID.Get());
                SaveData();
                SendReply(player, Msg("OptedOut", player.UserIDString));
            }
            else if (arg == "status")
            {
                SendReply(player, Msg(WantsAutoAuth(player) ? "StatusOn" : "StatusOff", player.UserIDString));
            }
            else
            {
                SendReply(player, Msg("Usage", player.UserIDString));
            }
        }

        [ConsoleCommand("teamauth.sync")]
        private void CcmdSync(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            BasePlayer caller = arg.Player();
            if (caller != null && !permission.UserHasPermission(caller.UserIDString, PermAdmin) && !caller.IsAdmin)
            {
                arg.ReplyWith(Msg("NoPermission", caller.UserIDString));
                return;
            }

            string value = arg.GetString(0, "toggle");
            if (value == "on" || value == "off")
            {
                config.Enabled = value == "on";
                SaveConfig();
                string status = config.Enabled ? "on" : "off";
                if (caller != null) SendReply(caller, Msg("SyncDefault", caller.UserIDString, status));
                else Puts(string.Format("Server default is now {0}.", status));
            }

            ApplyToOnlineMembers();
        }

        private void ApplyToOnlineMembers()
        {
            int teams = 0;
            foreach (BasePlayer player in BasePlayer.activePlayerList)
            {
                if (player == null || player.currentTeam == 0) continue;
                RelationshipManager.PlayerTeam team = RelationshipManager.ServerInstance.FindTeam(player.currentTeam);
                if (team == null) continue;
                teams++;
                if (WantsAutoAuth(player)) AuthorizePlayer(player, team);
                else DeauthorizePlayer(player, team);
            }
            Puts(Msg("Synced", null, teams));
        }

        private void Unload()
        {
            SaveData();
        }
    }
}