← All changes | includes/Core/Request.php +282 -0 4.6.1 → 4.9.2 View file →

		@@ -6,8 +6,9 @@
6	6	}
7	7
8	8
9	9	use WPDeveloper\BetterDocs\Utils\Base;
	10	+use WPDeveloper\BetterDocs\Utils\Helper;
10	11
11	12	class Request extends Base {
12	13	/**
13	14	* Flag for already parsed or not
		@@ -151,8 +152,15 @@
151	152	* Hook into template_redirect to validate category-post relationships
152	153	* Priority 0 to run before WordPress canonical redirect (priority 10)
153	154	*/
154	155	add_action( 'template_redirect', [ $this, 'validate_single_docs_category_redirect' ], 0 );
	156	+
	157	+ /**
	158	+ * Hook into template_redirect to 301 non-canonical single doc URLs.
	159	+ * Priority 5: after the validation above (0) so requests already headed for
	160	+ * a 404 are left alone, and before WordPress canonical redirect (10).
	161	+ */
	162	+ add_action( 'template_redirect', [ $this, 'redirect_to_canonical_docs_url' ], 5 );
155	163	}
156	164
157	165	public function provide_compatibility( $element_id, $uri_parts, $request_url ) {
158	166	if ( $request_url == $this->settings->get( 'docs_slug' ) ) {
		@@ -394,8 +402,225 @@
394	402	}
395	403	}
396	404
397	405	/**
	406	+ * 301 redirect a single doc to its canonical permalink.
	407	+ *
	408	+ * With `enable_category_hierarchy_slugs` enabled the single doc rewrite rule
	409	+ * captures every segment between the base and the doc slug into `doc_category`
	410	+ * (see Rewrite::rules), and the category validation above only requires ONE of
	411	+ * those segments to match. That looseness is deliberate — a strict match would
	412	+ * 404 legitimate Multiple KB and WPML URLs, where the KB slug and translated
	413	+ * segments share the same capture group — but it also means a doc resolves on an
	414	+ * unlimited number of URLs, e.g. /docs/anything/real-category/doc-slug/.
	415	+ *
	416	+ * Rather than tightening the match, this compares the requested category path
	417	+ * against every path the doc legitimately has and redirects the rest. Every URL
	418	+ * that resolves today keeps resolving; only the extra ones collapse.
	419	+ */
	420	+ public function redirect_to_canonical_docs_url() {
	421	+ global $wp_query;
	422	+
	423	+ /**
	424	+ * Allow the canonical redirect to be disabled.
	425	+ *
	426	+ * @param bool $enabled Whether non-canonical single doc URLs should 301.
	427	+ */
	428	+ if ( ! apply_filters( 'betterdocs_enable_canonical_redirect', true ) ) {
	429	+ return;
	430	+ }
	431	+
	432	+ if ( is_admin() || wp_doing_ajax() || is_feed() || is_embed() || is_preview() || is_customize_preview() ) {
	433	+ return;
	434	+ }
	435	+
	436	+ $request_method = isset( $_SERVER['REQUEST_METHOD'] ) ? strtoupper( sanitize_text_field( wp_unslash( $_SERVER['REQUEST_METHOD'] ) ) ) : 'GET';
	437	+ if ( $request_method !== 'GET' ) {
	438	+ return;
	439	+ }
	440	+
	441	+ if ( ! is_singular( 'docs' ) || is_404() ) {
	442	+ return;
	443	+ }
	444	+
	445	+ /**
	446	+ * The request is already headed for a 404 — leave it alone. Note that
	447	+ * prevent_any_redirect_for_invalid_docs() cancels every wp_redirect() while
	448	+ * this flag is set, so the redirect below would be swallowed anyway.
	449	+ */
	450	+ if ( $this->invalid_request_query_vars !== null ) {
	451	+ return;
	452	+ }
	453	+
	454	+ $requested_category = isset( $wp_query->query_vars['doc_category'] ) ? $wp_query->query_vars['doc_category'] : '';
	455	+ if ( ! is_string( $requested_category ) || $requested_category === '' ) {
	456	+ return;
	457	+ }
	458	+
	459	+ $post_id = get_queried_object_id();
	460	+ if ( ! $post_id ) {
	461	+ return;
	462	+ }
	463	+
	464	+ $valid_paths = $this->get_valid_category_paths( $post_id );
	465	+ if ( empty( $valid_paths ) ) {
	466	+ return;
	467	+ }
	468	+
	469	+ $requested_category = urldecode( trim( $requested_category, '/' ) );
	470	+
	471	+ /**
	472	+ * Under Multiple KB the knowledge base segment is parsed into its own query
	473	+ * var, so put it back in front of the category chain before comparing —
	474	+ * otherwise a crossed `/kb-a/category-of-kb-b/doc/` would look canonical.
	475	+ */
	476	+ $requested_kb = isset( $wp_query->query_vars['knowledge_base'] ) ? $wp_query->query_vars['knowledge_base'] : '';
	477	+ if ( is_string( $requested_kb ) && $requested_kb !== '' ) {
	478	+ $requested_category = urldecode( trim( $requested_kb, '/' ) ) . '/' . $requested_category;
	479	+ }
	480	+
	481	+ if ( in_array( $requested_category, $valid_paths, true ) ) {
	482	+ return; // Already canonical (or another legitimate category of this doc).
	483	+ }
	484	+
	485	+ $canonical = get_permalink( $post_id );
	486	+ if ( ! $canonical ) {
	487	+ return;
	488	+ }
	489	+
	490	+ // Keep the multipage segment the rewrite rule captured.
	491	+ $page = isset( $wp_query->query_vars['page'] ) ? absint( $wp_query->query_vars['page'] ) : 0;
	492	+ if ( $page > 1 ) {
	493	+ $canonical = trailingslashit( $canonical ) . user_trailingslashit( $page, 'single_paged' );
	494	+ }
	495	+
	496	+ /**
	497	+ * Belt and braces: never redirect a URL onto itself. The allowed set is built
	498	+ * from the same term chains get_permalink() uses, so this should be
	499	+ * unreachable, but a third party filtering the permalink could otherwise turn
	500	+ * a redirect into a loop.
	501	+ */
	502	+ $requested_path = isset( $_SERVER['REQUEST_URI'] ) ? wp_parse_url( wp_unslash( $_SERVER['REQUEST_URI'] ), PHP_URL_PATH ) : '';
	503	+ $canonical_path = wp_parse_url( $canonical, PHP_URL_PATH );
	504	+ if ( untrailingslashit( urldecode( (string) $requested_path ) ) === untrailingslashit( urldecode( (string) $canonical_path ) ) ) {
	505	+ return;
	506	+ }
	507	+
	508	+ $query_string = isset( $_SERVER['QUERY_STRING'] ) ? sanitize_text_field( wp_unslash( $_SERVER['QUERY_STRING'] ) ) : '';
	509	+ if ( $query_string !== '' ) {
	510	+ $canonical .= ( strpos( $canonical, '?' ) === false ? '?' : '&' ) . $query_string;
	511	+ }
	512	+
	513	+ if ( wp_safe_redirect( $canonical, 301 ) ) {
	514	+ exit;
	515	+ }
	516	+ }
	517	+
	518	+ /**
	519	+ * Every category path a doc can legitimately be reached at.
	520	+ *
	521	+ * Includes the full parent/child chain of each assigned category, and — because
	522	+ * the hierarchy rewrite rule folds the knowledge base slug into `doc_category`
	523	+ * for the `docs/%knowledge_base%/%doc_category%` structure — the KB-prefixed
	524	+ * variants too.
	525	+ *
	526	+ * @param int $post_id The doc id.
	527	+ * @return string[] Normalised (urldecoded, unslashed) category paths.
	528	+ */
	529	+ protected function get_valid_category_paths( $post_id ) {
	530	+ $cat_terms = wp_get_object_terms( $post_id, 'doc_category' );
	531	+
	532	+ if ( is_wp_error( $cat_terms ) ) {
	533	+ return [];
	534	+ }
	535	+
	536	+ $paths = [];
	537	+ $cat_paths = [];
	538	+
	539	+ if ( empty( $cat_terms ) ) {
	540	+ $paths[] = 'uncategorized';
	541	+ } else {
	542	+ foreach ( $cat_terms as $cat_term ) {
	543	+ $path = PostType::build_category_path( $cat_term );
	544	+
	545	+ if ( $path !== '' ) {
	546	+ $paths[] = $path;
	547	+ $cat_paths[ $cat_term->term_id ] = $path;
	548	+ }
	549	+ }
	550	+ }
	551	+
	552	+ if ( taxonomy_exists( 'knowledge_base' ) ) {
	553	+ $kb_terms = wp_get_object_terms( $post_id, 'knowledge_base', [ 'fields' => 'slugs' ] );
	554	+
	555	+ if ( ! is_wp_error( $kb_terms ) && ! empty( $kb_terms ) ) {
	556	+ $kb_paths = [];
	557	+
	558	+ /**
	559	+ * Read the KB association once per category rather than once per
	560	+ * KB/category pair. The wp_get_object_terms() call above primes the
	561	+ * term meta cache for these terms (`update_term_meta_cache` defaults
	562	+ * to true), so these reads are cache hits and add no queries.
	563	+ *
	564	+ * The association mirrors how PostType::post_link() picks the
	565	+ * category via `doc_category_knowledge_base`. Without it a doc in
	566	+ * KB A / category A and KB B / category B would treat the crossed
	567	+ * `/kb-a/category-b/doc/` as canonical. A term with no association
	568	+ * meta is unassigned rather than KB specific, so it stays valid
	569	+ * under every KB — post_link() falls back the same way.
	570	+ */
	571	+ $term_kbs = [];
	572	+
	573	+ if ( ! empty( $cat_paths ) ) {
	574	+ foreach ( array_keys( $cat_paths ) as $term_id ) {
	575	+ $meta = get_term_meta( $term_id, 'doc_category_knowledge_base', true );
	576	+ $term_kbs[ $term_id ] = ( ! empty( $meta ) && is_array( $meta ) ) ? $meta : null;
	577	+ }
	578	+ }
	579	+
	580	+ foreach ( $kb_terms as $kb_slug ) {
	581	+ if ( empty( $cat_paths ) ) {
	582	+ // Uncategorised doc: the KB slug is the only prefix there is.
	583	+ foreach ( $paths as $path ) {
	584	+ $kb_paths[] = $kb_slug . '/' . $path;
	585	+ }
	586	+ continue;
	587	+ }
	588	+
	589	+ foreach ( $cat_paths as $term_id => $path ) {
	590	+ if ( $term_kbs[ $term_id ] !== null && ! in_array( $kb_slug, $term_kbs[ $term_id ], true ) ) {
	591	+ continue;
	592	+ }
	593	+
	594	+ $kb_paths[] = $kb_slug . '/' . $path;
	595	+ }
	596	+ }
	597	+
	598	+ $paths = array_merge( $paths, $kb_paths );
	599	+ }
	600	+ }
	601	+
	602	+ /**
	603	+ * Non-Latin slugs are stored URL encoded while the requested path arrives
	604	+ * decoded, so normalise both sides before comparing.
	605	+ */
	606	+ $paths = array_map(
	607	+ function ( $path ) {
	608	+ return urldecode( trim( $path, '/' ) );
	609	+ },
	610	+ $paths
	611	+ );
	612	+
	613	+ /**
	614	+ * Filter the category paths a doc is allowed to be reached at.
	615	+ *
	616	+ * @param string[] $paths Valid category paths.
	617	+ * @param int $post_id The doc id.
	618	+ */
	619	+ return array_values( array_unique( apply_filters( 'betterdocs_valid_docs_category_paths', $paths, $post_id ) ) );
	620	+ }
	621	+
	622	+ /**
398	623	* Check if a URL matches a BetterDocs single docs permalink structure
399	624	* but has invalid KB/category slugs that don't match the post.
400	625	*
401	626	* @param string $url The URL to check.
		@@ -1473,8 +1698,17 @@
1473	1698
1474	1699	public function parse( $wp ) {
1475	1700	static::$already_parsed = true;
1476	1701
	1702	+ // An API Reference rewrite rule already matched (/docs/api/{slug}).
	1703	+ // The permalink magic below re-interprets the raw path against the
	1704	+ // docs/category/KB structures and would hijack the request whenever a
	1705	+ // doc_category or knowledge_base term shares the reference's slug —
	1706	+ // an explicit CPT match always wins.
	1707	+ if ( isset( $wp->query_vars['betterdocs_api_ref'] ) ) {
	1708	+ return;
	1709	+ }
	1710	+
1477	1711	// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- legacy public filter name, retained for back-compat with Pro/extensions.
1478	1712	$this->perma_structure = apply_filters('docs_rewrite_rules', $this->perma_structure);
1479	1713
1480	1714	$this->permalink_magic( $wp );
		@@ -1505,8 +1739,15 @@
1505	1739	// Strip optional language prefix injected by Polylang/WPML (e.g. "en/", "bn/", "pt-br/")
1506	1740	// so that "bn/docs/..." matches the structure "docs/..." correctly.
1507	1741	$request_without_lang = preg_replace( '#^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8})?/#', '', $request );
1508	1742
	1743	+ // When WPML translates a taxonomy base slug per language (e.g. doc_tag
	1744	+ // "docs-tag" -> "docs-tag-bn"), the incoming URL uses the translated slug,
	1745	+ // but perma_structure is built from the default-language slug. Map the
	1746	+ // leading translated slug back to its default so the raw structures match.
	1747	+ // No-op on non-WPML sites and when the slug isn't translated.
	1748	+ $request_canonical = $this->canonicalize_translated_slug( $request_without_lang );
	1749	+
1509	1750	foreach ( $this->perma_structure as $_type => $structure ) {
1510	1751	// First try the raw (possibly language-prefixed) request, then the lang-stripped variant.
1511	1752	// This ensures we still match non-multilingual sites without stripping valid slugs.
1512	1753	$_perma_vars = $this->is_perma_valid_for( $structure, $request );
		@@ -1512,8 +1753,11 @@
1512	1753	$_perma_vars = $this->is_perma_valid_for( $structure, $request );
1513	1754	if ( ! $_perma_vars && $request_without_lang !== $request ) {
1514	1755	$_perma_vars = $this->is_perma_valid_for( $structure, $request_without_lang );
1515	1756	}
	1757	+ if ( ! $_perma_vars && $request_canonical !== $request_without_lang ) {
	1758	+ $_perma_vars = $this->is_perma_valid_for( $structure, $request_canonical );
	1759	+ }
1516	1760
1517	1761	// $_valid = empty( $_valid ) && $_perma_vars ? [ 'type' => $_type, 'query_vars' => $_perma_vars ] : $_valid;
1518	1762	if ( ( $_perma_vars && method_exists( $this, $_type ) && call_user_func_array( [$this, $_type], [ & $_perma_vars] ) ) ) {
1519	1763
		@@ -1561,8 +1805,46 @@
1561	1805	unset( $wp->query_vars['attachment'] );
1562	1806	}
1563	1807	}
1564	1808	}
	1809	+
	1810	+ /**
	1811	+ * Map a leading WPML-translated taxonomy base slug back to its default-language
	1812	+ * value so the default-language perma_structure patterns can match a translated URL.
	1813	+ *
	1814	+ * Only the first path segment is considered (the taxonomy base). Returns the
	1815	+ * request unchanged when WPML is inactive or the leading segment isn't a
	1816	+ * translated BetterDocs slug.
	1817	+ *
	1818	+ * @param string $request Language-stripped request path (no leading/trailing slash).
	1819	+ * @return string
	1820	+ */
	1821	+ private function canonicalize_translated_slug( $request ) {
	1822	+ if ( $request === '' || strpos( $request, '/' ) === false ) {
	1823	+ return $request;
	1824	+ }
	1825	+
	1826	+ $slug_map = [
	1827	+ 'doc_tag' => trim( $this->settings->get( 'tag_slug', 'docs-tag' ), '/' ),
	1828	+ 'doc_category' => trim( $this->settings->get( 'category_slug', 'docs-category' ), '/' ),
	1829	+ ];
	1830	+
	1831	+ $segments = explode( '/', $request );
	1832	+
	1833	+ foreach ( $slug_map as $taxonomy => $default ) {
	1834	+ if ( $default === '' ) {
	1835	+ continue;
	1836	+ }
	1837	+
	1838	+ $translated = Helper::wpml_translated_tax_slug( $taxonomy, $default );
	1839	+ if ( $translated !== $default && $segments[0] === $translated ) {
	1840	+ $segments[0] = $default;
	1841	+ return implode( '/', $segments );
	1842	+ }
	1843	+ }
	1844	+
	1845	+ return $request;
	1846	+ }
1565	1847
1566	1848	/**
1567	1849	* This method is responsible for checking a structure is valid again a request.
1568	1850	*