How to make a Rust auto code lock plugin (personal codes)

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

namespace Oxide.Plugins
{
    [Info("AutoCodeLock", "RustPluginGenerator", "1.0.0")]
    [Description("Attaches a code lock with the player's saved personal code to doors and boxes they place.")]
    public class AutoCodeLock : RustPlugin
    {
        private const string PermUse = "autocodelock.use";
        private const string DataFile = "AutoCodeLock";
        private const string CodeLockPrefab = "assets/prefabs/locks/keypad/lock.code.prefab";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Require permission")]
            public bool RequirePermission = true;

            [JsonProperty("Lock containers")]
            public bool LockContainers = true;

            [JsonProperty("Consume code lock from inventory")]
            public bool ConsumeCodeLock = true;
        }

        private class StoredData
        {
            [JsonProperty("Codes")]
            public Dictionary<string, string> Codes = new Dictionary<string, string>();
        }

        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>
            {
                ["Usage"] = "Usage: /autolock code <pin> or /autolock clear",
                ["CodeSet"] = "Your personal code is set to {0}. Doors and boxes you place will lock automatically.",
                ["CodeCleared"] = "Your personal code has been removed.",
                ["NoCode"] = "You do not have a personal code set. Use /autolock code <pin>.",
                ["HaveCode"] = "You have a personal code set ({0}). Use /autolock clear to remove it.",
                ["InvalidPin"] = "The code must be exactly 4 digits.",
                ["Locked"] = "Your personal code lock has been attached.",
                ["NoLock"] = "No code lock found in your inventory, the door was left unlocked."
            }, 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);
        }

        private void OnServerInitialized()
        {
            try
            {
                data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(DataFile);
            }
            catch
            {
                data = null;
            }
            if (data == null) data = new StoredData();
            if (data.Codes == null) data.Codes = new Dictionary<string, string>();
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, data);
        }

        private bool CanUse(BasePlayer player)
        {
            if (player == null || player.IsNpc) return false;
            if (config.RequirePermission && !permission.UserHasPermission(player.UserIDString, PermUse)) return false;
            return true;
        }

        [ChatCommand("autolock")]
        private void CmdAutoLock(BasePlayer player, string command, string[] args)
        {
            if (player == null || player.IsNpc) return;
            if (config.RequirePermission && !permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoCode", player.UserIDString));
                return;
            }

            if (args == null || args.Length == 0)
            {
                string existing;
                if (data.Codes.TryGetValue(player.UserIDString, out existing))
                    SendReply(player, Msg("HaveCode", player.UserIDString, existing));
                else
                    SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            string action = args[0].ToLower();
            if (action == "code")
            {
                if (args.Length < 2 || args[1].Length != 4 || !int.TryParse(args[1], out int _))
                {
                    SendReply(player, Msg("InvalidPin", player.UserIDString));
                    return;
                }
                data.Codes[player.UserIDString] = args[1];
                SendReply(player, Msg("CodeSet", player.UserIDString, args[1]));
                return;
            }

            if (action == "clear")
            {
                data.Codes.Remove(player.UserIDString);
                SendReply(player, Msg("CodeCleared", player.UserIDString));
                return;
            }

            SendReply(player, Msg("Usage", player.UserIDString));
        }

        private void OnEntityBuilt(Planner planner, UnityEngine.GameObject gameObject)
        {
            if (gameObject == null) return;
            BaseEntity entity = gameObject.ToBaseEntity();
            if (entity == null) return;

            bool isDoor = entity is Door;
            bool isContainer = config.LockContainers && entity is StorageContainer;
            if (!isDoor && !isContainer) return;

            if (planner == null) return;
            BasePlayer player = planner.GetOwnerPlayer();
            if (!CanUse(player)) return;

            string pin;
            if (!data.Codes.TryGetValue(player.UserIDString, out pin) || string.IsNullOrEmpty(pin)) return;

            Item lockItem = FindCodeLock(player);
            if (lockItem == null && config.ConsumeCodeLock)
            {
                SendReply(player, Msg("NoLock", player.UserIDString));
                return;
            }

            CodeLock codeLock = GameManager.server.CreateEntity(CodeLockPrefab, entity.transform.position, entity.transform.rotation) as CodeLock;
            if (codeLock == null) return;

            codeLock.OwnerID = player.userID.Get();
            codeLock.code = pin;
            codeLock.Spawn();
            codeLock.SetParent(entity, true, true);
            codeLock.whitelistPlayers.Add(player.userID.Get());
            codeLock.SendNetworkUpdate();

            if (config.ConsumeCodeLock && lockItem != null)
            {
                ItemContainer parent = lockItem.parent;
                lockItem.Remove();
                if (parent != null) parent.MarkDirty();
            }

            SendReply(player, Msg("Locked", player.UserIDString));
        }

        private Item FindCodeLock(BasePlayer player)
        {
            return FindIn(player.inventory.containerMain) ?? FindIn(player.inventory.containerBelt) ?? FindIn(player.inventory.containerWear);
        }

        private Item FindIn(ItemContainer container)
        {
            if (container == null) return null;
            foreach (Item item in container.itemList)
            {
                if (item?.info != null && item.info.shortname == "lock.code") return item;
            }
            return null;
        }
    }
}