<?php
|
namespace JVBase\utility;
|
|
if (!defined('ABSPATH')) {
|
exit;
|
}
|
/**
|
* FeatureFlags - Advanced feature detection and management
|
*
|
* Replaces repetitive jvbCheck() calls with a more elegant API
|
* Supports caching, bulk checks, and feature dependencies
|
*/
|
class Features
|
{
|
private array $config;
|
private string $type;
|
private string $slug;
|
private array $cache = [];
|
private static array $globalCache = [];
|
|
// Common feature groups for quick reference
|
const CONTENT_FEATURES = [
|
'hide_single', 'show_feed', 'show_directory', 'karma',
|
'favouritable', 'responses', 'is_calendar', 'single_image',
|
'redirectToAuthor', 'syncWithSquare', 'approve_new'
|
];
|
|
const TAXONOMY_FEATURES = [
|
'show_feed', 'show_directory', 'is_content', 'is_ownable',
|
'karma', 'verify_entry', 'approve_new', 'track_changes',
|
'invitable', 'associate_user_content', 'is_favouritable'
|
];
|
|
const USER_FEATURES = [
|
'has_dashboard', 'can_register', 'invitable', 'approve_new',
|
'keep_stats', 'can_favourite', 'member_verified'
|
];
|
|
const SITE_FEATURES = [
|
'dashboard', 'favourites', 'enthusiast', 'forum', 'notifications',
|
'has_support', 'has_membership', 'use_feed_block', 'square',
|
'gmb', 'umami', 'cloudflare', 'facebook', 'instagram', 'bluesky',
|
'social', 'limit_hours'
|
];
|
|
/**
|
* Constructor for type-specific feature flags
|
*/
|
public function __construct(array $config = [], string $type = '', string $slug = '')
|
{
|
$this->config = $config;
|
$this->type = $type;
|
$this->slug = $slug;
|
}
|
|
/**
|
* Create from a specific content type
|
*/
|
public static function forContent(string $slug): self
|
{
|
$slug = jvbNoBase($slug);
|
if (!isset(JVB_CONTENT[$slug])) {
|
return new self([], 'content', $slug);
|
}
|
return new self(JVB_CONTENT[$slug], 'content', $slug);
|
}
|
|
public static function hasIntegration(string $integration, string $type = 'site', ?string $subType = null):bool
|
{
|
$allowedTypes = ['site', 'content', 'taxonomy', 'user'];
|
if (!in_array($type, $allowedTypes)) {
|
return false;
|
}
|
if (in_array($type, ['content', 'taxonomy', 'user']) && !$subType) {
|
return false;
|
}
|
switch ($type) {
|
case 'site':
|
$feature = (array_key_exists('integrations', JVB_SITE)) ? new self(JVB_SITE['integrations'], 'integrations', 'site-integrations') : new self([], 'integrations', 'site-integrations');
|
break;
|
case 'content':
|
$feature = (!isset(JVB_CONTENT[$subType])|| !array_key_exists('integrations', JVB_CONTENT[$subType])) ? new self([], 'integrations', 'content-integrations') : new self(JVB_CONTENT[$subType]['integrations'], 'integrations', 'content-integrations');
|
break;
|
case 'taxonomy':
|
$feature = (!isset(JVB_TAXONOMY[$subType])|| !array_key_exists('integrations', JVB_TAXONOMY[$subType])) ? new self([], 'integrations', 'taxonomy-integrations') : new self(JVB_TAXONOMY[$subType]['integrations'], 'integrations', 'taxonomy-integrations');
|
break;
|
case 'user':
|
$feature = (!isset(JVB_USER[$subType])|| !array_key_exists('integrations', JVB_USER[$subType])) ? new self([], 'integrations', 'user-integrations') : new self(JVB_USER[$subType]['integrations'], 'integrations', 'user-integrations');
|
break;
|
default:
|
return false;
|
}
|
return $feature->has($integration);
|
}
|
|
public static function hasAnyIntegration(string $type = 'site', ?string $subType = null):bool
|
{
|
$allowedTypes = ['site', 'content', 'taxonomy', 'user'];
|
if (!in_array($type, $allowedTypes)) {
|
return false;
|
}
|
if (in_array($type, ['content', 'taxonomy', 'user']) && !$subType) {
|
return false;
|
}
|
switch ($type) {
|
case 'site':
|
return (array_key_exists('integrations', JVB_SITE) && !empty(JVB_SITE['integrations']));
|
case 'content':
|
return (array_key_exists($subType, JVB_CONTENT) && array_key_exists('integrations', JVB_CONTENT[$subType]) && !empty(JVB_CONTENT[$subType]['integrations']));
|
case 'taxonomy':
|
return (array_key_exists($subType, JVB_TAXONOMY) && array_key_exists('integrations', JVB_TAXONOMY[$subType]) && !empty(JVB_TAXONOMY[$subType]['integrations']));
|
case 'user':
|
return (array_key_exists($subType, JVB_USER) && array_key_exists('integrations', JVB_USER[$subType]) && !empty(JVB_USER[$subType]['integrations']));
|
default:
|
return false;
|
}
|
}
|
/**
|
* Create from a specific taxonomy
|
*/
|
public static function forTaxonomy(string $slug): self
|
{
|
$slug = jvbNoBase($slug);
|
if (!isset(JVB_TAXONOMY[$slug])) {
|
return new self([], 'taxonomy', $slug);
|
}
|
return new self(JVB_TAXONOMY[$slug], 'taxonomy', $slug);
|
}
|
|
/**
|
* Create from a specific user role
|
*/
|
public static function forUser(string $slug): self
|
{
|
$slug = jvbNoBase($slug);
|
if (!isset(JVB_USER[$slug])) {
|
return new self([], 'user', $slug);
|
}
|
return new self(JVB_USER[$slug], 'user', $slug);
|
}
|
|
/**
|
* Create for site-wide features
|
*/
|
public static function forSite(): self
|
{
|
return new self(JVB_SITE ?? [], 'site', 'site');
|
}
|
|
/**
|
* Create for membership features
|
*/
|
public static function forMembership(): self
|
{
|
return new self(JVB_MEMBERSHIP ?? [], 'membership', 'membership');
|
}
|
|
/**
|
* Check if a single feature is enabled
|
*/
|
public function has(string $feature): bool
|
{
|
// Check cache first
|
$cacheKey = $this->getCacheKey($feature);
|
if (isset($this->cache[$cacheKey])) {
|
return $this->cache[$cacheKey];
|
}
|
|
// Perform the check
|
$result = isset($this->config[$feature]) && $this->config[$feature] === true;
|
|
// Cache the result
|
$this->cache[$cacheKey] = $result;
|
|
return $result;
|
}
|
|
/**
|
* Check if ALL specified features are enabled
|
*/
|
public function hasAll(array $features): bool
|
{
|
foreach ($features as $feature) {
|
if (!$this->has($feature)) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
/**
|
* Check if ANY of the specified features are enabled
|
*/
|
public function hasAny(array $features): bool
|
{
|
foreach ($features as $feature) {
|
if ($this->has($feature)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/**
|
* Check if NONE of the specified features are enabled
|
*/
|
public function hasNone(array $features): bool
|
{
|
return !$this->hasAny($features);
|
}
|
|
/**
|
* Get all enabled features
|
*/
|
public function getEnabled(): array
|
{
|
$enabled = [];
|
|
// Determine which features to check based on type
|
$featuresToCheck = $this->getFeatureList();
|
|
foreach ($featuresToCheck as $feature) {
|
if ($this->has($feature)) {
|
$enabled[] = $feature;
|
}
|
}
|
|
return $enabled;
|
}
|
|
/**
|
* Get all disabled features
|
*/
|
public function getDisabled(): array
|
{
|
$disabled = [];
|
$featuresToCheck = $this->getFeatureList();
|
|
foreach ($featuresToCheck as $feature) {
|
if (!$this->has($feature)) {
|
$disabled[] = $feature;
|
}
|
}
|
|
return $disabled;
|
}
|
|
/**
|
* Check feature with a default value if not set
|
*/
|
public function get(string $feature, bool $default = false): bool
|
{
|
if (!isset($this->config[$feature])) {
|
return $default;
|
}
|
return $this->has($feature);
|
}
|
|
/**
|
* Check if a feature is explicitly set (regardless of value)
|
*/
|
public function isSet(string $feature): bool
|
{
|
return isset($this->config[$feature]);
|
}
|
|
/**
|
* Get the raw value of a feature (not just boolean)
|
*/
|
public function getValue(string $feature, $default = null)
|
{
|
return $this->config[$feature] ?? $default;
|
}
|
|
/**
|
* Check features with dependencies
|
*/
|
public function hasWithDependencies(string $feature): bool
|
{
|
if (!$this->has($feature)) {
|
return false;
|
}
|
|
// Check dependencies based on feature
|
$dependencies = $this->getFeatureDependencies($feature);
|
|
return $this->hasAll($dependencies);
|
}
|
|
/**
|
* Global feature checks across all types
|
*/
|
public static function anyContentHas(string $feature): bool
|
{
|
$cacheKey = "content_any_{$feature}";
|
|
if (isset(self::$globalCache[$cacheKey])) {
|
return self::$globalCache[$cacheKey];
|
}
|
|
foreach (JVB_CONTENT as $slug => $config) {
|
$flags = new self($config, 'content', $slug);
|
if ($flags->has($feature)) {
|
self::$globalCache[$cacheKey] = true;
|
return true;
|
}
|
}
|
|
self::$globalCache[$cacheKey] = false;
|
return false;
|
}
|
|
/**
|
* Check if any taxonomy has a feature
|
*/
|
public static function anyTaxonomyHas(string $feature): bool
|
{
|
$cacheKey = "taxonomy_any_{$feature}";
|
|
if (isset(self::$globalCache[$cacheKey])) {
|
return self::$globalCache[$cacheKey];
|
}
|
|
foreach (JVB_TAXONOMY as $slug => $config) {
|
$flags = new self($config, 'taxonomy', $slug);
|
if ($flags->has($feature)) {
|
self::$globalCache[$cacheKey] = true;
|
return true;
|
}
|
}
|
|
self::$globalCache[$cacheKey] = false;
|
return false;
|
}
|
|
/**
|
* Check if any user role has a feature
|
*/
|
public static function anyUserHas(string $feature): bool
|
{
|
$cacheKey = "user_any_{$feature}";
|
|
if (isset(self::$globalCache[$cacheKey])) {
|
return self::$globalCache[$cacheKey];
|
}
|
|
foreach (JVB_USER as $slug => $config) {
|
$flags = new self($config, 'user', $slug);
|
if ($flags->has($feature)) {
|
self::$globalCache[$cacheKey] = true;
|
return true;
|
}
|
}
|
|
self::$globalCache[$cacheKey] = false;
|
return false;
|
}
|
|
/**
|
* Get all types with a specific feature
|
*/
|
public static function getTypesWithFeature(string $feature, string $type = 'content'): array
|
{
|
$types = [];
|
|
$source = match ($type) {
|
'content' => JVB_CONTENT,
|
'taxonomy' => JVB_TAXONOMY,
|
'user' => JVB_USER,
|
default => []
|
};
|
|
foreach ($source as $slug => $config) {
|
$flags = new self($config, $type, $slug);
|
if ($flags->has($feature)) {
|
$types[] = $slug;
|
}
|
}
|
|
return $types;
|
}
|
|
/**
|
* Count types with a feature
|
*/
|
public static function countWithFeature(string $feature, string $type = 'content'): int
|
{
|
return count(self::getTypesWithFeature($feature, $type));
|
}
|
|
/**
|
* Check complex feature combinations
|
*/
|
public function meetsRequirements(array $requirements): bool
|
{
|
foreach ($requirements as $requirement => $expected) {
|
if (is_array($expected)) {
|
// Handle OR conditions
|
if (!$this->hasAny($expected)) {
|
return false;
|
}
|
} elseif (is_bool($expected)) {
|
// Handle boolean requirements
|
if ($this->has($requirement) !== $expected) {
|
return false;
|
}
|
} elseif (is_callable($expected)) {
|
// Handle custom validation
|
if (!$expected($this->getValue($requirement))) {
|
return false;
|
}
|
}
|
}
|
|
return true;
|
}
|
|
/**
|
* Get feature statistics
|
*/
|
public function getStats(): array
|
{
|
$all = $this->getFeatureList();
|
$enabled = $this->getEnabled();
|
|
return [
|
'total' => count($all),
|
'enabled' => count($enabled),
|
'disabled' => count($all) - count($enabled),
|
'percentage' => count($all) > 0 ? round((count($enabled) / count($all)) * 100, 2) : 0
|
];
|
}
|
|
/**
|
* Export configuration for debugging
|
*/
|
public function export(): array
|
{
|
return [
|
'type' => $this->type,
|
'slug' => $this->slug,
|
'features' => $this->getEnabled(),
|
'config' => $this->config
|
];
|
}
|
|
/**
|
* Check if configuration supports a specific workflow
|
*/
|
public function supportsWorkflow(string $workflow): bool
|
{
|
$workflows = [
|
'moderation' => ['approve_new', 'member_verified'],
|
'social' => ['karma', 'responses', 'favouritable'],
|
'calendar' => ['is_calendar'],
|
'directory' => ['show_directory'],
|
'ownership' => ['is_ownable', 'is_owned_by'],
|
'dashboard' => ['has_dashboard'],
|
'public_profile' => ['has_dashboard', 'profile'],
|
'content_creation' => ['can_create'],
|
'invitation' => ['invitable', 'can_invite'],
|
'feed' => ['show_feed', 'use_feed_block'],
|
'ecommerce' => ['square', 'syncWithSquare'],
|
'analytics' => ['keep_stats', 'umami'],
|
'forum' => ['forum', 'responses']
|
];
|
|
if (!isset($workflows[$workflow])) {
|
return false;
|
}
|
|
return $this->hasAny($workflows[$workflow]);
|
}
|
|
/**
|
* Get feature dependencies
|
*/
|
private function getFeatureDependencies(string $feature): array
|
{
|
$dependencies = [
|
'responses' => ['forum'],
|
'karma' => ['member_verified'],
|
'invitable' => ['can_invite'],
|
'keep_stats' => ['has_dashboard'],
|
'syncWithSquare' => ['square']
|
];
|
|
return $dependencies[$feature] ?? [];
|
}
|
|
/**
|
* Get list of features based on type
|
*/
|
private function getFeatureList(): array
|
{
|
return match ($this->type) {
|
'content' => self::CONTENT_FEATURES,
|
'taxonomy' => self::TAXONOMY_FEATURES,
|
'user' => self::USER_FEATURES,
|
'site' => self::SITE_FEATURES,
|
'membership' => array_keys($this->config),
|
default => array_keys($this->config)
|
};
|
}
|
|
/**
|
* Generate cache key
|
*/
|
private function getCacheKey(string $feature): string
|
{
|
return "{$this->type}_{$this->slug}_{$feature}";
|
}
|
|
/**
|
* Clear cache
|
*/
|
public function clearCache(): void
|
{
|
$this->cache = [];
|
}
|
|
/**
|
* Clear global cache
|
*/
|
public static function clearGlobalCache(): void
|
{
|
self::$globalCache = [];
|
}
|
|
/**
|
* Magic method for property-style access
|
*/
|
public function __get(string $name): bool
|
{
|
return $this->has($name);
|
}
|
|
/**
|
* Magic method for method-style checks
|
*/
|
public function __call(string $name, array $arguments): bool
|
{
|
// Support is*, has*, can* method calls
|
if (preg_match('/^(is|has|can)(.+)$/', $name, $matches)) {
|
$feature = lcfirst($matches[2]);
|
|
// Convert camelCase to snake_case
|
$feature = strtolower(preg_replace('/([A-Z])/', '_$1', $feature));
|
|
return $this->has($feature);
|
}
|
|
throw new \BadMethodCallException("Method {$name} does not exist");
|
}
|
}
|
