How to make a Rust crate loot lock plugin (first opener claims it)

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

namespace Oxide.Plugins
{
    [Info("CrateLootLock", "RustPluginGenerator", "1.0.0")]
    [Description("Locks a loot container to its first opener for a configurable period.")]
    public class CrateLootLock : RustPlugin
    {
        private const string PermUse = "cratelootlock.use";
        private const string PermAdmin = "cratelootlock.admin";

        private PluginConfig config;
        private readonly Dictionary<ulong, Claim> claims = new Dictionary<ulong, Claim>();

        private class Claim
        {
            public ulong OwnerId;
            public ulong TeamId;
            public int Expiry;
        }

        private class PluginConfig
        {
            [JsonProperty("Lock Seconds")]
            public int LockSeconds = 60;

            [JsonProperty("Lock Corpses")]
            public bool LockCorpses = true;

            [JsonProperty("Lock Crates")]
            public bool LockCrates = true;

            [JsonProperty("Lock Dropped Containers")]
            public bool LockDroppedContainers = true;

            [JsonProperty("Lock Resource Containers")]
            public bool LockResourceContainers = true;

            [JsonProperty("Use Team Check")]
            public bool UseTeamCheck = true;
        }

        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>
            {
                ["Locked"] = "This container is locked to its first opener. {0}s remaining.",
                ["LockedOther"] = "This container is locked to another player.",
                ["NotAllowed"] = "You are not permitted to claim loot containers."
            }, this);
        }

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

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

        private object HandleAttempt(BasePlayer player, BaseNetworkable entity)
        {
            if (player == null || entity == null || entity.net == null) return null;
            if (player.IsNpc) return null;
            if (!permission.UserHasPermission(player.UserIDString, PermUse)) return null;

            ulong id = entity.net.ID.Value;
            int now = Facepunch.Math.Epoch.Current;

            Claim claim;
            if (claims.TryGetValue(id, out claim))
            {
                if (claim.Expiry <= now)
                {
                    claims.Remove(id);
                }
                else
                {
                    if (claim.OwnerId == player.userID) return null;
                    if (config.UseTeamCheck && claim.TeamId != 0 && player.currentTeam == claim.TeamId) return null;

                    int remaining = Mathf.Max(1, claim.Expiry - now);
                    player.ChatMessage(Msg("Locked", player.UserIDString, remaining));
                    return false;
                }
            }

            claims[id] = new Claim
            {
                OwnerId = player.userID,
                TeamId = config.UseTeamCheck ? player.currentTeam : 0,
                Expiry = now + Math.Max(1, config.LockSeconds)
            };
            return null;
        }

        private object CanLootEntity(BasePlayer player, StorageContainer storageContainer)
        {
            if (!config.LockCrates) return null;
            return HandleAttempt(player, storageContainer);
        }

        private object CanLootEntity(BasePlayer player, LootableCorpse lootableCorpse)
        {
            if (!config.LockCorpses) return null;
            return HandleAttempt(player, lootableCorpse);
        }

        private object CanLootEntity(BasePlayer player, DroppedItemContainer droppedItemContainer)
        {
            if (!config.LockDroppedContainers) return null;
            return HandleAttempt(player, droppedItemContainer);
        }

        private object CanLootEntity(BasePlayer player, ResourceContainer resourceContainer)
        {
            if (!config.LockResourceContainers) return null;
            if (resourceContainer == null) return null;
            return HandleAttempt(player, resourceContainer.GetComponent<BaseNetworkable>());
        }

        private void OnEntityKill(BaseNetworkable entity)
        {
            if (entity == null || entity.net == null) return;
            claims.Remove(entity.net.ID.Value);
        }

        [ConsoleCommand("cratelootlock.status")]
        private void CmdStatus(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin)) return;
            if (player == null && !arg.IsAdmin) return;

            arg.ReplyWith($"Active claims: {claims.Count}. Lock duration: {config.LockSeconds}s.");
        }

        private void Unload()
        {
            claims.Clear();
        }
    }
}