=Single Event page setup done through the new Event block. Currently workin...

Jake Vanderwerf

2026-09-13 1aa7c404dae63c9518468fe9b579fad819f8d871

 inc/registrar/Registrar.php

@@ -3,6 +3,7 @@


use JVBase\base\Site;
use JVBase\inc\registrar\helpers\AddCustomFields;
use JVBase\inc\registrar\helpers\HideSingle;
use JVBase\managers\Cache;
use JVBase\managers\CRUD;
@@ -14,6 +15,7 @@
use JVBase\registrar\config\Directory;
use JVBase\registrar\config\Feed;
use JVBase\registrar\config\Integration;
use JVBase\registrar\config\Register;
use JVBase\registrar\config\Section;
use JVBase\registrar\config\SEO;
use JVBase\registrar\helpers\AddIntegrationFields;
@@ -53,12 +55,16 @@
   public string $prefix_with = 'by';

   public bool $system = false;
   public bool $baseless = false;
   public bool $modify = false;

   protected ?AddCustomFields $addFields = null;

   protected static array $allFlags = [
      //Shared Flags
      'favouritable', 'karma', 'show_feed', 'show_directory', 'approve_new', 'has_responses', 'invitable',
      //Post Flags
      'hide_single', 'redirect_to_author', 'is_calendar', 'single_image', 'is_timeline', 'is_gallery', 'is_faq', 'is_glossary', 'rewrite_taxonomy', 'add_image_column',
      'hide_single', 'redirect_to_author', 'is_calendar', 'single_image', 'is_timeline', 'is_gallery', 'is_faq', 'is_glossary', 'rewrite_taxonomy', 'add_image_column', 'is_profile', 'is_food_menu',
      //Taxonomy Flags
      'is_content', 'is_ownable', 'verify_entry', 'track_changes', 'associate_user_content', 'prefix_post_type',
      //User Flags
@@ -116,7 +122,7 @@
    * @var bool Whether to make this a calendar type (example: events)
    */
   protected bool $is_calendar = false;
   protected ?MakeCalendarType $isCalendarHandler = null;

   /**
    * @var bool Whether this is a before/after post type
    */
@@ -188,8 +194,10 @@
    * @var bool Whether to generate a profile for this user role
    */
   public bool $profile_link;
   public bool $is_profile = false;
   public bool $is_food_menu = false;
   /**
    * @var array|string
    * @var array
    */
   protected array $can_create = [];
   /**
@@ -212,20 +220,27 @@
   protected Dashboard $dashboard;
   protected Directory|false $directory;
   protected Feed|false $feed;
   protected Register|false $login;
// protected Management $management;
// protected Responses $responses;
   protected ?SEO $seo = null;

   /** Helpers **/
   protected MakeCalendarType|false $calendar = false;
   protected bool $hasIntegrations = true;
   protected array $integrationConfigs = [];
   protected array $integrationFields = [];
   protected MakeTrackChanges $trackChanges;
   protected MakeVerification $verification;

   protected string $umami_event;

   private static array $instances = [];

   protected string $based;


   protected static array $processing = ['terms'=>[],'posts'=>[],'users' =>[]];
   private function __construct(string $slug, string $singular, string $plural, string $type) {
      $this->slug = $slug;
      $this->based = jvbCheckBase($slug);
@@ -239,7 +254,10 @@
      $this->setFields();

      add_action('init', [$this, 'register'], 2);
      add_filter('jvbDashboardPage', [$this, 'renderDashPage'], 10, 3);
      if ($this->slug !== 'dash') {
         add_action(BASE.'dashboard_page_'.$this->slug, [$this, 'renderDashPage'], 10, 2);
      }

   }

   public static function maybeExcludeSingles(array $IDs):array
@@ -250,20 +268,17 @@
      foreach ($features as $feature) {
         foreach (self::withFeature($feature) as $instance) {
            $instance = self::getInstance($instance);
            $cache = Cache::for('tsf')->connect($instance->getType());
            $cache = Cache::for('tsf', $instance->getType());
            $cache->flush();

            $exclude = $cache->remember(
               $feature,
               function () use ($instance, $feature) {
                  switch ($feature) {
                     case 'hide_single':
                        return $instance->excludeSingle();
                     case 'is_timeline':
                        return $instance->excludeTimeline();
                     default:
                        return [];
                  }
                  return match ($feature) {
                     'hide_single' => $instance->excludeSingle(),
                     'is_timeline' => $instance->excludeTimeline(),
                     default => [],
                  };
               }
            );

@@ -294,13 +309,25 @@
         'post_parent__not_in'   => [0], // Only get posts with a parent
      ]);
   }

   public function ensureRegistrar():void
   {
      $this->initRegistrar();
   }
   protected function initRegistrar():void {
      $this->registrar = match ($this->type) {
         'post' => new Posts($this->slug, $this->singular, $this->plural),
         'term' => new Terms($this->slug, $this->singular, $this->plural),
         default => false,
      };


      if ($this->baseless) {
         $this->registrar->baseless = true;
         $this->registrar->postType = jvbNoBase($this->slug);
      }
      if ($this->modify) {
         $this->registrar->modify = true;
      }
   }

   protected function initClasses():void {
@@ -318,6 +345,8 @@
   /**
    * Instantiates for post types
    * @param string $slug
    * @param string $singular
    * @param string $plural
    * @return self
    */
   public static function forPost(string $slug, string $singular, string $plural):self
@@ -331,6 +360,8 @@
   /**
    * Instantiates for term types
    * @param string $slug
    * @param string $singular
    * @param string $plural
    * @return self
    */
   public static function forTerm(string $slug, string $singular, string $plural):self
@@ -344,6 +375,8 @@
   /**
    * Instantiates for user types
    * @param string $slug
    * @param string $singular
    * @param string $plural
    * @return self
    */
   public static function forUser(string $slug, string $singular, string $plural):self
@@ -354,6 +387,8 @@
      return self::$instances[$slug];
   }



   /**
    * Adds the properties for register_post_type or register_taxonomy
    * @param array $args
@@ -393,16 +428,27 @@
      return $this->args;
   }

   public function baseless():self
   {
      $this->baseless = true;
      return $this;
   }
   public function modify():self
   {
      $this->modify = true;
      return $this;
   }

   public function setFields():void
   {
      $this->fields = new Fields($this->type, $this);
   }
   public function getFields():array
   public function getFields(bool $includeDefaults = true):array
   {
      return array_map(function ($field) {
         return $field->getConfig();
      },
         $this->fields->getFields()
         $this->fields->getFields($includeDefaults)
      );
   }
   public function setIcon(string $icon):self
@@ -447,7 +493,7 @@
         error_log('Integration not available for '.$this->slug.': '.$integration);
         return $this;
      }
      $this->integrationConfigs[$integration] = new Integration($integration, $this);
      $this->integrationConfigs[$integration] = new Integration($integration);
      $this->integrationFields[$integration] = new AddIntegrationFields($integration, $this);
      return $this;
   }
@@ -468,11 +514,19 @@
   {
      return $this->integrationConfigs;
   }
   public function hasIntegration(string $integration) {
   public function hasIntegration(string $integration):bool
   {
      if (!$this->hasIntegrations) {
         return false;
      }
      return array_key_exists($integration, $this->integrationConfigs);
   }
    public function hasAnyIntegrations(array $integrations = []):bool
    {
      if (!$this->hasIntegrations) {
         return false;
      }

        if (empty($integrations)) {
            $integrations = array_keys($this->integrationConfigs);
            return !empty($integrations);
@@ -552,6 +606,9 @@
      foreach ($flags as $flag) {
         $this->$flag = true;
         switch ($flag) {
            case 'is_calendar':
               $this->calendar = new MakeCalendarType($this->slug, $this);
               break;
            case 'is_content':
               add_action('init', [$this, 'setupContent'], 20);
               break;
@@ -562,6 +619,24 @@
      }
      return $this;
   }
   public function unsetAll(array $flags):self
   {
      $flags = array_filter($flags, function($flag) {
         return in_array($flag, static::$allFlags);
      });
      foreach ($flags as $flag) {
         $this->$flag = false;
         switch ($flag) {
            case 'is_content':
               remove_action('init', [$this, 'setupContent'], 20);
               break;
            case 'is_glossary':
               $this->hide_single = false;
               break;
         }
      }
      return $this;
   }
   public function prefixWith(string $prefix):self
   {
      $this->prefix_with = sanitize_title($prefix);
@@ -618,8 +693,8 @@
   public static function withIntegration(string $integration, ?string $type = null):array
   {
      self::ensureInstanced();

      if (!Site::has($integration)) {
      Site::getInstance();
      if (!Site::hasIntegration($integration)) {
         error_log('[Registrar]::withIntegration Integration not available to fetch: '.$integration);
         return [];
      }
@@ -628,13 +703,13 @@
         if (!is_null($type) && $inst->type !== $type) {
            return false;
         }
         return array_key_exists($integration, $this->integrationConfigs);
         return array_key_exists($integration, $inst->integrationConfigs);
      }));
   }

   public function config(string $config):mixed
   {
      $allowed = ['breadcrumbs','calendar','dashboard','directory','feed','management','has_responses','seo','trackchanges','verification'];
      $allowed = ['breadcrumbs','calendar','register','login','dashboard','directory','feed','management','has_responses','seo','trackchanges','verification'];
      if (!in_array(strtolower($config), $allowed)) {
         error_log('Invalid config requested from Registrar: '.$config);
         return [];
@@ -643,6 +718,7 @@
         'breadcrumbs'  => $this->getBreadcrumbs(),
         'dashboard'    => $this->getDashboard(),
         'directory'    => $this->getDirectory(),
            'register','login' => $this->getLogin(),
         'feed'         => $this->getFeed(),
         'management'   => $this->getManagement(),
         'has_responses'   => $this->getResponses(),
@@ -651,10 +727,17 @@
         'verification' => $this->getVerification()
      };
   }
        protected function getLogin():Register|false
        {
            if (!isset($this->login)) {
                $this->login = new Register();
            }
            return $this->login;
        }
      protected function getBreadcrumbs():Breadcrumbs
      {
         if (!isset($this->breadcrumbs)) {
            $this->breadcrumbs = new Breadcrumbs($this->slug, $this);
            $this->breadcrumbs = new Breadcrumbs($this->slug);
         }

         return $this->breadcrumbs;
@@ -672,7 +755,7 @@
      protected function getDashboard():Dashboard
      {
         if (!isset($this->dashboard)) {
            $this->dashboard = new Dashboard($this->plural, $this);
            $this->dashboard = new Dashboard($this->plural);
         }

         return $this->dashboard;
@@ -705,9 +788,10 @@
   public function getSections():array
   {
      $allSections = array_map(function($section) {
         return $section->getConfig;
         return $section->getConfig();
      }, $this->sections);


      if (!empty($this->sectionOrder)) {
         $allSections['order'] = $this->sectionOrder;
      }
@@ -715,11 +799,40 @@
   }
   public function addSection(string $title):Section
   {
      $section = new Section($title, $this);
      $this->sections[] = $section;
      return $section;
      $slug = sanitize_title($title);
      if (!array_key_exists($slug, $this->sections)) {
         $section = new Section($title, $this);
         $this->sections[$slug] = $section;
      }

      return $this->sections[$slug];
   }

   public static function maybeBuildSections():void
   {
      foreach (self::$instances as $inst) {
         $inst->buildSections();
      }
   }
      protected function buildSections():void
      {
         $fields = $this->getFields();
         $sections = array_unique(array_values(array_map(function ($f) {
            return array_key_exists('section', $f) && !is_null($f['section']) ? $f['section'] : 'main';
         }, $fields)));

         foreach ($sections as $s) {
            $section = new Section($s, $this);
            $section->setTitle(ucwords(implode(' ', explode('-', $s))));
            $sectionFields = array_filter($fields, function ($f) use ($s) {
               $tmp = array_key_exists('section', $f) && !is_null($f['section']) ? $f['section'] : 'main';
               return $s === $tmp;
            });
            $section->setFields(array_keys($sectionFields));
            $this->sections[$s] = $section;
         }
      }

   public function setSectionOrder(array $sections):self
   {
      $allSections = array_map(function($section) {
@@ -767,12 +880,9 @@
            $this->hideSingleHandler = new HideSingle($this->slug, $this);
         }
         if ($this->is_timeline) {
            $this->isTimelineHandler = new MakeTimelineType($this->slug, $this);
            $this->isTimelineHandler = new MakeTimelineType($this->slug);
            $this->registrar->hierarchical = true;
         }
         if ($this->is_calendar) {
            $this->isCalendarHandler = new MakeCalendarType($this->slug, $this);
         }

         if (!is_null($this->rewrite_taxonomy)) {
            $this->registrar->addTaxonomyRewrite($this->rewrite_taxonomy);
@@ -781,6 +891,7 @@
         if ($this->registrar) {
            $this->registrar->register();
         }
         $this->addFields = new AddCustomFields($this);
         if ($this->add_image_column) {
            add_filter("manage_{$this->based}_posts_columns", [$this, 'addImageColumn']);
            add_action("manage_{$this->based}_posts_custom_column", [$this, 'showImageColumn'], 10, 2);
@@ -808,6 +919,11 @@
         $this->karmaManager = KarmaManager::for($this->slug, $this->type);
      }
   }

   public function getKarmaManager():?KarmaManager
   {
      return $this->karmaManager;
   }
   public static function getInstance(string $slug):Registrar|false
   {
      self::ensureInstanced();
@@ -876,16 +992,10 @@
      return $this;
   }

   public function renderDashPage(string $content, string $page, string $slug):string
   public function renderDashPage(string $page, string $slug):void
   {
      if ($slug === $this->slug) {
         ob_start();
         $crud = new CRUD($slug);
         $crud->render();
         return ob_get_clean();
      }

      return $content;
      $crud = new CRUD($slug);
      $crud->render();
   }

   public function setupContent():void
@@ -953,15 +1063,14 @@
      }
      public function addTermUpdatedMeta(int $termId):void
      {

            static $processing = [];
            if (isset($processing[$termId])) return;
            $processing[$termId] = true;
            if (self::$processing['terms'][$termId]) return;
         self::$processing['terms'][$termId] = true;

            update_term_meta($termId, BASE . 'date_modified', date('Y-m-d H:i:s'));

            unset($processing[$termId]);
            unset(self::$processing['terms'][$termId]);
      }

   public function renderContent(string $content, array $block):string
   {
      if (!is_page($this->page)) {
@@ -970,9 +1079,6 @@
      if ($block['blockName'] !== 'core/post-content') {
         return $content;
      }
      if (JVB_TESTING) {
         Cache::for($this->slug)->flush();
      }

        $per_page = 10;
        $page = $_GET['tp']??1;
@@ -989,7 +1095,7 @@
         'order'     => 'desc',
        ]);

        $cache = Cache::for($this->slug)->connect('taxonomy');
        $cache = Cache::for($this->slug, 'term');
      $max = $cache->remember(
         'max',
         function () {
@@ -1031,7 +1137,7 @@


      $out = $nav. Cache::for($this->slug)->remember(
         $cache->generateKey(['type' =>'contentArchive', ... $args]),
         ['type' =>'contentArchive', ... $args],
         function() use ($args) {


@@ -1104,8 +1210,8 @@
   public static function ensureInstanced():void
   {
      if (empty(self::$instances)) {
         do_action('jvbDefineRegistrar');
         do_action('jvbDefineRegistrarFields');
         do_action('jvb_define_registrar');
         do_action('jvb_define_fields');
      }
   }

@@ -1128,8 +1234,16 @@

      $this->profile = $slug;

      return Registrar::forPost($slug, $singular, $plural);
      $reg = Registrar::forPost($slug, $singular, $plural);
      $reg->setProfile();

      return $reg;
   }

      public function setProfile():void
      {
         $this->is_profile = true;
      }
   public function getProfile():self|false
   {
      if (!$this->profile_link) {
@@ -1150,6 +1264,15 @@
        }, $hasProfiles));
    }

   public function setAsFoodMenu():void
   {
      $this->is_food_menu = true;
   }
      public static function getFoodMenuTypes():array
      {
         return array_map('jvbCheckBase', self::withFeature('is_food_menu'));
      }

   public function setUserSubtype(string $type):self
   {
      $this->user_subtype = sanitize_text_field($type);
@@ -1225,4 +1348,51 @@

      return [$images,$fields];
   }

   public function setHasIntegrations(bool $has = true):void
   {
      $this->hasIntegrations = $has;
   }

   public function isOwnable():bool
   {
      return $this->is_ownable??false;
   }

   public function umamiEvent(string $event):void
   {
      $this->umami_event = str_replace('-', '_', sanitize_title($event));
   }
   public function getUmamiEvent():string
   {
      return $this->umami_event??$this->getDefaultUmamiType();
   }
      protected function getDefaultUmamiType():string
      {
         return match($this->type) {
            'post'   => $this->getDefaultPostUmamiType(),
            'term'   => $this->getDefaultTermUmamiType(),
            'user'   => $this->getDefaultUserUmamiType(),
            default => ''
         };
      }
         protected function getDefaultPostUmamiType():string
         {
            if ($this->is_profile) {
               return 'view_profile';
            }
            return 'view_content';
         }
         protected function getDefaultTermUmamiType():string
         {
            if ($this->is_content) {
               return 'view_collective';
            }
            return 'view_term';
         }
         protected function getDefaultUserUmamiType():string
         {

            return 'view_user';
         }
}