Source: components/class-router.php

  1. <?php
  2. /**
  3.  * Router component.
  4.  *
  5.  * @package HivePress\Components
  6.  */
  8. namespace HivePress\Components;
  10. use HivePress\Helpers as hp;
  12. // Exit if accessed directly.
  13. defined( 'ABSPATH' ) || exit;
  15. /**
  16.  * Handles URL routing.
  17.  */
  18. final class Router extends Component {
  20. 	/**
  21. 	 * All routes.
  22. 	 *
  23. 	 * @var array
  24. 	 */
  25. 	protected $routes = [];
  27. 	/**
  28. 	 * The current route.
  29. 	 *
  30. 	 * @var array
  31. 	 */
  32. 	protected $route;
  34. 	/**
  35. 	 * Class constructor.
  36. 	 *
  37. 	 * @param array $args Component arguments.
  38. 	 */
  39. 	public function __construct( $args = [] ) {
  41. 		// Register REST routes.
  42. 		add_action( 'rest_api_init', [ $this, 'register_rest_routes' ] );
  44. 		// Add rewrite rules.
  45. 		add_action( 'init', [ $this, 'add_rewrite_rules' ] );
  47. 		// Set rewrite slugs.
  48. 		add_filter( 'register_post_type_args', [ $this, 'set_rewrite_slug' ], 10, 2 );
  49. 		add_filter( 'register_taxonomy_args', [ $this, 'set_rewrite_slug' ], 10, 2 );
  51. 		// Flush rewrite rules.
  52. 		add_action( 'hivepress/v1/activate', [ $this, 'flush_rewrite_rules' ] );
  53. 		add_action( 'hivepress/v1/update', [ $this, 'flush_rewrite_rules' ] );
  54. 		add_action( 'hivepress/v1/deactivate', [ $this, 'flush_rewrite_rules' ] );
  56. 		if ( ! is_admin() ) {
  58. 			// Set page title.
  59. 			add_filter( 'document_title_parts', [ $this, 'set_page_title' ] );
  61. 			// Disable page title.
  62. 			add_filter( 'rank_math/frontend/title', [ $this, 'disable_page_title' ] );
  64. 			// Set page context.
  65. 			add_filter( 'hivepress/v1/templates/page', [ $this, 'set_page_context' ] );
  67. 			// Set page template.
  68. 			add_filter( 'template_include', [ $this, 'set_page_template' ], 10000 );
  70. 			// Disable page redirect.
  71. 			add_filter( 'redirect_canonical', [ $this, 'disable_page_redirect' ] );
  72. 		}
  74. 		parent::__construct( $args );
  75. 	}
  77. 	/**
  78. 	 * Gets routes.
  79. 	 *
  80. 	 * @return array
  81. 	 */
  82. 	protected function get_routes() {
  83. 		if ( empty( $this->routes ) ) {
  85. 			// Merge routes.
  86. 			foreach ( hivepress()->get_controllers() as $controller ) {
  87. 				$this->routes = hp\merge_arrays( $this->routes, $controller->get_routes() );
  88. 			}
  90. 			/**
  91. 			 * Filters URL routes registered by HivePress. If you customize the route URLs using this hook, don't forget to refresh permalinks afterwards.
  92. 			 *
  93. 			 * @hook hivepress/v1/routes
  94. 			 * @param {array} $routes Route configurations.
  95. 			 * @return {array} Route configurations.
  96. 			 */
  97. 			$this->routes = apply_filters( 'hivepress/v1/routes', $this->routes );
  98. 		}
  100. 		return $this->routes;
  101. 	}
  103. 	/**
  104. 	 * Gets route.
  105. 	 *
  106. 	 * @param string $name Route name.
  107. 	 * @return array
  108. 	 */
  109. 	public function get_route( $name ) {
  110. 		return hp\get_array_value( $this->get_routes(), $name );
  111. 	}
  113. 	/**
  114. 	 * Gets the current route.
  115. 	 *
  116. 	 * @return array
  117. 	 */
  118. 	public function get_current_route() {
  119. 		if ( ! isset( $this->route ) ) {
  120. 			$this->route = false;
  122. 			if ( hivepress()->request->get_param( 'route' ) ) {
  124. 				// Get route name.
  125. 				$name = hivepress()->request->get_param( 'route' );
  127. 				// Get route.
  128. 				$route = $this->get_route( $name );
  130. 				if ( $route && ! hp\get_array_value( $route, 'rest' ) ) {
  131. 					$this->route = array_merge( $route, [ 'name' => $name ] );
  132. 				}
  133. 			} else {
  135. 				// Match routes.
  136. 				foreach ( $this->get_routes() as $name => $route ) {
  137. 					if ( isset( $route['match'] ) && call_user_func( $route['match'] ) ) {
  138. 						$this->route = array_merge( $route, [ 'name' => $name ] );
  140. 						break;
  141. 					}
  142. 				}
  143. 			}
  144. 		}
  146. 		return $this->route;
  147. 	}
  149. 	/**
  150. 	 * Gets the current route name.
  151. 	 *
  152. 	 * @return string
  153. 	 */
  154. 	public function get_current_route_name() {
  155. 		return hp\get_array_value( $this->get_current_route(), 'name' );
  156. 	}
  158. 	/**
  159. 	 * Gets URL path.
  160. 	 *
  161. 	 * @param string $name Route name.
  162. 	 * @return string
  163. 	 */
  164. 	protected function get_url_path( $name ) {
  165. 		$path = '';
  167. 		// Get route.
  168. 		$route = $this->get_route( $name );
  170. 		// Merge paths.
  171. 		while ( $route ) {
  172. 			if ( isset( $route['path'] ) ) {
  173. 				$path = $route['path'] . $path;
  174. 			}
  176. 			if ( isset( $route['base'] ) ) {
  177. 				$route = $this->get_route( $route['base'] );
  178. 			} else {
  179. 				break;
  180. 			}
  181. 		}
  183. 		return $path;
  184. 	}
  186. 	/**
  187. 	 * Gets URL parameters.
  188. 	 *
  189. 	 * @param string $name Route name.
  190. 	 * @return array
  191. 	 */
  192. 	protected function get_url_params( $name ) {
  193. 		preg_match_all( '/<([a-z_]+)>/', $this->get_url_path( $name ), $params );
  195. 		array_shift( $params );
  197. 		return hp\get_first_array_value( $params );
  198. 	}
  200. 	/**
  201. 	 * Gets route URL.
  202. 	 *
  203. 	 * @param string $name Route name.
  204. 	 * @param array  $query URL query.
  205. 	 * @param bool   $filter Remove custom query parameters?
  206. 	 * @return string
  207. 	 */
  208. 	public function get_url( $name, $query = [], $filter = false ) {
  209. 		$url = '';
  211. 		// Get route.
  212. 		$route = $this->get_route( $name );
  214. 		if ( $route ) {
  215. 			if ( isset( $route['url'] ) ) {
  217. 				// Set URL.
  218. 				$url = call_user_func( $route['url'], $query );
  219. 			} else {
  221. 				// Get URL path.
  222. 				$path = $this->get_url_path( $name );
  224. 				if ( $path ) {
  226. 					// Get URL params.
  227. 					$params = $this->get_url_params( $name );
  229. 					// Get query variables.
  230. 					$vars = array_diff_key( $query, array_flip( $params ) );
  232. 					// Set URL query.
  233. 					$query = array_merge(
  234. 						array_fill_keys( $params, null ),
  235. 						array_diff_key( $query, $vars ),
  236. 						[
  237. 							'route' => $name,
  238. 						]
  239. 					);
  241. 					// Set URL path.
  242. 					if ( get_option( 'permalink_structure' ) || hp\get_array_value( $route, 'rest' ) ) {
  243. 						foreach ( $params as $param ) {
  244. 							$path = preg_replace( '/\(\?P<' . preg_quote( $param, '/' ) . '>[^\)]+\)\??/', hp\get_array_value( $query, $param, '' ), $path );
  245. 						}
  247. 						$path = rtrim( str_replace( '/?', '/', $path ), '/' ) . '/';
  248. 					} else {
  249. 						$path = '/?' . http_build_query( array_combine( hp\prefix( array_keys( $query ) ), $query ) );
  250. 					}
  252. 					// Set URL.
  253. 					if ( hp\get_array_value( $route, 'rest' ) ) {
  254. 						$url = get_rest_url( null, 'hivepress/v1' . $path );
  255. 					} else {
  256. 						$url = home_url( $path );
  257. 					}
  259. 					// Add query variables.
  260. 					if ( $vars && ! $filter ) {
  261. 						$url = add_query_arg( array_map( 'rawurlencode', array_map( 'strval', $vars ) ), $url );
  262. 					}
  263. 				}
  264. 			}
  265. 		}
  267. 		return $url;
  268. 	}
  270. 	/**
  271. 	 * Gets the current URL.
  272. 	 *
  273. 	 * @return string
  274. 	 */
  275. 	public function get_current_url() {
  276. 		global $wp;
  278. 		$path = rtrim( $wp->request, '/' ) . '/';
  280. 		if ( $_GET ) {
  281. 			$path .= '?' . http_build_query( $_GET );
  282. 		}
  284. 		return home_url( $path );
  285. 	}
  287. 	/**
  288. 	 * Gets return URL.
  289. 	 *
  290. 	 * @param string $name Route name.
  291. 	 * @param array  $query URL query.
  292. 	 * @return string
  293. 	 */
  294. 	public function get_return_url( $name, $query = [] ) {
  295. 		return $this->get_url(
  296. 			$name,
  297. 			array_merge(
  298. 				$query,
  299. 				[
  300. 					'redirect' => $this->get_current_url(),
  301. 				]
  302. 			)
  303. 		);
  304. 	}
  306. 	/**
  307. 	 * Gets admin URL.
  308. 	 *
  309. 	 * @param string $type Object type.
  310. 	 * @param int    $id Object ID.
  311. 	 * @return string
  312. 	 */
  313. 	public function get_admin_url( $type, $id ) {
  314. 		$path = '';
  315. 		$args = [];
  317. 		switch ( $type ) {
  318. 			case 'user':
  319. 				$path = $type . '-edit.php';
  320. 				$args = [
  321. 					'user_id' => $id,
  322. 				];
  324. 				break;
  326. 			case 'post':
  327. 				$path = $type . '.php';
  328. 				$args = [
  329. 					'action' => 'edit',
  330. 					'post'   => $id,
  331. 				];
  333. 				break;
  335. 			case 'comment':
  336. 				$path = $type . '.php';
  337. 				$args = [
  338. 					'action' => 'editcomment',
  339. 					'c'      => $id,
  340. 				];
  342. 				break;
  343. 		}
  345. 		return admin_url( $path . '?' . http_build_query( $args ) );
  346. 	}
  348. 	/**
  349. 	 * Gets redirect URL.
  350. 	 *
  351. 	 * @return string
  352. 	 */
  353. 	public function get_redirect_url() {
  354. 		return wp_validate_redirect( (string) hp\get_array_value( $_GET, 'redirect' ) );
  355. 	}
  357. 	/**
  358. 	 * Gets redirect callbacks.
  359. 	 *
  360. 	 * @param array $callbacks Callback arguments.
  361. 	 * @return array
  362. 	 */
  363. 	protected function get_redirect_callbacks( $callbacks ) {
  365. 		// Normalize callbacks.
  366. 		if ( count( $callbacks ) === 2 && is_object( hp\get_first_array_value( $callbacks ) ) ) {
  367. 			$callbacks = [
  368. 				[
  369. 					'callback' => $callbacks,
  370. 					'_order'   => 5,
  371. 				],
  372. 			];
  373. 		}
  375. 		// Sort callbacks.
  376. 		$callbacks = array_filter(
  377. 			array_map(
  378. 				function ( $args ) {
  379. 					return hp\get_array_value( $args, 'callback' );
  380. 				},
  381. 				hp\sort_array( $callbacks )
  382. 			)
  383. 		);
  385. 		return $callbacks;
  386. 	}
  388. 	/**
  389. 	 * Registers REST routes.
  390. 	 */
  391. 	public function register_rest_routes() {
  392. 		foreach ( $this->get_routes() as $name => $route ) {
  393. 			if ( hp\get_array_value( $route, 'rest' ) && isset( $route['action'] ) ) {
  394. 				register_rest_route(
  395. 					'hivepress/v1',
  396. 					$this->get_url_path( $name ),
  397. 					[
  398. 						'methods'             => hp\get_array_value( $route, 'method', 'GET' ),
  399. 						'callback'            => $route['action'],
  400. 						'permission_callback' => '__return_true',
  401. 					]
  402. 				);
  403. 			}
  404. 		}
  405. 	}
  407. 	/**
  408. 	 * Adds rewrite rules.
  409. 	 */
  410. 	public function add_rewrite_rules() {
  412. 		// Set rewrite tags.
  413. 		$tags = [ 'route' ];
  415. 		foreach ( $this->get_routes() as $name => $route ) {
  416. 			if ( ! hp\get_array_value( $route, 'rest' ) && isset( $route['path'] ) && ( isset( $route['redirect'] ) || isset( $route['action'] ) ) ) {
  418. 				// Get URL path.
  419. 				$path = ltrim( $this->get_url_path( $name ), '/' );
  421. 				// Get URL params.
  422. 				$params = $this->get_url_params( $name );
  424. 				// Get query string.
  425. 				$query = ltrim(
  426. 					implode(
  427. 						'&',
  428. 						array_map(
  429. 							function ( $index, $param ) {
  430. 								return hp\prefix( $param ) . '=$matches[' . ( $index + 1 ) . ']';
  431. 							},
  432. 							array_keys( $params ),
  433. 							$params
  434. 						)
  435. 					) . '&hp_route=' . rawurlencode( $name ),
  436. 					'&'
  437. 				);
  439. 				// Add rewrite rules.
  440. 				add_rewrite_rule( '^' . $path . '/?$', 'index.php?' . $query, 'top' );
  442. 				if ( hp\get_array_value( $route, 'paginated' ) ) {
  443. 					add_rewrite_rule( '^' . $path . '/page/(\d+)/?$', 'index.php?paged=$matches[' . ( count( $params ) + 1 ) . ']&' . $query, 'top' );
  444. 				}
  446. 				// Add rewrite tags.
  447. 				$tags = array_merge( $tags, $params );
  448. 			}
  449. 		}
  451. 		// Add rewrite tags.
  452. 		foreach ( array_unique( $tags ) as $tag ) {
  453. 			add_rewrite_tag( '%' . hp\prefix( $tag ) . '%', '([^&]+)' );
  454. 		}
  455. 	}
  457. 	/**
  458. 	 * Sets rewrite slug.
  459. 	 *
  460. 	 * @param array  $args Default arguments.
  461. 	 * @param string $type Post type or taxonomy.
  462. 	 * @return array
  463. 	 */
  464. 	public function set_rewrite_slug( $args, $type ) {
  466. 		// Check arguments.
  467. 		if ( strpos( $type, 'hp_' ) !== 0 || ! hp\get_array_value( $args, 'public', true ) ) {
  468. 			return $args;
  469. 		}
  471. 		// Get permalinks.
  472. 		$permalinks = (array) get_option( 'hp_permalinks', [] );
  474. 		if ( ! $permalinks ) {
  475. 			return $args;
  476. 		}
  478. 		// Set rewrite slug.
  479. 		$slug = hp\get_array_value( $permalinks, hp\unprefix( $type . '_slug' ) );
  481. 		if ( $slug ) {
  482. 			$args['rewrite']['slug'] = $slug;
  483. 		}
  485. 		return $args;
  486. 	}
  488. 	/**
  489. 	 * Flushes rewrite rules.
  490. 	 */
  491. 	public function flush_rewrite_rules() {
  492. 		delete_option( 'rewrite_rules' );
  493. 	}
  495. 	/**
  496. 	 * Sets page title.
  497. 	 *
  498. 	 * @param array $parts Title parts.
  499. 	 * @return array
  500. 	 */
  501. 	public function set_page_title( $parts ) {
  503. 		// Get the current route.
  504. 		$route = $this->get_current_route();
  506. 		if ( $route && isset( $route['title'] ) ) {
  508. 			// Remove query title.
  509. 			if ( count( $parts ) > 1 ) {
  510. 				array_shift( $parts );
  511. 			}
  513. 			// Add route title.
  514. 			array_unshift( $parts, $route['title'] );
  515. 		}
  517. 		return $parts;
  518. 	}
  520. 	/**
  521. 	 * Disables page title.
  522. 	 *
  523. 	 * @param string $title Page title.
  524. 	 * @return string
  525. 	 */
  526. 	public function disable_page_title( $title ) {
  527. 		if ( hp\get_array_value( hivepress()->router->get_current_route(), 'title' ) ) {
  528. 			return false;
  529. 		}
  531. 		return $title;
  532. 	}
  534. 	/**
  535. 	 * Sets page context.
  536. 	 *
  537. 	 * @param array $args Template arguments.
  538. 	 * @return array
  539. 	 */
  540. 	public function set_page_context( $args ) {
  541. 		$context = [];
  543. 		// Get title.
  544. 		$context['page_title'] = hp\get_array_value( $this->get_current_route(), 'title' );
  546. 		// @todo Remove theme-specific condition once fixed.
  547. 		if ( is_tax() && ( ! function_exists( 'hivetheme' ) || ! is_tax( 'hp_listing_category' ) ) ) {
  548. 			$term = get_queried_object();
  550. 			// Set title.
  551. 			$context['page_title'] = $term->name;
  553. 			// Set description.
  554. 			if ( $term->description ) {
  555. 				$context['page_description'] = apply_filters( 'the_content', $term->description );
  556. 			}
  557. 		}
  559. 		return hp\merge_arrays(
  560. 			$args,
  561. 			[
  562. 				'context' => $context,
  563. 			]
  564. 		);
  565. 	}
  567. 	/**
  568. 	 * Sets page template.
  569. 	 *
  570. 	 * @param array $template Template filepath.
  571. 	 * @return string
  572. 	 */
  573. 	public function set_page_template( $template ) {
  574. 		global $wp_query;
  576. 		// Get the current route.
  577. 		$route = $this->get_current_route();
  579. 		if ( $route ) {
  581. 			// Set query variables.
  582. 			if ( isset( $route['path'] ) ) {
  583. 				$wp_query->is_home = false;
  584. 				$wp_query->is_404  = false;
  585. 			}
  587. 			// Get menu redirect.
  588. 			$menu_redirect = home_url();
  590. 			foreach ( hivepress()->get_classes( 'menus' ) as $menu_class ) {
  591. 				if ( $menu_class::get_meta( 'chained' ) ) {
  593. 					// Create menu.
  594. 					$menu = hp\create_class_instance( $menu_class );
  596. 					if ( in_array( $route['name'], array_column( $menu->get_items(), 'route' ), true ) ) {
  598. 						// Get menu items.
  599. 						$menu_items      = $menu->get_items();
  600. 						$menu_item_names = array_keys( $menu_items );
  602. 						foreach ( $menu_items as $menu_item_name => $menu_item ) {
  603. 							if ( isset( $menu_item['route'] ) ) {
  605. 								// Get redirect URL.
  606. 								if ( $menu_item['route'] === $route['name'] ) {
  607. 									$next_menu_item = hp\get_array_value( $menu_items, hp\get_array_value( $menu_item_names, array_search( $menu_item_name, $menu_item_names, true ) + 1 ) );
  609. 									if ( $next_menu_item ) {
  610. 										$menu_redirect = $next_menu_item['url'];
  611. 									}
  613. 									break;
  614. 								}
  616. 								// Get menu route.
  617. 								$menu_route = $this->get_route( $menu_item['route'] );
  619. 								if ( $menu_route && isset( $menu_route['redirect'] ) ) {
  620. 									foreach ( $this->get_redirect_callbacks( $menu_route['redirect'] ) as $menu_route_redirect ) {
  621. 										if ( ! in_array( call_user_func( $menu_route_redirect ), [ null, true ], true ) ) {
  622. 											wp_safe_redirect( $menu_item['url'] );
  624. 											exit;
  625. 										}
  626. 									}
  627. 								}
  628. 							}
  629. 						}
  631. 						break;
  632. 					}
  633. 				}
  634. 			}
  636. 			// Set title.
  637. 			$title = hp\get_array_value( $route, 'title' );
  639. 			if ( is_callable( $title ) ) {
  640. 				$this->route['title'] = call_user_func( $title );
  641. 			}
  643. 			// Redirect page.
  644. 			if ( isset( $route['redirect'] ) ) {
  645. 				foreach ( $this->get_redirect_callbacks( $route['redirect'] ) as $route_redirect ) {
  646. 					$redirect = call_user_func( $route_redirect );
  648. 					if ( $redirect ) {
  649. 						if ( is_bool( $redirect ) ) {
  650. 							$redirect = $menu_redirect;
  651. 						}
  653. 						wp_safe_redirect( $redirect );
  655. 						exit;
  656. 					}
  657. 				}
  658. 			}
  660. 			// Render page.
  661. 			if ( isset( $route['action'] ) ) {
  662. 				echo call_user_func( $route['action'] );
  664. 				exit;
  665. 			}
  666. 		}
  668. 		return $template;
  669. 	}
  671. 	/**
  672. 	 * Disables page redirect.
  673. 	 *
  674. 	 * @param string $url Redirect URL.
  675. 	 * @return string
  676. 	 */
  677. 	public function disable_page_redirect( $url ) {
  678. 		foreach ( hivepress()->get_config( 'post_types' ) as $type => $args ) {
  679. 			if ( ! hp\get_array_value( $args, 'redirect_canonical', true ) && is_singular( hp\prefix( $type ) ) ) {
  680. 				$url = false;
  682. 				break;
  683. 			}
  684. 		}
  686. 		return $url;
  687. 	}
  688. }