Jake Vanderwerf
2025-10-18 b0194e10a87e16797a568d8a30d53ebecd27d8a4
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
<?php
namespace JVBase\registry;
 
if (!defined('ABSPATH')) {
    exit;
}
 
use JVBase\managers\RoleManager;
use JVBase\meta\MetaRegistry;
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 MetaRegistry($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);
        }
    }
 
    /**
     * Register REST routes
     */
    public function registerRestRoutes(): void
    {
        // Register routes for post types
        foreach (JVB_CONTENT as $slug => $config) {
            $this->registerRoute($slug, $config);
        }
 
        // Register routes for content taxonomies
        foreach (JVB_TAXONOMY as $slug => $config) {
            if (jvbCheck('is_content', $config)) {
                $this->registerRoute($slug, $config, 'content_tax');
            }
        }
 
        // Register routes for options
        if (!empty(JVB_OPTIONS)) {
            $this->registerRoute('options', JVB_OPTIONS['fields'], 'options');
        }
    }
 
    /**
     * Register a single route
     */
    protected function registerRoute(string $slug, array $config, string $type = ''): void
    {
        JVB()->addRoute($slug, new RegisterRoutes($slug, $config));
    }
}
 
new ContentRegistry();