Jake Vanderwerf
2026-02-04 2127b1bdd73ecd2423e443992da4b442f5a3c1a3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
<?php
namespace JVBase\registry;
 
if (!defined('ABSPATH')) {
    exit;
}
 
use JVBase\managers\RoleManager;
use JVBase\meta\Registry;
use JVBase\rest\RegisterRoutes;
 
class ContentRegistry
{
    private FieldRegistry $fieldRegistry;
    private bool $initialized = false;
 
 
    public function __construct()
    {
        $this->fieldRegistry = FieldRegistry::getInstance();
 
        // Hook registration at different priorities for proper sequencing
        add_action('init', [$this, 'registerAll'], 5);
 
//      add_action('init', [$this, 'registerMetaFields'], 10);
//      add_action('rest_api_init', [$this, 'registerRestRoutes'], 10);
    }
 
    /**
     * Handle plugin activation
     */
    public function onActivation(): void
    {
        // Initialize field registry early
        $this->fieldRegistry->initializeFields();
 
        // Register post types and taxonomies immediately for activation
        $this->registerPostTypes();
        $this->registerTaxonomies();
        $this->registerUserRoles();
 
        // Flush rewrite rules after registration
        flush_rewrite_rules();
    }
 
    /**
     * Register all content types
     */
    public function registerAll(): void
    {
//      if ($this->initialized) {
//          return;
//      }
 
        $this->registerPostTypes();
        $this->registerTaxonomies();
 
//      $this->initialized = true;
    }
 
    /**
     * Register meta fields for all types
     */
    public function registerMetaFields(): void
    {
        if ($this->initialized) {
            return;
        }
        // Register post type fields
        foreach (JVB_CONTENT as $slug => $config) {
 
            if (!empty($config['fields'])) {
                $fields = $this->fieldRegistry->getFields($slug, 'post');
                $this->registerFieldsForType(BASE . $slug, $fields, 'post');
            }
        }
 
        // Register taxonomy fields
        foreach (JVB_TAXONOMY as $slug => $config) {
            if (!empty($config['fields'])) {
                $fields = $this->fieldRegistry->getFields($slug, 'term');
                $this->registerFieldsForType(BASE . $slug, $fields, 'term');
            }
        }
 
        // Register user fields
        foreach (JVB_USER as $slug => $config) {
            if (!empty($config['settings']) || !empty($config['admin'])) {
                $fields = $this->fieldRegistry->getFields($slug, 'user');
                $this->registerFieldsForType(BASE . $slug, $fields, 'user');
            }
        }
        $this->intialized = true;
    }
 
    /**
     * Register fields for a specific type
     */
    private function registerFieldsForType(string $type, array $fields, string $object_type): void
    {
        if (empty($fields)) {
            return;
        }
 
        $meta_registry = new Registry($fields, $type, $object_type);
        $meta_registry->registerMetaFields();
    }
 
    /**
     * Register post types
     */
    private function registerPostTypes(): void
    {
        foreach (JVB_CONTENT as $slug => $config) {
            $registrar = new PostTypeRegistrar($slug, $config);
            $registrar->register();
 
            // Set up calendar functionality if needed
            if ($config['is_calendar'] ?? false) {
                new MakeCalendarType($slug, $config['rewrite']['slug']??$slug);
            }
        }
    }
 
    /**
     * Register taxonomies
     */
    private function registerTaxonomies(): void
    {
        foreach (JVB_TAXONOMY as $slug => $config) {
            $registrar = new TaxonomyRegistrar($slug, $config);
            $registrar->register();
        }
    }
 
    /**
     * Register user roles
     */
    public function registerUserRoles(): void
    {
        $registrar = new RoleManager();
        error_log('Registering User Roles');
        $registrar->activate();
    }
 
    /**
     * Register options
     */
    private function registerOptions(): void
    {
        if (empty(JVB_OPTIONS)) {
            return;
        }
 
        $fields = $this->fieldRegistry->getFields('options', 'options');
 
        if (!empty($fields)) {
            new OptionsRegistry($fields);
        }
    }
}
 
new ContentRegistry();