CanAcceptItem

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

namespace Oxide.Plugins
{
    [Info("Container Item Filter", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks configured items from being placed into containers marked as restricted")]
    public class ContainerItemFilter : RustPlugin
    {
        private const string PermUse = "containeritemfilter.use";
        private const string DataFile = "ContainerItemFilter/marked";
        private const string BlockedResult = "false";

        private PluginConfig config;
        private HashSet<ulong> marked = new HashSet<ulong>();
        private HashSet<int> blockedItemIds = new HashSet<int>();

        private class PluginConfig
        {
            [JsonProperty("Blocked shortnames")]
            public List<string> BlockedShortnames = new List<string> { "explosive.satchel", "explosive.timed", "rocket.launcher" };
        }

        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 Init()
        {
            permission.RegisterPermission(PermUse, this);
            marked = Interface.Oxide.DataFileSystem.ReadObject<HashSet<ulong>>(DataFile) ?? new HashSet<ulong>();

            blockedItemIds.Clear();
            foreach (var shortname in config.BlockedShortnames)
            {
                var def = ItemManager.FindItemDefinition(shortname);
                if (def != null) blockedItemIds.Add(def.itemid);
            }
        }

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

        [ConsoleCommand("containerfilter.mark")]
        private void CmdMark(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player == null) { arg.ReplyWith("Run this in game."); return; }
            if (!player.IsAdmin && !permission.UserHasPermission(player.UserIDString, PermUse))
            {
                arg.ReplyWith("No permission.");
                return;
            }
            var entity = GetLookingEntity(player);
            if (entity == null) { arg.ReplyWith("Look at a container."); return; }
            if (!marked.Add(entity.net.ID.Value))
            {
                marked.Remove(entity.net.ID.Value);
                arg.ReplyWith("Container unmarked.");
            }
            else arg.ReplyWith("Container marked.");
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, marked);
        }

        private BaseEntity GetLookingEntity(BasePlayer player)
        {
            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.HeadRay(), out hit, 4f)) return null;
            return hit.GetEntity();
        }

        private object CanAcceptItem(ItemContainer itemContainer, Item item, int targetPos, BasePlayer player)
        {
            if (itemContainer == null || item == null || item.info == null) return null;
            var owner = itemContainer.entityOwner;
            if (owner == null || !marked.Contains(owner.net.ID.Value)) return null;
            if (!blockedItemIds.Contains(item.info.itemid)) return null;
            return ItemContainer.CanAcceptResult.CannotAccept;
        }
    }
}