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

		@@ -152,8 +152,15 @@
152	152	* Hook into template_redirect to validate category-post relationships
153	153	* Priority 0 to run before WordPress canonical redirect (priority 10)
154	154	*/
155	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 );
156	163	}
157	164
158	165	public function provide_compatibility( $element_id, $uri_parts, $request_url ) {
159	166	if ( $request_url == $this->settings->get( 'docs_slug' ) ) {
		@@ -395,8 +402,225 @@
395	402	}
396	403	}
397	404
398	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	+ /**
399	623	* Check if a URL matches a BetterDocs single docs permalink structure
400	624	* but has invalid KB/category slugs that don't match the post.
401	625	*
402	626	* @param string $url The URL to check.
		@@ -1473,8 +1697,17 @@
1473	1697	}
1474	1698
1475	1699	public function parse( $wp ) {
1476	1700	static::$already_parsed = true;
	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	+ }
1477	1710
1478	1711	// phpcs:ignore WordPress.NamingConventions.PrefixAllGlobals.NonPrefixedHooknameFound -- legacy public filter name, retained for back-compat with Pro/extensions.
1479	1712	$this->perma_structure = apply_filters('docs_rewrite_rules', $this->perma_structure);
1480	1713