/wp-content/plugins/sitepress-multilingual-cms/inc/query-filtering/wpml-query-parser.class.php

https://gitlab.com/woxiprogrammers/infinia-wordpress · PHP · 372 lines · 325 code · 15 blank · 32 comment · 74 complexity · 3df8dbaa00d0cfdcb83fc904e1417711 MD5 · raw file 

    

  1. <?php
    2. 

  2. 

  3. /**
    4. 

  4.  * Class WPML_Query_Parser
    5. 

  5.  *
    6. 

  6.  * @since 3.2.3
    7. 

  7.  */
    8. 

  8. class WPML_Query_Parser extends WPML_Full_Translation_API {
    9. 

  9. 

  10. 	/** @var WPML_Query_Filter $query_filter */
    11. 

  11. 	private $query_filter;
    12. 

  12. 

  13. 	/**
    14. 

  14. 	 * @param SitePress             $sitepress
    15. 

  15. 	 * @param wpdb                  $wpdb
    16. 

  16. 	 * @param WPML_Post_Translation $post_translation
    17. 

  17. 	 * @param WPML_Term_Translation $term_translation
    18. 

  18. 	 * @param WPML_Query_Filter     $query_filter
    19. 

  19. 	 */
    20. 

  20. 	public function __construct( &$sitepress, &$wpdb, &$post_translation, &$term_translation, &$query_filter ) {
    21. 

  21. 		parent::__construct( $sitepress, $wpdb, $post_translation, $term_translation );
    22. 

  22. 		$this->query_filter = &$query_filter;
    23. 

  23. 	}
    24. 

  24. 

  25. 	/**
    26. 

  26. 	 * @param WP_Query $q
    27. 

  27. 	 *
    28. 

  28. 	 * @return WP_Query
    29. 

  29. 	 */
    30. 

  30. 	function parse_query( $q ) {
    31. 

  31. 		if ( is_admin() ) {
    32. 

  32. 			return $q;
    33. 

  33. 		}
    34. 

  34. 

  35. 		$current_language = $this->sitepress->get_current_language();
    36. 

  36. 		$q                = $this->maybe_adjust_name_var( $q );
    37. 

  37. 		if ( $current_language !== $this->sitepress->get_default_language() ) {
    38. 

  38. 			$cat_array = ! empty( $q->query_vars['cat'] ) ? array_map( 'intval',
    39. 

  39. 			                                                           array_map( 'trim',
    40. 

  40. 			                                                                      explode( ',',
    41. 

  41. 			                                                                               $q->query_vars['cat'] ) ) ) : array();
    42. 

  42. 			if ( ! empty( $q->query_vars['category_name'] ) ) {
    43. 

  43. 				$categories = array_filter( array_map( 'trim', explode( ",", $q->query_vars['category_name'] ) ) );
    44. 

  44. 				$cat_array  = array();
    45. 

  45. 				foreach ( $categories as $category ) {
    46. 

  46. 					$cat = get_term_by( 'slug', preg_replace( '#((.*)/)#', '', $category ), 'category' );
    47. 

  47. 					$cat = $cat ? $cat : get_term_by( 'name', $category, 'category' );
    48. 

  48. 					if ( is_object( $cat ) && $cat->term_id ) {
    49. 

  49. 						$cat_array[] = $cat->term_id;
    50. 

  50. 					}
    51. 

  51. 				}
    52. 

  52. 				if ( empty( $cat_array ) ) {
    53. 

  53. 					$q->query_vars['p'] = - 1;
    54. 

  54. 				}
    55. 

  55. 			}
    56. 

  56. 			if ( ! empty( $q->query_vars['category__and'] ) ) {
    57. 

  57. 				$cat_array = $q->query_vars['category__and'];
    58. 

  58. 			}
    59. 

  59. 			if ( ! empty( $q->query_vars['category__in'] ) ) {
    60. 

  60. 				$cat_array = array_unique( array_merge( $cat_array,
    61. 

  61. 				                                        array_map( 'intval', $q->query_vars['category__in'] ) ) );
    62. 

  62. 			}
    63. 

  63. 			if ( ! empty( $q->query_vars['category__not_in'] ) ) {
    64. 

  64. 				$__cats = array();
    65. 

  65. 				foreach ( $q->query_vars['category__not_in'] as $key => $val ) {
    66. 

  66. 					$__cats[ $key ] = - 1 * intval( $val );
    67. 

  67. 				}
    68. 

  68. 				$cat_array = array_unique( array_merge( $cat_array, $__cats ) );
    69. 

  69. 			}
    70. 

  70. 			if ( ! empty( $cat_array ) ) {
    71. 

  71. 				$translated_ids = array();
    72. 

  72. 				foreach ( $cat_array as $c ) {
    73. 

  73. 					$sign             = intval( $c ) < 0 ? - 1 : 1;
    74. 

  74. 					$translated_ids[] = $sign * intval( $this->term_translations->term_id_in( abs( $c ),
    75. 

  75. 					                                                                          $current_language,
    76. 

  76. 					                                                                          true ) );
    77. 

  77. 				}
    78. 

  78. 				if ( ! empty( $q->query_vars['cat'] ) ) {
    79. 

  79. 					$q->query_vars['cat'] = join( ',', $translated_ids );
    80. 

  80. 				}
    81. 

  81. 				if ( ! empty( $q->query_vars['category_name'] ) ) {
    82. 

  82. 					$_ctmp                          = get_term_by( 'id', $translated_ids[0], 'category' );
    83. 

  83. 					$q->query_vars['category_name'] = $_ctmp->slug;
    84. 

  84. 				}
    85. 

  85. 				if ( ! empty( $q->query_vars['category__and'] ) ) {
    86. 

  86. 					$q->query_vars['category__and'] = $translated_ids;
    87. 

  87. 				}
    88. 

  88. 				if ( ! empty( $q->query_vars['category__in'] ) ) {
    89. 

  89. 					$__translated_in = array();
    90. 

  90. 					foreach ( $translated_ids as $key => $t_id ) {
    91. 

  91. 						if ( $t_id > 0 ) {
    92. 

  92. 							$__translated_in[ $key ] = $t_id;
    93. 

  93. 						}
    94. 

  94. 					}
    95. 

  95. 					$q->query_vars['category__in'] = $__translated_in;
    96. 

  96. 				}
    97. 

  97. 				if ( ! empty( $q->query_vars['category__not_in'] ) ) {
    98. 

  98. 					$__translated_not_in = array();
    99. 

  99. 					foreach ( $translated_ids as $key => $t_id ) {
    100. 

  100. 						if ( $t_id < 0 ) {
    101. 

  101. 							$__translated_not_in[ $key ] = $t_id;
    102. 

  102. 						}
    103. 

  103. 					}
    104. 

  104. 					$q->query_vars['category__not_in'] = $__translated_not_in;
    105. 

  105. 				}
    106. 

  106. 			}
    107. 

  107. 			$tag_array = array();
    108. 

  108. 			$tag_glue  = '';
    109. 

  109. 			if ( ! empty( $q->query_vars['tag'] ) ) {
    110. 

  110. 				$tag_glue = false !== strpos( $q->query_vars['tag'], ' ' ) ? '+' : ',';
    111. 

  111. 				$exp      = explode( ' ', $q->query_vars['tag'] );
    112. 

  112. 				foreach ( $exp as $e ) {
    113. 

  113. 					$tag_array[] = $this->wpdb->get_var( $this->wpdb->prepare( "SELECT x.term_id FROM {$this->wpdb->terms} t
    114. 

  114. 						JOIN {$this->wpdb->term_taxonomy} x ON t.term_id=x.term_id WHERE x.taxonomy='post_tag' AND t.slug=%s LIMIT 1",
    115. 

  115. 					                                                           $e ) );
    116. 

  116. 				}
    117. 

  117. 				$_tmp = array_unique( $tag_array );
    118. 

  118. 				if ( count( $_tmp ) == 1 && empty( $_tmp[0] ) ) {
    119. 

  119. 					$tag_array = array();
    120. 

  120. 				}
    121. 

  121. 			}
    122. 

  122. 			if ( ! empty( $q->query_vars['tag_id'] ) ) {
    123. 

  123. 				$tag_array = array_map( 'trim', explode( ',', $q->query_vars['tag_id'] ) );
    124. 

  124. 			}
    125. 

  125. 

  126. 			foreach ( array( 'tag__not_in', 'tag__in', 'tag__and' ) as $index ) {
    127. 

  127. 				if ( ! empty( $q->query_vars[ $index ] ) ) {
    128. 

  128. 					$tag_array = $q->query_vars[ $index ];
    129. 

  129. 					break;
    130. 

  130. 				}
    131. 

  131. 			}
    132. 

  132. 			// tag_slug__in
    133. 

  133. 			if ( ! empty( $q->query_vars['tag_slug__in'] ) ) {
    134. 

  134. 				foreach ( $q->query_vars['tag_slug__in'] as $t ) {
    135. 

  135. 					if ( $tg = $this->wpdb->get_var( $this->wpdb->prepare( "
    136. 

  136. 								SELECT x.term_id FROM {$this->wpdb->terms} t
    137. 

  137. 								JOIN {$this->wpdb->term_taxonomy} x ON t.term_id=x.term_id
    138. 

  138. 								WHERE x.taxonomy='post_tag' AND t.slug=%s LIMIT 1",
    139. 

  139. 					                                                       $t ) )
    140. 

  140. 					) {
    141. 

  141. 						$tag_array[] = $tg;
    142. 

  142. 					}
    143. 

  143. 				}
    144. 

  144. 			}
    145. 

  145. 			if ( ! empty( $q->query_vars['tag_slug__and'] ) ) {
    146. 

  146. 				foreach ( $q->query_vars['tag_slug__and'] as $t ) {
    147. 

  147. 					$tag_array[] = $this->wpdb->get_var( $this->wpdb->prepare( "SELECT x.term_id FROM {$this->wpdb->terms} t
    148. 

  148. 						JOIN {$this->wpdb->term_taxonomy} x ON t.term_id=x.term_id WHERE x.taxonomy='post_tag' AND t.slug=%s LIMIT 1",
    149. 

  149. 					                                                           $t ) );
    150. 

  150. 				}
    151. 

  151. 			}
    152. 

  152. 			if ( ! empty( $tag_array ) ) {
    153. 

  153. 				$translated_ids = array();
    154. 

  154. 				foreach ( $tag_array as $c ) {
    155. 

  155. 					if ( intval( $c ) < 0 ) {
    156. 

  156. 						$sign = - 1;
    157. 

  157. 					} else {
    158. 

  158. 						$sign = 1;
    159. 

  159. 					}
    160. 

  160. 					$_tid             = intval( $this->term_translations->term_id_in( abs( $c ),
    161. 

  161. 					                                                                  $current_language,
    162. 

  162. 					                                                                  true ) );
    163. 

  163. 					$translated_ids[] = $sign * $_tid;
    164. 

  164. 				}
    165. 

  165. 			}
    166. 

  166. 			if ( ! empty( $translated_ids ) ) {
    167. 

  167. 				if ( isset( $q->query_vars['tag'] ) && $q->query_vars['tag'] !== "" ) {
    168. 

  168. 					$slugs                = $this->wpdb->get_col( "SELECT slug
    169. 

  169.                                                                FROM {$this->wpdb->terms}
    170. 

  170.                                                                WHERE term_id IN (" . wpml_prepare_in( $translated_ids,
    171. 

  171. 					                                                                                  '%d' ) . ")" );
    172. 

  172. 					$q->query_vars['tag'] = join( $tag_glue, $slugs );
    173. 

  173. 				}
    174. 

  174. 				foreach ( array( 'tag__in', 'tag__and', 'tag_id' ) as $index ) {
    175. 

  175. 					if ( ! empty( $q->query_vars[ $index ] ) ) {
    176. 

  176. 						$q->query_vars[ $index ] = join( ',', $translated_ids );
    177. 

  177. 						break;
    178. 

  178. 					}
    179. 

  179. 				}
    180. 

  180. 				if ( ! empty( $q->query_vars['tag__not_in'] ) ) {
    181. 

  181. 					$q->query_vars['tag__not_in'] = array_map( 'abs', $translated_ids );
    182. 

  182. 				}
    183. 

  183. 				if ( ! empty( $q->query_vars['tag_slug__in'] ) ) {
    184. 

  184. 					$q->query_vars['tag_slug__in'] = $this->wpdb->get_col( "SELECT slug
    185. 

  185.                                                                FROM {$this->wpdb->terms}
    186. 

  186.                                                                WHERE term_id IN (" . wpml_prepare_in( $translated_ids,
    187. 

  187. 					                                                                                  '%d' ) . ")" );
    188. 

  188. 				}
    189. 

  189. 				if ( ! empty( $q->query_vars['tag_slug__and'] ) ) {
    190. 

  190. 					$q->query_vars['tag_slug__and'] = $this->wpdb->get_col( "SELECT slug
    191. 

  191.                                                                FROM {$this->wpdb->terms}
    192. 

  192.                                                                WHERE term_id IN (" . wpml_prepare_in( $translated_ids,
    193. 

  193. 					                                                                                  '%d' ) . ")" );
    194. 

  194. 				}
    195. 

  195. 			}
    196. 

  196. 

  197. 			$post_type = ! empty( $q->query_vars['post_type'] ) ? $q->query_vars['post_type'] : 'post';
    198. 

  198. 			if ( ! is_array( $post_type ) ) {
    199. 

  199. 				$post_type = (array) $post_type;
    200. 

  200. 			}
    201. 

  201. 			if ( ! empty( $q->query_vars['page_id'] ) ) {
    202. 

  202. 				$q->query_vars['page_id'] = $this->post_translations->element_id_in( $q->query_vars['page_id'],
    203. 

  203. 				                                                                     $current_language,
    204. 

  204. 				                                                                     true );
    205. 

  205. 				$q->query                 = preg_replace( '/page_id=[0-9]+/',
    206. 

  206. 				                                          'page_id=' . $q->query_vars['page_id'],
    207. 

  207. 				                                          $q->query );
    208. 

  208. 			}
    209. 

  209. 			$q = $this->adjust_query_ids( $q, 'include' );
    210. 

  210. 			$q = $this->adjust_query_ids( $q, 'exclude' );
    211. 

  211. 			if ( isset( $q->query_vars['p'] ) && ! empty( $q->query_vars['p'] ) ) {
    212. 

  212. 				$q->query_vars['p'] = $this->post_translations->element_id_in( $q->query_vars['p'],
    213. 

  213. 				                                                               $current_language,
    214. 

  214. 				                                                               true );
    215. 

  215. 			}
    216. 

  216. 			if ( $this->sitepress->is_translated_post_type( $post_type[0] ) && ! empty( $q->query_vars['name'] ) ) {
    217. 

  217. 				if ( is_post_type_hierarchical( $post_type[0] ) ) {
    218. 

  218. 					$reqpage = get_page_by_path( $q->query_vars['name'], OBJECT, $post_type[0] );
    219. 

  219. 					if ( $reqpage ) {
    220. 

  220. 						$q->query_vars['p'] = $this->post_translations->element_id_in( $reqpage->ID,
    221. 

  221. 						                                                               $current_language,
    222. 

  222. 						                                                               true );
    223. 

  223. 						unset( $q->query_vars['name'] );
    224. 

  224. 						// We need to set this to an empty string otherwise WP will derive the pagename from this.
    225. 

  225. 						$q->query_vars[ $post_type[0] ] = '';
    226. 

  226. 					}
    227. 

  227. 				} else {
    228. 

  228. 					$pid_prepared = $this->wpdb->prepare( "SELECT ID FROM {$this->wpdb->posts} WHERE post_name=%s AND post_type=%s LIMIT 1",
    229. 

  229. 					                                      array( $q->query_vars['name'], $post_type[0] ) );
    230. 

  230. 					$pid          = $this->wpdb->get_var( $pid_prepared );
    231. 

  231. 					if ( ! empty( $pid ) ) {
    232. 

  232. 						$q->query_vars['p'] = $this->post_translations->element_id_in( $pid, $current_language, true );
    233. 

  233. 						unset( $q->query_vars['name'] );
    234. 

  234. 					}
    235. 

  235. 				}
    236. 

  236. 			}
    237. 

  237. 			$q = $this->adjust_q_var_pids( $q, $post_type, 'post__in' );
    238. 

  238. 			$q = $this->adjust_q_var_pids( $q, $post_type, 'post__not_in' );
    239. 

  239. 			if ( ! empty( $q->query_vars['post_parent'] ) && $q->query_vars['post_type'] !== 'attachment' && $post_type ) {
    240. 

  240. 				$q->query_vars['post_parent'] = $this->post_translations->element_id_in( $q->query_vars['post_parent'],
    241. 

  241. 				                                                                         $current_language,
    242. 

  242. 				                                                                         true );
    243. 

  243. 			}
    244. 

  244. 			if ( isset( $q->query_vars['taxonomy'] ) && $q->query_vars['taxonomy'] ) {
    245. 

  245. 				$tax_id = $this->wpdb->get_var( $this->wpdb->prepare( "SELECT term_id FROM {$this->wpdb->terms} WHERE slug=%s LIMIT 1",
    246. 

  246. 				                                                      $q->query_vars['term'] ) );
    247. 

  247. 				if ( $tax_id ) {
    248. 

  248. 					$translated_tax_id = $this->term_translations->term_id_in( $tax_id, $current_language, true );
    249. 

  249. 				}
    250. 

  250. 				if ( isset( $translated_tax_id ) ) {
    251. 

  251. 					$q->query_vars['term']                  = $this->wpdb->get_var( $this->wpdb->prepare( "SELECT slug FROM {$this->wpdb->terms} WHERE term_id = %d LIMIT 1",
    252. 

  252. 					                                                                                      $translated_tax_id ) );
    253. 

  253. 					$q->query[ $q->query_vars['taxonomy'] ] = $q->query_vars['term'];
    254. 

  254. 				}
    255. 

  255. 			}
    256. 

  256. 			//TODO: [WPML 3.3] Discuss this. Why WP assumes it's there if query vars are altered? Look at wp-includes/query.php line #2468 search: if ( $this->query_vars_changed ) {
    257. 

  257. 			$q->query_vars['meta_query'] = isset( $q->query_vars['meta_query'] ) ? $q->query_vars['meta_query'] : array();
    258. 

  258. 			if ( isset( $q->query_vars['tax_query'] ) && is_array( $q->query_vars['tax_query'] ) ) {
    259. 

  259. 				foreach ( $q->query['tax_query'] as $num => $fields ) {
    260. 

  260. 					if ( ! isset( $fields['terms'] ) ) {
    261. 

  261. 						continue;
    262. 

  262. 					}
    263. 

  263. 					if ( is_array( $fields['terms'] ) ) {
    264. 

  264. 						foreach ( $fields['terms'] as $term ) {
    265. 

  265. 							$taxonomy = get_term_by( $fields['field'], $term, $fields['taxonomy'] );
    266. 

  266. 							if ( is_object( $taxonomy ) ) {
    267. 

  267. 								if ( $fields['field'] === 'id' ) {
    268. 

  268. 									$field = isset( $taxonomy->term_id ) ? $taxonomy->term_id : null;
    269. 

  269. 								} else {
    270. 

  270. 									$field = isset( $taxonomy->{$fields['field']} ) ? $taxonomy->{$fields['field']} : null;
    271. 

  271. 								}
    272. 

  272. 								$tmp   = $q->query['tax_query'][ $num ]['terms'];
    273. 

  273. 								$tmp   = array_diff( (array) $tmp,
    274. 

  274. 								                     array( $term ) ); // removes from array element with original value
    275. 

  275. 								$tmp[] = $field;
    276. 

  276. 								//Reindex array
    277. 

  277. 								$q->query['tax_query'][ $num ]['terms'] = array_values( $tmp );
    278. 

  278. 								$tmp                                    = isset( $q->tax_query->queries[ $num ]['terms'] ) ? $q->tax_query->queries[ $num ]['terms'] : array();
    279. 

  279. 								$tmp                                    = array_diff( (array) $tmp,
    280. 

  280. 								                                                      array( $term ) ); // see above
    281. 

  281. 								$tmp[]                                  = $field;
    282. 

  282. 								//Reindex array
    283. 

  283. 								$q->tax_query->queries[ $num ]['terms'] = array_values( $tmp );
    284. 

  284. 								$tmp                                    = $q->query_vars['tax_query'][ $num ]['terms'];
    285. 

  285. 								$tmp                                    = array_diff( (array) $tmp,
    286. 

  286. 								                                                      array( $term ) ); // see above
    287. 

  287. 								$tmp[]                                  = $field;
    288. 

  288. 								//Reindex array
    289. 

  289. 								$q->query_vars['tax_query'][ $num ]['terms'] = array_values( $tmp );
    290. 

  290. 								unset( $tmp );
    291. 

  291. 							}
    292. 

  292. 						}
    293. 

  293. 					} else if ( is_string( $fields['terms'] ) ) {
    294. 

  294. 						$taxonomy = get_term_by( $fields['field'], $fields['terms'], $fields['taxonomy'] );
    295. 

  295. 						if ( is_object( $taxonomy ) ) {
    296. 

  296. 							$field                                       = isset( $taxonomy->{$fields['field']} ) ? $taxonomy->{$fields['field']} : null;
    297. 

  297. 							$q->query['tax_query'][ $num ]['terms']      = $field;
    298. 

  298. 							$q->tax_query->queries[ $num ]['terms'][0]   = $field;
    299. 

  299. 							$q->query_vars['tax_query'][ $num ]['terms'] = $field;
    300. 

  300. 						}
    301. 

  301. 					}
    302. 

  302. 				}
    303. 

  303. 			}
    304. 

  304. 		}
    305. 

  305. 

  306. 		return $q;
    307. 

  307. 	}
    308. 

  308. 

  309. 	/**
    310. 

  310. 	 * Tries to transform certain queries from "by name" querying to "by ID" to overcome WordPress Core functionality
    311. 

  311. 	 * for resolving names not being filtered by language
    312. 

  312. 	 *
    313. 

  313. 	 * @param WP_Query $q
    314. 

  314. 	 *
    315. 

  315. 	 * @return WP_Query
    316. 

  316. 	 */
    317. 

  317. 	private function maybe_adjust_name_var( $q ) {
    318. 

  318. 		if ( ( (bool) ( $name_in_q = $q->get( 'name' ) ) === true
    319. 

  319. 		     || (bool) ( $name_in_q = $q->get( 'pagename' ) ) === true )
    320. 

  320. 			&& (bool) $q->get( 'page_id' ) === false
    321. 

  321. 			|| ( (bool) ( $post_type = $q->get('post_type') ) === true
    322. 

  322.                 && is_scalar($post_type)
    323. 

  323.                 && (bool) ( $name_in_q = $q->get($post_type)) === true ) ) {
    324. 

  324. 			list( $name_found, $type, $altered ) = $this->query_filter->get_404_util()->guess_cpt_by_name( $name_in_q,
    325. 

  325. 			                                                                                               $q );
    326. 

  326. 			if ( $altered === true ) {
    327. 

  327. 				$name_before = $q->get( 'name' );
    328. 

  328. 				$q->set( 'name', $name_found );
    329. 

  329. 			}
    330. 

  330. 			$type = $type ? $type : 'page';
    331. 

  331. 			$type = is_scalar( $type ) ? $type : ( count( $type ) === 1 ? end( $type ) : false );
    332. 

  332. 			$q    = $type ? $this->query_filter->get_page_name_filter( $type )->filter_page_name( $q ) : $q;
    333. 

  333. 			if ( isset( $name_before ) ) {
    334. 

  334. 				$q->set( 'name', $name_before );
    335. 

  335. 			}
    336. 

  336. 		}
    337. 

  337. 

  338. 		return $q;
    339. 

  339. 	}
    340. 

  340. 

  341. 	private function adjust_query_ids( $q, $index ) {
    342. 

  342. 		if ( ! empty( $q->query_vars[ $index ] ) ) {
    343. 

  343. 			$untranslated = is_array( $q->query_vars[ $index ] ) ? $q->query_vars[ $index ] : explode( ',',
    344. 

  344. 			                                                                                           $q->query_vars[ $index ] );
    345. 

  345. 			$this->post_translations->prefetch_ids( $untranslated );
    346. 

  346. 			$ulanguage_code = $this->sitepress->get_current_language();
    347. 

  347. 			$translated     = array();
    348. 

  348. 			foreach ( $untranslated as $element_id ) {
    349. 

  349. 				$translated[] = $this->post_translations->element_id_in( $element_id, $ulanguage_code );
    350. 

  350. 			}
    351. 

  351. 			$q->query_vars[ $index ] = is_array( $q->query_vars[ $index ] ) ? $translated : implode( ',', $translated );
    352. 

  352. 		}
    353. 

  353. 

  354. 		return $q;
    355. 

  355. 	}
    356. 

  356. 

  357. 	private function adjust_q_var_pids( $q, $post_types, $index ) {
    358. 

  358. 		if ( ! empty( $q->query_vars[ $index ] ) && (bool) $post_types !== false ) {
    359. 

  359. 

  360. 			$untranslated = $q->query_vars[ $index ];
    361. 

  361. 			$this->post_translations->prefetch_ids( $untranslated );
    362. 

  362. 			$current_lang = $this->sitepress->get_current_language();
    363. 

  363. 			$pid          = array();
    364. 

  364. 			foreach ( $q->query_vars[ $index ] as $p ) {
    365. 

  365. 				$pid[] = $this->post_translations->element_id_in( $p, $current_lang, true );
    366. 

  366. 			}
    367. 

  367. 			$q->query_vars[ $index ] = $pid;
    368. 

  368. 		}
    369. 

  369. 

  370. 		return $q;
    371. 

  371. 	}
    372. 

  372. }
    373.