<?php
|
if (!defined('ABSPATH')) {
|
exit;
|
}
|
|
use JVBase\utility\Features;
|
|
function jvbGlobalDirectories():array
|
{
|
$directories = get_option(BASE.'_global_directories');
|
if (JVB_TESTING) {
|
$directories = false;
|
}
|
if ($directories === false) {
|
$directories = array_merge(
|
array_fill_keys(array_keys(array_filter(JVB_CONTENT, function ($content) {
|
return jvbCheck('show_directory', $content);
|
})), 'content'),
|
array_fill_keys(array_keys(array_filter(JVB_TAXONOMY, function ($taxonomy) {
|
return jvbCheck('show_directory', $taxonomy);
|
})), 'tax')
|
);
|
// update_option(BASE.'_global_directories', $directories);
|
}
|
return $directories;
|
}
|
|
function jvbGlobalKarma():array
|
{
|
$karma = get_option(BASE.'_global_karma');
|
if (JVB_TESTING) {
|
$karma = false;
|
}
|
if ($karma === false) {
|
$karma = [
|
'content' => array_keys(array_filter(JVB_CONTENT, function ($content) {
|
return isset($content['karma']) && $content['karma'] === true;
|
})),
|
'taxonomy' => array_keys(array_filter(JVB_TAXONOMY, function ($taxonomy) {
|
return isset($taxonomy['karma']) && $taxonomy['karma'] === true;
|
}))
|
];
|
// update_option(BASE.'_global_karma');
|
}
|
return $karma;
|
}
|
|
function jvbGlobalTaxonomyFor():array
|
{
|
$taxonomy_for = get_option(BASE.'_global_taxonomy_for');
|
if (JVB_TESTING) {
|
$taxonomy_for = false;
|
}
|
if ($taxonomy_for === false) {
|
$taxonomy_for = [];
|
foreach (JVB_TAXONOMY as $tax => $config) {
|
$taxonomy_for[$tax] = $config['for_content'];
|
}
|
// update_option(BASE.'_global_taxonomy_for', $taxonomy_for);
|
}
|
return $taxonomy_for;
|
}
|
|
function jvbGlobalFeedContent():array {
|
$content = get_option(BASE.'_global_feed_content');
|
if (JVB_TESTING) {
|
$content = false;
|
}
|
if (!$content) {
|
$taxonomy = array_fill_keys(array_keys(array_filter(JVB_TAXONOMY, function ($tax) {
|
return jvbCheck('is_content', $tax);
|
})), 'tax');
|
$content = array_fill_keys(array_keys(array_filter(JVB_CONTENT, function ($c) {
|
return jvbCheck('show_feed', $c);
|
})), 'content');
|
$content = array_merge($content, $taxonomy);
|
update_option(BASE.'_global_feed_content', $content);
|
}
|
return $content;
|
}
|
|
function jvbBasedFeedContent():array
|
{
|
$content = get_option(BASE.'_based_feed_content');
|
if (!$content) {
|
$content = array_map(function ($c) {
|
return jvbCheckBase($c);
|
}, jvbGlobalFeedContent());
|
update_option(BASE.'based_feed_content', $content);
|
}
|
return $content;
|
}
|
|
function jvbGlobalResponses():array
|
{
|
$responses = get_option(BASE.'_global_responses');
|
if (JVB_TESTING) {
|
$responses = false;
|
}
|
if ($responses === false) {
|
$responses = [
|
'content' => array_keys(array_filter(JVB_CONTENT, function ($content) {
|
return isset($content['responses']) && $content['responses'] === true;
|
})),
|
'taxonomy' => array_keys(array_filter(JVB_TAXONOMY, function ($taxonomy) {
|
return isset($taxonomy['responses']) && $taxonomy['responses'] === true;
|
}))
|
];
|
// update_option(BASE.'_global_responses', $responses);
|
}
|
return $responses;
|
}
|
|
function jvbGetFields(string $type, ?string $object_type = null): array
|
{
|
return JVBase\registry\FieldRegistry::getInstance()->getFields($type, $object_type);
|
}
|
|
|
function jvbGetValidType(string $type) {
|
return str_replace('-', '_', (jvbNoBase($type)));
|
}
|
function jvbGetSections(string $type, ?string $object_type = null):array
|
{
|
$type = jvbGetValidType($type);
|
|
if (!jvbIsValidType($type)) {
|
return [];
|
}
|
if (!$object_type) {
|
$object_type = jvbGetObjectType($type);
|
}
|
|
$optionKey = BASE.$type.'_'.$object_type.'_sections';
|
$sections = get_option($optionKey, false);
|
$sections = false;
|
if (JVB_TESTING) {
|
$sections = false;
|
}
|
if (!$sections) {
|
$fields = jvbGetFields($type, $object_type);
|
$sections = ['basic' => 'Basic'];
|
|
foreach ($fields as $field) {
|
if (array_key_exists('section', $field)) {
|
$sections[sanitize_title($field['section'])] = jvbSectionTitle($field['section']);
|
}
|
}
|
|
update_option($optionKey, $sections);
|
}
|
|
return $sections;
|
}
|
|
function jvbSectionTitle(string $section):string
|
{
|
switch ($section) {
|
case 'gmb':
|
return 'Google My Business';
|
case 'square-config':
|
return 'Square Options';
|
case 'sync':
|
return 'Sync Settings';
|
default:
|
return ucwords(str_replace('-', ' ', $section));
|
}
|
}
|
function jvbSectionIcon(string $section):string
|
{
|
switch ($section) {
|
case 'gmb':
|
return 'storefront';
|
case 'square-config':
|
return 'square-logo';
|
case 'sync':
|
return 'plugs-connected';
|
default:
|
return '';
|
}
|
}
|
|
function jvbSectionDescription(string $section): string
|
{
|
switch ($section) {
|
case 'gmb':
|
return 'These optional fields help optimize your Google Business listing.';
|
case 'variations':
|
return 'If you have different purchase options for this item, list them here. Example: small, medium, large';
|
default:
|
return '';
|
}
|
}
|
function jvbRegisterCommonFields(array $common)
|
{
|
$fields = [];
|
foreach ($common??[] as $field => $c) {
|
if (!is_numeric($field)) {
|
$f = JVBase\registry\MetaFieldRegistrar::getCommonMeta($field, $c);
|
} else {
|
$f = JVBase\registry\MetaFieldRegistrar::getCommonMeta($c);
|
}
|
$fields = array_merge($fields, $f);
|
}
|
return $fields;
|
}
|
|
function jvbGetAllDashboardPages()
|
{
|
$manageableContent = get_option(BASE.'all_dashboard_pages');
|
if (JVB_TESTING) {
|
$manageableContent = false;
|
}
|
if ($manageableContent === false) {
|
|
$manageableContent = [];
|
$bios = [];
|
foreach (JVB_USER as $role => $config) {
|
$manageableContent = array_merge($manageableContent, jvbRolePages($role));
|
}
|
|
if (Features::forSite()->has('referrals')) {
|
$manageableContent[] = 'referrals';
|
}
|
foreach (JVB_TAXONOMY as $tax => $config) {
|
if (jvbCheck('is_content', $config)) {
|
$manageableContent[] = strtolower($config['plural']);
|
}
|
}
|
|
if (jvbCheck('can_invite', JVB_MEMBERSHIP)) {
|
$manageableContent[] = 'invites';
|
}
|
|
if (jvbCheck('term_approval', JVB_MEMBERSHIP)) {
|
$manageableContent[] = 'approvals';
|
}
|
|
if (jvbSiteHasForum()) {
|
$manageableContent[] = 'news';
|
}
|
|
if (jvbCheck('member_content', JVB_MEMBERSHIP)) {
|
$manageableContent[] = 'metrics';
|
}
|
|
if (!empty($bios)) {
|
$manageableContent[] = 'bio';
|
}
|
|
if (jvbCheck('favourites', JVB_SITE)) {
|
$manageableContent[] = 'favourites';
|
}
|
|
if (jvbSiteHasKarma()) {
|
$manageableContent[] = 'karmic-score';
|
}
|
|
if (jvbSiteHasNotifications()) {
|
$manageableContent[] = 'notifications';
|
}
|
|
if (jvbSiteHasSupport()) {
|
$manageableContent[] = 'support';
|
}
|
|
if (jvbSiteHasIntegrations()) {
|
$manageableContent[] = 'integrations';
|
}
|
|
$manageableContent[] = 'admin';
|
$manageableContent = apply_filters('jvbDashboardPages', $manageableContent);
|
$manageableContent = array_unique($manageableContent);
|
sort($manageableContent);
|
$manageableContent = array_map(function ($content) {
|
return str_replace('_', '-', $content);
|
}, $manageableContent);
|
update_option(BASE.'all_dashboard_pages', $manageableContent);
|
}
|
|
|
return $manageableContent;
|
}
|
|
function jvbRolePages($role)
|
{
|
$manageableContent = get_option(BASE.$role.'_pages');
|
if (JVB_TESTING) {
|
$manageableContent = false;
|
}
|
if ($manageableContent === false) {
|
$manageableContent = [];
|
$config = JVB_USER[$role];
|
$content = $config['can_create'];
|
$settings = $bio = false;
|
if (array_key_exists('profile', $config)) {
|
$manageableContent[] = $config['profile'];
|
}
|
$manageableContent = array_merge($manageableContent, jvbExtractUserContent($config['can_create']));
|
|
|
if (array_key_exists('has_dashboard', $config)) {
|
$manageableContent[] = 'settings';
|
}
|
|
update_option(BASE.$role.'_pages', $manageableContent);
|
}
|
|
return $manageableContent;
|
}
|
|
function jvbExtractUserContent(array $content):array
|
{
|
// Deprecated: Use Features::forUser($role)->getCreatableContent() instead
|
_deprecated_function(__FUNCTION__, '2.0.0', 'Features::forUser($role)->getCreatableContent()');
|
|
$out = [];
|
foreach ($content as $c) {
|
if (is_array($c)) {
|
foreach ($c as $type => $contents) {
|
$out = array_merge($out, $contents);
|
}
|
} else {
|
$out = array_merge($out, [$c]);
|
}
|
}
|
return $out;
|
}
|
|
function jvbGlobalDirectoryInfo():array
|
{
|
return get_option(BASE.'directory_list',[]);
|
}
|
function jvbGlobalDirectoryIds():array
|
{
|
return get_option(BASE.'directory_ids',[]);
|
}
|
|
function jvbContentTaxContent(string $type):array
|
{
|
$content = get_option(BASE.$type.'_content');
|
if (JVB_TESTING) {
|
$content = false;
|
}
|
if ($content === false) {
|
global $jvb_taxonomy_for;
|
$content = $jvb_taxonomy_for[$type] ?? [];
|
|
if (jvbCheck('associate_user_content', JVB_TAXONOMY[$type])) {
|
$userTypes = jvbUserTypes();
|
foreach ($content as $c) {
|
$c = jvbCheckBase($c);
|
if (in_array($c, $userTypes)) {
|
$user = array_search($c, $userTypes);
|
$content = array_merge($content, jvbExtractUserContent(JVB_USER[$user]['can_create']??[]));
|
}
|
}
|
$content = array_unique($content);
|
$content = array_filter($content, function ($c) {
|
return array_key_exists($c, jvbGlobalFeedContent());
|
});
|
}
|
|
update_option(BASE.$type.'_content', $content);
|
}
|
return $content;
|
}
|
|
|
function jvbContentTaxonomies():array
|
{
|
$types = get_option(BASE.'content_taxonomies');
|
if (JVB_TESTING) {
|
$types = false;
|
}
|
if ($types === false) {
|
$types = array_map(function ($content) { return BASE.$content; },
|
array_keys(array_filter(JVB_TAXONOMY, function ($tax) {
|
return jvbCheck('is_content', $tax);
|
})));
|
update_option(BASE.'content_taxonomies', $types);
|
}
|
return $types;
|
}
|
|
function jvbContentTaxonomiesTableFields(string $type):array
|
{
|
$fields = get_option(BASE.$type.'_content_fields');
|
if (JVB_TESTING) {
|
$fields = false;
|
}
|
|
if (!$fields) {
|
$all = JVB_TAXONOMY[$type]['content_table']??[];
|
|
$fields = $all['fields']??[];
|
|
$temp = [];
|
if (!empty($fields)) {
|
$index = jvbGetFields($type);
|
foreach ($fields as $field) {
|
$temp[$field] = $index[$field];
|
}
|
$all['fields'] = $temp;
|
}
|
$fields = $all;
|
update_option(BASE.$type.'_content_fields', $fields);
|
}
|
return $fields;
|
}
|
|
function jvbApprovalTypes():array
|
{
|
return get_option(BASE.'approval_types', []);
|
}
|
|
//Gets the user roles of users that can create
|
function jvbAuthorUsers():array
|
{
|
return array_keys(array_filter(JVB_USER, function ($value) {
|
return !empty($value['can_create']??[]);
|
}));
|
}
|
|
function jvbNoSingleContentTypes():array
|
{
|
return array_keys(array_filter(JVB_CONTENT, function ($value) {
|
return jvbCheck('hide_single', $value);
|
}));
|
}
|
|
function jvbTaxonomiesForContent(string $content):array
|
{
|
$taxonomies = get_option(BASE.$content.'_taxonomies');
|
if (JVB_TESTING) {
|
$taxonomies = false;
|
}
|
if (!$taxonomies) {
|
global $jvb_taxonomy_for;
|
$taxonomies = [];
|
foreach ($jvb_taxonomy_for as $tax => $contentTypes) {
|
if (in_array($content, $contentTypes)) {
|
$taxonomies[] = BASE.$tax;
|
}
|
}
|
update_option(BASE.$content.'_taxonomies', $taxonomies);
|
}
|
return $taxonomies;
|
}
|
|
function jvbGetRandomSeed():string
|
{
|
return floor(time() / 1800);
|
}
|
|
/**
|
* The following return a slug => $config pair array of any registered types.
|
*/
|
function jvbCalendarTableTypes():array
|
{
|
//Set on activation through CheckCustomTables.php
|
return get_option(BASE.'calendar_tables');
|
}
|
|
function jvbCalenderTables():array
|
{
|
$tables = [];
|
foreach (jvbCalendarTableTypes() as $type => $config) {
|
$tables[$type] = BASE.'calendar_'.$type;
|
}
|
return $tables;
|
}
|
|
function jvbKarmaTableTypes():array
|
{
|
//Set on activation through CheckCustomTables.php
|
return get_option(BASE.'karma_tables');
|
}
|
function jvbKarmaTables():array
|
{
|
$tables = [];
|
foreach (jvbKarmaTableTypes() as $type => $config) {
|
$tables[$type] = BASE.'karma_'.$type;
|
}
|
return $tables;
|
}
|
|
function jvbStatsTableTypes():array
|
{
|
//Set on activation through CheckCustomTables.php
|
return get_option(BASE.'stats_tables');
|
}
|
|
function jvbStatsTables():array
|
{
|
$tables = [];
|
foreach (jvbStatsTableTypes() as $type => $config) {
|
$tables[$type] = BASE.'stats_'.$type;
|
}
|
return $tables;
|
}
|
|
function jvbInviteTableTypes():array
|
{
|
//Set on activation through CheckCustomTables.php
|
return get_option(BASE.'invite_tables');
|
}
|
|
function jvbInviteTables():array
|
{
|
$tables = [];
|
foreach (jvbInviteTableTypes() as $type => $config) {
|
$tables[$type] = BASE.'invitations_'.$type;
|
}
|
return $tables;
|
}
|
|
function jvbVerifyEntryTableTypes():array
|
{
|
//Set on activation through CheckCustomTables.php
|
return get_option(BASE.'verify_entry_tables');
|
}
|
|
|
function jvbVerifyEntryTables():array
|
{
|
$tables = [];
|
foreach (jvbVerifyEntryTableTypes() as $type => $config) {
|
$contents = $config['for_content'];
|
foreach($contents as $content) {
|
$tables[$type][$content] = BASE.$content.'_'.$type.'_requests';
|
}
|
}
|
return $tables;
|
}
|
|
function jvbApprovalTableTypes():array
|
{
|
//Set on activation through CheckCustomTables.php
|
return get_option(BASE.'approval_tables');
|
}
|
|
function jvbApprovalTables():array
|
{
|
$tables = [];
|
foreach (jvbApprovalTableTypes() as $type => $config) {
|
$tables['requests'][$type] = BASE.'approval_'.$type.'_requests';
|
$tables['votes'][$type] = BASE.'approval_'.$type.'_votes';
|
}
|
return $tables;
|
}
|
|
function jvbHistoryTableTypes():array
|
{
|
//Set on activation through CheckCustomTables.php
|
return get_option(BASE.'history_tables');
|
}
|
|
function jvbHistoryTables():array
|
{
|
$tables = [];
|
foreach (jvbHistoryTableTypes() as $type => $config) {
|
$contents = $config['for_content'];
|
foreach($contents as $content) {
|
$tables[$type][$content] = BASE.'history_'.$content.'_'.$type;
|
}
|
}
|
return $tables;
|
}
|
|
|
function jvbSquarePOSTypes():array {
|
$enabled_types = [];
|
|
foreach (JVB_CONTENT as $post_type => $config) {
|
if (!empty($config['integrations']['square']['enabled'])) {
|
$enabled_types[] = $post_type;
|
}
|
}
|
|
return $enabled_types;
|
}
|
|
|
function jvbGetLabels():array {
|
$labels = get_option(BASE.'content_labels');
|
$labels = false;
|
if (!$labels) {
|
$labels = [];
|
$all = array_merge(JVB_CONTENT, JVB_TAXONOMY);
|
foreach ($all as $type => $config) {
|
$labels[$type] = [
|
'single' => $config['singular'],
|
'plural' => $config['plural']
|
];
|
}
|
update_option(BASE.'content_labels', $labels);
|
}
|
return $labels;
|
}
|
