jakevan/jvb.git

<?php
namespace JVBase;
 
use JVBase\blocks\CustomBlocks;
use JVBase\integrations\BlueSky;
use JVBase\managers\Cache;
use JVBase\managers\EmailManager;
use JVBase\managers\ErrorHandler;
use JVBase\managers\InvitationsManager;
use JVBase\managers\LoginManager;
use JVBase\managers\MagicLinkManager;
use JVBase\managers\queue\Queue;
use JVBase\managers\DashboardManager;
use JVBase\managers\DirectoryManager;
use JVBase\managers\ReferralManager;
use JVBase\managers\RoleManager;
//use JVBase\managers\SchemaManager;
use JVBase\managers\SEO\render\SchemaOutput;
use JVBase\managers\SEO\SchemaOutputManager;
use JVBase\admin\SEOAdmin;
use JVBase\managers\AdminPages;
use JVBase\managers\NotificationManager;
use JVBase\managers\TaxonomyRelationships;
use JVBase\managers\UserTermsManager;
use JVBase\registrar\Registrar;
use JVBase\rest\routes\FeedRoutes;
use JVBase\rest\routes\FavouritesRoutes;
use JVBase\rest\routes\IntegrationsSquareRoutes;
use JVBase\rest\routes\IntegrationsHelcimRoutes;
use JVBase\rest\routes\NotificationsRoutes;
use JVBase\rest\routes\ContentRoutes;
use JVBase\rest\routes\TermRoutes;
use JVBase\rest\routes\UploadRoutes;
//use JVBase\rest\routes\BioRoutes;
use JVBase\rest\routes\SettingsRoutes;
//use JVBase\rest\routes\ShopRoutes;
use JVBase\rest\routes\ContentTermsRoutes;
use JVBase\rest\routes\SEORoutes;
use JVBase\rest\routes\QueueRoutes;
use JVBase\rest\routes\ErrorRoutes;
use JVBase\rest\routes\FormRoutes;
use JVBase\rest\routes\LoginRoutes;
use JVBase\rest\routes\NewsRoutes;
use JVBase\rest\routes\ReferralRoutes;
//use JVBase\rest\routes\MagicLinkRoutes;
use JVBase\rest\routes\ResponseRoutes;
use JVBase\rest\routes\OptionsRoutes;
use JVBase\rest\routes\VoteRoutes;
use JVBase\rest\routes\Invitations;
use JVBase\rest\routes\ApprovalRoutes;
use JVBase\rest\routes\AdminRoutes;
use JVBase\rest\routes\IntegrationsRoutes;
use JVBase\utility\Features;
use JVBase\base\SchemaHelper;
 
if (!defined('ABSPATH')) {
    exit;
}
 
class JVB
{
    protected static JVB|null $instance = null;
    protected array $managers = [];
    protected array $content = [];
    protected array $taxonomies = [];
    protected array $integrations = [];
    protected array $blocks = [];
    protected array $routes = [];
    protected CustomBlocks $customBlocks;
 
    protected array $serviceMap = [
        'maps' => 'JVBase\integrations\GoogleMaps',
        'square' => 'JVBase\integrations\Square',
        'facebook' => 'JVBase\integrations\Facebook',
        'helcim' => 'JVBase\integrations\Helcim',
        'instagram' => 'JVBase\integrations\Instagram',
        'bluesky' => 'JVBase\integrations\BlueSky',
        'gmb' => 'JVBase\integrations\GoogleMyBusiness',
        'cloudflare' => 'JVBase\integrations\Cloudflare',
        'umami' => 'JVBase\integrations\Umami',
        'postmark' => 'JVBase\integrations\PostMark',
    ];
 
    public static function getInstance(): JVB
    {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }
 
 
    public function __construct()
    {
        $this->customBlocks = new CustomBlocks();
        $this->managers = [
            'errors'    => new ErrorHandler(),
            'queue'     => new Queue(),
//            'dash'    => new DashboardManager(),
            'roles'     => new RoleManager(),
//            'forms'   => new FormManager(),
//          'schema'    => new SchemaOutputManager(),
            'admin'     => new AdminPages(),
            'seoAdmin'  => new SEOAdmin(),
            'seo'       => new SchemaOutput(),
            'schemaHelper' => new SchemaHelper(),
//          'uploads'   => new UploadManager(),
            'userTerms' => new UserTermsManager(),
            'email'     => new EmailManager(),
            'terms'     => new TaxonomyRelationships(),
        ];
 
        $this->routes = [
            'login' => new LoginRoutes(),
            'integrations' => new IntegrationsRoutes(),
            'seo' => new SEORoutes(),
            'queue' => new QueueRoutes(),
            'settings' => new SettingsRoutes(),
            'upload' => new UploadRoutes(),
            'forms' => new FormRoutes()
        ];
 
        if (Features::forSite()->has('magicLink')) {
//          $this->routes['magicLink'] = new MagicLinkRoutes();
            $this->managers['magicLink'] = new MagicLinkManager();
        }
        if (Features::forSite()->has('referrals')) {
            $this->managers['referral'] = new ReferralManager();
            $this->routes['referral'] = new ReferralRoutes();
        }
 
        if (Features::forSite()->has('dashboard')) {
            $this->managers['dash'] = new DashboardManager();
        }
 
        if (Features::hasIntegration('square')) {
            $this->routes['square'] = new IntegrationsSquareRoutes();
        }
        if (Features::hasIntegration('helcim')) {
            $this->routes['helcim'] = new IntegrationsHelcimRoutes();
        }
 
        if (Features::forSite()->has('feed_block')) {
            $this->routes['feed'] = new FeedRoutes();
        }
        if (Features::forMembership()->has('notifications')) {
            $this->managers['notifications'] = new NotificationManager();
            $this->routes['notifications'] = new NotificationsRoutes();
        }
        if (Features::forSite()->has('feed_block') || Features::forSite()->has('dashboard')) {
            $this->routes['term'] = new TermRoutes();
        }
 
        if (Features::forSite()->has('is_directory')) {
            $this->managers['directory'] = new DirectoryManager();
        }
 
        if (Features::forSite()->has('dashboard')) {
            $this->routes['error'] = new ErrorRoutes();
            $this->routes['admin']  = new AdminRoutes();
            $this->routes['content'] = new ContentRoutes();
//            $this->routes['bio']    = new BioRoutes();
//          $this->routes['shop'] = new ShopRoutes();
            $this->routes['contentTax'] = new ContentTermsRoutes();
            $this->routes['options'] = new OptionsRoutes();
        }
 
        if (Features::forSite()->has('favourites')) {
            $this->routes['favourites'] = new FavouritesRoutes();
        }
 
        if (Features::forMembership()->has('forum')) {
            $this->routes['news'] = new NewsRoutes();
        }
        if (Features::forMembership()->has('invitable')) {
            $this->managers['invitations'] = new InvitationsManager();
        }
        if (!empty(Registrar::getFeatured('has_responses'))) {
            $this->routes['comments'] = new ResponseRoutes();
        }
        if (!empty(Registrar::getFeatured('karma'))) {
            $this->routes['vote'] = new VoteRoutes();
        }
        if (!empty(Registrar::getFeatured('karma'))
            || Features::forMembership()->has('member_verified') ||
            Features::forMembership()->has('term_approval')) {
            $this->routes['approvals'] = new ApprovalRoutes();
        }
        if (Features::forMembership()->has('can_invite')) {
            $this->routes['invites'] = new Invitations();
        }
 
        $this->setupIntegrations();
 
        add_action('wp_footer', [$this, 'additionalActions']);
//        $this->managers['notifications'] = new NotificationManager();
        // Register activation hook
        register_activation_hook(JVB_DIR . '/jvb.php', [$this, 'activate']);
    }
 
 
    protected function setupIntegrations(): void
    {
        if (array_key_exists('integrations', JVB_SITE)) {
            foreach (JVB_SITE['integrations'] as $service => $use) {
                if (!$use) {
                    continue;
                }
                if (array_key_exists($service, $this->serviceMap)) {
                    $this->integrations[$service] = new $this->serviceMap[$service]();
                }
 
            }
        }
    }
 
    public function registeredContent(): array
    {
        return array_merge(array_keys($this->content), array_keys($this->taxonomies));
    }
 
    public function dashboard(): DashboardManager|false
    {
        return $this->managers['dash'] ?? false;
    }
 
    public function directories(): DirectoryManager|false
    {
        return $this->managers['directory'] ?? false;
    }
 
    public function error(): ErrorHandler
    {
        return $this->managers['errors'];
    }
 
    public function file()
    {
        return $this->managers['file'];
    }
 
    public function queue(): Queue
    {
        return $this->managers['queue'];
    }
//    public function forms()
//    {
//        return $this->managers['forms'];
//    }
    public function notification(): NotificationManager|false
    {
        return $this->managers['notifications'] ?? false;
    }
 
    public function routes($route): mixed
    {
        if (array_key_exists($route, $this->routes)) {
            return $this->routes[$route];
        }
        return false;
    }
 
    public function roles(): RoleManager
    {
        return $this->managers['roles'];
    }
 
    public function admin()
    {
        return $this->managers['admin'];
    }
 
    public function seoAdmin()
    {
        return $this->managers['seoAdmin'];
    }
 
    public function getFields($type): array
    {
        return Registrar::getFieldsFor($type)??[];
    }
 
    public function getContent($type): mixed
    {
        return $this->content[$type] ?? $this->taxonomies[$type] ?? $this->blocks[$type] ?? null;
    }
 
    public function connect(string $service, ?int $userID = null): mixed
    {
        if ($userID) {
            if (!$this->userCanConnect($service, $userID)) {
                return null;
            }
 
            if (!array_key_exists($service, $this->integrations)) {
                return null;
            }
            return new $this->serviceMap[$service]($userID);
        }
        return (array_key_exists($service, $this->integrations)) ? $this->integrations[$service] : null;
    }
 
    public function userCanConnect(string $service, int $userID): bool
    {
        $allowed = JVB_USER[jvbUserRole($userID)]['integrations'] ?? [];
        return user_can($userID, 'manage_options') || in_array($service, $allowed);
    }
 
    public function getAvailableServices(bool $keys = true): array
    {
 
        return ($keys) ? array_keys($this->integrations) : $this->integrations;
    }
 
    public function activate(): void
    {
        // Activate roles - will be properly initialized after post types are registered
        $this->roles()->activate();
    }
 
    public function addRoute($slug, $class): void
    {
        $this->routes[$slug] = $class;
    }
 
    public function email(): EmailManager
    {
        return $this->managers['email'];
    }
 
    public function referrals(): ReferralManager|false
    {
        return $this->managers['referral'] ?? false;
    }
 
    public function magicLink(): MagicLinkManager|false
    {
        return $this->managers['magicLink'] ?? false;
    }
 
    public function invitations(): InvitationsManager|false
    {
        return $this->managers['invitations'] ?? false;
    }
 
    public function additionalActions():void
    {
        if (LoginManager::isLogin()) {
            return;
        }
        $extras = apply_filters('jvbAdditionalActions', []);
        $extras = array_filter($extras, function ($extra) {
            return is_array($extra) && array_key_exists('button', $extra) && array_key_exists('content', $extra);
        });
        if (empty ($extras)) {
            return;
        }
        $buttons = array_map(function ($extra) {
            return $extra['button'];
        }, $extras);
        $contents = array_map(function($extra) {
            return $extra['content'];
        }, $extras);
 
        if (!empty ($buttons)) {
            ?>
            <section class="additional-actions">
                <div class="buttons col">
                    <?= implode($buttons); ?>
                </div>
                <div class="actions">
                    <?= implode($contents); ?>
                </div>
            </section>
            <?php
        }
    }
 
    public function seo():SchemaOutput
    {
        return $this->managers['seo'];
    }
 
    public function blocks():CustomBlocks|bool
    {
        return $this->customBlocks??false;
    }
    public function schemaHelper():SchemaHelper
    {
        return $this->managers['schemaHelper'];
    }
 
    public function termRelationships():TaxonomyRelationships
    {
        return $this->managers['terms'];
    }
}