func setExistsInArray(key []string, value interface{}, log logr.Logger, notIn bool) (invalidType bool, keyExists bool) {
	switch valuesAvailable := value.(type) {
	case []interface{}:
		var valueSlice []string
		for _, val := range valuesAvailable {
			v, ok := val.(string)
			if !ok {
				return true, false
			}
			valueSlice = append(valueSlice, v)
		}
		if notIn {
			return false, isNotIn(key, valueSlice)
		}
		return false, isIn(key, valueSlice)
	case string:
		if len(key) == 1 && key[0] == valuesAvailable {
			return false, true
		}
		var arr []string
		if err := json.Unmarshal([]byte(valuesAvailable), &arr); err != nil {
			log.Error(err, "failed to unmarshal value to JSON string array", "key", key, "value", value)
			return true, false
		}
		if notIn {
			return false, isNotIn(key, arr)
		}
		return false, isIn(key, arr)
	default:
		return true, false
	}
}
setExistsInArray checks if the key is a subset of value
The value can be a string, an array of strings, or a JSON format
array of strings (e.g. ["val1", "val2", "val3"].
notIn argument if set to true will check for NotIn
package operator
import (
	"encoding/json"
	"fmt"
	"github.com/minio/pkg/wildcard"
	"github.com/go-logr/logr"
	"github.com/kyverno/kyverno/pkg/engine/context"
)
func NewInHandler(log logr.Logger, ctx context.EvalInterface) OperatorHandler {
	return InHandler{
		ctx: ctx,
		log: log,
	}
}
type InHandler struct {
	ctx context.EvalInterface
	log logr.Logger
}
func (in InHandler) Evaluate(key, value interface{}) bool {
	switch typedKey := key.(type) {
	case string:
		return in.validateValueWithStringPattern(typedKey, value)
	case []interface{}:
		var stringSlice []string
		for _, v := range typedKey {
			stringSlice = append(stringSlice, v.(string))
		}
		return in.validateValueWithStringSetPattern(stringSlice, value)
	default:
		in.log.Info("Unsupported type", "value", typedKey, "type", fmt.Sprintf("%T", typedKey))
		return false
	}
}
func (in InHandler) validateValueWithStringPattern(key string, value interface{}) (keyExists bool) {
	invalidType, keyExists := keyExistsInArray(key, value, in.log)
	if invalidType {
		in.log.Info("expected type []string", "value", value, "type", fmt.Sprintf("%T", value))
		return false
	}
	return keyExists
}
func keyExistsInArray(key string, value interface{}, log logr.Logger) (invalidType bool, keyExists bool) {
	switch valuesAvailable := value.(type) {
	case []interface{}:
		for _, val := range valuesAvailable {
			v, ok := val.(string)
			if !ok {
				return true, false
			}
			if ok && wildcard.Match(key, v) {
				return false, true
			}
		}
	case string:
		if wildcard.Match(valuesAvailable, key) {
			return false, true
		}
		var arr []string
		if err := json.Unmarshal([]byte(valuesAvailable), &arr); err != nil {
			log.Error(err, "failed to unmarshal value to JSON string array", "key", key, "value", value)
			return true, false
		}
		for _, val := range arr {
			if key == val {
				return false, true
			}
		}
	default:
		invalidType = true
		return
	}
	return false, false
}
func (in InHandler) validateValueWithStringSetPattern(key []string, value interface{}) (keyExists bool) {
	invalidType, isIn := setExistsInArray(key, value, in.log, false)
	if invalidType {
		in.log.Info("expected type []string", "value", value, "type", fmt.Sprintf("%T", value))
		return false
	}
	return isIn
}