golden hour

/home/godaofbq/hardchambers.com/wp-content/plugins/betterdocs/includes/Core

File/Folder	Size	Actions
Admin.php	41.35 KB
BaseAPI.php	2.89 KB
FAQBuilder.php	20.6 KB
Glossaries.php	17.95 KB
Install.php	7.74 KB
KBMigration.php	19.14 KB
Migration.php	2.65 KB
PostType.php	37.2 KB
Query.php	33.44 KB
Request.php	7.11 KB
Rewrite.php	8.87 KB
Roles.php	3.05 KB
Scripts.php	5.24 KB
Settings.php	107.08 KB
SetupWizard.php	18.35 KB
Shortcode.php	3.44 KB
ShortcodeFactory.php	1.93 KB
WriteWithAI.php	36 KB

Edit: Query.php

<?php

namespace WPDeveloper\BetterDocs\Core;

use WP_Query;
use WPDeveloper\BetterDocs\Utils\Base;
use WPDeveloper\BetterDocs\Utils\Database;
use WPDeveloper\BetterDocs\Dependencies\DI\Container;

class Query extends Base {
	private $container;
	protected $database;
	protected $settings;

public function __construct( Container $container, Database $database, Settings $settings ) {
		$this->container = $container;
		$this->database  = $database;
		$this->settings  = $settings;

add_action( 'parse_term_query', [ $this, 'parse_term_query' ] );
		// add_action( 'parse_query', [$this, 'parse_query'], 1 );
		add_action( 'pre_get_posts', [ $this, 'pre_get_posts' ], 1 );

/**
		 * These below filters are hooked for navigation only.
		 *
		 * For old version of this portion.
		 * @see `betterdocs_single_post_nav` filter
		 *
		 * For details:
		 * @see https://developer.wordpress.org/reference/functions/get_next_post/
		 * @see https://developer.wordpress.org/reference/functions/get_previous_post/
		 *
		 * @link https://developer.wordpress.org/reference/hooks/get_adjacent_post_where/
		 */
		add_filter( 'get_next_post_where', [ $this, 'next_post_where' ], 99, 5 );
		add_filter( 'get_previous_post_where', [ $this, 'previous_post_where' ], 99, 5 );

$this->init();

/**
		 * Modify Popular Docs Query (For Shortcode & Widget)
		 */
		add_filter( 'posts_clauses', [ $this, 'mod_query_popular_docs' ], 10, 2 );
	}

public function mod_query_popular_docs( $clauses, $wp_query ) {
		if ( isset( $wp_query->query['meta_key'] ) ) {
			if ( $wp_query->query['meta_key'] == '_betterdocs_meta_views' ) {
				global $wpdb;
				$order              = isset( $wp_query->query['order'] ) ? $wp_query->query['order'] : '';
				$order_by_query     = ( $order == 'ASC' || $order == 'DESC' ) ? "SUM({$wpdb->prefix}betterdocs_analytics.impressions) {$order}" : ( $order == 'MODIFIED' ? "{$wpdb->prefix}posts.post_modified_gmt DESC" : "{$wpdb->prefix}posts.post_date_gmt DESC" );
				$clauses['join']    = "JOIN {$wpdb->prefix}betterdocs_analytics ON {$wpdb->prefix}posts.ID = {$wpdb->prefix}betterdocs_analytics.post_id";
				$clauses['where']   = ! is_user_logged_in() ? "AND ( ( {$wpdb->prefix}posts.post_type = 'docs' ) AND ( {$wpdb->prefix}posts.post_status = 'publish' OR {$wpdb->prefix}posts.post_status = 'future' ) )" : "AND ( ( {$wpdb->prefix}posts.post_type = 'docs' ) AND ( {$wpdb->prefix}posts.post_status = 'publish' OR {$wpdb->prefix}posts.post_status = 'future' OR {$wpdb->prefix}posts.post_status = 'draft' OR {$wpdb->prefix}posts.post_status = 'pending' OR {$wpdb->prefix}posts.post_status = 'private' ) )";
				$clauses['orderby'] = $order_by_query;
				$clauses['groupby'] = "{$wpdb->prefix}betterdocs_analytics.post_id";
				if ( is_plugin_active( 'sitepress-multilingual-cms/sitepress.php' ) ) {
					global $sitepress;
					if ( $sitepress->is_setup_complete() ) {
						$constant_language_code = ICL_LANGUAGE_CODE;
						$clauses['join']       .= " JOIN {$wpdb->prefix}icl_translations ON {$wpdb->prefix}posts.ID = {$wpdb->prefix}icl_translations.element_id";
						$clauses['where']      .= " AND ( {$wpdb->prefix}icl_translations.language_code = '{$constant_language_code}' ) AND ( {$wpdb->prefix}icl_translations.element_type = CONCAT('post_', {$wpdb->prefix}posts.post_type ) )";
					}
				}
			}
		}
		return $clauses;
	}

public function init() {
	}

public function parse_term_query( $term_query ) {
		if ( empty( $term_query->query_vars['taxonomy'] ) ) {
			return;
		}

if ( ! in_array( 'doc_category', $term_query->query_vars['taxonomy'], true ) ) {
			return;
		}

global $current_screen;

if ( $current_screen == null ) {
			return;
		}

if ( $current_screen->taxonomy !== 'doc_category' || $current_screen->id != 'edit-doc_category' ) {
			return;
		}

$term_query->query_vars['meta_query'] = [
			[
				'key'  => 'doc_category_order',
				'type' => 'NUMERIC'
			]
		];

$term_query->query_vars['orderby'] = 'meta_value_num';
	}

public function parse_query( &$query ) {
		// dump( is_single(), $query->query_vars );
		// if ( is_single() && isset( $query->query_vars['post_type'] ) && $query->query_vars['post_type'] == 'docs' ) {
		//     $query->is_single = false;
		//     $query->is_archive = true;
		//     $query->set( 'knowledge_base', $query->query_vars['docs'] );
		// }
	}

public function pre_get_posts( &$query ) {
		if ( is_admin() || ! $query->is_main_query() ) {
			return;
		}

if ( is_tax( 'doc_category' ) ) {
			$query->set( 'post_type', 'docs' );
			$query->set( 'posts_per_archive_page', -1 );

$term = get_term_by( 'slug', $query->get( 'doc_category', '' ), 'doc_category' );

$post__in = $this->get_docs_order_by_terms( $term->term_id );
			if ( ! empty( $post__in ) ) {
				$query->set( 'orderby', 'post__in' );
				$query->set( 'post__in', $post__in );
			}

// if ( ! empty( $query->query_vars['knowledge_base'] ) ) {
			//     $query->betterdocs_terms = get_terms( [
			//         'taxonomy'   => 'doc_category',
			//         'parent'     => 0,
			//         'hide_empty' => true,
			//         'meta_query' => [
			//             'relation' => 'OR',
			//             [
			//                 'key'     => 'doc_category_knowledge_base',
			//                 'value'   => $query->query_vars['knowledge_base'],
			//                 'compare' => 'LIKE'
			//             ]
			//         ]
			//     ] );
			// }
		}

// dump( is_archive(), $query->query_vars );
	}

/**
	 * Get docs orders by term_id.
	 *
	 * @since 2.5.0
	 * @param int $term_id
	 *
	 * @return array
	 */
	public function get_docs_order_by_terms( $term_id ) {
		global $wpdb;
		$_docs_order = get_term_meta( $term_id, '_docs_order', true );
		$query       = $wpdb->prepare( "SELECT * FROM {$wpdb->prefix}term_relationships WHERE term_taxonomy_id = %d", $term_id );
		$query_key   = "docs_order_by_terms_{$term_id}_" . md5( $query );

if ( ( $results = $this->database->get_cache( $query_key ) ) !== false ) {
			return $results;
		}

if ( ! empty( $_docs_order ) ) {
			$_docs_order = explode( ',', $_docs_order );
			$new_ids     = [];

$results = $wpdb->get_results( $query ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared

if ( is_array( $results ) && ! empty( $results ) ) {
				$object_ids = array_filter(
					$results,
					function ( $value ) use ( $_docs_order ) {
						return ! in_array( $value->object_id, $_docs_order );
					}
				);

if ( ! empty( $object_ids ) ) {
					array_walk(
						$object_ids,
						function ( $value ) use ( &$new_ids ) {
							$new_ids[] = $value->object_id;
						}
					);
				}
			}

$_docs_order = array_merge( $new_ids, $_docs_order );
			$this->database->set_cache( $query_key, $_docs_order, 1 );

return $_docs_order;
		}

return [];
	}

/**
	 * For determine the next post ID
	 *
	 * @link https://developer.wordpress.org/reference/hooks/get_adjacent_post_where/
	 *
	 * @param mixed $where
	 * @param mixed $in_same_term
	 * @param mixed $excluded_terms
	 * @param mixed $taxonomy
	 * @param mixed $post
	 * @return mixed
	 */
	public function next_post_where( $where, $in_same_term, $excluded_terms, $taxonomy, $post ) {
		return $this->get_adjacent_post_id( 'next', $where, $post, $taxonomy );
	}

/**
	 * For determine the previous post ID
	 *
	 * @link https://developer.wordpress.org/reference/hooks/get_adjacent_post_where/
	 *
	 * @param mixed $where
	 * @param mixed $in_same_term
	 * @param mixed $excluded_terms
	 * @param mixed $taxonomy
	 * @param mixed $post
	 * @return mixed
	 */
	public function previous_post_where( $where, $in_same_term, $excluded_terms, $taxonomy, $post ) {
		return $this->get_adjacent_post_id( 'previous', $where, $post, $taxonomy );
	}

/**
	 * Get where clause for next/previous post ID mainly used in post navigation.
	 *
	 * @see `previous_post_where` and `next_post_where` methods.
	 *
	 * @param mixed $adjacent
	 * @param mixed $where
	 * @param mixed $post
	 * @param mixed $taxonomy
	 * @return mixed
	 */
	private function get_adjacent_post_id( $adjacent, $where, $post, $taxonomy ) {
		if ( $taxonomy !== 'doc_category' ) {
			return $where;
		}

$_id    = null;
		$_terms = get_the_terms( $post->ID, 'doc_category' );
		if ( empty( $_terms ) ) {
			return $where;
		}

global $wp_query, $wpdb;

$_docs_order = $this->get_docs_order_by_terms( $_terms[0]->term_id );

$_where = explode( 'AND', $where );
		if ( is_array( $_where ) ) {
			// $_where[0] = str_replace( 'WHERE ', '', $_where[0] );
			unset( $_where[0] );
			$_where = implode( 'AND', $_where );
		}

$_orderby    = $this->settings->get( 'alphabetically_order_post', 'betterdocs_order' );
		$_order      = $this->settings->get( 'docs_order', 'ASC' );
		$_docs_order = $_orderby === 'betterdocs_order' ? $_docs_order : [];

if ( empty( $_docs_order ) ) {
			$statuses = [ 'publish' ];

if ( is_user_logged_in() ) {
				$statuses[] = 'private';
			}

$_args = [
				'post_status' => $statuses
			];
			if ( isset( $wp_query->query_vars['doc_category'] ) ) {
				$_args['tax_query'][] = [
					'taxonomy'         => 'doc_category',
					'field'            => 'slug',
					'terms'            => $wp_query->query_vars['doc_category'],
					'operator'         => 'AND',
					'include_children' => false
				];
			}

$_args['orderby'] = $_orderby;
			if ( $_orderby != 'betterdocs_order' ) {
				$_args['order'] = $_order;
			}

/**
			 * Before Query
			 */
			do_action_ref_array( 'betterdocs_navigation_docs_query', [ &$_args ] );
			$docs = $this->get_posts( $this->docs_query_args( $_args ) );

$_docs = [];
			if ( $docs->have_posts() ) {
				array_map(
					function ( $post ) use ( &$_docs ) {
						$_docs[] = $post->ID;
					},
					$docs->posts
				);
			}

$_docs_order = $_docs;
		}

$_docs_order = apply_filters( 'betterdocs_adjacent_docs_order', $_docs_order, $_terms );

$_id_index = array_search( $post->ID, $_docs_order );
		$_id_index = $adjacent === 'next' ? $_id_index + 1 : $_id_index - 1;
		$_id       = isset( $_docs_order[ $_id_index ] ) ? (int) $_docs_order[ $_id_index ] : null;

return $wpdb->prepare( "WHERE p.ID = %s AND $_where", (int) $_id );
	}

public function parse_terms_args( $args = [] ) {
		$_default_args = [
			'hide_empty' => true,
			'taxonomy'   => 'doc_category'
		];

// OrderBy & Order
		$_orderby = ! empty( $args['orderby'] ) && $args['orderby'] != 1 ? $args['orderby'] : 'name';
		$_order   = ! empty( $args['order'] ) ? $args['order'] : '';

if ( $_orderby == 'betterdocs_order' ) {
			$args['meta_key'] = 'doc_category_order';
			$args['orderby']  = 'meta_value_num';
			$args['order']    = 'ASC';
		} else {
			$args['orderby'] = $_orderby;
			$args['order']   = $_order;
		}

// Nested Sub Category
		// $args['parent'] = 0;
		// if ( $nested_subcategory == true ) {
		// }

if ( ! isset( $args['number'] ) ) {
			global $wp_query;
			if ( $wp_query->query === null || ( isset( $wp_query->query['post_type'] ) && $wp_query->query['post_type'] != 'docs' ) ) {
				$args['number'] = 4;
			}
		}

// Includes
		if ( isset( $args['include'] ) ) {
			$_include        = ! is_array( $args['include'] ) ? explode( ',', $args['include'] ) : $args['include'];
			$args['include'] = $_include;
			$args['orderby'] = 'include';

unset( $args['parent'] );
		}

$_meta_query        = ! empty( $args['meta_query'] ) ? $args['meta_query'] : [];
		$args['meta_query'] = apply_filters( 'betterdocs_taxonomy_object_meta_query', $_meta_query, $args );

return apply_filters( 'betterdocs_category_terms_object', wp_parse_args( $args, $_default_args ), $args );
	}

public function get_terms( $args ) {
		return get_terms( $this->parse_terms_args( $args ) );
	}

public function get_child_terms( $args ) {
		if ( ! isset( $args['number'] ) ) {
			global $wp_query;
			if ( $wp_query->query === null || ( isset( $wp_query->query['post_type'] ) && $wp_query->query['post_type'] != 'docs' ) ) {
				$args['number'] = 1;
			}
		}

return $this->get_terms( $args );
	}

/**
	 * Get POSTs of Docs type.
	 *
	 * @param mixed $args
	 * @return WP_Query
	 */
	public function get_posts( $args, $ignore = false ) {
		if ( ! $ignore ) {
			$args = $this->docs_query_args( $args );
		}

return new WP_Query( $args );
	}

public function get_taxonomy( $tax = '' ) {
		global $wp_query;
		if ( is_tax( 'knowledge_base' ) ) {
			$_tax = $wp_query->tax_query->queried_terms;
			if ( array_key_exists( 'doc_category', $_tax ) ) {
				$tax = 'doc_category';
			} else {
				$tax = 'knowledge_base';
			}
		} elseif ( is_tax( 'doc_category' ) ) {
			$tax = 'doc_category';
		}

return $tax;
	}

public function terms_query( $args = [] ) {
		global $wp_query;
		$_origin_args = $args;

$default_args = [
			'hide_empty' => true,
			'taxonomy'   => 'doc_category',
			'orderby'    => 'name'
		];

/**
		 * Number Set
		 *
		 * @FIX: If Built-in Docs page off and docs_page in use, then Terms Query Number 4|1 set.
		 */
		// if ( $wp_query->query === NULL || ( isset( $wp_query->query['post_type'] ) && $wp_query->query['post_type'] != 'docs' ) ) {
		//     $default_args['number'] = 1;
		// }

/**
		 * Nested Sub Category
		 */
		if ( isset( $args['nested_subcategory'] ) && $args['nested_subcategory'] == true ) {
			$default_args['parent'] = 0;
			unset( $args['nested_subcategory'] );
			// if ( $wp_query->query === NULL || ( isset( $wp_query->query['post_type'] ) && $wp_query->query['post_type'] != 'docs' ) ) {
			//     $default_args['number'] = 4;
			// }
		}

/**
		 * OrderBy and Order
		 */
		if ( ! isset( $args['orderby'] ) ) {
			$_orderby = $this->settings->get( 'terms_orderby', 'name' );
			$_order   = $this->settings->get( 'terms_order', '' );
		} else {
			$_orderby = $args['orderby'];
			$_order   = ! empty( $args['order'] ) ? $args['order'] : '';
		}

if ( 'betterdocs_order' === $_orderby ) {
			$default_args['meta_key'] = 'doc_category_order';
			$_orderby                 = 'meta_value_num';
			$_order                   = 'ASC';
		} elseif ( $_orderby === true ) {
			$_orderby = 'name';
		}

$args['orderby'] = $_orderby;
		if ( ! empty( $_order ) ) {
			$args['order'] = $_order;
		}

/**
		 * @todo old hook
		 * hook: betterdocs_child_taxonomy_meta_query
		 */
		$_multiple_kb = apply_filters(
			'betterdocs_query_args_multiple_kb_enabled',
			isset( $args['multiple_kb'] ) ? (bool) $args['multiple_kb'] : false,
			$_origin_args
		);

$_kb_slug = isset( $args['kb_slug'] ) ? trim( $args['kb_slug'] ) : '';

unset( $args['multiple_kb'] );
		unset( $args['kb_slug'] );

$meta_query = ! empty( $args['meta_query'] ) ? $args['meta_query'] : [];
		$meta_query = apply_filters( 'betterdocs_terms_meta_query_args', $meta_query, $_multiple_kb, $_kb_slug, $_origin_args );

if ( ! empty( $meta_query ) ) {
			$default_args['meta_query'] = $meta_query;
		}

if ( ! empty( $args['terms'] ) ) {
			$args['include'] = explode( ',', $args['terms'] );
			$args['orderby'] = 'include';
			$args['order']   = 'ASC';

unset( $default_args['parent'] );
			unset( $args['parent'] );
			unset( $args['terms'] );
		}

$_query_args = wp_parse_args( $args, $default_args );
		return apply_filters( 'betterdocs_terms_query_args', $_query_args, $_origin_args );
	}

public function get_term_parents( $term_id, $taxonomy = 'doc_category', $args = [] ) {
		$term = get_term( $term_id, $taxonomy );
		if ( is_wp_error( $term ) ) {
			return $term;
		}

if ( ! $term ) {
			return [];
		}

$_lists      = [];
		$origin_term = $term_id;
		$term_id     = $term->term_id;

$defaults = [
			'format'    => 'name',
			'inclusive' => true
		];

$args = wp_parse_args( $args, $defaults );

$args['inclusive'] = wp_validate_boolean( $args['inclusive'] );

$parents = get_ancestors( $term_id, $taxonomy );

if ( $args['inclusive'] ) {
			array_unshift( $parents, $term_id );
		}

foreach ( array_reverse( $parents ) as $term_id ) {
			$parent         = get_term( $term_id, $taxonomy );
			$name           = ( 'slug' === $args['format'] ) ? $parent->slug : $parent->name;
			$term_permalink = get_term_link( $parent->term_id, $taxonomy );
			$term_permalink = apply_filters( 'betterdocs_breadcrumb_term_permalink', $term_permalink, $term_id );

$_item = [
				'url'  => $term_permalink,
				'text' => $name
			];

$_lists[] = $_item;
		}

return apply_filters( 'betterdocs_breadcrumb_archive_lists', $_lists, $origin_term );
	}

/**
	 * Get all non-empty child term IDs recursively for a given taxonomy and parent term.
	 *
	 * This function retrieves all child terms for a specified taxonomy and parent term,
	 * recursively fetching child terms of child terms, and returns only those with a non-zero post count.
	 *
	 * @param string $taxonomy  The taxonomy name (e.g., 'doc_category').
	 * @param int    $parent_id The ID of the parent term to start retrieving children from.
	 *
	 * @return array An array of non-empty child term IDs.
	 */
	public function get_all_child_term_ids( $taxonomy, $parent_id ) {
		// Set up the arguments for retrieving child terms
		$args = apply_filters(
			'betterdocs_get_child_term_ids_args',
			[
				'taxonomy'   => $taxonomy,
				'parent'     => $parent_id,
				'hide_empty' => true,
				'fields'     => 'ids'
			]
		);

// Get the terms based on the arguments
		$terms = get_terms( $args );

// Initialize an empty array to hold non-empty child term IDs
		$non_empty_children = [];

// Check if terms were retrieved without errors and that the result isn't empty
		if ( ! is_wp_error( $terms ) && ! empty( $terms ) ) {
			$term_ids = [];

// Loop through each term ID
			foreach ( $terms as $term_id ) {
				// Add the current term ID to the term_ids array
				$term_ids[] = $term_id;

// Recursively get child terms for the current term
				$child_term_ids = $this->get_all_child_term_ids( $taxonomy, $term_id );

// If there are child terms, merge them into the term_ids array
				if ( ! empty( $child_term_ids ) ) {
					$term_ids = array_merge( $term_ids, $child_term_ids );
				}
			}

// Loop through all retrieved term IDs to filter out empty ones
			foreach ( $term_ids as $term_id ) {
				// Get the term object for the current term ID
				$child_term = get_term( $term_id, $taxonomy );

// Only include terms that have a non-zero post count
				if ( $child_term && $child_term->count > 0 ) {
					$non_empty_children[] = $child_term->term_id;
				}
			}
		}

// Return the final array of non-empty child term IDs
		return $non_empty_children;
	}

/**
	 * Get all nested child term IDs of a specific parent term in a taxonomy and return as a comma-separated string.
	 *
	 * @param string $taxonomy The taxonomy.
	 * @param int $parent_id The parent term ID.
	 * @return string The comma-separated term IDs.
	 */
	public function get_child_term_ids_by_parent_id( $taxonomy, $parent_id ) {
		$term_ids = $this->get_all_child_term_ids( $taxonomy, $parent_id );
		return implode( ',', $term_ids );
	}

public function get_terms_children( $taxonomy, $parent_id ) {
		$children           = get_term_children( $parent_id, $taxonomy );
		$non_empty_children = [];
		if ( ! is_wp_error( $children ) && ! empty( $children ) ) {
			foreach ( $children as $child_id ) {
				$child_term = get_term( $child_id, $taxonomy );

// Only include non-empty terms
				if ( $child_term && $child_term->count > 0 ) {
					$non_empty_children[] = $child_term;
				}
			}
		}

return $non_empty_children;
	}

public function get_terms_children_ids( $taxonomy, $parent_id ) {
		$children = $this->get_terms_children( $taxonomy, $parent_id );
		$term_ids = wp_list_pluck( $children, 'term_id' );

return implode( ',', $term_ids );
	}

public function count_terms_children( $taxonomy, $parent_id ) {
		return count( $this->get_terms_children( $taxonomy, $parent_id ) );
	}

public function is_inner_templates() {
		if ( is_tax( 'knowledge_base' ) || is_tax( 'doc_category' ) || is_tax( 'doc_tag' ) || is_singular( 'docs' ) ) {
			return true;
		}
		return false;
	}

/**
	 * Summary of docs_query_args
	 * @param mixed $args
	 * @throws \Exception
	 * @return mixed
	 */
	public function docs_query_args( $args, $filter = [] ) {
		$_origin_args = $args;

$default_args = [
			'post_type' => 'docs'
		];

if ( ! empty( $args['post_type'] ) && trim( $args['post_type'] ) === 'docs_any' ) {
			$default_args['post_type']   = 'docs';
			$default_args['post_status'] = 'any';

unset( $args['post_type'] );
		}

/**
		 * OrderBy and Order
		 */
		if ( ! isset( $args['orderby'] ) ) {
			$_orderby = $this->settings->get( 'alphabetically_order_post' );
			$_order   = $this->settings->get( 'docs_order', 'ASC' );
		} else {
			$_orderby = $args['orderby'];
			$_order   = ! empty( $args['order'] ) ? $args['order'] : 'ASC';
		}

if ( 'betterdocs_order' != $_orderby ) {
			if ( $_orderby === true ) {
				$args['orderby'] = 'title';
			} else {
				$args['orderby'] = $_orderby;
			}

$args['order'] = $_order;
		} elseif ( 'betterdocs_order' == $_orderby ) {
			unset( $args['orderby'] );
		}

if ( empty( $args['orderby'] ) ) {
			unset( $args['order'] );
		}

/**
		 * Term ID
		 */
		$_term_id = null;
		if ( ! empty( $args['term_id'] ) ) {
			$_term_id = intval( $args['term_id'] );
			unset( $args['term_id'] );
		}

// if ( $_term_id == null ) {
		//     throw new \Exception( __( '$args["term_id"] cannot be null.', 'betterdocs' ) );
		// }

/**
		 * Term Slug for tax_query
		 */
		$_term_slug = '';
		if ( ! empty( $args['term_slug'] ) ) {
			$_term_slug = trim( $args['term_slug'] );
			unset( $args['term_slug'] );
		}

/**
		 * @todo old hook
		 * hook: betterdocs_cat_template_multikb
		 */

$_multiple_kb = apply_filters(
			'betterdocs_enable_multiple_knowledge_base',
			isset( $args['multiple_kb'] ) ? (bool) $args['multiple_kb'] : false,
			$_origin_args
		);

$_kb_slug = isset( $args['kb_slug'] ) ? trim( $args['kb_slug'] ) : '';

unset( $args['multiple_kb'] );
		unset( $args['kb_slug'] );

$tax_query = [
			[
				'taxonomy'         => 'doc_category',
				'field'            => 'slug',
				'terms'            => $_term_slug,
				'operator'         => 'AND',
				'include_children' => false
			]
		];

if ( ! isset( $args['orderby'] ) || $args['orderby'] == 'betterdocs_order' ) {
			$args['orderby']  = 'post__in';
			$args['post__in'] = $this->get_docs_order_by_terms( $_term_id );
		}

if ( isset( $args['tax_query'] ) ) {
			$tax_query = $args['tax_query'];
		}

$args['tax_query'] = apply_filters(
			'betterdocs_docs_tax_query_args',
			$tax_query,
			$_multiple_kb,
			$_term_slug,
			$_kb_slug,
			$_origin_args,
			$this->is_inner_templates()
		);
		/**
		 * Final parse args
		 */
		$args = wp_parse_args( $args, $default_args );

if ( ! empty( $filter ) ) {
			$filter = array_flip( $filter );
			$args   = array_filter(
				$args,
				function ( $item ) use ( $filter ) {
					return ! array_key_exists( $item, $filter );
				},
				ARRAY_FILTER_USE_KEY
			);
		}

return apply_filters( 'betterdocs_articles_args', $args, $_term_id, $_origin_args );
	}

public function faq_terms_query_args( $includes = '', $excludes = '', $args = [] ) {
		$_args = [
			'taxonomy'   => 'betterdocs_faq_category',
			'meta_key'   => 'order',
			'orderby'    => 'meta_value_num',
			'order'      => 'ASC',
			'include'    => $includes,
			'exclude'    => $excludes,
			'meta_query' => [
				[
					'key'     => 'status',
					'value'   => 1,
					'compare' => '=='
				]
			]
		];

if ( $_args['include'] == 'all' ) {
			unset( $_args['include'] );
			unset( $_args['exclude'] );
		}

if ( empty( $_args['exclude'] ) ) {
			unset( $_args['exclude'] );
		}

if ( empty( $_args['include'] ) ) {
			unset( $_args['include'] );
		}

return wp_parse_args( $args, $_args );
	}

public function get_faq_by_term( $term_id ) {
		global $wpdb;

$args = [
			'post_type'      => 'betterdocs_faq',
			'post_status'    => 'publish',
			'tax_query'      => [
				[
					'taxonomy' => 'betterdocs_faq_category',
					'field'    => 'term_id',
					'terms'    => $term_id,
					'operator' => 'AND'
				]
			],
			'posts_per_page' => -1
		];

$args['orderby']  = 'post__in';
		$args['post__in'] = $this->get_faq_orders( $term_id );

return new WP_Query( $args );
	}

public function get_faq_orders( $term_id = null ) {
		global $wpdb;
		$faq_order = get_term_meta( $term_id, '_betterdocs_faq_order', true );
		$faq_order = explode( ',', $faq_order );

$query     = $wpdb->prepare( "SELECT * FROM {$wpdb->prefix}term_relationships WHERE term_taxonomy_id = %d", $term_id );
		$query_key = 'betterdocs_faq_order_' . md5( $query );

if ( ( $results = $this->database->get_cache( $query_key ) ) !== false ) {
			return $results;
		}

if ( ! empty( $faq_order ) ) {
			$new_ids = [];
			$results = $wpdb->get_results( $query ); // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared

if ( ! is_null( $results ) && ! empty( $results ) && is_array( $results ) ) {
				$object_ids = array_filter(
					$results,
					function ( $value ) use ( $faq_order ) {
						return ! in_array( $value->object_id, $faq_order );
					}
				);

if ( ! empty( $object_ids ) ) {
					array_walk(
						$object_ids,
						function ( $value ) use ( &$new_ids ) {
							$new_ids[] = $value->object_id;
						}
					);
				}
			}

$faq_order = array_merge( $new_ids, $faq_order );
		}

$this->database->set_cache( $query_key, $faq_order, 1 );

return $faq_order;
	}

public function get_faq_terms( $terms = [] ) {
		$_terms = get_terms(
			[
				'taxonomy'   => 'betterdocs_faq_category',
				'hide_empty' => true,
				'orderby'    => 'name',
				'order'      => 'ASC',
				'meta_query' => [
					[
						'key'     => 'status',
						'value'   => 1,
						'compare' => '=='
					]
				]
			]
		);

if ( ! is_wp_error( $_terms ) ) {
			foreach ( $_terms as $term ) {
				$terms[ $term->term_id ] = $term->name;
			}
		}

return $terms;
	}

public function get_doc_terms( $terms = [] ) {
		$_terms = get_terms(
			[
				'taxonomy'   => 'doc_category',
				'hide_empty' => true,
				'orderby'    => 'name',
				'order'      => 'ASC',
			]
		);

if ( ! is_wp_error( $_terms ) ) {
			foreach ( $_terms as $term ) {
				$terms[ $term->term_id ] = $term->name;
			}
		}

return $terms;
	}

public function get_docs_count( $term, $nested_subcategory = false, $args = [] ) {
		$counts = isset( $term->count ) ? $term->count : 0;

if ( $nested_subcategory == false ) {
			return apply_filters( 'betterdocs_docs_count', $counts, $term, $nested_subcategory, $args );
		}

$_child_terms_docs_ids = $this->get_doc_ids_by_term( $term, null, $nested_subcategory );
		if ( is_array( $_child_terms_docs_ids ) ) {
			$counts = count( $_child_terms_docs_ids );
		}

return apply_filters( 'betterdocs_docs_count', $counts, $term, $nested_subcategory, $args );
	}

public function get_doc_ids_by_term( $term, $optional = null, $nested_subcategory = false ) {
		$args = ['include' => $term->term_id];
        if ( $nested_subcategory ) {
            $args['child_of'] = $term->term_id;
            unset( $args['include'] );
        }
        $_child_terms = get_terms( $term->taxonomy, $args );

if ( ! is_array( $_child_terms ) ) {
            return false;
        }

array_unshift( $_child_terms, $term );

$_child_terms_ids      = array_column( $_child_terms, 'term_id' );
        $_child_terms_taxs     = array_column( $_child_terms, 'taxonomy' );
        $_child_terms_docs_ids = get_objects_in_term( $_child_terms_ids, $_child_terms_taxs );

if ( $optional !== null ) {
            $_optional_doc_ids     = get_objects_in_term( $optional->term_id, $optional->taxonomy );
            $_child_terms_docs_ids = array_intersect( $_child_terms_docs_ids, $_optional_doc_ids );
        }

return array_filter( $_child_terms_docs_ids, function ( $doc_id ) {
            if ( ! is_user_logged_in() ) {
                return is_post_publicly_viewable( $doc_id );
            }

$_status = get_post_status( $doc_id );
            return $_status == 'private' || is_post_publicly_viewable( $doc_id );
        } );
	}

/**
	 * Get the common query arguments for WP_Query.
	 *
	 * @param string $terms The taxonomy.
	 * @param string $term_slug The taxonomy term slug.
	 * @param array $additional_args Additional arguments to merge with the common arguments.
	 * @return array The query arguments.
	 */
	private function tax_query_args( $terms, $term_slug, $additional_args = array() ) {
		$common_args = array(
			'post_type'   => 'docs',
			'post_status' => 'publish',
			'tax_query'   => array(
				array(
					'taxonomy' => $terms,
					'field'    => 'slug',
					'terms'    => $term_slug,
				),
			),
		);
		return array_merge( $common_args, $additional_args );
	}

/**
	 * Get the latest updated date for a specific taxonomy term.
	 *
	 * @param string $terms The taxonomy.
	 * @param string $term_slug The taxonomy term slug.
	 * @return string|null The latest modified date or null if no posts found.
	 */
	public function latest_updated_date( $terms, $term_slug ) {
		$args = $this->tax_query_args(
			$terms,
			$term_slug,
			array(
				'posts_per_page' => 1,
				'orderby'        => 'modified',
				'order'          => 'DESC',
			)
		);

$query = new WP_Query( $args );

if ( $query->have_posts() ) {
			while ( $query->have_posts() ) {
				$query->the_post();
				$latest_post = get_the_modified_date();
				wp_reset_postdata();
				return $latest_post;
			}
		} else {
			return null;
		}
	}

/**
	 * Check if there are any new posts within the last 7 days for a specific taxonomy term.
	 *
	 * @param string $terms The taxonomy.
	 * @param string $term_slug The taxonomy term slug.
	 * @return bool True if there are new posts, false otherwise.
	 */
	public function check_new_posts( $terms, $term_slug ) {
		$date_7_days_ago = date( 'Y-m-d H:i:s', strtotime( '-7 days' ) );

$args = $this->tax_query_args(
			$terms,
			$term_slug,
			array(
				'posts_per_page' => 1,
				'orderby'        => 'modified',
				'order'          => 'DESC',
				'date_query'     => array(
					array(
						'after'     => $date_7_days_ago,
						'inclusive' => true,
					),
				),
			)
		);

$query = new WP_Query( $args );

$has_new_posts = $query->have_posts();

wp_reset_postdata();

return $has_new_posts;
	}

public function insert_search_keyword( $search_input, $input_not_found ) {
		if ( empty( $search_input ) ) {
			return false;
		}

global $wpdb;
		$search = $wpdb->get_results(
			$wpdb->prepare(
				"SELECT *
                FROM {$wpdb->prefix}betterdocs_search_keyword
                WHERE keyword = %s",
				$search_input
			)
		);

if ( ! empty( $search ) ) {
			$search_log = $wpdb->get_results(
				$wpdb->prepare(
					"SELECT *
                    FROM {$wpdb->prefix}betterdocs_search_log
                    WHERE created_at = %s AND keyword_id = %d",
					date( 'Y-m-d' ),
					$search[0]->id
				)
			);

if ( ! empty( $search_log ) ) {
				if ( ! empty( $input_not_found ) ) {
					$tbl_field = 'not_found_count';
					$count     = $search_log[0]->not_found_count + 1;
				} else {
					$tbl_field = 'count';
					$count     = $search_log[0]->count + 1;
				}
                // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared
				$insert = $wpdb->query(
					$wpdb->prepare(
						"UPDATE {$wpdb->prefix}betterdocs_search_log
                        SET " . $tbl_field . ' = ' . $count . '
                        WHERE created_at = %s AND keyword_id = %d',
						$search_log[0]->created_at,
						$search_log[0]->keyword_id
					)
				);
			} else {
				if ( ! empty( $input_not_found ) ) {
					$count           = 0;
					$not_found_count = 1;
				} else {
					$count           = 1;
					$not_found_count = 0;
				}
				$insert = $wpdb->query(
					$wpdb->prepare(
						"INSERT INTO {$wpdb->prefix}betterdocs_search_log
                        ( keyword_id, count, not_found_count, created_at  )
                        VALUES ( %d, %d, %d, %s )",
						[
							$search[0]->id,
							$count,
							$not_found_count,
							date( 'Y-m-d' )
						]
					)
				);
			}
		} else {
			$insert = $wpdb->query(
				$wpdb->prepare(
					"INSERT INTO {$wpdb->prefix}betterdocs_search_keyword
                    ( keyword )
                    VALUES ( %s )",
					[
						$search_input
					]
				)
			);

if ( $insert ) {
				if ( ! empty( $input_not_found ) ) {
					$count           = 0;
					$not_found_count = 1;
				} else {
					$count           = 1;
					$not_found_count = 0;
				}
				$insert = $wpdb->query(
					$wpdb->prepare(
						"INSERT INTO {$wpdb->prefix}betterdocs_search_log
                        ( keyword_id, count, not_found_count, created_at )
                        VALUES ( %d, %d, %d, %s )",
						[
							$wpdb->insert_id,
							$count,
							$not_found_count,
							date( 'Y-m-d' )
						]
					)
				);
			}
		}
		return $insert;
	}

/**
	 * Counts the number of 'doc_category' terms assigned to a specific 'knowledge_base' by slug.
	 *
	 * This method retrieves all terms in the 'doc_category' taxonomy and checks the term meta
	 * 'doc_category_knowledge_base' to determine how many 'doc_category' terms are associated
	 * with a given 'knowledge_base' slug.
	 *
	 * @param string $knowledge_base_slug The slug of the 'knowledge_base' to count the assignments for.
	 *
	 * @return int The count of 'doc_category' terms assigned to the specified 'knowledge_base'.
	 */
	public function count_doc_categories_for_knowledge_base( $knowledge_base_slug ) {
		$count = 0;

$doc_categories = get_terms(
			array(
				'taxonomy'   => 'doc_category',
				'hide_empty' => true,
			)
		);

if ( ! empty( $doc_categories ) && ! is_wp_error( $doc_categories ) ) {
			foreach ( $doc_categories as $term ) {
				$meta_value = get_term_meta( $term->term_id, 'doc_category_knowledge_base', true );

if ( $meta_value ) {
					$knowledge_bases = maybe_unserialize( $meta_value );

// Check if the specific knowledge base slug is present in the meta value array
					if ( is_array( $knowledge_bases ) && in_array( $knowledge_base_slug, $knowledge_bases ) ) {
						++$count;
					}
				}
			}
		}

return $count;
	}
}