| @@ -1,350 +1,333 @@ | ||
| 1 | 1 | <?php |
| 2 | 2 | |
| 3 | 3 | namespace Boxzilla; |
| 4 | 4 | |
| 5 | -class BoxLoader | |
| 6 | -{ | |
| 7 | - /** | |
| 8 | - * @var Plugin | |
| 9 | - */ | |
| 10 | - private $plugin; | |
| 5 | +class BoxLoader { | |
| 11 | 6 | |
| 12 | - /** | |
| 13 | - * @var array | |
| 14 | - */ | |
| 15 | - private $box_ids_to_load = []; | |
| 16 | 7 | |
| 17 | - /** | |
| 18 | - * @var array | |
| 19 | - */ | |
| 20 | - protected $options; | |
| 8 | + /** | |
| 9 | + * @var Plugin | |
| 10 | + */ | |
| 11 | + private $plugin; | |
| 21 | 12 | |
| 22 | - /** | |
| 23 | - * Constructor | |
| 24 | - * | |
| 25 | - * @param Plugin $plugin | |
| 26 | - * @param array $options | |
| 27 | - */ | |
| 28 | - public function __construct(Plugin $plugin, array $options) | |
| 29 | - { | |
| 30 | - $this->plugin = $plugin; | |
| 31 | - $this->options = $options; | |
| 32 | - } | |
| 13 | + /** | |
| 14 | + * @var array | |
| 15 | + */ | |
| 16 | + private $box_ids_to_load = array(); | |
| 33 | 17 | |
| 34 | - /** | |
| 35 | - * Initializes the plugin, runs on `wp` hook. | |
| 36 | - */ | |
| 37 | - public function init() | |
| 38 | - { | |
| 39 | - $this->box_ids_to_load = $this->filter_boxes(); | |
| 18 | + /** | |
| 19 | + * @var array | |
| 20 | + */ | |
| 21 | + protected $options; | |
| 40 | 22 | |
| 41 | - // Only add other hooks if necessary | |
| 42 | - add_action('wp_head', [$this, 'print_preload_js']); | |
| 43 | - if (count($this->box_ids_to_load) > 0) { | |
| 44 | - add_action('wp_footer', [ $this, 'print_boxes_content' ], 1); | |
| 45 | - add_action('wp_enqueue_scripts', [ $this, 'load_assets' ], 90); | |
| 46 | - } | |
| 47 | - } | |
| 23 | + /** | |
| 24 | + * Constructor | |
| 25 | + * | |
| 26 | + * @param Plugin $plugin | |
| 27 | + * @param array $options | |
| 28 | + */ | |
| 29 | + public function __construct( Plugin $plugin, array $options ) { | |
| 30 | + $this->plugin = $plugin; | |
| 31 | + $this->options = $options; | |
| 32 | + } | |
| 48 | 33 | |
| 49 | - /** | |
| 50 | - * Prints the preload API so that the Boxzilla JS API can be used before Boxzilla itself is loaded | |
| 51 | - * This allows us to defer the Boxzilla script itself. | |
| 52 | - */ | |
| 53 | - public function print_preload_js() | |
| 54 | - { | |
| 55 | - echo '<script>'; | |
| 56 | - echo file_get_contents(BOXZILLA_DIR . '/assets/js/preload.js'); | |
| 57 | - echo '</script>'; | |
| 58 | - } | |
| 34 | + /** | |
| 35 | + * Initializes the plugin, runs on `wp` hook. | |
| 36 | + */ | |
| 37 | + public function init() { | |
| 38 | + $this->box_ids_to_load = $this->filter_boxes(); | |
| 59 | 39 | |
| 60 | - /** | |
| 61 | - * Get global rules for all boxes | |
| 62 | - * | |
| 63 | - * @return array | |
| 64 | - */ | |
| 65 | - protected function get_filter_rules() | |
| 66 | - { | |
| 67 | - $rules = get_option('boxzilla_rules', []); | |
| 68 | - return is_array($rules) ? $rules : []; | |
| 69 | - } | |
| 40 | + // Only add other hooks if necessary | |
| 41 | + if ( count( $this->box_ids_to_load ) > 0 ) { | |
| 42 | + add_action( 'wp_footer', array( $this, 'print_boxes_content' ), 1 ); | |
| 43 | + add_action( 'wp_enqueue_scripts', array( $this, 'load_assets' ), 90 ); | |
| 44 | + } | |
| 45 | + } | |
| 70 | 46 | |
| 47 | + /** | |
| 48 | + * Get global rules for all boxes | |
| 49 | + * | |
| 50 | + * @return array | |
| 51 | + */ | |
| 52 | + protected function get_filter_rules() { | |
| 53 | + $rules = get_option( 'boxzilla_rules', array() ); | |
| 71 | 54 | |
| 72 | - /** | |
| 73 | - * Match a string against an array of patterns, glob-style. | |
| 74 | - * | |
| 75 | - * @param string $string | |
| 76 | - * @param array $patterns | |
| 77 | - * @param boolean $contains | |
| 78 | - * @return boolean | |
| 79 | - */ | |
| 80 | - protected function match_patterns($string, array $patterns, $contains = false) | |
| 81 | - { | |
| 82 | - $string = strtolower($string); | |
| 55 | + if ( ! is_array( $rules ) ) { | |
| 56 | + return array(); | |
| 57 | + } | |
| 83 | 58 | |
| 84 | - foreach ($patterns as $pattern) { | |
| 85 | - $pattern = rtrim($pattern, '/'); | |
| 86 | - $pattern = strtolower($pattern); | |
| 59 | + return $rules; | |
| 60 | + } | |
| 87 | 61 | |
| 88 | - if ($contains) { | |
| 89 | - // contains means we should do a simple occurrence check | |
| 90 | - // does not support wildcards | |
| 91 | - $match = strpos($string, $pattern) !== false; | |
| 92 | - } elseif (function_exists('fnmatch')) { | |
| 93 | - $match = fnmatch($pattern, $string); | |
| 94 | - } else { | |
| 95 | - $match = ( $pattern === $string ); | |
| 96 | - } | |
| 97 | 62 | |
| 98 | - if ($match) { | |
| 99 | - return true; | |
| 100 | - } | |
| 101 | - } | |
| 63 | + /** | |
| 64 | + * Match a string against an array of patterns, glob-style. | |
| 65 | + * | |
| 66 | + * @param string $string | |
| 67 | + * @param array $patterns | |
| 68 | + * @param boolean $contains | |
| 69 | + * @return boolean | |
| 70 | + */ | |
| 71 | + protected function match_patterns( $string, array $patterns, $contains = false ) { | |
| 72 | + $string = strtolower( $string ); | |
| 102 | 73 | |
| 103 | - return false; | |
| 104 | - } | |
| 74 | + foreach ( $patterns as $pattern ) { | |
| 75 | + $pattern = rtrim( $pattern, '/' ); | |
| 76 | + $pattern = strtolower( $pattern ); | |
| 105 | 77 | |
| 106 | - /** | |
| 107 | - * @return string | |
| 108 | - */ | |
| 109 | - protected function get_request_url() | |
| 110 | - { | |
| 111 | - return rtrim($_SERVER['REQUEST_URI'], '/'); | |
| 112 | - } | |
| 78 | + if ( $contains ) { | |
| 79 | + // contains means we should do a simple occurrence check | |
| 80 | + // does not support wildcards | |
| 81 | + $match = strpos( $string, $pattern ) !== false; | |
| 82 | + } else if ( function_exists( 'fnmatch' ) ) { | |
| 83 | + $match = fnmatch( $pattern, $string ); | |
| 84 | + } else { | |
| 85 | + $match = ( $pattern === $string ); | |
| 86 | + } | |
| 113 | 87 | |
| 114 | - /** | |
| 115 | - * Check if this rule passes (conditional matches expected value) | |
| 116 | - * | |
| 117 | - * @param string $condition | |
| 118 | - * @param string $value | |
| 119 | - * @param boolean $qualifier | |
| 120 | - * | |
| 121 | - * @return bool | |
| 122 | - */ | |
| 123 | - protected function match_rule($condition, $value, $qualifier = true) | |
| 124 | - { | |
| 125 | - $matched = false; | |
| 88 | + if ( $match ) { | |
| 89 | + return true; | |
| 90 | + } | |
| 91 | + } | |
| 126 | 92 | |
| 127 | - // cast value to array & trim whitespace or excess comma's | |
| 128 | - $values = array_map('trim', explode(',', rtrim(trim($value), ','))); | |
| 93 | + return false; | |
| 94 | + } | |
| 129 | 95 | |
| 130 | - switch ($condition) { | |
| 131 | - case 'everywhere': | |
| 132 | - $matched = true; | |
| 133 | - break; | |
| 96 | + /** | |
| 97 | + * @return string | |
| 98 | + */ | |
| 99 | + protected function get_request_url() { | |
| 100 | + return rtrim( $_SERVER['REQUEST_URI'], '/' ); | |
| 101 | + } | |
| 134 | 102 | |
| 135 | - case 'is_url': | |
| 136 | - $url = $this->get_request_url(); | |
| 137 | - $matched = $this->match_patterns($url, $values, $qualifier === 'contains' || $qualifier === 'not_contains'); | |
| 138 | - break; | |
| 103 | + /** | |
| 104 | + * Check if this rule passes (conditional matches expected value) | |
| 105 | + * | |
| 106 | + * @param string $condition | |
| 107 | + * @param string $value | |
| 108 | + * @param boolean $qualifier | |
| 109 | + * | |
| 110 | + * @return bool | |
| 111 | + */ | |
| 112 | + protected function match_rule( $condition, $value, $qualifier = true ) { | |
| 113 | + $matched = false; | |
| 139 | 114 | |
| 140 | - case 'is_referer': | |
| 141 | - if (! empty($_SERVER['HTTP_REFERER'])) { | |
| 142 | - $referer = $_SERVER['HTTP_REFERER']; | |
| 143 | - $matched = $this->match_patterns($referer, $values, $qualifier === 'contains' || $qualifier === 'not_contains'); | |
| 144 | - } | |
| 145 | - break; | |
| 115 | + // cast value to array & trim whitespace or excess comma's | |
| 116 | + $values = array_map( 'trim', explode( ',', rtrim( trim( $value ), ',' ) ) ); | |
| 146 | 117 | |
| 147 | - case 'is_post_type': | |
| 148 | - $post_type = (string) get_post_type(); | |
| 149 | - $matched = in_array($post_type, $values, true); | |
| 150 | - break; | |
| 118 | + switch ( $condition ) { | |
| 119 | + case 'everywhere': | |
| 120 | + $matched = true; | |
| 121 | + break; | |
| 151 | 122 | |
| 152 | - case 'is_single': | |
| 153 | - case 'is_post': | |
| 154 | - // convert to empty string if array with just empty string in it | |
| 155 | - $value = ( $values === [ '' ] ) ? '' : $values; | |
| 156 | - $matched = is_single($value); | |
| 157 | - break; | |
| 123 | + case 'is_url': | |
| 124 | + $url = $this->get_request_url(); | |
| 125 | + $matched = $this->match_patterns( $url, $values, $qualifier === 'contains' || $qualifier === 'not_contains' ); | |
| 126 | + break; | |
| 158 | 127 | |
| 159 | - case 'is_post_in_category': | |
| 160 | - $matched = is_singular() && has_category($values); | |
| 161 | - break; | |
| 128 | + case 'is_referer': | |
| 129 | + if ( ! empty( $_SERVER['HTTP_REFERER'] ) ) { | |
| 130 | + $referer = $_SERVER['HTTP_REFERER']; | |
| 131 | + $matched = $this->match_patterns( $referer, $values, $qualifier === 'contains' || $qualifier === 'not_contains' ); | |
| 132 | + } | |
| 133 | + break; | |
| 162 | 134 | |
| 163 | - case 'is_page': | |
| 164 | - $matched = is_page($values); | |
| 165 | - break; | |
| 135 | + case 'is_post_type': | |
| 136 | + $post_type = (string) get_post_type(); | |
| 137 | + $matched = in_array( $post_type, $values, true ); | |
| 138 | + break; | |
| 166 | 139 | |
| 167 | - case 'is_post_with_tag': | |
| 168 | - $matched = is_singular() && has_tag($values); | |
| 169 | - break; | |
| 140 | + case 'is_single': | |
| 141 | + case 'is_post': | |
| 142 | + // convert to empty string if array with just empty string in it | |
| 143 | + $value = ( $values === array( '' ) ) ? '' : $values; | |
| 144 | + $matched = is_single( $value ); | |
| 145 | + break; | |
| 170 | 146 | |
| 171 | - case 'is_user_logged_in': | |
| 172 | - $matched = is_user_logged_in(); | |
| 173 | - break; | |
| 174 | - } | |
| 147 | + case 'is_post_in_category': | |
| 148 | + $matched = is_singular() && has_category( $values ); | |
| 149 | + break; | |
| 175 | 150 | |
| 176 | - /** | |
| 177 | - * Filters whether a given box rule matches the condition and expected value. | |
| 178 | - * | |
| 179 | - * The dynamic portion of the hook, `$condition`, refers to the condition being matched. | |
| 180 | - * | |
| 181 | - * @param boolean $matched | |
| 182 | - * @param array $values | |
| 183 | - */ | |
| 184 | - $matched = apply_filters('boxzilla_box_rule_matches_' . $condition, $matched, $values); | |
| 151 | + case 'is_page': | |
| 152 | + $matched = is_page( $values ); | |
| 153 | + break; | |
| 185 | 154 | |
| 186 | - // if qualifier is set to false, we need to reverse this value here. | |
| 187 | - if (! $qualifier || $qualifier === 'not_contains') { | |
| 188 | - $matched = ! $matched; | |
| 189 | - } | |
| 155 | + case 'is_post_with_tag': | |
| 156 | + $matched = is_singular() && has_tag( $values ); | |
| 157 | + break; | |
| 190 | 158 | |
| 191 | - return $matched; | |
| 192 | - } | |
| 159 | + case 'is_user_logged_in': | |
| 160 | + $matched = is_user_logged_in(); | |
| 161 | + break; | |
| 162 | + } | |
| 193 | 163 | |
| 194 | - /** | |
| 195 | - * Checks which boxes should be loaded for this request. | |
| 196 | - * | |
| 197 | - * @return array | |
| 198 | - */ | |
| 199 | - private function filter_boxes() | |
| 200 | - { | |
| 201 | - $box_ids_to_load = []; | |
| 202 | - $rules = $this->get_filter_rules(); | |
| 164 | + /** | |
| 165 | + * Filters whether a given box rule matches the condition and expected value. | |
| 166 | + * | |
| 167 | + * The dynamic portion of the hook, `$condition`, refers to the condition being matched. | |
| 168 | + * | |
| 169 | + * @param boolean $matched | |
| 170 | + * @param array $values | |
| 171 | + */ | |
| 172 | + $matched = apply_filters( 'boxzilla_box_rule_matches_' . $condition, $matched, $values ); | |
| 203 | 173 | |
| 204 | - foreach ($rules as $box_id => $box_rules) { | |
| 205 | - $matched = false; | |
| 206 | - $comparision = isset($box_rules['comparision']) ? $box_rules['comparision'] : 'any'; | |
| 174 | + // if qualifier is set to false, we need to reverse this value here. | |
| 175 | + if ( ! $qualifier || $qualifier === 'not_contains' ) { | |
| 176 | + $matched = ! $matched; | |
| 177 | + } | |
| 207 | 178 | |
| 208 | - // loop through all rules for all boxes | |
| 209 | - foreach ($box_rules as $rule) { | |
| 210 | - // skip faulty values (and comparision rule) | |
| 211 | - if (empty($rule['condition'])) { | |
| 212 | - continue; | |
| 213 | - } | |
| 179 | + return $matched; | |
| 180 | + } | |
| 214 | 181 | |
| 215 | - $qualifier = isset($rule['qualifier']) ? $rule['qualifier'] : true; | |
| 216 | - $matched = $this->match_rule($rule['condition'], $rule['value'], $qualifier); | |
| 182 | + /** | |
| 183 | + * Checks which boxes should be loaded for this request. | |
| 184 | + * | |
| 185 | + * @return array | |
| 186 | + */ | |
| 187 | + private function filter_boxes() { | |
| 188 | + $box_ids_to_load = array(); | |
| 189 | + $rules = $this->get_filter_rules(); | |
| 217 | 190 | |
| 218 | - // break out of loop if we've already matched | |
| 219 | - if ($comparision === 'any' && $matched) { | |
| 220 | - break; | |
| 221 | - } | |
| 191 | + foreach ( $rules as $box_id => $box_rules ) { | |
| 192 | + $matched = false; | |
| 193 | + $comparision = isset( $box_rules['comparision'] ) ? $box_rules['comparision'] : 'any'; | |
| 222 | 194 | |
| 223 | - // no need to continue if this rule didn't match | |
| 224 | - if ($comparision === 'all' && ! $matched) { | |
| 225 | - break; | |
| 226 | - } | |
| 227 | - } | |
| 195 | + // loop through all rules for all boxes | |
| 196 | + foreach ( $box_rules as $rule ) { | |
| 228 | 197 | |
| 229 | - // value of $matched at this point determines whether box should be loaded | |
| 230 | - $load_box = $matched; | |
| 198 | + // skip faulty values (and comparision rule) | |
| 199 | + if ( empty( $rule['condition'] ) ) { | |
| 200 | + continue; | |
| 201 | + } | |
| 231 | 202 | |
| 232 | - /** | |
| 233 | - * Filters whether a box should be loaded into the page HTML. | |
| 234 | - * | |
| 235 | - * The dynamic portion of the hook, `$box_id`, refers to the ID of the box. Return true if you want to output the box. | |
| 236 | - * | |
| 237 | - * @param boolean $load_box | |
| 238 | - */ | |
| 239 | - $load_box = apply_filters('boxzilla_load_box_' . $box_id, $load_box); | |
| 203 | + $qualifier = isset( $rule['qualifier'] ) ? $rule['qualifier'] : true; | |
| 204 | + $matched = $this->match_rule( $rule['condition'], $rule['value'], $qualifier ); | |
| 240 | 205 | |
| 241 | - /** | |
| 242 | - * Filters whether a box should be loaded into the page HTML. | |
| 243 | - * | |
| 244 | - * @param boolean $load_box | |
| 245 | - * @param int $box_id | |
| 246 | - */ | |
| 247 | - $load_box = apply_filters('boxzilla_load_box', $load_box, $box_id); | |
| 206 | + // break out of loop if we've already matched | |
| 207 | + if ( $comparision === 'any' && $matched ) { | |
| 208 | + break; | |
| 209 | + } | |
| 248 | 210 | |
| 249 | - // if matched, box should be loaded on this page | |
| 250 | - if ($load_box) { | |
| 251 | - $box_ids_to_load[] = $box_id; | |
| 252 | - } | |
| 253 | - } | |
| 211 | + // no need to continue if this rule didn't match | |
| 212 | + if ( $comparision === 'all' && ! $matched ) { | |
| 213 | + break; | |
| 214 | + } | |
| 215 | + } | |
| 254 | 216 | |
| 255 | - /** | |
| 256 | - * Filters which boxes should be loaded on this page, expects an array of post ID's. | |
| 257 | - * | |
| 258 | - * @param array $box_ids_to_load | |
| 259 | - */ | |
| 260 | - return apply_filters('boxzilla_load_boxes', $box_ids_to_load); | |
| 261 | - } | |
| 217 | + // value of $matched at this point determines whether box should be loaded | |
| 218 | + $load_box = $matched; | |
| 262 | 219 | |
| 263 | - /** | |
| 264 | - * Load plugin styles | |
| 265 | - */ | |
| 266 | - public function load_assets() | |
| 267 | - { | |
| 268 | - wp_enqueue_style('boxzilla', $this->plugin->url('/assets/css/styles.css'), [], $this->plugin->version()); | |
| 269 | - wp_enqueue_script('boxzilla', $this->plugin->url('/assets/js/script.js'), [], $this->plugin->version(), [ | |
| 270 | - 'strategy' => 'defer', | |
| 271 | - 'in_footer' => true, | |
| 272 | - ]); | |
| 220 | + /** | |
| 221 | + * Filters whether a box should be loaded into the page HTML. | |
| 222 | + * | |
| 223 | + * The dynamic portion of the hook, `$box_id`, refers to the ID of the box. Return true if you want to output the box. | |
| 224 | + * | |
| 225 | + * @param boolean $load_box | |
| 226 | + */ | |
| 227 | + $load_box = apply_filters( 'boxzilla_load_box_' . $box_id, $load_box ); | |
| 273 | 228 | |
| 274 | - // create boxzilla_Global_Options object | |
| 275 | - $plugin_options = $this->options; | |
| 276 | - $boxes = $this->get_matched_boxes(); | |
| 229 | + /** | |
| 230 | + * Filters whether a box should be loaded into the page HTML. | |
| 231 | + * | |
| 232 | + * @param boolean $load_box | |
| 233 | + * @param int $box_id | |
| 234 | + */ | |
| 235 | + $load_box = apply_filters( 'boxzilla_load_box', $load_box, $box_id ); | |
| 277 | 236 | |
| 278 | - $data = [ | |
| 279 | - 'testMode' => (bool) $plugin_options['test_mode'], | |
| 280 | - 'boxes' => (array) array_map( | |
| 281 | - function (Box $box) { | |
| 282 | - return $box->get_client_options(); | |
| 283 | - }, | |
| 284 | - $boxes | |
| 285 | - ), | |
| 286 | - ]; | |
| 237 | + // if matched, box should be loaded on this page | |
| 238 | + if ( $load_box ) { | |
| 239 | + $box_ids_to_load[] = $box_id; | |
| 240 | + } | |
| 241 | + } | |
| 287 | 242 | |
| 288 | - wp_localize_script('boxzilla', 'boxzilla_options', $data); | |
| 243 | + /** | |
| 244 | + * Filters which boxes should be loaded on this page, expects an array of post ID's. | |
| 245 | + * | |
| 246 | + * @param array $box_ids_to_load | |
| 247 | + */ | |
| 248 | + return apply_filters( 'boxzilla_load_boxes', $box_ids_to_load ); | |
| 249 | + } | |
| 289 | 250 | |
| 290 | - do_action('boxzilla_load_assets', $this); | |
| 291 | - } | |
| 251 | + /** | |
| 252 | + * Load plugin styles | |
| 253 | + */ | |
| 254 | + public function load_assets() { | |
| 255 | + $pre_suffix = defined( 'SCRIPT_DEBUG' ) && SCRIPT_DEBUG ? '' : '.min'; | |
| 256 | + wp_enqueue_script( 'boxzilla', $this->plugin->url( '/assets/js/script' . $pre_suffix . '.js' ), array(), $this->plugin->version(), true ); | |
| 292 | 257 | |
| 293 | - public function print_boxes_content() | |
| 294 | - { | |
| 295 | - $boxes = $this->get_matched_boxes(); | |
| 296 | - if (empty($boxes)) { | |
| 297 | - return; | |
| 298 | - } | |
| 258 | + // create boxzilla_Global_Options object | |
| 259 | + $plugin_options = $this->options; | |
| 260 | + $boxes = $this->get_matched_boxes(); | |
| 299 | 261 | |
| 300 | - echo '<div style="display: none;">'; | |
| 301 | - foreach ($boxes as $box) { | |
| 302 | - echo "<div id=\"boxzilla-box-{$box->ID}-content\">", $box->get_content(), "</div>"; | |
| 303 | - } | |
| 304 | - echo '</div>'; | |
| 305 | - } | |
| 262 | + $data = array( | |
| 263 | + 'testMode' => (bool) $plugin_options['test_mode'], | |
| 264 | + 'boxes' => (array) array_map( | |
| 265 | + function ( Box $box ) { | |
| 266 | + return $box->get_client_options(); | |
| 267 | + }, | |
| 268 | + $boxes | |
| 269 | + ), | |
| 270 | + ); | |
| 306 | 271 | |
| 307 | - /** | |
| 308 | - * Get an array of Box objects. These are the boxes that will be loaded for the current request. | |
| 309 | - * | |
| 310 | - * @return Box[] | |
| 311 | - */ | |
| 312 | - public function get_matched_boxes() | |
| 313 | - { | |
| 314 | - static $boxes; | |
| 272 | + wp_localize_script( 'boxzilla', 'boxzilla_options', $data ); | |
| 315 | 273 | |
| 316 | - if (is_null($boxes)) { | |
| 317 | - if (count($this->box_ids_to_load) === 0) { | |
| 318 | - return []; | |
| 319 | - } | |
| 274 | + do_action( 'boxzilla_load_assets', $this ); | |
| 275 | + } | |
| 320 | 276 | |
| 321 | - // query Box posts | |
| 322 | - $q = new \WP_Query(); | |
| 323 | - $posts = $q->query( | |
| 324 | - [ | |
| 325 | - 'post_type' => 'boxzilla-box', | |
| 326 | - 'post_status' => 'publish', | |
| 327 | - 'post__in' => $this->box_ids_to_load, | |
| 328 | - 'posts_per_page' => count($this->box_ids_to_load), | |
| 329 | - 'ignore_sticky_posts' => true, | |
| 330 | - 'no_found_rows' => true, | |
| 331 | - ] | |
| 332 | - ); | |
| 277 | + public function print_boxes_content() { | |
| 278 | + $boxes = $this->get_matched_boxes(); | |
| 279 | + if ( empty( $boxes ) ) { | |
| 280 | + return; | |
| 281 | + } | |
| 333 | 282 | |
| 334 | - // create `Box` instances out of \WP_Post instances | |
| 335 | - $boxes = []; | |
| 336 | - foreach ($posts as $key => $post) { | |
| 337 | - $box = new Box($post); | |
| 283 | + echo '<div style="display: none;">'; | |
| 284 | + foreach ( $boxes as $box ) { | |
| 285 | + echo sprintf( '<div id="boxzilla-box-%d-content">', $box->ID ) . $box->get_content() . '</div>'; | |
| 286 | + } | |
| 287 | + echo '</div>'; | |
| 288 | + } | |
| 338 | 289 | |
| 339 | - // skip boxes without any content | |
| 340 | - if ($box->get_content() === '') { | |
| 341 | - continue; | |
| 342 | - } | |
| 290 | + /** | |
| 291 | + * Get an array of Box objects. These are the boxes that will be loaded for the current request. | |
| 292 | + * | |
| 293 | + * @return Box[] | |
| 294 | + */ | |
| 295 | + public function get_matched_boxes() { | |
| 296 | + static $boxes; | |
| 343 | 297 | |
| 344 | - $boxes[ $key ] = $box; | |
| 345 | - } | |
| 346 | - } | |
| 298 | + if ( is_null( $boxes ) ) { | |
| 299 | + if ( count( $this->box_ids_to_load ) === 0 ) { | |
| 300 | + $boxes = array(); | |
| 301 | + return $boxes; | |
| 302 | + } | |
| 347 | 303 | |
| 348 | - return $boxes; | |
| 349 | - } | |
| 304 | + // query Box posts | |
| 305 | + $q = new \WP_Query(); | |
| 306 | + $posts = $q->query( | |
| 307 | + array( | |
| 308 | + 'post_type' => 'boxzilla-box', | |
| 309 | + 'post_status' => 'publish', | |
| 310 | + 'post__in' => $this->box_ids_to_load, | |
| 311 | + 'posts_per_page' => count( $this->box_ids_to_load ), | |
| 312 | + 'ignore_sticky_posts' => true, | |
| 313 | + 'no_found_rows' => true, | |
| 314 | + ) | |
| 315 | + ); | |
| 316 | + | |
| 317 | + // create `Box` instances out of \WP_Post instances | |
| 318 | + $boxes = array(); | |
| 319 | + foreach ( $posts as $key => $post ) { | |
| 320 | + $box = new Box( $post ); | |
| 321 | + | |
| 322 | + // skip boxes without any content | |
| 323 | + if ( $box->get_content() === '' ) { | |
| 324 | + continue; | |
| 325 | + } | |
| 326 | + | |
| 327 | + $boxes[ $key ] = $box; | |
| 328 | + } | |
| 329 | + } | |
| 330 | + | |
| 331 | + return $boxes; | |
| 332 | + } | |
| 350 | 333 | } |
