function clea_patrice_show_img_cat()
{
    // see https://wordpress.org/support/topic/product-category-in-the-library-dashboard
    global $wp_taxonomies;
    foreach (get_taxonomies_for_attachments('object') as $taxonomy => $params) {
        if (in_array('attachment', $params->object_type) && in_array('product', $params->object_type)) {
            // turns on taxonomy columns
            $wp_taxonomies[$taxonomy]->show_admin_column = 1;
        }
    }
}
 function wpuxss_eml_shortcode_atts($out, $pairs, $atts)
 {
     $is_filter_based = false;
     $id = isset($atts['id']) ? intval($atts['id']) : 0;
     // enforce order defaults
     $pairs['order'] = 'ASC';
     $pairs['orderby'] = 'menu_order ID';
     foreach ($pairs as $name => $default) {
         if (array_key_exists($name, $atts)) {
             $out[$name] = $atts[$name];
         } else {
             $out[$name] = $default;
         }
     }
     if (isset($atts['monthnum']) && isset($atts['year'])) {
         $is_filter_based = true;
     }
     $tax_query = array();
     foreach (get_taxonomies_for_attachments('names') as $taxonomy) {
         if (isset($atts[$taxonomy])) {
             $terms = explode(',', $atts[$taxonomy]);
             $tax_query[] = array('taxonomy' => $taxonomy, 'field' => 'term_id', 'terms' => $terms, 'operator' => 'IN');
             $is_filter_based = true;
         }
     }
     if (!$is_filter_based) {
         return $out;
     }
     $ids = array();
     $mime_type = isset($out['type']) && ('audio' === $out['type'] || 'video' === $out['type']) ? $out['type'] : 'image';
     $query = array('post_status' => 'inherit', 'post_type' => 'attachment', 'post_mime_type' => $mime_type, 'order' => $out['order'], 'orderby' => $out['orderby'], 'posts_per_page' => isset($atts['limit']) ? intval($atts['limit']) : -1, 'fields' => 'ids');
     if (isset($atts['monthnum']) && isset($atts['year'])) {
         $query['monthnum'] = $atts['monthnum'];
         $query['year'] = $atts['year'];
     }
     if ('post__in' === $out['orderby']) {
         $query['orderby'] = 'menu_order ID';
     }
     if (!empty($tax_query)) {
         $tax_query['relation'] = 'AND';
         $query['tax_query'] = $tax_query;
     }
     if ($id) {
         $query['post_parent'] = $id;
     }
     $ids = get_posts($query);
     if (!empty($ids)) {
         $out['ids'] = $out['include'] = implode(',', $ids);
     }
     return $out;
 }
示例#3
0
/**
 * Ajax handler for querying attachments.
 *
 * @since 3.5.0
 */
function wp_ajax_query_attachments()
{
    if (!current_user_can('upload_files')) {
        wp_send_json_error();
    }
    $query = isset($_REQUEST['query']) ? (array) $_REQUEST['query'] : array();
    $keys = array('s', 'order', 'orderby', 'posts_per_page', 'paged', 'post_mime_type', 'post_parent', 'post__in', 'post__not_in', 'year', 'monthnum');
    foreach (get_taxonomies_for_attachments('objects') as $t) {
        if ($t->query_var && isset($query[$t->query_var])) {
            $keys[] = $t->query_var;
        }
    }
    $query = array_intersect_key($query, array_flip($keys));
    $query['post_type'] = 'attachment';
    if (MEDIA_TRASH && !empty($_REQUEST['query']['post_status']) && 'trash' === $_REQUEST['query']['post_status']) {
        $query['post_status'] = 'trash';
    } else {
        $query['post_status'] = 'inherit';
    }
    if (current_user_can(get_post_type_object('attachment')->cap->read_private_posts)) {
        $query['post_status'] .= ',private';
    }
    /**
     * Filter the arguments passed to WP_Query during an AJAX
     * call for querying attachments.
     *
     * @since 3.7.0
     *
     * @see WP_Query::parse_query()
     *
     * @param array $query An array of query variables.
     */
    $query = apply_filters('ajax_query_attachments_args', $query);
    $query = new WP_Query($query);
    $posts = array_map('wp_prepare_attachment_for_js', $query->posts);
    $posts = array_filter($posts);
    wp_send_json_success($posts);
}
示例#4
0
 /**
  * Retrieve the posts based on query variables.
  *
  * There are a few filters and actions that can be used to modify the post
  * database query.
  *
  * @since 1.5.0
  * @access public
  *
  * @return array List of posts.
  */
 public function get_posts()
 {
     $this->parse_query();
     /**
      * Fires after the query variable object is created, but before the actual query is run.
      *
      * Note: If using conditional tags, use the method versions within the passed instance
      * (e.g. $this->is_main_query() instead of is_main_query()). This is because the functions
      * like is_main_query() test against the global $wp_query instance, not the passed one.
      *
      * @since 2.0.0
      *
      * @param WP_Query &$this The WP_Query instance (passed by reference).
      */
     do_action_ref_array('pre_get_posts', array(&$this));
     // Shorthand.
     $q =& $this->query_vars;
     // Fill again in case pre_get_posts unset some vars.
     $q = $this->fill_query_vars($q);
     // Parse meta query
     $this->meta_query = new WP_Meta_Query();
     $this->meta_query->parse_query_vars($q);
     // Set a flag if a pre_get_posts hook changed the query vars.
     $hash = md5(serialize($this->query_vars));
     if ($hash != $this->query_vars_hash) {
         $this->query_vars_changed = true;
         $this->query_vars_hash = $hash;
     }
     unset($hash);
     // First let's clear some variables
     $distinct = '';
     $whichauthor = '';
     $whichmimetype = '';
     $where = '';
     $limits = '';
     $join = '';
     $search = '';
     $groupby = '';
     $post_status_join = false;
     $page = 1;
     if (isset($q['caller_get_posts'])) {
         _deprecated_argument('WP_Query', '3.1.0', __('"caller_get_posts" is deprecated. Use "ignore_sticky_posts" instead.'));
         if (!isset($q['ignore_sticky_posts'])) {
             $q['ignore_sticky_posts'] = $q['caller_get_posts'];
         }
     }
     if (!isset($q['ignore_sticky_posts'])) {
         $q['ignore_sticky_posts'] = false;
     }
     if (!isset($q['suppress_filters'])) {
         $q['suppress_filters'] = false;
     }
     if (!isset($q['cache_results'])) {
         if (wp_using_ext_object_cache()) {
             $q['cache_results'] = false;
         } else {
             $q['cache_results'] = true;
         }
     }
     if (!isset($q['update_post_term_cache'])) {
         $q['update_post_term_cache'] = true;
     }
     if (!isset($q['lazy_load_term_meta'])) {
         $q['lazy_load_term_meta'] = $q['update_post_term_cache'];
     }
     if (!isset($q['update_post_meta_cache'])) {
         $q['update_post_meta_cache'] = true;
     }
     if (!isset($q['post_type'])) {
         if ($this->is_search) {
             $q['post_type'] = 'any';
         } else {
             $q['post_type'] = '';
         }
     }
     $post_type = $q['post_type'];
     if (empty($q['posts_per_page'])) {
         $q['posts_per_page'] = get_option('posts_per_page');
     }
     if (isset($q['showposts']) && $q['showposts']) {
         $q['showposts'] = (int) $q['showposts'];
         $q['posts_per_page'] = $q['showposts'];
     }
     if (isset($q['posts_per_archive_page']) && $q['posts_per_archive_page'] != 0 && ($this->is_archive || $this->is_search)) {
         $q['posts_per_page'] = $q['posts_per_archive_page'];
     }
     if (!isset($q['nopaging'])) {
         if ($q['posts_per_page'] == -1) {
             $q['nopaging'] = true;
         } else {
             $q['nopaging'] = false;
         }
     }
     if ($this->is_feed) {
         // This overrides posts_per_page.
         if (!empty($q['posts_per_rss'])) {
             $q['posts_per_page'] = $q['posts_per_rss'];
         } else {
             $q['posts_per_page'] = get_option('posts_per_rss');
         }
         $q['nopaging'] = false;
     }
     $q['posts_per_page'] = (int) $q['posts_per_page'];
     if ($q['posts_per_page'] < -1) {
         $q['posts_per_page'] = abs($q['posts_per_page']);
     } elseif ($q['posts_per_page'] == 0) {
         $q['posts_per_page'] = 1;
     }
     if (!isset($q['comments_per_page']) || $q['comments_per_page'] == 0) {
         $q['comments_per_page'] = get_option('comments_per_page');
     }
     if ($this->is_home && (empty($this->query) || $q['preview'] == 'true') && 'page' == get_option('show_on_front') && get_option('page_on_front')) {
         $this->is_page = true;
         $this->is_home = false;
         $q['page_id'] = get_option('page_on_front');
     }
     if (isset($q['page'])) {
         $q['page'] = trim($q['page'], '/');
         $q['page'] = absint($q['page']);
     }
     // If true, forcibly turns off SQL_CALC_FOUND_ROWS even when limits are present.
     if (isset($q['no_found_rows'])) {
         $q['no_found_rows'] = (bool) $q['no_found_rows'];
     } else {
         $q['no_found_rows'] = false;
     }
     switch ($q['fields']) {
         case 'ids':
             $fields = "{$this->db->posts}.ID";
             break;
         case 'id=>parent':
             $fields = "{$this->db->posts}.ID, {$this->db->posts}.post_parent";
             break;
         default:
             $fields = "{$this->db->posts}.*";
     }
     if ('' !== $q['menu_order']) {
         $where .= " AND {$this->db->posts}.menu_order = " . $q['menu_order'];
     }
     // The "m" parameter is meant for months but accepts datetimes of varying specificity
     if ($q['m']) {
         $where .= " AND YEAR({$this->db->posts}.post_date)=" . substr($q['m'], 0, 4);
         if (strlen($q['m']) > 5) {
             $where .= " AND MONTH({$this->db->posts}.post_date)=" . substr($q['m'], 4, 2);
         }
         if (strlen($q['m']) > 7) {
             $where .= " AND DAYOFMONTH({$this->db->posts}.post_date)=" . substr($q['m'], 6, 2);
         }
         if (strlen($q['m']) > 9) {
             $where .= " AND HOUR({$this->db->posts}.post_date)=" . substr($q['m'], 8, 2);
         }
         if (strlen($q['m']) > 11) {
             $where .= " AND MINUTE({$this->db->posts}.post_date)=" . substr($q['m'], 10, 2);
         }
         if (strlen($q['m']) > 13) {
             $where .= " AND SECOND({$this->db->posts}.post_date)=" . substr($q['m'], 12, 2);
         }
     }
     // Handle the other individual date parameters
     $date_parameters = array();
     if ('' !== $q['hour']) {
         $date_parameters['hour'] = $q['hour'];
     }
     if ('' !== $q['minute']) {
         $date_parameters['minute'] = $q['minute'];
     }
     if ('' !== $q['second']) {
         $date_parameters['second'] = $q['second'];
     }
     if ($q['year']) {
         $date_parameters['year'] = $q['year'];
     }
     if ($q['monthnum']) {
         $date_parameters['monthnum'] = $q['monthnum'];
     }
     if ($q['w']) {
         $date_parameters['week'] = $q['w'];
     }
     if ($q['day']) {
         $date_parameters['day'] = $q['day'];
     }
     if ($date_parameters) {
         $date_query = new WP_Date_Query(array($date_parameters));
         $where .= $date_query->get_sql();
     }
     unset($date_parameters, $date_query);
     // Handle complex date queries
     if (!empty($q['date_query'])) {
         $this->date_query = new WP_Date_Query($q['date_query']);
         $where .= $this->date_query->get_sql();
     }
     // If we've got a post_type AND it's not "any" post_type.
     if (!empty($q['post_type']) && 'any' != $q['post_type']) {
         foreach ((array) $q['post_type'] as $_post_type) {
             $ptype_obj = get_post_type_object($_post_type);
             if (!$ptype_obj || !$ptype_obj->query_var || empty($q[$ptype_obj->query_var])) {
                 continue;
             }
             if (!$ptype_obj->hierarchical) {
                 // Non-hierarchical post types can directly use 'name'.
                 $q['name'] = $q[$ptype_obj->query_var];
             } else {
                 // Hierarchical post types will operate through 'pagename'.
                 $q['pagename'] = $q[$ptype_obj->query_var];
                 $q['name'] = '';
             }
             // Only one request for a slug is possible, this is why name & pagename are overwritten above.
             break;
         }
         //end foreach
         unset($ptype_obj);
     }
     if ('' !== $q['title']) {
         $where .= $this->db->prepare(" AND {$this->db->posts}.post_title = %s", stripslashes($q['title']));
     }
     // Parameters related to 'post_name'.
     if ('' != $q['name']) {
         $q['name'] = sanitize_title_for_query($q['name']);
         $where .= " AND {$this->db->posts}.post_name = '" . $q['name'] . "'";
     } elseif ('' != $q['pagename']) {
         if (isset($this->queried_object_id)) {
             $reqpage = $this->queried_object_id;
         } else {
             if ('page' != $q['post_type']) {
                 foreach ((array) $q['post_type'] as $_post_type) {
                     $ptype_obj = get_post_type_object($_post_type);
                     if (!$ptype_obj || !$ptype_obj->hierarchical) {
                         continue;
                     }
                     $reqpage = get_page_by_path($q['pagename'], OBJECT, $_post_type);
                     if ($reqpage) {
                         break;
                     }
                 }
                 unset($ptype_obj);
             } else {
                 $reqpage = get_page_by_path($q['pagename']);
             }
             if (!empty($reqpage)) {
                 $reqpage = $reqpage->ID;
             } else {
                 $reqpage = 0;
             }
         }
         $page_for_posts = get_option('page_for_posts');
         if ('page' != get_option('show_on_front') || empty($page_for_posts) || $reqpage != $page_for_posts) {
             $q['pagename'] = sanitize_title_for_query(wp_basename($q['pagename']));
             $q['name'] = $q['pagename'];
             $where .= " AND ({$this->db->posts}.ID = '{$reqpage}')";
             $reqpage_obj = get_post($reqpage);
             if (is_object($reqpage_obj) && 'attachment' == $reqpage_obj->post_type) {
                 $this->is_attachment = true;
                 $post_type = $q['post_type'] = 'attachment';
                 $this->is_page = true;
                 $q['attachment_id'] = $reqpage;
             }
         }
     } elseif ('' != $q['attachment']) {
         $q['attachment'] = sanitize_title_for_query(wp_basename($q['attachment']));
         $q['name'] = $q['attachment'];
         $where .= " AND {$this->db->posts}.post_name = '" . $q['attachment'] . "'";
     } elseif (is_array($q['post_name__in']) && !empty($q['post_name__in'])) {
         $q['post_name__in'] = array_map('sanitize_title_for_query', $q['post_name__in']);
         $post_name__in = "'" . implode("','", $q['post_name__in']) . "'";
         $where .= " AND {$this->db->posts}.post_name IN ({$post_name__in})";
     }
     // If an attachment is requested by number, let it supersede any post number.
     if ($q['attachment_id']) {
         $q['p'] = absint($q['attachment_id']);
     }
     // If a post number is specified, load that post
     if ($q['p']) {
         $where .= " AND {$this->db->posts}.ID = " . $q['p'];
     } elseif ($q['post__in']) {
         $post__in = implode(',', array_map('absint', $q['post__in']));
         $where .= " AND {$this->db->posts}.ID IN ({$post__in})";
     } elseif ($q['post__not_in']) {
         $post__not_in = implode(',', array_map('absint', $q['post__not_in']));
         $where .= " AND {$this->db->posts}.ID NOT IN ({$post__not_in})";
     }
     if (is_numeric($q['post_parent'])) {
         $where .= $this->db->prepare(" AND {$this->db->posts}.post_parent = %d ", $q['post_parent']);
     } elseif ($q['post_parent__in']) {
         $post_parent__in = implode(',', array_map('absint', $q['post_parent__in']));
         $where .= " AND {$this->db->posts}.post_parent IN ({$post_parent__in})";
     } elseif ($q['post_parent__not_in']) {
         $post_parent__not_in = implode(',', array_map('absint', $q['post_parent__not_in']));
         $where .= " AND {$this->db->posts}.post_parent NOT IN ({$post_parent__not_in})";
     }
     if ($q['page_id']) {
         if ('page' != get_option('show_on_front') || $q['page_id'] != get_option('page_for_posts')) {
             $q['p'] = $q['page_id'];
             $where = " AND {$this->db->posts}.ID = " . $q['page_id'];
         }
     }
     // If a search pattern is specified, load the posts that match.
     if (strlen($q['s'])) {
         $search = $this->parse_search($q);
     }
     if (!$q['suppress_filters']) {
         /**
          * Filters the search SQL that is used in the WHERE clause of WP_Query.
          *
          * @since 3.0.0
          *
          * @param string   $search Search SQL for WHERE clause.
          * @param WP_Query $this   The current WP_Query object.
          */
         $search = apply_filters_ref_array('posts_search', array($search, &$this));
     }
     // Taxonomies
     if (!$this->is_singular) {
         $this->parse_tax_query($q);
         $clauses = $this->tax_query->get_sql($this->db->posts, 'ID');
         $join .= $clauses['join'];
         $where .= $clauses['where'];
     }
     if ($this->is_tax) {
         if (empty($post_type)) {
             // Do a fully inclusive search for currently registered post types of queried taxonomies
             $post_type = array();
             $taxonomies = array_keys($this->tax_query->queried_terms);
             foreach (get_post_types(array('exclude_from_search' => false)) as $pt) {
                 $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
                 if (array_intersect($taxonomies, $object_taxonomies)) {
                     $post_type[] = $pt;
                 }
             }
             if (!$post_type) {
                 $post_type = 'any';
             } elseif (count($post_type) == 1) {
                 $post_type = $post_type[0];
             }
             $post_status_join = true;
         } elseif (in_array('attachment', (array) $post_type)) {
             $post_status_join = true;
         }
     }
     /*
      * Ensure that 'taxonomy', 'term', 'term_id', 'cat', and
      * 'category_name' vars are set for backward compatibility.
      */
     if (!empty($this->tax_query->queried_terms)) {
         /*
          * Set 'taxonomy', 'term', and 'term_id' to the
          * first taxonomy other than 'post_tag' or 'category'.
          */
         if (!isset($q['taxonomy'])) {
             foreach ($this->tax_query->queried_terms as $queried_taxonomy => $queried_items) {
                 if (empty($queried_items['terms'][0])) {
                     continue;
                 }
                 if (!in_array($queried_taxonomy, array('category', 'post_tag'))) {
                     $q['taxonomy'] = $queried_taxonomy;
                     if ('slug' === $queried_items['field']) {
                         $q['term'] = $queried_items['terms'][0];
                     } else {
                         $q['term_id'] = $queried_items['terms'][0];
                     }
                     // Take the first one we find.
                     break;
                 }
             }
         }
         // 'cat', 'category_name', 'tag_id'
         foreach ($this->tax_query->queried_terms as $queried_taxonomy => $queried_items) {
             if (empty($queried_items['terms'][0])) {
                 continue;
             }
             if ('category' === $queried_taxonomy) {
                 $the_cat = get_term_by($queried_items['field'], $queried_items['terms'][0], 'category');
                 if ($the_cat) {
                     $this->set('cat', $the_cat->term_id);
                     $this->set('category_name', $the_cat->slug);
                 }
                 unset($the_cat);
             }
             if ('post_tag' === $queried_taxonomy) {
                 $the_tag = get_term_by($queried_items['field'], $queried_items['terms'][0], 'post_tag');
                 if ($the_tag) {
                     $this->set('tag_id', $the_tag->term_id);
                 }
                 unset($the_tag);
             }
         }
     }
     if (!empty($this->tax_query->queries) || !empty($this->meta_query->queries)) {
         $groupby = "{$this->db->posts}.ID";
     }
     // Author/user stuff
     if (!empty($q['author']) && $q['author'] != '0') {
         $q['author'] = addslashes_gpc('' . urldecode($q['author']));
         $authors = array_unique(array_map('intval', preg_split('/[,\\s]+/', $q['author'])));
         foreach ($authors as $author) {
             $key = $author > 0 ? 'author__in' : 'author__not_in';
             $q[$key][] = abs($author);
         }
         $q['author'] = implode(',', $authors);
     }
     if (!empty($q['author__not_in'])) {
         $author__not_in = implode(',', array_map('absint', array_unique((array) $q['author__not_in'])));
         $where .= " AND {$this->db->posts}.post_author NOT IN ({$author__not_in}) ";
     } elseif (!empty($q['author__in'])) {
         $author__in = implode(',', array_map('absint', array_unique((array) $q['author__in'])));
         $where .= " AND {$this->db->posts}.post_author IN ({$author__in}) ";
     }
     // Author stuff for nice URLs
     if ('' != $q['author_name']) {
         if (strpos($q['author_name'], '/') !== false) {
             $q['author_name'] = explode('/', $q['author_name']);
             if ($q['author_name'][count($q['author_name']) - 1]) {
                 $q['author_name'] = $q['author_name'][count($q['author_name']) - 1];
                 // no trailing slash
             } else {
                 $q['author_name'] = $q['author_name'][count($q['author_name']) - 2];
                 // there was a trailing slash
             }
         }
         $q['author_name'] = sanitize_title_for_query($q['author_name']);
         $q['author'] = get_user_by('slug', $q['author_name']);
         if ($q['author']) {
             $q['author'] = $q['author']->ID;
         }
         $whichauthor .= " AND ({$this->db->posts}.post_author = " . absint($q['author']) . ')';
     }
     // MIME-Type stuff for attachment browsing
     if (isset($q['post_mime_type']) && '' != $q['post_mime_type']) {
         $whichmimetype = wp_post_mime_type_where($q['post_mime_type'], $this->db->posts);
     }
     $where .= $search . $whichauthor . $whichmimetype;
     if (!empty($this->meta_query->queries)) {
         $clauses = $this->meta_query->get_sql('post', $this->db->posts, 'ID', $this);
         $join .= $clauses['join'];
         $where .= $clauses['where'];
     }
     $rand = isset($q['orderby']) && 'rand' === $q['orderby'];
     if (!isset($q['order'])) {
         $q['order'] = $rand ? '' : 'DESC';
     } else {
         $q['order'] = $rand ? '' : $this->parse_order($q['order']);
     }
     // Order by.
     if (empty($q['orderby'])) {
         /*
          * Boolean false or empty array blanks out ORDER BY,
          * while leaving the value unset or otherwise empty sets the default.
          */
         if (isset($q['orderby']) && (is_array($q['orderby']) || false === $q['orderby'])) {
             $orderby = '';
         } else {
             $orderby = "{$this->db->posts}.post_date " . $q['order'];
         }
     } elseif ('none' == $q['orderby']) {
         $orderby = '';
     } elseif ($q['orderby'] == 'post__in' && !empty($post__in)) {
         $orderby = "FIELD( {$this->db->posts}.ID, {$post__in} )";
     } elseif ($q['orderby'] == 'post_parent__in' && !empty($post_parent__in)) {
         $orderby = "FIELD( {$this->db->posts}.post_parent, {$post_parent__in} )";
     } elseif ($q['orderby'] == 'post_name__in' && !empty($post_name__in)) {
         $orderby = "FIELD( {$this->db->posts}.post_name, {$post_name__in} )";
     } else {
         $orderby_array = array();
         if (is_array($q['orderby'])) {
             foreach ($q['orderby'] as $_orderby => $order) {
                 $orderby = addslashes_gpc(urldecode($_orderby));
                 $parsed = $this->parse_orderby($orderby);
                 if (!$parsed) {
                     continue;
                 }
                 $orderby_array[] = $parsed . ' ' . $this->parse_order($order);
             }
             $orderby = implode(', ', $orderby_array);
         } else {
             $q['orderby'] = urldecode($q['orderby']);
             $q['orderby'] = addslashes_gpc($q['orderby']);
             foreach (explode(' ', $q['orderby']) as $i => $orderby) {
                 $parsed = $this->parse_orderby($orderby);
                 // Only allow certain values for safety.
                 if (!$parsed) {
                     continue;
                 }
                 $orderby_array[] = $parsed;
             }
             $orderby = implode(' ' . $q['order'] . ', ', $orderby_array);
             if (empty($orderby)) {
                 $orderby = "{$this->db->posts}.post_date " . $q['order'];
             } elseif (!empty($q['order'])) {
                 $orderby .= " {$q['order']}";
             }
         }
     }
     // Order search results by relevance only when another "orderby" is not specified in the query.
     if (!empty($q['s'])) {
         $search_orderby = '';
         if (!empty($q['search_orderby_title']) && (empty($q['orderby']) && !$this->is_feed) || isset($q['orderby']) && 'relevance' === $q['orderby']) {
             $search_orderby = $this->parse_search_order($q);
         }
         if (!$q['suppress_filters']) {
             /**
              * Filters the ORDER BY used when ordering search results.
              *
              * @since 3.7.0
              *
              * @param string   $search_orderby The ORDER BY clause.
              * @param WP_Query $this           The current WP_Query instance.
              */
             $search_orderby = apply_filters('posts_search_orderby', $search_orderby, $this);
         }
         if ($search_orderby) {
             $orderby = $orderby ? $search_orderby . ', ' . $orderby : $search_orderby;
         }
     }
     if (is_array($post_type) && count($post_type) > 1) {
         $post_type_cap = 'multiple_post_type';
     } else {
         if (is_array($post_type)) {
             $post_type = reset($post_type);
         }
         $post_type_object = get_post_type_object($post_type);
         if (empty($post_type_object)) {
             $post_type_cap = $post_type;
         }
     }
     if (isset($q['post_password'])) {
         $where .= $this->db->prepare(" AND {$this->db->posts}.post_password = %s", $q['post_password']);
         if (empty($q['perm'])) {
             $q['perm'] = 'readable';
         }
     } elseif (isset($q['has_password'])) {
         $where .= sprintf(" AND {$this->db->posts}.post_password %s ''", $q['has_password'] ? '!=' : '=');
     }
     if (!empty($q['comment_status'])) {
         $where .= $this->db->prepare(" AND {$this->db->posts}.comment_status = %s ", $q['comment_status']);
     }
     if (!empty($q['ping_status'])) {
         $where .= $this->db->prepare(" AND {$this->db->posts}.ping_status = %s ", $q['ping_status']);
     }
     if ('any' == $post_type) {
         $in_search_post_types = get_post_types(array('exclude_from_search' => false));
         if (empty($in_search_post_types)) {
             $where .= ' AND 1=0 ';
         } else {
             $where .= " AND {$this->db->posts}.post_type IN ('" . join("', '", $in_search_post_types) . "')";
         }
     } elseif (!empty($post_type) && is_array($post_type)) {
         $where .= " AND {$this->db->posts}.post_type IN ('" . join("', '", $post_type) . "')";
     } elseif (!empty($post_type)) {
         $where .= " AND {$this->db->posts}.post_type = '{$post_type}'";
         $post_type_object = get_post_type_object($post_type);
     } elseif ($this->is_attachment) {
         $where .= " AND {$this->db->posts}.post_type = 'attachment'";
         $post_type_object = get_post_type_object('attachment');
     } elseif ($this->is_page) {
         $where .= " AND {$this->db->posts}.post_type = 'page'";
         $post_type_object = get_post_type_object('page');
     } else {
         $where .= " AND {$this->db->posts}.post_type = 'post'";
         $post_type_object = get_post_type_object('post');
     }
     $edit_cap = 'edit_post';
     $read_cap = 'read_post';
     if (!empty($post_type_object)) {
         $edit_others_cap = $post_type_object->cap->edit_others_posts;
         $read_private_cap = $post_type_object->cap->read_private_posts;
     } else {
         $edit_others_cap = 'edit_others_' . $post_type_cap . 's';
         $read_private_cap = 'read_private_' . $post_type_cap . 's';
     }
     $user_id = get_current_user_id();
     $q_status = array();
     if (!empty($q['post_status'])) {
         $statuswheres = array();
         $q_status = $q['post_status'];
         if (!is_array($q_status)) {
             $q_status = explode(',', $q_status);
         }
         $r_status = array();
         $p_status = array();
         $e_status = array();
         if (in_array('any', $q_status)) {
             foreach (get_post_stati(array('exclude_from_search' => true)) as $status) {
                 if (!in_array($status, $q_status)) {
                     $e_status[] = "{$this->db->posts}.post_status <> '{$status}'";
                 }
             }
         } else {
             foreach (get_post_stati() as $status) {
                 if (in_array($status, $q_status)) {
                     if ('private' == $status) {
                         $p_status[] = "{$this->db->posts}.post_status = '{$status}'";
                     } else {
                         $r_status[] = "{$this->db->posts}.post_status = '{$status}'";
                     }
                 }
             }
         }
         if (empty($q['perm']) || 'readable' != $q['perm']) {
             $r_status = array_merge($r_status, $p_status);
             unset($p_status);
         }
         if (!empty($e_status)) {
             $statuswheres[] = "(" . join(' AND ', $e_status) . ")";
         }
         if (!empty($r_status)) {
             if (!empty($q['perm']) && 'editable' == $q['perm'] && !current_user_can($edit_others_cap)) {
                 $statuswheres[] = "({$this->db->posts}.post_author = {$user_id} " . "AND (" . join(' OR ', $r_status) . "))";
             } else {
                 $statuswheres[] = "(" . join(' OR ', $r_status) . ")";
             }
         }
         if (!empty($p_status)) {
             if (!empty($q['perm']) && 'readable' == $q['perm'] && !current_user_can($read_private_cap)) {
                 $statuswheres[] = "({$this->db->posts}.post_author = {$user_id} " . "AND (" . join(' OR ', $p_status) . "))";
             } else {
                 $statuswheres[] = "(" . join(' OR ', $p_status) . ")";
             }
         }
         if ($post_status_join) {
             $join .= " LEFT JOIN {$this->db->posts} AS p2 ON ({$this->db->posts}.post_parent = p2.ID) ";
             foreach ($statuswheres as $index => $statuswhere) {
                 $statuswheres[$index] = "({$statuswhere} OR ({$this->db->posts}.post_status = 'inherit' AND " . str_replace($this->db->posts, 'p2', $statuswhere) . "))";
             }
         }
         $where_status = implode(' OR ', $statuswheres);
         if (!empty($where_status)) {
             $where .= " AND ({$where_status})";
         }
     } elseif (!$this->is_singular) {
         $where .= " AND ({$this->db->posts}.post_status = 'publish'";
         // Add public states.
         $public_states = get_post_stati(array('public' => true));
         foreach ((array) $public_states as $state) {
             if ('publish' == $state) {
                 // Publish is hard-coded above.
                 continue;
             }
             $where .= " OR {$this->db->posts}.post_status = '{$state}'";
         }
         if ($this->is_admin) {
             // Add protected states that should show in the admin all list.
             $admin_all_states = get_post_stati(array('protected' => true, 'show_in_admin_all_list' => true));
             foreach ((array) $admin_all_states as $state) {
                 $where .= " OR {$this->db->posts}.post_status = '{$state}'";
             }
         }
         if (is_user_logged_in()) {
             // Add private states that are limited to viewing by the author of a post or someone who has caps to read private states.
             $private_states = get_post_stati(array('private' => true));
             foreach ((array) $private_states as $state) {
                 $where .= current_user_can($read_private_cap) ? " OR {$this->db->posts}.post_status = '{$state}'" : " OR {$this->db->posts}.post_author = {$user_id} AND {$this->db->posts}.post_status = '{$state}'";
             }
         }
         $where .= ')';
     }
     /*
      * Apply filters on where and join prior to paging so that any
      * manipulations to them are reflected in the paging by day queries.
      */
     if (!$q['suppress_filters']) {
         /**
          * Filters the WHERE clause of the query.
          *
          * @since 1.5.0
          *
          * @param string   $where The WHERE clause of the query.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $where = apply_filters_ref_array('posts_where', array($where, &$this));
         /**
          * Filters the JOIN clause of the query.
          *
          * @since 1.5.0
          *
          * @param string   $where The JOIN clause of the query.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $join = apply_filters_ref_array('posts_join', array($join, &$this));
     }
     // Paging
     if (empty($q['nopaging']) && !$this->is_singular) {
         $page = absint($q['paged']);
         if (!$page) {
             $page = 1;
         }
         // If 'offset' is provided, it takes precedence over 'paged'.
         if (isset($q['offset']) && is_numeric($q['offset'])) {
             $q['offset'] = absint($q['offset']);
             $pgstrt = $q['offset'] . ', ';
         } else {
             $pgstrt = absint(($page - 1) * $q['posts_per_page']) . ', ';
         }
         $limits = 'LIMIT ' . $pgstrt . $q['posts_per_page'];
     }
     // Comments feeds
     if ($this->is_comment_feed && !$this->is_singular) {
         if ($this->is_archive || $this->is_search) {
             $cjoin = "JOIN {$this->db->posts} ON ({$this->db->comments}.comment_post_ID = {$this->db->posts}.ID) {$join} ";
             $cwhere = "WHERE comment_approved = '1' {$where}";
             $cgroupby = "{$this->db->comments}.comment_id";
         } else {
             // Other non singular e.g. front
             $cjoin = "JOIN {$this->db->posts} ON ( {$this->db->comments}.comment_post_ID = {$this->db->posts}.ID )";
             $cwhere = "WHERE ( post_status = 'publish' OR ( post_status = 'inherit' && post_type = 'attachment' ) ) AND comment_approved = '1'";
             $cgroupby = '';
         }
         if (!$q['suppress_filters']) {
             /**
              * Filters the JOIN clause of the comments feed query before sending.
              *
              * @since 2.2.0
              *
              * @param string   $cjoin The JOIN clause of the query.
              * @param WP_Query &$this The WP_Query instance (passed by reference).
              */
             $cjoin = apply_filters_ref_array('comment_feed_join', array($cjoin, &$this));
             /**
              * Filters the WHERE clause of the comments feed query before sending.
              *
              * @since 2.2.0
              *
              * @param string   $cwhere The WHERE clause of the query.
              * @param WP_Query &$this  The WP_Query instance (passed by reference).
              */
             $cwhere = apply_filters_ref_array('comment_feed_where', array($cwhere, &$this));
             /**
              * Filters the GROUP BY clause of the comments feed query before sending.
              *
              * @since 2.2.0
              *
              * @param string   $cgroupby The GROUP BY clause of the query.
              * @param WP_Query &$this    The WP_Query instance (passed by reference).
              */
             $cgroupby = apply_filters_ref_array('comment_feed_groupby', array($cgroupby, &$this));
             /**
              * Filters the ORDER BY clause of the comments feed query before sending.
              *
              * @since 2.8.0
              *
              * @param string   $corderby The ORDER BY clause of the query.
              * @param WP_Query &$this    The WP_Query instance (passed by reference).
              */
             $corderby = apply_filters_ref_array('comment_feed_orderby', array('comment_date_gmt DESC', &$this));
             /**
              * Filters the LIMIT clause of the comments feed query before sending.
              *
              * @since 2.8.0
              *
              * @param string   $climits The JOIN clause of the query.
              * @param WP_Query &$this   The WP_Query instance (passed by reference).
              */
             $climits = apply_filters_ref_array('comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
         }
         $cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
         $corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
         $comments = (array) $this->db->get_results("SELECT {$distinct} {$this->db->comments}.* FROM {$this->db->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}");
         // Convert to WP_Comment
         $this->comments = array_map('get_comment', $comments);
         $this->comment_count = count($this->comments);
         $post_ids = array();
         foreach ($this->comments as $comment) {
             $post_ids[] = (int) $comment->comment_post_ID;
         }
         $post_ids = join(',', $post_ids);
         $join = '';
         if ($post_ids) {
             $where = "AND {$this->db->posts}.ID IN ({$post_ids}) ";
         } else {
             $where = "AND 0";
         }
     }
     $pieces = array('where', 'groupby', 'join', 'orderby', 'distinct', 'fields', 'limits');
     /*
      * Apply post-paging filters on where and join. Only plugins that
      * manipulate paging queries should use these hooks.
      */
     if (!$q['suppress_filters']) {
         /**
          * Filters the WHERE clause of the query.
          *
          * Specifically for manipulating paging queries.
          *
          * @since 1.5.0
          *
          * @param string   $where The WHERE clause of the query.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $where = apply_filters_ref_array('posts_where_paged', array($where, &$this));
         /**
          * Filters the GROUP BY clause of the query.
          *
          * @since 2.0.0
          *
          * @param string   $groupby The GROUP BY clause of the query.
          * @param WP_Query &$this   The WP_Query instance (passed by reference).
          */
         $groupby = apply_filters_ref_array('posts_groupby', array($groupby, &$this));
         /**
          * Filters the JOIN clause of the query.
          *
          * Specifically for manipulating paging queries.
          *
          * @since 1.5.0
          *
          * @param string   $join  The JOIN clause of the query.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $join = apply_filters_ref_array('posts_join_paged', array($join, &$this));
         /**
          * Filters the ORDER BY clause of the query.
          *
          * @since 1.5.1
          *
          * @param string   $orderby The ORDER BY clause of the query.
          * @param WP_Query &$this   The WP_Query instance (passed by reference).
          */
         $orderby = apply_filters_ref_array('posts_orderby', array($orderby, &$this));
         /**
          * Filters the DISTINCT clause of the query.
          *
          * @since 2.1.0
          *
          * @param string   $distinct The DISTINCT clause of the query.
          * @param WP_Query &$this    The WP_Query instance (passed by reference).
          */
         $distinct = apply_filters_ref_array('posts_distinct', array($distinct, &$this));
         /**
          * Filters the LIMIT clause of the query.
          *
          * @since 2.1.0
          *
          * @param string   $limits The LIMIT clause of the query.
          * @param WP_Query &$this  The WP_Query instance (passed by reference).
          */
         $limits = apply_filters_ref_array('post_limits', array($limits, &$this));
         /**
          * Filters the SELECT clause of the query.
          *
          * @since 2.1.0
          *
          * @param string   $fields The SELECT clause of the query.
          * @param WP_Query &$this  The WP_Query instance (passed by reference).
          */
         $fields = apply_filters_ref_array('posts_fields', array($fields, &$this));
         /**
          * Filters all query clauses at once, for convenience.
          *
          * Covers the WHERE, GROUP BY, JOIN, ORDER BY, DISTINCT,
          * fields (SELECT), and LIMITS clauses.
          *
          * @since 3.1.0
          *
          * @param array    $clauses The list of clauses for the query.
          * @param WP_Query &$this   The WP_Query instance (passed by reference).
          */
         $clauses = (array) apply_filters_ref_array('posts_clauses', array(compact($pieces), &$this));
         $where = isset($clauses['where']) ? $clauses['where'] : '';
         $groupby = isset($clauses['groupby']) ? $clauses['groupby'] : '';
         $join = isset($clauses['join']) ? $clauses['join'] : '';
         $orderby = isset($clauses['orderby']) ? $clauses['orderby'] : '';
         $distinct = isset($clauses['distinct']) ? $clauses['distinct'] : '';
         $fields = isset($clauses['fields']) ? $clauses['fields'] : '';
         $limits = isset($clauses['limits']) ? $clauses['limits'] : '';
     }
     /**
      * Fires to announce the query's current selection parameters.
      *
      * For use by caching plugins.
      *
      * @since 2.3.0
      *
      * @param string $selection The assembled selection query.
      */
     do_action('posts_selection', $where . $groupby . $orderby . $limits . $join);
     /*
      * Filters again for the benefit of caching plugins.
      * Regular plugins should use the hooks above.
      */
     if (!$q['suppress_filters']) {
         /**
          * Filters the WHERE clause of the query.
          *
          * For use by caching plugins.
          *
          * @since 2.5.0
          *
          * @param string   $where The WHERE clause of the query.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $where = apply_filters_ref_array('posts_where_request', array($where, &$this));
         /**
          * Filters the GROUP BY clause of the query.
          *
          * For use by caching plugins.
          *
          * @since 2.5.0
          *
          * @param string   $groupby The GROUP BY clause of the query.
          * @param WP_Query &$this   The WP_Query instance (passed by reference).
          */
         $groupby = apply_filters_ref_array('posts_groupby_request', array($groupby, &$this));
         /**
          * Filters the JOIN clause of the query.
          *
          * For use by caching plugins.
          *
          * @since 2.5.0
          *
          * @param string   $join  The JOIN clause of the query.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $join = apply_filters_ref_array('posts_join_request', array($join, &$this));
         /**
          * Filters the ORDER BY clause of the query.
          *
          * For use by caching plugins.
          *
          * @since 2.5.0
          *
          * @param string   $orderby The ORDER BY clause of the query.
          * @param WP_Query &$this   The WP_Query instance (passed by reference).
          */
         $orderby = apply_filters_ref_array('posts_orderby_request', array($orderby, &$this));
         /**
          * Filters the DISTINCT clause of the query.
          *
          * For use by caching plugins.
          *
          * @since 2.5.0
          *
          * @param string   $distinct The DISTINCT clause of the query.
          * @param WP_Query &$this    The WP_Query instance (passed by reference).
          */
         $distinct = apply_filters_ref_array('posts_distinct_request', array($distinct, &$this));
         /**
          * Filters the SELECT clause of the query.
          *
          * For use by caching plugins.
          *
          * @since 2.5.0
          *
          * @param string   $fields The SELECT clause of the query.
          * @param WP_Query &$this  The WP_Query instance (passed by reference).
          */
         $fields = apply_filters_ref_array('posts_fields_request', array($fields, &$this));
         /**
          * Filters the LIMIT clause of the query.
          *
          * For use by caching plugins.
          *
          * @since 2.5.0
          *
          * @param string   $limits The LIMIT clause of the query.
          * @param WP_Query &$this  The WP_Query instance (passed by reference).
          */
         $limits = apply_filters_ref_array('post_limits_request', array($limits, &$this));
         /**
          * Filters all query clauses at once, for convenience.
          *
          * For use by caching plugins.
          *
          * Covers the WHERE, GROUP BY, JOIN, ORDER BY, DISTINCT,
          * fields (SELECT), and LIMITS clauses.
          *
          * @since 3.1.0
          *
          * @param array    $pieces The pieces of the query.
          * @param WP_Query &$this  The WP_Query instance (passed by reference).
          */
         $clauses = (array) apply_filters_ref_array('posts_clauses_request', array(compact($pieces), &$this));
         $where = isset($clauses['where']) ? $clauses['where'] : '';
         $groupby = isset($clauses['groupby']) ? $clauses['groupby'] : '';
         $join = isset($clauses['join']) ? $clauses['join'] : '';
         $orderby = isset($clauses['orderby']) ? $clauses['orderby'] : '';
         $distinct = isset($clauses['distinct']) ? $clauses['distinct'] : '';
         $fields = isset($clauses['fields']) ? $clauses['fields'] : '';
         $limits = isset($clauses['limits']) ? $clauses['limits'] : '';
     }
     if (!empty($groupby)) {
         $groupby = 'GROUP BY ' . $groupby;
     }
     if (!empty($orderby)) {
         $orderby = 'ORDER BY ' . $orderby;
     }
     $found_rows = '';
     if (!$q['no_found_rows'] && !empty($limits)) {
         $found_rows = 'SQL_CALC_FOUND_ROWS';
     }
     $this->request = $old_request = "SELECT {$found_rows} {$distinct} {$fields} FROM {$this->db->posts} {$join} WHERE 1=1 {$where} {$groupby} {$orderby} {$limits}";
     if (!$q['suppress_filters']) {
         /**
          * Filters the completed SQL query before sending.
          *
          * @since 2.0.0
          *
          * @param string   $request The complete SQL query.
          * @param WP_Query &$this   The WP_Query instance (passed by reference).
          */
         $this->request = apply_filters_ref_array('posts_request', array($this->request, &$this));
     }
     /**
      * Filters the posts array before the query takes place.
      *
      * Return a non-null value to bypass WordPress's default post queries.
      *
      * Filtering functions that require pagination information are encouraged to set
      * the `found_posts` and `max_num_pages` properties of the WP_Query object,
      * passed to the filter by reference. If WP_Query does not perform a database
      * query, it will not have enough information to generate these values itself.
      *
      * @since 4.6.0
      *
      * @param array|null $posts Return an array of post data to short-circuit WP's query,
      *                          or null to allow WP to run its normal queries.
      * @param WP_Query   $this  The WP_Query instance, passed by reference.
      */
     $this->posts = apply_filters_ref_array('posts_pre_query', array(null, &$this));
     if ('ids' == $q['fields']) {
         if (null === $this->posts) {
             $this->posts = $this->db->get_col($this->request);
         }
         $this->posts = array_map('intval', $this->posts);
         $this->post_count = count($this->posts);
         $this->set_found_posts($q, $limits);
         return $this->posts;
     }
     if ('id=>parent' == $q['fields']) {
         if (null === $this->posts) {
             $this->posts = $this->db->get_results($this->request);
         }
         $this->post_count = count($this->posts);
         $this->set_found_posts($q, $limits);
         $r = array();
         foreach ($this->posts as $key => $post) {
             $this->posts[$key]->ID = (int) $post->ID;
             $this->posts[$key]->post_parent = (int) $post->post_parent;
             $r[(int) $post->ID] = (int) $post->post_parent;
         }
         return $r;
     }
     if (null === $this->posts) {
         $split_the_query = $old_request == $this->request && "{$this->db->posts}.*" == $fields && !empty($limits) && $q['posts_per_page'] < 500;
         /**
          * Filters whether to split the query.
          *
          * Splitting the query will cause it to fetch just the IDs of the found posts
          * (and then individually fetch each post by ID), rather than fetching every
          * complete row at once. One massive result vs. many small results.
          *
          * @since 3.4.0
          *
          * @param bool     $split_the_query Whether or not to split the query.
          * @param WP_Query $this            The WP_Query instance.
          */
         $split_the_query = apply_filters('split_the_query', $split_the_query, $this);
         if ($split_the_query) {
             // First get the IDs and then fill in the objects
             $this->request = "SELECT {$found_rows} {$distinct} {$this->db->posts}.ID FROM {$this->db->posts} {$join} WHERE 1=1 {$where} {$groupby} {$orderby} {$limits}";
             /**
              * Filters the Post IDs SQL request before sending.
              *
              * @since 3.4.0
              *
              * @param string   $request The post ID request.
              * @param WP_Query $this    The WP_Query instance.
              */
             $this->request = apply_filters('posts_request_ids', $this->request, $this);
             $ids = $this->db->get_col($this->request);
             if ($ids) {
                 $this->posts = $ids;
                 $this->set_found_posts($q, $limits);
                 _prime_post_caches($ids, $q['update_post_term_cache'], $q['update_post_meta_cache']);
             } else {
                 $this->posts = array();
             }
         } else {
             $this->posts = $this->db->get_results($this->request);
             $this->set_found_posts($q, $limits);
         }
     }
     // Convert to WP_Post objects.
     if ($this->posts) {
         $this->posts = array_map('get_post', $this->posts);
     }
     if (!$q['suppress_filters']) {
         /**
          * Filters the raw post results array, prior to status checks.
          *
          * @since 2.3.0
          *
          * @param array    $posts The post results array.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $this->posts = apply_filters_ref_array('posts_results', array($this->posts, &$this));
     }
     if (!empty($this->posts) && $this->is_comment_feed && $this->is_singular) {
         /** This filter is documented in wp-includes/query.php */
         $cjoin = apply_filters_ref_array('comment_feed_join', array('', &$this));
         /** This filter is documented in wp-includes/query.php */
         $cwhere = apply_filters_ref_array('comment_feed_where', array("WHERE comment_post_ID = '{$this->posts[0]->ID}' AND comment_approved = '1'", &$this));
         /** This filter is documented in wp-includes/query.php */
         $cgroupby = apply_filters_ref_array('comment_feed_groupby', array('', &$this));
         $cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
         /** This filter is documented in wp-includes/query.php */
         $corderby = apply_filters_ref_array('comment_feed_orderby', array('comment_date_gmt DESC', &$this));
         $corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
         /** This filter is documented in wp-includes/query.php */
         $climits = apply_filters_ref_array('comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
         $comments_request = "SELECT {$this->db->comments}.* FROM {$this->db->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}";
         $comments = $this->db->get_results($comments_request);
         // Convert to WP_Comment
         $this->comments = array_map('get_comment', $comments);
         $this->comment_count = count($this->comments);
     }
     // Check post status to determine if post should be displayed.
     if (!empty($this->posts) && ($this->is_single || $this->is_page)) {
         $status = get_post_status($this->posts[0]);
         if ('attachment' === $this->posts[0]->post_type && 0 === (int) $this->posts[0]->post_parent) {
             $this->is_page = false;
             $this->is_single = true;
             $this->is_attachment = true;
         }
         $post_status_obj = get_post_status_object($status);
         // If the post_status was specifically requested, let it pass through.
         if (!$post_status_obj->public && !in_array($status, $q_status)) {
             if (!is_user_logged_in()) {
                 // User must be logged in to view unpublished posts.
                 $this->posts = array();
             } else {
                 if ($post_status_obj->protected) {
                     // User must have edit permissions on the draft to preview.
                     if (!current_user_can($edit_cap, $this->posts[0]->ID)) {
                         $this->posts = array();
                     } else {
                         $this->is_preview = true;
                         if ('future' != $status) {
                             $this->posts[0]->post_date = current_time('mysql');
                         }
                     }
                 } elseif ($post_status_obj->private) {
                     if (!current_user_can($read_cap, $this->posts[0]->ID)) {
                         $this->posts = array();
                     }
                 } else {
                     $this->posts = array();
                 }
             }
         }
         if ($this->is_preview && $this->posts && current_user_can($edit_cap, $this->posts[0]->ID)) {
             /**
              * Filters the single post for preview mode.
              *
              * @since 2.7.0
              *
              * @param WP_Post  $post_preview  The Post object.
              * @param WP_Query &$this         The WP_Query instance (passed by reference).
              */
             $this->posts[0] = get_post(apply_filters_ref_array('the_preview', array($this->posts[0], &$this)));
         }
     }
     // Put sticky posts at the top of the posts array
     $sticky_posts = get_option('sticky_posts');
     if ($this->is_home && $page <= 1 && is_array($sticky_posts) && !empty($sticky_posts) && !$q['ignore_sticky_posts']) {
         $num_posts = count($this->posts);
         $sticky_offset = 0;
         // Loop over posts and relocate stickies to the front.
         for ($i = 0; $i < $num_posts; $i++) {
             if (in_array($this->posts[$i]->ID, $sticky_posts)) {
                 $sticky_post = $this->posts[$i];
                 // Remove sticky from current position
                 array_splice($this->posts, $i, 1);
                 // Move to front, after other stickies
                 array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
                 // Increment the sticky offset. The next sticky will be placed at this offset.
                 $sticky_offset++;
                 // Remove post from sticky posts array
                 $offset = array_search($sticky_post->ID, $sticky_posts);
                 unset($sticky_posts[$offset]);
             }
         }
         // If any posts have been excluded specifically, Ignore those that are sticky.
         if (!empty($sticky_posts) && !empty($q['post__not_in'])) {
             $sticky_posts = array_diff($sticky_posts, $q['post__not_in']);
         }
         // Fetch sticky posts that weren't in the query results
         if (!empty($sticky_posts)) {
             $stickies = get_posts(array('post__in' => $sticky_posts, 'post_type' => $post_type, 'post_status' => 'publish', 'nopaging' => true));
             foreach ($stickies as $sticky_post) {
                 array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
                 $sticky_offset++;
             }
         }
     }
     // If comments have been fetched as part of the query, make sure comment meta lazy-loading is set up.
     if (!empty($this->comments)) {
         wp_queue_comments_for_comment_meta_lazyload($this->comments);
     }
     if (!$q['suppress_filters']) {
         /**
          * Filters the array of retrieved posts after they've been fetched and
          * internally processed.
          *
          * @since 1.5.0
          *
          * @param array    $posts The array of retrieved posts.
          * @param WP_Query &$this The WP_Query instance (passed by reference).
          */
         $this->posts = apply_filters_ref_array('the_posts', array($this->posts, &$this));
     }
     // Ensure that any posts added/modified via one of the filters above are
     // of the type WP_Post and are filtered.
     if ($this->posts) {
         $this->post_count = count($this->posts);
         $this->posts = array_map('get_post', $this->posts);
         if ($q['cache_results']) {
             update_post_caches($this->posts, $post_type, $q['update_post_term_cache'], $q['update_post_meta_cache']);
         }
         $this->post = reset($this->posts);
     } else {
         $this->post_count = 0;
         $this->posts = array();
     }
     if ($q['lazy_load_term_meta']) {
         wp_queue_posts_for_term_meta_lazyload($this->posts);
     }
     return $this->posts;
 }
 public function get_columns()
 {
     $posts_columns = array();
     $posts_columns['cb'] = '<input type="checkbox" />';
     $posts_columns['icon'] = '';
     /* translators: column name */
     $posts_columns['title'] = _x('File', 'column name');
     $posts_columns['author'] = __('Author');
     $taxonomies = get_taxonomies_for_attachments('objects');
     $taxonomies = wp_filter_object_list($taxonomies, array('show_admin_column' => true), 'and', 'name');
     /**
      * Filter the taxonomy columns for attachments in the Media list table.
      *
      * @since 3.5.0
      *
      * @param array $taxonomies An array of registered taxonomies to show for attachments.
      * @param string $post_type The post type. Default 'attachment'.
      */
     $taxonomies = apply_filters('manage_taxonomies_for_attachment_columns', $taxonomies, 'attachment');
     $taxonomies = array_filter($taxonomies, 'taxonomy_exists');
     foreach ($taxonomies as $taxonomy) {
         if ('category' == $taxonomy) {
             $column_key = 'categories';
         } elseif ('post_tag' == $taxonomy) {
             $column_key = 'tags';
         } else {
             $column_key = 'taxonomy-' . $taxonomy;
         }
         $posts_columns[$column_key] = get_taxonomy($taxonomy)->labels->name;
     }
     /* translators: column name */
     if (!$this->detached) {
         $posts_columns['parent'] = _x('Uploaded to', 'column name');
         if (post_type_supports('attachment', 'comments')) {
             $posts_columns['comments'] = '<span class="vers"><span title="' . esc_attr__('Comments') . '" class="comment-grey-bubble"></span></span>';
         }
     }
     /* translators: column name */
     $posts_columns['date'] = _x('Date', 'column name');
     /**
      * Filter the Media list table columns.
      *
      * @since 2.5.0
      *
      * @param array $posts_columns An array of columns displayed in the Media list table.
      * @param bool $detached Whether the list table contains media not attached
      *                             to any posts. Default true.
      */
     $posts_columns = apply_filters('manage_media_columns', $posts_columns, $this->detached);
     return $posts_columns;
 }
示例#6
0
文件: MENU.PHP 项目: pauEscarcia/AIMM
	$submenu['edit.php'][10]  = array( _x('Add New', 'post'), get_post_type_object( 'post' )->cap->create_posts, 'post-new.php' );

	$i = 15;
	foreach ( get_taxonomies( array(), 'objects' ) as $tax ) {
		if ( ! $tax->show_ui || ! in_array('post', (array) $tax->object_type, true) )
			continue;

		$submenu['edit.php'][$i++] = array( esc_attr( $tax->labels->menu_name ), $tax->cap->manage_terms, 'edit-tags.php?taxonomy=' . $tax->name );
	}
	unset($tax);

$menu[10] = array( __('Media'), 'upload_files', 'upload.php', '', 'menu-top menu-icon-media', 'menu-media', 'none' );
	$submenu['upload.php'][5] = array( __('Library'), 'upload_files', 'upload.php');
	/* translators: add new file */
	$submenu['upload.php'][10] = array( _x('Add New', 'file'), 'upload_files', 'media-new.php');
	foreach ( get_taxonomies_for_attachments( 'objects' ) as $tax ) {
		if ( ! $tax->show_ui )
			continue;

		$submenu['upload.php'][$i++] = array( esc_attr( $tax->labels->menu_name ), $tax->cap->manage_terms, 'edit-tags.php?taxonomy=' . $tax->name . '&amp;post_type=attachment' );
	}
	unset($tax);

$menu[15] = array( __('Links'), 'manage_links', 'link-manager.php', '', 'menu-top menu-icon-links', 'menu-links', 'none' );
	$submenu['link-manager.php'][5] = array( _x('All Links', 'admin menu'), 'manage_links', 'link-manager.php' );
	/* translators: add new links */
	$submenu['link-manager.php'][10] = array( _x('Add New', 'link'), 'manage_links', 'link-add.php' );
	$submenu['link-manager.php'][15] = array( __('Link Categories'), 'manage_categories', 'edit-tags.php?taxonomy=link_category' );

$menu[20] = array( __('Pages'), 'edit_pages', 'edit.php?post_type=page', '', 'menu-top menu-icon-page', 'menu-pages', 'none' );
	$submenu['edit.php?post_type=page'][5] = array( __('All Pages'), 'edit_pages', 'edit.php?post_type=page' );
 function query_get_post_types($query, $_if_empty_set_post_types = FALSE)
 {
     $query_post_types = isset($query->query_vars['post_type']) ? $query->query_vars['post_type'] : array();
     if (!empty($query_post_types) && !is_array($query_post_types)) {
         $query_post_types = (array) $query_post_types;
     }
     if (empty($query_post_types) && !is_array($query_post_types)) {
         $query_post_types = array();
     }
     /**
      * 
      *   If empty post type query field AND use default category taxonomy, use post
      *   To check further
      * 
      */
     if (empty($query_post_types) && $_if_empty_set_post_types === FALSE) {
         $taxonomies = array();
         if (isset($query->tax_query) && isset($query->tax_query->queries)) {
             $taxonomies = APTO_query_utils::get_query_taxonomies($query->tax_query->queries);
         }
         if (count($taxonomies) > 0 && count($taxonomies) < 2) {
             reset($taxonomies);
             $query_taxonomy = current($taxonomies);
             if ($query_taxonomy == 'category') {
                 $query_post_types[] = 'post';
             }
         }
     }
     if (empty($query_post_types) && $_if_empty_set_post_types === TRUE) {
         $taxonomies = array();
         if (isset($query->tax_query) && isset($query->tax_query->queries)) {
             $taxonomies = APTO_query_utils::get_query_taxonomies($query->tax_query->queries);
         }
         $ignore = array('revision', 'nav_menu_item');
         foreach ($this->get_post_types($ignore) as $pt) {
             $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
             if (array_intersect($taxonomies, $object_taxonomies)) {
                 $query_post_types[] = $pt;
             }
         }
         //v3.0  ??????chose the first
         /*
         if(count($query_post_types) > 1)
             $query_post_types  =   array_slice($query_post_types, 0, 1);
         */
         if (count($query_post_types) < 1) {
             $query_post_types[] = 'post';
         }
     }
     return $query_post_types;
 }
/**
 * Checks whether a given query is for events
 * @package event-query-functions
 * @param WP_Query $query The query to test
 * @param bool $exclusive Whether to test if the query is *exclusively* for events, or can include other post types
 * @return bool True if the query is an event query. False otherwise.
 */
function eventorganiser_is_event_query($query, $exclusive = false)
{
    $post_types = $query->get('post_type');
    if ('any' == $post_types) {
        $post_types = get_post_types(array('exclude_from_search' => false));
    }
    if ($post_types == 'event' || array('event') == $post_types) {
        $bool = true;
    } elseif ($query && $query->is_feed('eo-events') || is_feed('eo-events')) {
        $bool = true;
    } elseif (empty($post_types) && eo_is_event_taxonomy($query)) {
        //Querying by taxonomy - check if 'event' is the only post type
        $post_types = array();
        $taxonomies = wp_list_pluck($query->tax_query->queries, 'taxonomy');
        foreach (get_post_types() as $pt) {
            if (version_compare('3.4', get_bloginfo('version')) <= 0) {
                $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
            } else {
                //Backwards compat for 3.3
                $object_taxonomies = $pt === 'attachment' ? array() : get_object_taxonomies($pt);
            }
            if (array_intersect($taxonomies, $object_taxonomies)) {
                $post_types[] = $pt;
            }
        }
        if (in_array('event', $post_types)) {
            if ($exclusive && 1 == count($post_types)) {
                $query->set('post_type', 'event');
                $bool = true;
            } elseif (!$exclusive) {
                $bool = true;
            } else {
                $bool = false;
            }
        } else {
            $bool = false;
        }
    } elseif ($exclusive) {
        $bool = false;
    } elseif (is_array($post_types) && in_array('event', $post_types)) {
        $bool = true;
    } else {
        $bool = false;
    }
    return apply_filters('eventorganiser_is_event_query', $bool, $query, $exclusive);
}
示例#9
0
文件: query.php 项目: snagga/urbantac
 /**
  * Retrieve the posts based on query variables.
  *
  * There are a few filters and actions that can be used to modify the post
  * database query.
  *
  * @since 1.5.0
  * @access public
  * @uses do_action_ref_array() Calls 'pre_get_posts' hook before retrieving posts.
  *
  * @return array List of posts.
  */
 function get_posts()
 {
     global $wpdb, $user_ID, $_wp_using_ext_object_cache;
     $this->parse_query();
     do_action_ref_array('pre_get_posts', array(&$this));
     // Shorthand.
     $q =& $this->query_vars;
     // Fill again in case pre_get_posts unset some vars.
     $q = $this->fill_query_vars($q);
     // Parse meta query
     $this->meta_query = new WP_Meta_Query();
     $this->meta_query->parse_query_vars($q);
     // Set a flag if a pre_get_posts hook changed the query vars.
     $hash = md5(serialize($this->query_vars));
     if ($hash != $this->query_vars_hash) {
         $this->query_vars_changed = true;
         $this->query_vars_hash = $hash;
     }
     unset($hash);
     // First let's clear some variables
     $distinct = '';
     $whichauthor = '';
     $whichmimetype = '';
     $where = '';
     $limits = '';
     $join = '';
     $search = '';
     $groupby = '';
     $fields = '';
     $post_status_join = false;
     $page = 1;
     if (isset($q['caller_get_posts'])) {
         _deprecated_argument('WP_Query', '3.1', __('"caller_get_posts" is deprecated. Use "ignore_sticky_posts" instead.'));
         if (!isset($q['ignore_sticky_posts'])) {
             $q['ignore_sticky_posts'] = $q['caller_get_posts'];
         }
     }
     if (!isset($q['ignore_sticky_posts'])) {
         $q['ignore_sticky_posts'] = false;
     }
     if (!isset($q['suppress_filters'])) {
         $q['suppress_filters'] = false;
     }
     if (!isset($q['cache_results'])) {
         if ($_wp_using_ext_object_cache) {
             $q['cache_results'] = false;
         } else {
             $q['cache_results'] = true;
         }
     }
     if (!isset($q['update_post_term_cache'])) {
         $q['update_post_term_cache'] = true;
     }
     if (!isset($q['update_post_meta_cache'])) {
         $q['update_post_meta_cache'] = true;
     }
     if (!isset($q['post_type'])) {
         if ($this->is_search) {
             $q['post_type'] = 'any';
         } else {
             $q['post_type'] = '';
         }
     }
     $post_type = $q['post_type'];
     if (!isset($q['posts_per_page']) || $q['posts_per_page'] == 0) {
         $q['posts_per_page'] = get_option('posts_per_page');
     }
     if (isset($q['showposts']) && $q['showposts']) {
         $q['showposts'] = (int) $q['showposts'];
         $q['posts_per_page'] = $q['showposts'];
     }
     if (isset($q['posts_per_archive_page']) && $q['posts_per_archive_page'] != 0 && ($this->is_archive || $this->is_search)) {
         $q['posts_per_page'] = $q['posts_per_archive_page'];
     }
     if (!isset($q['nopaging'])) {
         if ($q['posts_per_page'] == -1) {
             $q['nopaging'] = true;
         } else {
             $q['nopaging'] = false;
         }
     }
     if ($this->is_feed) {
         $q['posts_per_page'] = get_option('posts_per_rss');
         $q['nopaging'] = false;
     }
     $q['posts_per_page'] = (int) $q['posts_per_page'];
     if ($q['posts_per_page'] < -1) {
         $q['posts_per_page'] = abs($q['posts_per_page']);
     } else {
         if ($q['posts_per_page'] == 0) {
             $q['posts_per_page'] = 1;
         }
     }
     if (!isset($q['comments_per_page']) || $q['comments_per_page'] == 0) {
         $q['comments_per_page'] = get_option('comments_per_page');
     }
     if ($this->is_home && (empty($this->query) || $q['preview'] == 'true') && 'page' == get_option('show_on_front') && get_option('page_on_front')) {
         $this->is_page = true;
         $this->is_home = false;
         $q['page_id'] = get_option('page_on_front');
     }
     if (isset($q['page'])) {
         $q['page'] = trim($q['page'], '/');
         $q['page'] = absint($q['page']);
     }
     // If true, forcibly turns off SQL_CALC_FOUND_ROWS even when limits are present.
     if (isset($q['no_found_rows'])) {
         $q['no_found_rows'] = (bool) $q['no_found_rows'];
     } else {
         $q['no_found_rows'] = false;
     }
     switch ($q['fields']) {
         case 'ids':
             $fields = "{$wpdb->posts}.ID";
             break;
         case 'id=>parent':
             $fields = "{$wpdb->posts}.ID, {$wpdb->posts}.post_parent";
             break;
         default:
             $fields = "{$wpdb->posts}.*";
     }
     if ('' !== $q['menu_order']) {
         $where .= " AND {$wpdb->posts}.menu_order = " . $q['menu_order'];
     }
     // If a month is specified in the querystring, load that month
     if ($q['m']) {
         $q['m'] = '' . preg_replace('|[^0-9]|', '', $q['m']);
         $where .= " AND YEAR({$wpdb->posts}.post_date)=" . substr($q['m'], 0, 4);
         if (strlen($q['m']) > 5) {
             $where .= " AND MONTH({$wpdb->posts}.post_date)=" . substr($q['m'], 4, 2);
         }
         if (strlen($q['m']) > 7) {
             $where .= " AND DAYOFMONTH({$wpdb->posts}.post_date)=" . substr($q['m'], 6, 2);
         }
         if (strlen($q['m']) > 9) {
             $where .= " AND HOUR({$wpdb->posts}.post_date)=" . substr($q['m'], 8, 2);
         }
         if (strlen($q['m']) > 11) {
             $where .= " AND MINUTE({$wpdb->posts}.post_date)=" . substr($q['m'], 10, 2);
         }
         if (strlen($q['m']) > 13) {
             $where .= " AND SECOND({$wpdb->posts}.post_date)=" . substr($q['m'], 12, 2);
         }
     }
     if ('' !== $q['hour']) {
         $where .= " AND HOUR({$wpdb->posts}.post_date)='" . $q['hour'] . "'";
     }
     if ('' !== $q['minute']) {
         $where .= " AND MINUTE({$wpdb->posts}.post_date)='" . $q['minute'] . "'";
     }
     if ('' !== $q['second']) {
         $where .= " AND SECOND({$wpdb->posts}.post_date)='" . $q['second'] . "'";
     }
     if ($q['year']) {
         $where .= " AND YEAR({$wpdb->posts}.post_date)='" . $q['year'] . "'";
     }
     if ($q['monthnum']) {
         $where .= " AND MONTH({$wpdb->posts}.post_date)='" . $q['monthnum'] . "'";
     }
     if ($q['day']) {
         $where .= " AND DAYOFMONTH({$wpdb->posts}.post_date)='" . $q['day'] . "'";
     }
     // If we've got a post_type AND its not "any" post_type.
     if (!empty($q['post_type']) && 'any' != $q['post_type']) {
         foreach ((array) $q['post_type'] as $_post_type) {
             $ptype_obj = get_post_type_object($_post_type);
             if (!$ptype_obj || !$ptype_obj->query_var || empty($q[$ptype_obj->query_var])) {
                 continue;
             }
             if (!$ptype_obj->hierarchical || strpos($q[$ptype_obj->query_var], '/') === false) {
                 // Non-hierarchical post_types & parent-level-hierarchical post_types can directly use 'name'
                 $q['name'] = $q[$ptype_obj->query_var];
             } else {
                 // Hierarchical post_types will operate through the
                 $q['pagename'] = $q[$ptype_obj->query_var];
                 $q['name'] = '';
             }
             // Only one request for a slug is possible, this is why name & pagename are overwritten above.
             break;
         }
         //end foreach
         unset($ptype_obj);
     }
     if ('' != $q['name']) {
         $q['name'] = sanitize_title_for_query($q['name']);
         $where .= " AND {$wpdb->posts}.post_name = '" . $q['name'] . "'";
     } elseif ('' != $q['pagename']) {
         if (isset($this->queried_object_id)) {
             $reqpage = $this->queried_object_id;
         } else {
             if ('page' != $q['post_type']) {
                 foreach ((array) $q['post_type'] as $_post_type) {
                     $ptype_obj = get_post_type_object($_post_type);
                     if (!$ptype_obj || !$ptype_obj->hierarchical) {
                         continue;
                     }
                     $reqpage = get_page_by_path($q['pagename'], OBJECT, $_post_type);
                     if ($reqpage) {
                         break;
                     }
                 }
                 unset($ptype_obj);
             } else {
                 $reqpage = get_page_by_path($q['pagename']);
             }
             if (!empty($reqpage)) {
                 $reqpage = $reqpage->ID;
             } else {
                 $reqpage = 0;
             }
         }
         $page_for_posts = get_option('page_for_posts');
         if ('page' != get_option('show_on_front') || empty($page_for_posts) || $reqpage != $page_for_posts) {
             $q['pagename'] = sanitize_title_for_query(wp_basename($q['pagename']));
             $q['name'] = $q['pagename'];
             $where .= " AND ({$wpdb->posts}.ID = '{$reqpage}')";
             $reqpage_obj = get_post($reqpage);
             if (is_object($reqpage_obj) && 'attachment' == $reqpage_obj->post_type) {
                 $this->is_attachment = true;
                 $post_type = $q['post_type'] = 'attachment';
                 $this->is_page = true;
                 $q['attachment_id'] = $reqpage;
             }
         }
     } elseif ('' != $q['attachment']) {
         $q['attachment'] = sanitize_title_for_query(wp_basename($q['attachment']));
         $q['name'] = $q['attachment'];
         $where .= " AND {$wpdb->posts}.post_name = '" . $q['attachment'] . "'";
     }
     if ($q['w']) {
         $where .= ' AND ' . _wp_mysql_week("`{$wpdb->posts}`.`post_date`") . " = '" . $q['w'] . "'";
     }
     if (intval($q['comments_popup'])) {
         $q['p'] = absint($q['comments_popup']);
     }
     // If an attachment is requested by number, let it supersede any post number.
     if ($q['attachment_id']) {
         $q['p'] = absint($q['attachment_id']);
     }
     // If a post number is specified, load that post
     if ($q['p']) {
         $where .= " AND {$wpdb->posts}.ID = " . $q['p'];
     } elseif ($q['post__in']) {
         $post__in = implode(',', array_map('absint', $q['post__in']));
         $where .= " AND {$wpdb->posts}.ID IN ({$post__in})";
     } elseif ($q['post__not_in']) {
         $post__not_in = implode(',', array_map('absint', $q['post__not_in']));
         $where .= " AND {$wpdb->posts}.ID NOT IN ({$post__not_in})";
     }
     if (is_numeric($q['post_parent'])) {
         $where .= $wpdb->prepare(" AND {$wpdb->posts}.post_parent = %d ", $q['post_parent']);
     }
     if ($q['page_id']) {
         if ('page' != get_option('show_on_front') || $q['page_id'] != get_option('page_for_posts')) {
             $q['p'] = $q['page_id'];
             $where = " AND {$wpdb->posts}.ID = " . $q['page_id'];
         }
     }
     // If a search pattern is specified, load the posts that match
     if (!empty($q['s'])) {
         // added slashes screw with quote grouping when done early, so done later
         $q['s'] = stripslashes($q['s']);
         if (empty($_GET['s']) && $this->is_main_query()) {
             $q['s'] = urldecode($q['s']);
         }
         if (!empty($q['sentence'])) {
             $q['search_terms'] = array($q['s']);
         } else {
             preg_match_all('/".*?("|$)|((?<=[\\r\\n\\t ",+])|^)[^\\r\\n\\t ",+]+/', $q['s'], $matches);
             $q['search_terms'] = array_map('_search_terms_tidy', $matches[0]);
         }
         $n = !empty($q['exact']) ? '' : '%';
         $searchand = '';
         foreach ((array) $q['search_terms'] as $term) {
             $term = esc_sql(like_escape($term));
             $search .= "{$searchand}(({$wpdb->posts}.post_title LIKE '{$n}{$term}{$n}') OR ({$wpdb->posts}.post_content LIKE '{$n}{$term}{$n}'))";
             $searchand = ' AND ';
         }
         if (!empty($search)) {
             $search = " AND ({$search}) ";
             if (!is_user_logged_in()) {
                 $search .= " AND ({$wpdb->posts}.post_password = '') ";
             }
         }
     }
     // Allow plugins to contextually add/remove/modify the search section of the database query
     $search = apply_filters_ref_array('posts_search', array($search, &$this));
     // Taxonomies
     if (!$this->is_singular) {
         $this->parse_tax_query($q);
         $clauses = $this->tax_query->get_sql($wpdb->posts, 'ID');
         $join .= $clauses['join'];
         $where .= $clauses['where'];
     }
     if ($this->is_tax) {
         if (empty($post_type)) {
             // Do a fully inclusive search for currently registered post types of queried taxonomies
             $post_type = array();
             $taxonomies = wp_list_pluck($this->tax_query->queries, 'taxonomy');
             foreach (get_post_types(array('exclude_from_search' => false)) as $pt) {
                 $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
                 if (array_intersect($taxonomies, $object_taxonomies)) {
                     $post_type[] = $pt;
                 }
             }
             if (!$post_type) {
                 $post_type = 'any';
             }
             $post_status_join = true;
         } elseif (in_array('attachment', (array) $post_type)) {
             $post_status_join = true;
         }
     }
     // Back-compat
     if (!empty($this->tax_query->queries)) {
         $tax_query_in_and = wp_list_filter($this->tax_query->queries, array('operator' => 'NOT IN'), 'NOT');
         if (!empty($tax_query_in_and)) {
             if (!isset($q['taxonomy'])) {
                 foreach ($tax_query_in_and as $a_tax_query) {
                     if (!in_array($a_tax_query['taxonomy'], array('category', 'post_tag'))) {
                         $q['taxonomy'] = $a_tax_query['taxonomy'];
                         if ('slug' == $a_tax_query['field']) {
                             $q['term'] = $a_tax_query['terms'][0];
                         } else {
                             $q['term_id'] = $a_tax_query['terms'][0];
                         }
                         break;
                     }
                 }
             }
             $cat_query = wp_list_filter($tax_query_in_and, array('taxonomy' => 'category'));
             if (!empty($cat_query)) {
                 $cat_query = reset($cat_query);
                 $the_cat = get_term_by($cat_query['field'], $cat_query['terms'][0], 'category');
                 if ($the_cat) {
                     $this->set('cat', $the_cat->term_id);
                     $this->set('category_name', $the_cat->slug);
                 }
                 unset($the_cat);
             }
             unset($cat_query);
             $tag_query = wp_list_filter($tax_query_in_and, array('taxonomy' => 'post_tag'));
             if (!empty($tag_query)) {
                 $tag_query = reset($tag_query);
                 $the_tag = get_term_by($tag_query['field'], $tag_query['terms'][0], 'post_tag');
                 if ($the_tag) {
                     $this->set('tag_id', $the_tag->term_id);
                 }
                 unset($the_tag);
             }
             unset($tag_query);
         }
     }
     if (!empty($this->tax_query->queries) || !empty($this->meta_query->queries)) {
         $groupby = "{$wpdb->posts}.ID";
     }
     // Author/user stuff
     if (empty($q['author']) || $q['author'] == '0') {
         $whichauthor = '';
     } else {
         $q['author'] = (string) urldecode($q['author']);
         $q['author'] = addslashes_gpc($q['author']);
         if (strpos($q['author'], '-') !== false) {
             $eq = '!=';
             $andor = 'AND';
             $q['author'] = explode('-', $q['author']);
             $q['author'] = (string) absint($q['author'][1]);
         } else {
             $eq = '=';
             $andor = 'OR';
         }
         $author_array = preg_split('/[,\\s]+/', $q['author']);
         $_author_array = array();
         foreach ($author_array as $key => $_author) {
             $_author_array[] = "{$wpdb->posts}.post_author " . $eq . ' ' . absint($_author);
         }
         $whichauthor .= ' AND (' . implode(" {$andor} ", $_author_array) . ')';
         unset($author_array, $_author_array);
     }
     // Author stuff for nice URLs
     if ('' != $q['author_name']) {
         if (strpos($q['author_name'], '/') !== false) {
             $q['author_name'] = explode('/', $q['author_name']);
             if ($q['author_name'][count($q['author_name']) - 1]) {
                 $q['author_name'] = $q['author_name'][count($q['author_name']) - 1];
                 // no trailing slash
             } else {
                 $q['author_name'] = $q['author_name'][count($q['author_name']) - 2];
                 // there was a trailing slash
             }
         }
         $q['author_name'] = sanitize_title_for_query($q['author_name']);
         $q['author'] = get_user_by('slug', $q['author_name']);
         if ($q['author']) {
             $q['author'] = $q['author']->ID;
         }
         $whichauthor .= " AND ({$wpdb->posts}.post_author = " . absint($q['author']) . ')';
     }
     // MIME-Type stuff for attachment browsing
     if (isset($q['post_mime_type']) && '' != $q['post_mime_type']) {
         $whichmimetype = wp_post_mime_type_where($q['post_mime_type'], $wpdb->posts);
     }
     $where .= $search . $whichauthor . $whichmimetype;
     if (empty($q['order']) || strtoupper($q['order']) != 'ASC' && strtoupper($q['order']) != 'DESC') {
         $q['order'] = 'DESC';
     }
     // Order by
     if (empty($q['orderby'])) {
         $orderby = "{$wpdb->posts}.post_date " . $q['order'];
     } elseif ('none' == $q['orderby']) {
         $orderby = '';
     } elseif ($q['orderby'] == 'post__in' && !empty($post__in)) {
         $orderby = "FIELD( {$wpdb->posts}.ID, {$post__in} )";
     } else {
         // Used to filter values
         $allowed_keys = array('name', 'author', 'date', 'title', 'modified', 'menu_order', 'parent', 'ID', 'rand', 'comment_count');
         if (!empty($q['meta_key'])) {
             $allowed_keys[] = $q['meta_key'];
             $allowed_keys[] = 'meta_value';
             $allowed_keys[] = 'meta_value_num';
         }
         $q['orderby'] = urldecode($q['orderby']);
         $q['orderby'] = addslashes_gpc($q['orderby']);
         $orderby_array = array();
         foreach (explode(' ', $q['orderby']) as $i => $orderby) {
             // Only allow certain values for safety
             if (!in_array($orderby, $allowed_keys)) {
                 continue;
             }
             switch ($orderby) {
                 case 'menu_order':
                     $orderby = "{$wpdb->posts}.menu_order";
                     break;
                 case 'ID':
                     $orderby = "{$wpdb->posts}.ID";
                     break;
                 case 'rand':
                     $orderby = 'RAND()';
                     break;
                 case $q['meta_key']:
                 case 'meta_value':
                     $orderby = "{$wpdb->postmeta}.meta_value";
                     break;
                 case 'meta_value_num':
                     $orderby = "{$wpdb->postmeta}.meta_value+0";
                     break;
                 case 'comment_count':
                     $orderby = "{$wpdb->posts}.comment_count";
                     break;
                 default:
                     $orderby = "{$wpdb->posts}.post_" . $orderby;
             }
             $orderby_array[] = $orderby;
         }
         $orderby = implode(',', $orderby_array);
         if (empty($orderby)) {
             $orderby = "{$wpdb->posts}.post_date " . $q['order'];
         } else {
             $orderby .= " {$q['order']}";
         }
     }
     if (is_array($post_type)) {
         $post_type_cap = 'multiple_post_type';
     } else {
         $post_type_object = get_post_type_object($post_type);
         if (empty($post_type_object)) {
             $post_type_cap = $post_type;
         }
     }
     if ('any' == $post_type) {
         $in_search_post_types = get_post_types(array('exclude_from_search' => false));
         if (!empty($in_search_post_types)) {
             $where .= " AND {$wpdb->posts}.post_type IN ('" . join("', '", $in_search_post_types) . "')";
         }
     } elseif (!empty($post_type) && is_array($post_type)) {
         $where .= " AND {$wpdb->posts}.post_type IN ('" . join("', '", $post_type) . "')";
     } elseif (!empty($post_type)) {
         $where .= " AND {$wpdb->posts}.post_type = '{$post_type}'";
         $post_type_object = get_post_type_object($post_type);
     } elseif ($this->is_attachment) {
         $where .= " AND {$wpdb->posts}.post_type = 'attachment'";
         $post_type_object = get_post_type_object('attachment');
     } elseif ($this->is_page) {
         $where .= " AND {$wpdb->posts}.post_type = 'page'";
         $post_type_object = get_post_type_object('page');
     } else {
         $where .= " AND {$wpdb->posts}.post_type = 'post'";
         $post_type_object = get_post_type_object('post');
     }
     if (!empty($post_type_object)) {
         $edit_cap = $post_type_object->cap->edit_post;
         $read_cap = $post_type_object->cap->read_post;
         $edit_others_cap = $post_type_object->cap->edit_others_posts;
         $read_private_cap = $post_type_object->cap->read_private_posts;
     } else {
         $edit_cap = 'edit_' . $post_type_cap;
         $read_cap = 'read_' . $post_type_cap;
         $edit_others_cap = 'edit_others_' . $post_type_cap . 's';
         $read_private_cap = 'read_private_' . $post_type_cap . 's';
     }
     if (!empty($q['post_status'])) {
         $statuswheres = array();
         $q_status = $q['post_status'];
         if (!is_array($q_status)) {
             $q_status = explode(',', $q_status);
         }
         $r_status = array();
         $p_status = array();
         $e_status = array();
         if (in_array('any', $q_status)) {
             foreach (get_post_stati(array('exclude_from_search' => true)) as $status) {
                 $e_status[] = "{$wpdb->posts}.post_status <> '{$status}'";
             }
         } else {
             foreach (get_post_stati() as $status) {
                 if (in_array($status, $q_status)) {
                     if ('private' == $status) {
                         $p_status[] = "{$wpdb->posts}.post_status = '{$status}'";
                     } else {
                         $r_status[] = "{$wpdb->posts}.post_status = '{$status}'";
                     }
                 }
             }
         }
         if (empty($q['perm']) || 'readable' != $q['perm']) {
             $r_status = array_merge($r_status, $p_status);
             unset($p_status);
         }
         if (!empty($e_status)) {
             $statuswheres[] = "(" . join(' AND ', $e_status) . ")";
         }
         if (!empty($r_status)) {
             if (!empty($q['perm']) && 'editable' == $q['perm'] && !current_user_can($edit_others_cap)) {
                 $statuswheres[] = "({$wpdb->posts}.post_author = {$user_ID} " . "AND (" . join(' OR ', $r_status) . "))";
             } else {
                 $statuswheres[] = "(" . join(' OR ', $r_status) . ")";
             }
         }
         if (!empty($p_status)) {
             if (!empty($q['perm']) && 'readable' == $q['perm'] && !current_user_can($read_private_cap)) {
                 $statuswheres[] = "({$wpdb->posts}.post_author = {$user_ID} " . "AND (" . join(' OR ', $p_status) . "))";
             } else {
                 $statuswheres[] = "(" . join(' OR ', $p_status) . ")";
             }
         }
         if ($post_status_join) {
             $join .= " LEFT JOIN {$wpdb->posts} AS p2 ON ({$wpdb->posts}.post_parent = p2.ID) ";
             foreach ($statuswheres as $index => $statuswhere) {
                 $statuswheres[$index] = "({$statuswhere} OR ({$wpdb->posts}.post_status = 'inherit' AND " . str_replace($wpdb->posts, 'p2', $statuswhere) . "))";
             }
         }
         foreach ($statuswheres as $statuswhere) {
             $where .= " AND {$statuswhere}";
         }
     } elseif (!$this->is_singular) {
         $where .= " AND ({$wpdb->posts}.post_status = 'publish'";
         // Add public states.
         $public_states = get_post_stati(array('public' => true));
         foreach ((array) $public_states as $state) {
             if ('publish' == $state) {
                 // Publish is hard-coded above.
                 continue;
             }
             $where .= " OR {$wpdb->posts}.post_status = '{$state}'";
         }
         if ($this->is_admin) {
             // Add protected states that should show in the admin all list.
             $admin_all_states = get_post_stati(array('protected' => true, 'show_in_admin_all_list' => true));
             foreach ((array) $admin_all_states as $state) {
                 $where .= " OR {$wpdb->posts}.post_status = '{$state}'";
             }
         }
         if (is_user_logged_in()) {
             // Add private states that are limited to viewing by the author of a post or someone who has caps to read private states.
             $private_states = get_post_stati(array('private' => true));
             foreach ((array) $private_states as $state) {
                 $where .= current_user_can($read_private_cap) ? " OR {$wpdb->posts}.post_status = '{$state}'" : " OR {$wpdb->posts}.post_author = {$user_ID} AND {$wpdb->posts}.post_status = '{$state}'";
             }
         }
         $where .= ')';
     }
     if (!empty($this->meta_query->queries)) {
         $clauses = $this->meta_query->get_sql('post', $wpdb->posts, 'ID', $this);
         $join .= $clauses['join'];
         $where .= $clauses['where'];
     }
     // Apply filters on where and join prior to paging so that any
     // manipulations to them are reflected in the paging by day queries.
     if (!$q['suppress_filters']) {
         $where = apply_filters_ref_array('posts_where', array($where, &$this));
         $join = apply_filters_ref_array('posts_join', array($join, &$this));
     }
     // Paging
     if (empty($q['nopaging']) && !$this->is_singular) {
         $page = absint($q['paged']);
         if (!$page) {
             $page = 1;
         }
         if (empty($q['offset'])) {
             $pgstrt = ($page - 1) * $q['posts_per_page'] . ', ';
         } else {
             // we're ignoring $page and using 'offset'
             $q['offset'] = absint($q['offset']);
             $pgstrt = $q['offset'] . ', ';
         }
         $limits = 'LIMIT ' . $pgstrt . $q['posts_per_page'];
     }
     // Comments feeds
     if ($this->is_comment_feed && ($this->is_archive || $this->is_search || !$this->is_singular)) {
         if ($this->is_archive || $this->is_search) {
             $cjoin = "JOIN {$wpdb->posts} ON ({$wpdb->comments}.comment_post_ID = {$wpdb->posts}.ID) {$join} ";
             $cwhere = "WHERE comment_approved = '1' {$where}";
             $cgroupby = "{$wpdb->comments}.comment_id";
         } else {
             // Other non singular e.g. front
             $cjoin = "JOIN {$wpdb->posts} ON ( {$wpdb->comments}.comment_post_ID = {$wpdb->posts}.ID )";
             $cwhere = "WHERE post_status = 'publish' AND comment_approved = '1'";
             $cgroupby = '';
         }
         if (!$q['suppress_filters']) {
             $cjoin = apply_filters_ref_array('comment_feed_join', array($cjoin, &$this));
             $cwhere = apply_filters_ref_array('comment_feed_where', array($cwhere, &$this));
             $cgroupby = apply_filters_ref_array('comment_feed_groupby', array($cgroupby, &$this));
             $corderby = apply_filters_ref_array('comment_feed_orderby', array('comment_date_gmt DESC', &$this));
             $climits = apply_filters_ref_array('comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
         }
         $cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
         $corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
         $this->comments = (array) $wpdb->get_results("SELECT {$distinct} {$wpdb->comments}.* FROM {$wpdb->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}");
         $this->comment_count = count($this->comments);
         $post_ids = array();
         foreach ($this->comments as $comment) {
             $post_ids[] = (int) $comment->comment_post_ID;
         }
         $post_ids = join(',', $post_ids);
         $join = '';
         if ($post_ids) {
             $where = "AND {$wpdb->posts}.ID IN ({$post_ids}) ";
         } else {
             $where = "AND 0";
         }
     }
     $pieces = array('where', 'groupby', 'join', 'orderby', 'distinct', 'fields', 'limits');
     // Apply post-paging filters on where and join. Only plugins that
     // manipulate paging queries should use these hooks.
     if (!$q['suppress_filters']) {
         $where = apply_filters_ref_array('posts_where_paged', array($where, &$this));
         $groupby = apply_filters_ref_array('posts_groupby', array($groupby, &$this));
         $join = apply_filters_ref_array('posts_join_paged', array($join, &$this));
         $orderby = apply_filters_ref_array('posts_orderby', array($orderby, &$this));
         $distinct = apply_filters_ref_array('posts_distinct', array($distinct, &$this));
         $limits = apply_filters_ref_array('post_limits', array($limits, &$this));
         $fields = apply_filters_ref_array('posts_fields', array($fields, &$this));
         // Filter all clauses at once, for convenience
         $clauses = (array) apply_filters_ref_array('posts_clauses', array(compact($pieces), &$this));
         foreach ($pieces as $piece) {
             ${$piece} = isset($clauses[$piece]) ? $clauses[$piece] : '';
         }
     }
     // Announce current selection parameters. For use by caching plugins.
     do_action('posts_selection', $where . $groupby . $orderby . $limits . $join);
     // Filter again for the benefit of caching plugins. Regular plugins should use the hooks above.
     if (!$q['suppress_filters']) {
         $where = apply_filters_ref_array('posts_where_request', array($where, &$this));
         $groupby = apply_filters_ref_array('posts_groupby_request', array($groupby, &$this));
         $join = apply_filters_ref_array('posts_join_request', array($join, &$this));
         $orderby = apply_filters_ref_array('posts_orderby_request', array($orderby, &$this));
         $distinct = apply_filters_ref_array('posts_distinct_request', array($distinct, &$this));
         $fields = apply_filters_ref_array('posts_fields_request', array($fields, &$this));
         $limits = apply_filters_ref_array('post_limits_request', array($limits, &$this));
         // Filter all clauses at once, for convenience
         $clauses = (array) apply_filters_ref_array('posts_clauses_request', array(compact($pieces), &$this));
         foreach ($pieces as $piece) {
             ${$piece} = isset($clauses[$piece]) ? $clauses[$piece] : '';
         }
     }
     if (!empty($groupby)) {
         $groupby = 'GROUP BY ' . $groupby;
     }
     if (!empty($orderby)) {
         $orderby = 'ORDER BY ' . $orderby;
     }
     $found_rows = '';
     if (!$q['no_found_rows'] && !empty($limits)) {
         $found_rows = 'SQL_CALC_FOUND_ROWS';
     }
     $this->request = $old_request = "SELECT {$found_rows} {$distinct} {$fields} FROM {$wpdb->posts} {$join} WHERE 1=1 {$where} {$groupby} {$orderby} {$limits}";
     if (!$q['suppress_filters']) {
         $this->request = apply_filters_ref_array('posts_request', array($this->request, &$this));
     }
     if ('ids' == $q['fields']) {
         $this->posts = $wpdb->get_col($this->request);
         $this->post_count = count($this->posts);
         $this->set_found_posts($q, $limits);
         return $this->posts;
     }
     if ('id=>parent' == $q['fields']) {
         $this->posts = $wpdb->get_results($this->request);
         $this->post_count = count($this->posts);
         $this->set_found_posts($q, $limits);
         $r = array();
         foreach ($this->posts as $post) {
             $r[$post->ID] = $post->post_parent;
         }
         return $r;
     }
     $split_the_query = $old_request == $this->request && "{$wpdb->posts}.*" == $fields && !empty($limits) && $q['posts_per_page'] < 500;
     $split_the_query = apply_filters('split_the_query', $split_the_query, $this);
     if ($split_the_query) {
         // First get the IDs and then fill in the objects
         $this->request = "SELECT {$found_rows} {$distinct} {$wpdb->posts}.ID FROM {$wpdb->posts} {$join} WHERE 1=1 {$where} {$groupby} {$orderby} {$limits}";
         $this->request = apply_filters('posts_request_ids', $this->request, $this);
         $ids = $wpdb->get_col($this->request);
         if ($ids) {
             $this->posts = $ids;
             $this->set_found_posts($q, $limits);
             _prime_post_caches($ids, $q['update_post_term_cache'], $q['update_post_meta_cache']);
         } else {
             $this->posts = array();
         }
     } else {
         $this->posts = $wpdb->get_results($this->request);
         $this->set_found_posts($q, $limits);
     }
     // Convert to WP_Post objects
     if ($this->posts) {
         $this->posts = array_map('get_post', $this->posts);
     }
     // Raw results filter. Prior to status checks.
     if (!$q['suppress_filters']) {
         $this->posts = apply_filters_ref_array('posts_results', array($this->posts, &$this));
     }
     if (!empty($this->posts) && $this->is_comment_feed && $this->is_singular) {
         $cjoin = apply_filters_ref_array('comment_feed_join', array('', &$this));
         $cwhere = apply_filters_ref_array('comment_feed_where', array("WHERE comment_post_ID = '{$this->posts[0]->ID}' AND comment_approved = '1'", &$this));
         $cgroupby = apply_filters_ref_array('comment_feed_groupby', array('', &$this));
         $cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
         $corderby = apply_filters_ref_array('comment_feed_orderby', array('comment_date_gmt DESC', &$this));
         $corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
         $climits = apply_filters_ref_array('comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
         $comments_request = "SELECT {$wpdb->comments}.* FROM {$wpdb->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}";
         $this->comments = $wpdb->get_results($comments_request);
         $this->comment_count = count($this->comments);
     }
     // Check post status to determine if post should be displayed.
     if (!empty($this->posts) && ($this->is_single || $this->is_page)) {
         $status = get_post_status($this->posts[0]);
         $post_status_obj = get_post_status_object($status);
         //$type = get_post_type($this->posts[0]);
         if (!$post_status_obj->public) {
             if (!is_user_logged_in()) {
                 // User must be logged in to view unpublished posts.
                 $this->posts = array();
             } else {
                 if ($post_status_obj->protected) {
                     // User must have edit permissions on the draft to preview.
                     if (!current_user_can($edit_cap, $this->posts[0]->ID)) {
                         $this->posts = array();
                     } else {
                         $this->is_preview = true;
                         if ('future' != $status) {
                             $this->posts[0]->post_date = current_time('mysql');
                         }
                     }
                 } elseif ($post_status_obj->private) {
                     if (!current_user_can($read_cap, $this->posts[0]->ID)) {
                         $this->posts = array();
                     }
                 } else {
                     $this->posts = array();
                 }
             }
         }
         if ($this->is_preview && $this->posts && current_user_can($edit_cap, $this->posts[0]->ID)) {
             $this->posts[0] = get_post(apply_filters_ref_array('the_preview', array($this->posts[0], &$this)));
         }
     }
     // Put sticky posts at the top of the posts array
     $sticky_posts = get_option('sticky_posts');
     if ($this->is_home && $page <= 1 && is_array($sticky_posts) && !empty($sticky_posts) && !$q['ignore_sticky_posts']) {
         $num_posts = count($this->posts);
         $sticky_offset = 0;
         // Loop over posts and relocate stickies to the front.
         for ($i = 0; $i < $num_posts; $i++) {
             if (in_array($this->posts[$i]->ID, $sticky_posts)) {
                 $sticky_post = $this->posts[$i];
                 // Remove sticky from current position
                 array_splice($this->posts, $i, 1);
                 // Move to front, after other stickies
                 array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
                 // Increment the sticky offset. The next sticky will be placed at this offset.
                 $sticky_offset++;
                 // Remove post from sticky posts array
                 $offset = array_search($sticky_post->ID, $sticky_posts);
                 unset($sticky_posts[$offset]);
             }
         }
         // If any posts have been excluded specifically, Ignore those that are sticky.
         if (!empty($sticky_posts) && !empty($q['post__not_in'])) {
             $sticky_posts = array_diff($sticky_posts, $q['post__not_in']);
         }
         // Fetch sticky posts that weren't in the query results
         if (!empty($sticky_posts)) {
             $stickies = get_posts(array('post__in' => $sticky_posts, 'post_type' => $post_type, 'post_status' => 'publish', 'nopaging' => true));
             foreach ($stickies as $sticky_post) {
                 array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
                 $sticky_offset++;
             }
         }
     }
     if (!$q['suppress_filters']) {
         $this->posts = apply_filters_ref_array('the_posts', array($this->posts, &$this));
     }
     // Ensure that any posts added/modified via one of the filters above are
     // of the type WP_Post and are filtered.
     if ($this->posts) {
         $this->post_count = count($this->posts);
         $this->posts = array_map('get_post', $this->posts);
         if ($q['cache_results']) {
             update_post_caches($this->posts, $post_type, $q['update_post_term_cache'], $q['update_post_meta_cache']);
         }
         $this->post = reset($this->posts);
     } else {
         $this->post_count = 0;
         $this->posts = array();
     }
     return $this->posts;
 }
/**
 * Get a taxonomy post type.
 *
 * @since 1.0.0
 * @package GeoDirectory
 * @global object $wp_query WordPress Query object.
 * @param string $taxonomy The WordPress taxonomy string.
 * @return bool|string Post type on success. false on failure.
 */
function geodir_get_taxonomy_posttype($taxonomy = '')
{
    global $wp_query;
    $post_type = array();
    $taxonomies = array();
    if (!empty($taxonomy)) {
        $taxonomies[] = $taxonomy;
    } elseif (isset($wp_query->tax_query->queries)) {
        $tax_arr = $wp_query->tax_query->queries;
        //if tax query has 'relation' set then it will break wp_list_pluck so we remove it
        if (isset($tax_arr['relation'])) {
            unset($tax_arr['relation']);
        }
        $taxonomies = wp_list_pluck($tax_arr, 'taxonomy');
    }
    if (!empty($taxonomies)) {
        foreach (geodir_get_posttypes() as $pt) {
            $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
            if (array_intersect($taxonomies, $object_taxonomies)) {
                $post_type[] = $pt;
            }
        }
    }
    if (!empty($post_type)) {
        return $post_type[0];
    } else {
        return false;
    }
}
 /**
  * Retrieve the posts based on query variables.
  *
  * There are a few filters and actions that can be used to modify the post
  * database query.
  *
  * @since 1.5.0
  * @access public
  * @uses do_action_ref_array() Calls 'pre_get_posts' hook before retrieving posts.
  *
  * @todo determine early if the query can be run using ES, otherwise defer to WP_Query
  *
  * @return array List of posts.
  */
 public function get_posts()
 {
     global $wpdb;
     /**
      * In addition to what's below, other fields include:
      * 		post_id
      *      post_author
      *      	post_author.user_nicename
      * 		post_date
      * 			post_date.year
      * 			post_date.month
      * 			post_date.week
      * 			post_date.day
      * 			post_date.day_of_year
      * 			post_date.day_of_week
      * 			post_date.hour
      * 			post_date.minute
      * 			post_date.second
      * 		post_date_gmt (plus all the same tokens as post_date)
      * 		post_content
      * 			post_content.analyzed
      * 		post_title
      * 			post_title.analyzed
      * 		post_excerpt
      * 		post_status
      * 		ping_status
      * 		post_password
      * 		post_name
      * 		post_modified (plus all the same tokens as post_date)
      * 		post_modified_gmt (plus all the same tokens as post_date)
      * 		post_parent
      * 		menu_order
      * 		post_type
      * 		post_mime_type
      * 		comment_count
      */
     $this->es_map = apply_filters('es_field_map', array('post_meta' => 'post_meta.%s', 'post_meta.analyzed' => 'post_meta.%s.analyzed', 'post_meta.long' => 'post_meta.%s.long', 'post_meta.double' => 'post_meta.%s.double', 'post_meta.binary' => 'post_meta.%s.boolean', 'post_meta.date' => 'post_meta.%s.date', 'post_meta.datetime' => 'post_meta.%s.datetime', 'post_meta.time' => 'post_meta.%s.time', 'post_meta.signed' => 'post_meta.%s.signed', 'post_meta.unsigned' => 'post_meta.%s.unsigned', 'term_id' => 'terms.%s.term_id', 'term_slug' => 'terms.%s.slug', 'term_name' => 'terms.%s.name', 'term_tt_id' => 'terms.%s.term_taxonomy_id', 'category_id' => 'terms.%s.term_id', 'category_slug' => 'terms.%s.slug', 'category_name' => 'terms.%s.name', 'category_tt_id' => 'terms.%s.term_taxonomy_id', 'tag_id' => 'terms.%s.term_id', 'tag_slug' => 'terms.%s.slug', 'tag_name' => 'terms.%s.name', 'tag_tt_id' => 'terms.%s.term_taxonomy_id'));
     $this->parse_query();
     if (isset($this->query_vars['es'])) {
         unset($this->query_vars['es']);
     }
     do_action_ref_array('pre_get_posts', array(&$this));
     do_action_ref_array('es_pre_get_posts', array(&$this));
     // Shorthand.
     $q =& $this->query_vars;
     // Fill again in case pre_get_posts unset some vars.
     $q = $this->fill_query_vars($q);
     // Parse meta query
     $this->meta_query = new ES_WP_Meta_Query();
     $this->meta_query->parse_query_vars($q);
     // Set a flag if a pre_get_posts hook changed the query vars.
     $hash = md5(serialize($this->query_vars));
     if ($hash != $this->query_vars_hash) {
         $this->query_vars_changed = true;
         $this->query_vars_hash = $hash;
     }
     unset($hash);
     // First let's clear some variables
     $distinct = '';
     $whichauthor = '';
     $whichmimetype = '';
     $where = '';
     $limits = '';
     $join = '';
     $search = '';
     $groupby = '';
     $post_status_join = false;
     $page = 1;
     // ES
     $filter = array();
     $query = array();
     $sort = array();
     $fields = array();
     $from = 0;
     $size = 10;
     if (!isset($q['ignore_sticky_posts'])) {
         $q['ignore_sticky_posts'] = false;
     }
     if (!isset($q['suppress_filters'])) {
         $q['suppress_filters'] = false;
     }
     if (!isset($q['cache_results'])) {
         if (wp_using_ext_object_cache()) {
             $q['cache_results'] = false;
         } else {
             $q['cache_results'] = true;
         }
     }
     if (!isset($q['update_post_term_cache'])) {
         $q['update_post_term_cache'] = true;
     }
     if (!isset($q['update_post_meta_cache'])) {
         $q['update_post_meta_cache'] = true;
     }
     if (!isset($q['post_type'])) {
         if ($this->is_search) {
             $q['post_type'] = 'any';
         } else {
             $q['post_type'] = '';
         }
     }
     $post_type = $q['post_type'];
     if (!isset($q['posts_per_page']) || $q['posts_per_page'] == 0) {
         $q['posts_per_page'] = get_option('posts_per_page');
     }
     if (isset($q['showposts']) && $q['showposts']) {
         $q['showposts'] = (int) $q['showposts'];
         $q['posts_per_page'] = $q['showposts'];
     }
     if (isset($q['posts_per_archive_page']) && $q['posts_per_archive_page'] != 0 && ($this->is_archive || $this->is_search)) {
         $q['posts_per_page'] = $q['posts_per_archive_page'];
     }
     if (!isset($q['nopaging'])) {
         if ($q['posts_per_page'] == -1) {
             $q['nopaging'] = true;
         } else {
             $q['nopaging'] = false;
         }
     }
     if ($this->is_feed) {
         $q['posts_per_page'] = get_option('posts_per_rss');
         $q['nopaging'] = false;
     }
     $q['posts_per_page'] = (int) $q['posts_per_page'];
     if ($q['posts_per_page'] < -1) {
         $q['posts_per_page'] = abs($q['posts_per_page']);
     } else {
         if ($q['posts_per_page'] == 0) {
             $q['posts_per_page'] = 1;
         }
     }
     if (!isset($q['comments_per_page']) || $q['comments_per_page'] == 0) {
         $q['comments_per_page'] = get_option('comments_per_page');
     }
     if ($this->is_home && (empty($this->query) || $q['preview'] == 'true') && 'page' == get_option('show_on_front') && get_option('page_on_front')) {
         $this->is_page = true;
         $this->is_home = false;
         $q['page_id'] = get_option('page_on_front');
     }
     if (isset($q['page'])) {
         $q['page'] = trim($q['page'], '/');
         $q['page'] = absint($q['page']);
     }
     switch ($q['fields']) {
         case 'ids':
             $fields = array($this->es_map('post_id'));
             break;
         case 'id=>parent':
             $fields = array($this->es_map('post_id'), $this->es_map('post_parent'));
             break;
         default:
             if (apply_filters('es_query_use_source', false)) {
                 $fields = array('_source');
             } else {
                 $fields = array($this->es_map('post_id'));
             }
     }
     if ('' !== $q['menu_order']) {
         $filter[] = $this->dsl_terms($this->es_map('menu_order'), $q['menu_order']);
     }
     // The "m" parameter is meant for months but accepts datetimes of varying specificity
     if ($q['m']) {
         $date = array('year' => substr($q['m'], 0, 4));
         $m_len = strlen($q['m']);
         if ($m_len > 5) {
             $date['month'] = substr($q['m'], 4, 2);
         }
         if ($m_len > 7) {
             $date['day'] = substr($q['m'], 6, 2);
         }
         if ($m_len > 9) {
             $date['hour'] = substr($q['m'], 8, 2);
         }
         if ($m_len > 11) {
             $date['minute'] = substr($q['m'], 10, 2);
         }
         if ($m_len > 13) {
             $date['second'] = substr($q['m'], 12, 2);
             // If we have absolute precision, we can use a term filter instead of a range
             $filter[] = $this->dsl_terms($this->es_map('post_date'), ES_WP_Date_Query::build_datetime($date));
         } else {
             // We don't have second-level precision, so we need to build a range query from what we have
             $date_query = new ES_WP_Date_Query(array('after' => $date, 'before' => $date, 'inclusive' => true));
             $date_filter = $date_query->get_dsl($this);
             if (!empty($date_filter)) {
                 $filter[] = $date_filter;
             } elseif (false === $date_filter) {
                 // @todo: potentially do this differently; see no_results() for more info
                 return $this->no_results();
             }
         }
     }
     unset($date_query, $date_filter, $date, $m_len);
     // Handle the other individual date parameters
     $date_parameters = array();
     if ('' !== $q['hour']) {
         $date_parameters['hour'] = $q['hour'];
     }
     if ('' !== $q['minute']) {
         $date_parameters['minute'] = $q['minute'];
     }
     if ('' !== $q['second']) {
         $date_parameters['second'] = $q['second'];
     }
     if ($q['year']) {
         $date_parameters['year'] = $q['year'];
     }
     if ($q['monthnum']) {
         $date_parameters['month'] = $q['monthnum'];
     }
     if ($q['w']) {
         $date_parameters['week'] = $q['w'];
     }
     if ($q['day']) {
         $date_parameters['day'] = $q['day'];
     }
     if ($date_parameters) {
         $date_query = new ES_WP_Date_Query(array($date_parameters));
         $date_filter = $date_query->get_dsl($this);
         if (!empty($date_filter)) {
             $filter[] = $date_filter;
         } elseif (false === $date_filter) {
             // @todo: potentially do this differently; see no_results() for more info
             return $this->no_results();
         }
     }
     unset($date_parameters, $date_query, $date_filter);
     // Handle complex date queries
     if (!empty($q['date_query'])) {
         $this->date_query = new ES_WP_Date_Query($q['date_query']);
         $date_filter = $this->date_query->get_dsl($this);
         if (!empty($date_filter)) {
             $filter[] = $date_filter;
         } elseif (false === $date_filter) {
             // @todo: potentially do this differently; see no_results() for more info
             return $this->no_results();
         }
         unset($date_filter);
     }
     // If we've got a post_type AND it's not "any" post_type.
     if (!empty($q['post_type']) && 'any' != $q['post_type']) {
         foreach ((array) $q['post_type'] as $_post_type) {
             $ptype_obj = get_post_type_object($_post_type);
             if (!$ptype_obj || !$ptype_obj->query_var || empty($q[$ptype_obj->query_var])) {
                 continue;
             }
             if (!$ptype_obj->hierarchical || strpos($q[$ptype_obj->query_var], '/') === false) {
                 // Non-hierarchical post_types & parent-level-hierarchical post_types can directly use 'name'
                 $q['name'] = $q[$ptype_obj->query_var];
             } else {
                 // Hierarchical post_types will operate through the
                 $q['pagename'] = $q[$ptype_obj->query_var];
                 $q['name'] = '';
             }
             // Only one request for a slug is possible, this is why name & pagename are overwritten above.
             break;
         }
         //end foreach
         unset($ptype_obj);
     }
     if ('' != $q['name']) {
         $q['name'] = sanitize_title_for_query($q['name']);
         $filter[] = $this->dsl_terms($this->es_map('post_name'), $q['name']);
     } elseif ('' != $q['pagename']) {
         if (isset($this->queried_object_id)) {
             $reqpage = $this->queried_object_id;
         } else {
             if ('page' != $q['post_type']) {
                 foreach ((array) $q['post_type'] as $_post_type) {
                     $ptype_obj = get_post_type_object($_post_type);
                     if (!$ptype_obj || !$ptype_obj->hierarchical) {
                         continue;
                     }
                     $reqpage = get_page_by_path($q['pagename'], OBJECT, $_post_type);
                     if ($reqpage) {
                         break;
                     }
                 }
                 unset($ptype_obj);
             } else {
                 $reqpage = get_page_by_path($q['pagename']);
             }
             if (!empty($reqpage)) {
                 $reqpage = $reqpage->ID;
             } else {
                 $reqpage = 0;
             }
         }
         $page_for_posts = get_option('page_for_posts');
         if ('page' != get_option('show_on_front') || empty($page_for_posts) || $reqpage != $page_for_posts) {
             $q['pagename'] = sanitize_title_for_query(wp_basename($q['pagename']));
             $q['name'] = $q['pagename'];
             $filter[] = $this->dsl_terms($this->es_map('post_id'), absint($reqpage));
             $reqpage_obj = get_post($reqpage);
             if (is_object($reqpage_obj) && 'attachment' == $reqpage_obj->post_type) {
                 $this->is_attachment = true;
                 $post_type = $q['post_type'] = 'attachment';
                 $this->is_page = true;
                 $q['attachment_id'] = $reqpage;
             }
         }
     } elseif ('' != $q['attachment']) {
         $q['attachment'] = sanitize_title_for_query(wp_basename($q['attachment']));
         $q['name'] = $q['attachment'];
         $filter[] = $this->dsl_terms($this->es_map('post_name'), $q['attachment']);
     }
     if (isset($q['comments_popup']) && intval($q['comments_popup'])) {
         $q['p'] = absint($q['comments_popup']);
     }
     // If an attachment is requested by number, let it supersede any post number.
     if ($q['attachment_id']) {
         $q['p'] = absint($q['attachment_id']);
     }
     // If a post number is specified, load that post
     if ($q['p']) {
         $filter[] = $this->dsl_terms($this->es_map('post_id'), absint($q['p']));
     } elseif ($q['post__in']) {
         $post__in = array_map('absint', $q['post__in']);
         $filter[] = $this->dsl_terms($this->es_map('post_id'), $post__in);
     } elseif ($q['post__not_in']) {
         $post__not_in = array_map('absint', $q['post__not_in']);
         $filter[] = array('not' => $this->dsl_terms($this->es_map('post_id'), $post__not_in));
     }
     if (is_numeric($q['post_parent'])) {
         $filter[] = $this->dsl_terms($this->es_map('post_parent'), absint($q['post_parent']));
     } elseif ($q['post_parent__in']) {
         $post_parent__in = array_map('absint', $q['post_parent__in']);
         $filter[] = $this->dsl_terms($this->es_map('post_parent'), $post_parent__in);
     } elseif ($q['post_parent__not_in']) {
         $post_parent__not_in = array_map('absint', $q['post_parent__not_in']);
         $filter[] = array('not' => $this->dsl_terms($this->es_map('post_parent'), $post_parent__not_in));
     }
     if ($q['page_id']) {
         if ('page' != get_option('show_on_front') || $q['page_id'] != get_option('page_for_posts')) {
             $q['p'] = $q['page_id'];
             $filter[] = $this->dsl_terms($this->es_map('post_id'), absint($q['page_id']));
         }
     }
     // If a search pattern is specified, load the posts that match.
     if (!empty($q['s'])) {
         $search = $this->parse_search($q);
     }
     /**
      * Filter the search query.
      *
      * @param string      $search Search filter for ES query.
      * @param ES_WP_Query $this   The current ES_WP_Query object.
      */
     if (!empty($search)) {
         $query['must'] = apply_filters_ref_array('es_posts_search', array($search, &$this));
         if (!is_user_logged_in()) {
             $filter[] = array('or' => array($this->dsl_terms($this->es_map('post_password'), ''), $this->dsl_missing($this->es_map('post_password'))));
         }
     }
     // Taxonomies
     if (!$this->is_singular) {
         $this->parse_tax_query($q);
         $this->tax_query = new ES_WP_Tax_Query($this->tax_query);
         $tax_filter = $this->tax_query->get_dsl($this);
         if (false === $tax_filter) {
             return $this->no_results();
         }
         if (!empty($tax_filter)) {
             $filter[] = $tax_filter;
         }
         unset($tax_filter);
     }
     if ($this->is_tax) {
         if (empty($post_type)) {
             // Do a fully inclusive search for currently registered post types of queried taxonomies
             $post_type = array();
             $taxonomies = wp_list_pluck($this->tax_query->queries, 'taxonomy');
             foreach (get_post_types(array('exclude_from_search' => false)) as $pt) {
                 $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
                 if (array_intersect($taxonomies, $object_taxonomies)) {
                     $post_type[] = $pt;
                 }
             }
             if (!$post_type) {
                 $post_type = 'any';
             } elseif (count($post_type) == 1) {
                 $post_type = $post_type[0];
             }
             // @todo: no good way to do this in ES; workarounds?
             $post_status_join = true;
         } elseif (in_array('attachment', (array) $post_type)) {
             // @todo: no good way to do this in ES; workarounds?
             $post_status_join = true;
         }
     }
     // Back-compat
     if (!empty($this->tax_query->queries)) {
         $tax_query_in_and = wp_list_filter($this->tax_query->queries, array('operator' => 'NOT IN'), 'NOT');
         if (!empty($tax_query_in_and)) {
             if (!isset($q['taxonomy'])) {
                 foreach ($tax_query_in_and as $a_tax_query) {
                     if (!in_array($a_tax_query['taxonomy'], array('category', 'post_tag'))) {
                         $q['taxonomy'] = $a_tax_query['taxonomy'];
                         if ('slug' == $a_tax_query['field']) {
                             $q['term'] = $a_tax_query['terms'][0];
                         } else {
                             $q['term_id'] = $a_tax_query['terms'][0];
                         }
                         break;
                     }
                 }
             }
             $cat_query = wp_list_filter($tax_query_in_and, array('taxonomy' => 'category'));
             if (!empty($cat_query)) {
                 $cat_query = reset($cat_query);
                 if (!empty($cat_query['terms'][0])) {
                     $the_cat = get_term_by($cat_query['field'], $cat_query['terms'][0], 'category');
                     if ($the_cat) {
                         $this->set('cat', $the_cat->term_id);
                         $this->set('category_name', $the_cat->slug);
                     }
                     unset($the_cat);
                 }
             }
             unset($cat_query);
             $tag_query = wp_list_filter($tax_query_in_and, array('taxonomy' => 'post_tag'));
             if (!empty($tag_query)) {
                 $tag_query = reset($tag_query);
                 if (!empty($tag_query['terms'][0])) {
                     $the_tag = get_term_by($tag_query['field'], $tag_query['terms'][0], 'post_tag');
                     if ($the_tag) {
                         $this->set('tag_id', $the_tag->term_id);
                     }
                     unset($the_tag);
                 }
             }
             unset($tag_query);
         }
     }
     // @todo: hmmmm
     if (!empty($this->tax_query->queries) || !empty($this->meta_query->queries)) {
         $groupby = "{$wpdb->posts}.ID";
     }
     // Author/user stuff
     if (!empty($q['author']) && $q['author'] != '0') {
         $q['author'] = addslashes_gpc('' . urldecode($q['author']));
         $authors = array_unique(array_map('intval', preg_split('/[,\\s]+/', $q['author'])));
         foreach ($authors as $author) {
             $key = $author > 0 ? 'author__in' : 'author__not_in';
             $q[$key][] = abs($author);
         }
         $q['author'] = implode(',', $authors);
     }
     if (!empty($q['author__not_in'])) {
         $author__not_in = array_map('absint', array_unique((array) $q['author__not_in']));
         $filter[] = array('not' => $this->dsl_terms($this->es_map('post_author'), $author__not_in));
     } elseif (!empty($q['author__in'])) {
         $author__in = array_map('absint', array_unique((array) $q['author__in']));
         $filter[] = $this->dsl_terms($this->es_map('post_author'), $author__in);
     }
     // Author stuff for nice URLs
     if ('' != $q['author_name']) {
         if (strpos($q['author_name'], '/') !== false) {
             $q['author_name'] = explode('/', $q['author_name']);
             if ($q['author_name'][count($q['author_name']) - 1]) {
                 $q['author_name'] = $q['author_name'][count($q['author_name']) - 1];
                 // no trailing slash
             } else {
                 $q['author_name'] = $q['author_name'][count($q['author_name']) - 2];
                 // there was a trailing slash
             }
         }
         $q['author_name'] = sanitize_title_for_query($q['author_name']);
         $filter[] = $this->dsl_terms($this->es_map('post_author.user_nicename'), $q['author_name']);
     }
     // MIME-Type stuff for attachment browsing
     if (isset($q['post_mime_type']) && '' != $q['post_mime_type']) {
         $es_mime = $this->post_mime_type_query($q['post_mime_type'], $wpdb->posts);
         if (!empty($es_mime['filters'])) {
             $filter[] = $es_mime['filters'];
         }
         if (!empty($es_mime['query'])) {
             if (empty($query['should'])) {
                 $query['should'] = $es_mime['query'];
             } else {
                 $query['should'] = array_merge($query['should'], $es_mime['query']);
             }
         }
     }
     if (!isset($q['order'])) {
         $q['order'] = 'desc';
     } else {
         $q['order'] = $this->parse_order($q['order']);
     }
     // Order by
     if (empty($q['orderby'])) {
         /*
          * Boolean false or empty array blanks out ORDER BY,
          * while leaving the value unset or otherwise empty sets the default.
          */
         if (isset($q['orderby']) && (is_array($q['orderby']) || false === $q['orderby'])) {
             $orderby = '';
         } else {
             $sort[] = array($this->es_map('post_date') => $q['order']);
         }
     } elseif ('none' == $q['orderby']) {
         // nothing to see here
     } elseif ($q['orderby'] == 'post__in' && !empty($post__in)) {
         // @todo: Figure this out... Elasticsearch doesn't have an equivalent of this
         // $orderby = "FIELD( {$wpdb->posts}.ID, $post__in )";
     } elseif ($q['orderby'] == 'post_parent__in' && !empty($post_parent__in)) {
         // (see above)
         // $orderby = "FIELD( {$wpdb->posts}.post_parent, $post_parent__in )";
     } else {
         if (is_array($q['orderby'])) {
             foreach ($q['orderby'] as $_orderby => $order) {
                 $orderby = addslashes_gpc(urldecode($_orderby));
                 $parsed = $this->parse_orderby($orderby);
                 if (!$parsed) {
                     continue;
                 }
                 $sort[] = array($parsed => $this->parse_order($order));
             }
         } else {
             $q['orderby'] = urldecode($q['orderby']);
             $q['orderby'] = addslashes_gpc($q['orderby']);
             foreach (explode(' ', $q['orderby']) as $i => $orderby) {
                 $parsed = $this->parse_orderby($orderby);
                 // Only allow certain values for safety.
                 if (!$parsed) {
                     continue;
                 }
                 $sort[] = array($parsed => $q['order']);
             }
             if (empty($sort)) {
                 $sort[] = array($this->es_map('post_date') => $q['order']);
             }
         }
     }
     // Order search results by relevance only when another "orderby" is not specified in the query.
     if (!empty($q['s'])) {
         $search_orderby = array();
         if (empty($q['orderby']) && !$this->is_feed || isset($q['orderby']) && 'relevance' === $q['orderby']) {
             $search_orderby = array('_score');
         }
         /**
          * Filter the order used when ordering search results.
          *
          * @param array       $search_orderby The order clause.
          * @param ES_WP_Query $this           The current ES_WP_Query instance.
          */
         $search_orderby = apply_filters('es_posts_search_orderby', $search_orderby, $this);
         if ($search_orderby) {
             $sort = $sort ? array_merge($search_orderby, $sort) : $search_orderby;
         }
     }
     if (is_array($post_type) && count($post_type) > 1) {
         $post_type_cap = 'multiple_post_type';
     } else {
         if (is_array($post_type)) {
             $post_type = reset($post_type);
         }
         $post_type_object = get_post_type_object($post_type);
         if (empty($post_type_object)) {
             $post_type_cap = $post_type;
         }
     }
     if ('any' == $post_type) {
         $in_search_post_types = get_post_types(array('exclude_from_search' => false));
         if (empty($in_search_post_types)) {
             // @todo: potentially do this differently; see no_results() for more info
             return $this->no_results();
         } else {
             $filter[] = $this->dsl_terms($this->es_map('post_type'), array_values($in_search_post_types));
         }
     } elseif (!empty($post_type)) {
         $filter[] = $this->dsl_terms($this->es_map('post_type'), array_values((array) $post_type));
         if (!is_array($post_type)) {
             $post_type_object = get_post_type_object($post_type);
         }
     } elseif ($this->is_attachment) {
         $filter[] = $this->dsl_terms($this->es_map('post_type'), 'attachment');
         $post_type_object = get_post_type_object('attachment');
     } elseif ($this->is_page) {
         $filter[] = $this->dsl_terms($this->es_map('post_type'), 'page');
         $post_type_object = get_post_type_object('page');
     } else {
         $filter[] = $this->dsl_terms($this->es_map('post_type'), 'post');
         $post_type_object = get_post_type_object('post');
     }
     $edit_cap = 'edit_post';
     $read_cap = 'read_post';
     if (!empty($post_type_object)) {
         $edit_others_cap = $post_type_object->cap->edit_others_posts;
         $read_private_cap = $post_type_object->cap->read_private_posts;
     } else {
         $edit_others_cap = 'edit_others_' . $post_type_cap . 's';
         $read_private_cap = 'read_private_' . $post_type_cap . 's';
     }
     $user_id = get_current_user_id();
     if (!empty($q['post_status'])) {
         $statuswheres = array();
         $q_status = $q['post_status'];
         if (!is_array($q_status)) {
             $q_status = explode(',', $q_status);
         }
         $r_status = array();
         $p_status = array();
         $e_status = array();
         if (in_array('any', $q_status)) {
             $e_status = get_post_stati(array('exclude_from_search' => true));
             $e_status = array_values($e_status);
         } else {
             foreach (get_post_stati() as $status) {
                 if (in_array($status, $q_status)) {
                     if ('private' == $status) {
                         $p_status[] = $status;
                     } else {
                         $r_status[] = $status;
                     }
                 }
             }
         }
         if (empty($q['perm']) || 'readable' != $q['perm']) {
             $r_status = array_merge($r_status, $p_status);
             unset($p_status);
         }
         if (!empty($e_status)) {
             // $statuswheres[] = "(" . join( ' AND ', $e_status ) . ")";
             $status_ands[] = array('not' => $this->dsl_terms($this->es_map('post_status'), $e_status));
         }
         if (!empty($r_status)) {
             if (!empty($q['perm']) && 'editable' == $q['perm'] && !current_user_can($edit_others_cap)) {
                 // $statuswheres[] = "($wpdb->posts.post_author = $user_id " . "AND (" . join( ' OR ', $r_status ) . "))";
                 $status_ands[] = array('bool' => array('must' => array($this->dsl_terms($this->es_map('post_author'), $user_id), $this->dsl_terms($this->es_map('post_status'), $r_status))));
             } else {
                 // $statuswheres[] = "(" . join( ' OR ', $r_status ) . ")";
                 $status_ands[] = $this->dsl_terms($this->es_map('post_status'), $r_status);
             }
         }
         if (!empty($p_status)) {
             if (!empty($q['perm']) && 'readable' == $q['perm'] && !current_user_can($read_private_cap)) {
                 // $statuswheres[] = "($wpdb->posts.post_author = $user_id " . "AND (" . join( ' OR ', $p_status ) . "))";
                 $status_ands[] = array('bool' => array('must' => array($this->dsl_terms($this->es_map('post_author'), $user_id), $this->dsl_terms($this->es_map('post_status'), $p_status))));
             } else {
                 // $statuswheres[] = "(" . join( ' OR ', $p_status ) . ")";
                 $status_ands[] = $this->dsl_terms($this->es_map('post_status'), $p_status);
             }
         }
         if ($post_status_join) {
             // @todo: no good way to do this in ES...
             /*
             $join .= " LEFT JOIN $wpdb->posts AS p2 ON ($wpdb->posts.post_parent = p2.ID) ";
             foreach ( $statuswheres as $index => $statuswhere )
             	$statuswheres[$index] = "($statuswhere OR ($wpdb->posts.post_status = 'inherit' AND " . str_replace($wpdb->posts, 'p2', $statuswhere) . "))";
             */
         }
         $filter = array_merge($filter, $status_ands);
     } elseif (!$this->is_singular) {
         $singular_states = array('publish');
         // Add public states.
         $singular_states = array_merge($singular_states, (array) get_post_stati(array('public' => true)));
         if ($this->is_admin) {
             // Add protected states that should show in the admin all list.
             $singular_states = array_merge($singular_states, (array) get_post_stati(array('protected' => true, 'show_in_admin_all_list' => true)));
         }
         if (is_user_logged_in()) {
             // Add private states that are limited to viewing by the author of a post or someone who has caps to read private states.
             $private_states = get_post_stati(array('private' => true));
             $singular_states_ors = array();
             foreach ((array) $private_states as $state) {
                 // @todo: leaving off here
                 if (current_user_can($read_private_cap)) {
                     $singular_states[] = $state;
                 } else {
                     $singular_states_ors[] = array('and' => array($this->dsl_terms($this->es_map('post_author'), $user_id), $this->dsl_terms($this->es_map('post_status'), $state)));
                 }
             }
         }
         $singular_states = array_values(array_unique($singular_states));
         $singular_states_filter = $this->dsl_terms($this->es_map('post_status'), $singular_states);
         if (!empty($singular_states_ors)) {
             $singular_states_ors[] = $singular_states_filter;
             $filter[] = array('or' => $singular_states_ors);
         } else {
             $filter[] = $singular_states_filter;
         }
         unset($singular_states, $singular_states_filter, $singular_states_ors, $private_states);
     }
     if (!empty($this->meta_query->queries)) {
         $filter[] = $this->meta_query->get_dsl($this, 'post');
     }
     // Apply filters on the filter clause prior to paging so that any
     // manipulations to them are reflected in the paging by day queries.
     if (!$q['suppress_filters']) {
         $filter = apply_filters_ref_array('es_query_filter', array($filter, &$this));
     }
     // Paging
     if (empty($q['nopaging']) && !$this->is_singular) {
         $page = absint($q['paged']);
         if (!$page) {
             $page = 1;
         }
         if (empty($q['offset'])) {
             $from = ($page - 1) * $q['posts_per_page'];
         } else {
             // we're ignoring $page and using 'offset'
             $from = absint($q['offset']);
         }
         $size = $q['posts_per_page'];
     } else {
         $from = $size = false;
     }
     // Comments feeds
     // @todo: come back to this
     if (0 && $this->is_comment_feed && ($this->is_archive || $this->is_search || !$this->is_singular)) {
         if ($this->is_archive || $this->is_search) {
             $cjoin = "JOIN {$wpdb->posts} ON ({$wpdb->comments}.comment_post_ID = {$wpdb->posts}.ID) {$join} ";
             $cwhere = "WHERE comment_approved = '1' {$where}";
             $cgroupby = "{$wpdb->comments}.comment_id";
         } else {
             // Other non singular e.g. front
             $cjoin = "JOIN {$wpdb->posts} ON ( {$wpdb->comments}.comment_post_ID = {$wpdb->posts}.ID )";
             $cwhere = "WHERE post_status = 'publish' AND comment_approved = '1'";
             $cgroupby = '';
         }
         if (!$q['suppress_filters']) {
             $cjoin = apply_filters_ref_array('es_comment_feed_join', array($cjoin, &$this));
             $cwhere = apply_filters_ref_array('es_comment_feed_where', array($cwhere, &$this));
             $cgroupby = apply_filters_ref_array('es_comment_feed_groupby', array($cgroupby, &$this));
             $corderby = apply_filters_ref_array('es_comment_feed_orderby', array('comment_date_gmt DESC', &$this));
             $climits = apply_filters_ref_array('es_comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
         }
         $cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
         $corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
         $this->comments = (array) $wpdb->get_results("SELECT {$distinct} {$wpdb->comments}.* FROM {$wpdb->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}");
         $this->comment_count = count($this->comments);
         $post_ids = array();
         foreach ($this->comments as $comment) {
             $post_ids[] = (int) $comment->comment_post_ID;
         }
         $post_ids = join(',', $post_ids);
         $join = '';
         if ($post_ids) {
             $where = "AND {$wpdb->posts}.ID IN ({$post_ids}) ";
         } else {
             $where = "AND 0";
         }
     }
     // Run cleanup on our filter and query
     $filter = array_filter($filter);
     if (!empty($filter)) {
         $filter = array('and' => $filter);
     }
     $query = array_filter($query);
     if (!empty($query)) {
         if (1 == count($query) && !empty($query['must']) && 1 == count($query['must'])) {
             $query = $query['must'];
         } else {
             $query = array('bool' => $query);
             if (!empty($query['bool']['should'])) {
                 $query['bool']['minimum_should_match'] = 1;
             }
         }
     }
     $pieces = array('filter', 'query', 'sort', 'fields', 'size', 'from');
     // Apply post-paging filters on our clauses. Only plugins that
     // manipulate paging queries should use these hooks.
     if (!$q['suppress_filters']) {
         $filter = apply_filters_ref_array('es_posts_filter_paged', array($filter, &$this));
         $query = apply_filters_ref_array('es_posts_query_paged', array($query, &$this));
         $sort = apply_filters_ref_array('es_posts_sort', array($sort, &$this));
         $fields = apply_filters_ref_array('es_posts_fields', array($fields, &$this));
         $size = apply_filters_ref_array('es_posts_size', array($size, &$this));
         $from = apply_filters_ref_array('es_posts_from', array($from, &$this));
         // Filter all clauses at once, for convenience
         $clauses = (array) apply_filters_ref_array('es_posts_clauses', array(compact($pieces), &$this));
         foreach ($pieces as $piece) {
             ${$piece} = isset($clauses[$piece]) ? $clauses[$piece] : '';
         }
     }
     // Announce current selection parameters. For use by caching plugins.
     do_action('es_posts_selection', array('filter' => $filter, 'query' => $query, 'sort' => $sort, 'fields' => $fields, 'size' => $size, 'from' => $from));
     // Filter again for the benefit of caching plugins. Regular plugins should use the hooks above.
     if (!$q['suppress_filters']) {
         $filter = apply_filters_ref_array('es_posts_filter_request', array($filter, &$this));
         $query = apply_filters_ref_array('es_posts_query_request', array($query, &$this));
         $sort = apply_filters_ref_array('es_posts_sort_request', array($sort, &$this));
         $fields = apply_filters_ref_array('es_posts_fields_request', array($fields, &$this));
         $size = apply_filters_ref_array('es_posts_size_request', array($size, &$this));
         $from = apply_filters_ref_array('es_posts_from_request', array($from, &$this));
         // Filter all clauses at once, for convenience
         $clauses = (array) apply_filters_ref_array('es_posts_clauses_request', array(compact($pieces), &$this));
         foreach ($pieces as $piece) {
             ${$piece} = isset($clauses[$piece]) ? $clauses[$piece] : '';
         }
     }
     $this->es_args = array('filter' => $filter, 'query' => $query, 'sort' => $sort, 'fields' => $fields, 'from' => $from, 'size' => $size);
     // Remove empty criteria
     foreach ($this->es_args as $key => $value) {
         if (empty($value) && 0 !== $value) {
             unset($this->es_args[$key]);
         }
     }
     // Elasticsearch needs a size, so we set it very high if posts_per_page = -1
     if (-1 == $q['posts_per_page'] && !isset($this->es_args['size'])) {
         $this->es_args['size'] = $size = apply_filters('es_query_max_results', 1000);
     }
     $old_args = $this->es_args;
     if (!$q['suppress_filters']) {
         $this->es_args = apply_filters_ref_array('es_posts_request', array($this->es_args, &$this));
     }
     if ('ids' == $q['fields'] || 'id=>parent' == $q['fields']) {
         $this->es_response = $this->query_es($this->es_args);
         $this->set_posts($q, $this->es_response);
         $this->post_count = count($this->posts);
         $this->set_found_posts($q, $this->es_response);
         return $this->posts;
     }
     $this->es_response = $this->query_es($this->es_args);
     $this->set_posts($q, $this->es_response);
     $this->set_found_posts($q, $this->es_response);
     // The rest of this method is mostly core
     // Convert to WP_Post objects
     if ($this->posts) {
         $this->posts = array_map('get_post', $this->posts);
     }
     // Raw results filter. Prior to status checks.
     if (!$q['suppress_filters']) {
         $this->posts = apply_filters_ref_array('es_posts_results', array($this->posts, &$this));
     }
     // @todo: address this
     if (0 && !empty($this->posts) && $this->is_comment_feed && $this->is_singular) {
         $cjoin = apply_filters_ref_array('es_comment_feed_join', array('', &$this));
         $cwhere = apply_filters_ref_array('es_comment_feed_where', array("WHERE comment_post_ID = '{$this->posts[0]->ID}' AND comment_approved = '1'", &$this));
         $cgroupby = apply_filters_ref_array('es_comment_feed_groupby', array('', &$this));
         $cgroupby = !empty($cgroupby) ? 'GROUP BY ' . $cgroupby : '';
         $corderby = apply_filters_ref_array('es_comment_feed_orderby', array('comment_date_gmt DESC', &$this));
         $corderby = !empty($corderby) ? 'ORDER BY ' . $corderby : '';
         $climits = apply_filters_ref_array('es_comment_feed_limits', array('LIMIT ' . get_option('posts_per_rss'), &$this));
         $comments_request = "SELECT {$wpdb->comments}.* FROM {$wpdb->comments} {$cjoin} {$cwhere} {$cgroupby} {$corderby} {$climits}";
         $this->comments = $wpdb->get_results($comments_request);
         $this->comment_count = count($this->comments);
     }
     // Check post status to determine if post should be displayed.
     if (!empty($this->posts) && ($this->is_single || $this->is_page)) {
         $status = get_post_status($this->posts[0]);
         $post_status_obj = get_post_status_object($status);
         //$type = get_post_type($this->posts[0]);
         if (!$post_status_obj->public) {
             if (!is_user_logged_in()) {
                 // User must be logged in to view unpublished posts.
                 $this->posts = array();
             } else {
                 if ($post_status_obj->protected) {
                     // User must have edit permissions on the draft to preview.
                     if (!current_user_can($edit_cap, $this->posts[0]->ID)) {
                         $this->posts = array();
                     } else {
                         $this->is_preview = true;
                         if ('future' != $status) {
                             $this->posts[0]->post_date = current_time('mysql');
                         }
                     }
                 } elseif ($post_status_obj->private) {
                     if (!current_user_can($read_cap, $this->posts[0]->ID)) {
                         $this->posts = array();
                     }
                 } else {
                     $this->posts = array();
                 }
             }
         }
         if ($this->is_preview && $this->posts && current_user_can($edit_cap, $this->posts[0]->ID)) {
             $this->posts[0] = get_post(apply_filters_ref_array('es_the_preview', array($this->posts[0], &$this)));
         }
     }
     // @todo: address this
     // Put sticky posts at the top of the posts array
     $sticky_posts = get_option('sticky_posts');
     if (0 && $this->is_home && $page <= 1 && is_array($sticky_posts) && !empty($sticky_posts) && !$q['ignore_sticky_posts']) {
         $num_posts = count($this->posts);
         $sticky_offset = 0;
         // Loop over posts and relocate stickies to the front.
         for ($i = 0; $i < $num_posts; $i++) {
             if (in_array($this->posts[$i]->ID, $sticky_posts)) {
                 $sticky_post = $this->posts[$i];
                 // Remove sticky from current position
                 array_splice($this->posts, $i, 1);
                 // Move to front, after other stickies
                 array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
                 // Increment the sticky offset. The next sticky will be placed at this offset.
                 $sticky_offset++;
                 // Remove post from sticky posts array
                 $offset = array_search($sticky_post->ID, $sticky_posts);
                 unset($sticky_posts[$offset]);
             }
         }
         // If any posts have been excluded specifically, Ignore those that are sticky.
         if (!empty($sticky_posts) && !empty($q['post__not_in'])) {
             $sticky_posts = array_diff($sticky_posts, $q['post__not_in']);
         }
         // Fetch sticky posts that weren't in the query results
         if (!empty($sticky_posts)) {
             $stickies = get_posts(array('post__in' => $sticky_posts, 'post_type' => $post_type, 'post_status' => 'publish', 'nopaging' => true));
             foreach ($stickies as $sticky_post) {
                 array_splice($this->posts, $sticky_offset, 0, array($sticky_post));
                 $sticky_offset++;
             }
         }
     }
     if (!$q['suppress_filters']) {
         $this->posts = apply_filters_ref_array('es_the_posts', array($this->posts, &$this));
     }
     // Ensure that any posts added/modified via one of the filters above are
     // of the type WP_Post and are filtered.
     if ($this->posts) {
         $this->post_count = count($this->posts);
         $this->posts = array_map('get_post', $this->posts);
         if ($q['cache_results']) {
             update_post_caches($this->posts, $post_type, $q['update_post_term_cache'], $q['update_post_meta_cache']);
         }
         $this->post = reset($this->posts);
     } else {
         $this->post_count = 0;
         $this->posts = array();
     }
     return $this->posts;
 }
 function get_columns()
 {
     $posts_columns = array();
     $posts_columns['cb'] = '<input type="checkbox" />';
     $posts_columns['icon'] = '';
     /* translators: column name */
     $posts_columns['title'] = _x('File', 'column name');
     $posts_columns['author'] = __('Author');
     $taxonomies = array();
     $taxonomies = get_taxonomies_for_attachments('objects');
     $taxonomies = wp_filter_object_list($taxonomies, array('show_admin_column' => true), 'and', 'name');
     $taxonomies = apply_filters('manage_taxonomies_for_attachment_columns', $taxonomies, 'attachment');
     $taxonomies = array_filter($taxonomies, 'taxonomy_exists');
     foreach ($taxonomies as $taxonomy) {
         if ('category' == $taxonomy) {
             $column_key = 'categories';
         } elseif ('post_tag' == $taxonomy) {
             $column_key = 'tags';
         } else {
             $column_key = 'taxonomy-' . $taxonomy;
         }
         $posts_columns[$column_key] = get_taxonomy($taxonomy)->labels->name;
     }
     /* translators: column name */
     if (!$this->detached) {
         $posts_columns['parent'] = _x('Uploaded to', 'column name');
         if (post_type_supports('attachment', 'comments')) {
             $posts_columns['comments'] = '<span class="vers"><div title="' . esc_attr__('Comments') . '" class="comment-grey-bubble"></div></span>';
         }
     }
     /* translators: column name */
     $posts_columns['date'] = _x('Date', 'column name');
     $posts_columns = apply_filters('manage_media_columns', $posts_columns, $this->detached);
     return $posts_columns;
 }
/**
 * Checks whether a given query is for events
 * @package event-query-functions
 * @param WP_Query $query The query to test
 * @param bool $exclusive Whether to test if the query is *exclusively* for events, or can include other post types
 * @return bool True if the query is an event query. False otherwise.
 */
function eventorganiser_is_event_query($query, $exclusive = false)
{
    $post_types = $query->get('post_type');
    if ('any' == $post_types) {
        $post_types = get_post_types(array('exclude_from_search' => false));
    }
    if ($post_types == 'event' || array('event') == $post_types) {
        $bool = true;
    } elseif ($query && $query->is_feed('eo-events') || is_feed('eo-events')) {
        $bool = true;
    } elseif (empty($post_types) && eo_is_event_taxonomy($query)) {
        //Querying by taxonomy - check if 'event' is the only post type
        $post_types = array();
        $taxonomies = wp_list_pluck($query->tax_query->queries, 'taxonomy');
        foreach (get_post_types() as $pt) {
            if (version_compare('3.4', get_bloginfo('version')) <= 0) {
                $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
            } else {
                //Backwards compat for 3.3
                $object_taxonomies = $pt === 'attachment' ? array() : get_object_taxonomies($pt);
            }
            if (array_intersect($taxonomies, $object_taxonomies)) {
                $post_types[] = $pt;
            }
        }
        if (in_array('event', $post_types)) {
            if ($exclusive && 1 == count($post_types)) {
                $query->set('post_type', 'event');
                $bool = true;
            } elseif (!$exclusive) {
                $bool = true;
            } else {
                $bool = false;
            }
        } else {
            $bool = false;
        }
    } elseif ($exclusive) {
        $bool = false;
    } elseif (is_array($post_types) && in_array('event', $post_types)) {
        $bool = true;
    } else {
        $bool = false;
    }
    /**
     * Filters whether the query is an event query.
     * 
     * This should be `true` if the query is for events, `false` otherwise. The 
     * third parameter, `$exclusive` qualifies if this means 'query exclusively 
     * for events' or not. If `true` then this filter should return `true` only 
     * if the query is exclusively for events.
     * 
     * @param bool     $bool      Whether the query is an event query.
     * @param WP_Query $query     The WP_Query instance to check.
     * @param bool     $exclusive Whether the check if for queries exclusively for events. 
     */
    return apply_filters('eventorganiser_is_event_query', $bool, $query, $exclusive);
}
示例#14
0
 /**
  * Builds the query param for the post status filter
  * @param array $params
  * @param Lift_WP_Query $lift_query
  * @return array
  */
 public static function _bq_filter_post_status($params, $lift_query)
 {
     $wp_query = $lift_query->wp_query;
     $q = $wp_query->query_vars;
     $user_ID = get_current_user_id();
     //mimic wp_query logic around post_type since it isn't performed on an accessible copy
     $post_type = $q['post_type'];
     if ($wp_query->is_tax && empty($post_type)) {
         $post_type = array();
         $taxonomies = wp_list_pluck($wp_query->tax_query->queries, 'taxonomy');
         foreach (get_post_types(array('exclude_from_search' => false)) as $pt) {
             $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
             if (array_intersect($taxonomies, $object_taxonomies)) {
                 $post_type[] = $pt;
             }
         }
         if (!$post_type) {
             $post_type = 'any';
         }
     }
     //direct copy from wp_query 3.5
     if (is_array($post_type)) {
         $post_type_cap = 'multiple_post_type';
     } else {
         $post_type_object = get_post_type_object($post_type);
         if (empty($post_type_object)) {
             $post_type_cap = $post_type;
         }
     }
     //direct copy from wp_query 3.5
     if ('any' == $post_type) {
         //unused code
     } elseif (!empty($post_type) && is_array($post_type)) {
         //unused code
     } elseif (!empty($post_type)) {
         $post_type_object = get_post_type_object($post_type);
     } elseif ($wp_query->is_attachment) {
         $post_type_object = get_post_type_object('attachment');
     } elseif ($wp_query->is_page) {
         $post_type_object = get_post_type_object('page');
     } else {
         $post_type_object = get_post_type_object('post');
     }
     //direct copy from wp_query 3.5
     if (!empty($post_type_object)) {
         $edit_cap = $post_type_object->cap->edit_post;
         $read_cap = $post_type_object->cap->read_post;
         $edit_others_cap = $post_type_object->cap->edit_others_posts;
         $read_private_cap = $post_type_object->cap->read_private_posts;
     } else {
         $edit_cap = 'edit_' . $post_type_cap;
         $read_cap = 'read_' . $post_type_cap;
         $edit_others_cap = 'edit_others_' . $post_type_cap . 's';
         $read_private_cap = 'read_private_' . $post_type_cap . 's';
     }
     if (!empty($q['post_status'])) {
         $q_status = $q['post_status'];
         $stati_expression = new Lift_Expression_Set('and');
         if (!is_array($q_status)) {
             $q_status = explode(',', $q_status);
         }
         $r_stati_expression = new Lift_Expression_Set();
         $p_stati_expression = new Lift_Expression_Set();
         $e_stati_expression = new Lift_Expression_Set('and');
         if (in_array('any', $q_status)) {
             foreach (get_post_stati(array('exclude_from_search' => true)) as $status) {
                 $e_stati_expression->addExpression(new Lift_Expression_Field('post_status', '-' . $status));
             }
         } else {
             foreach (get_post_stati() as $status) {
                 if (in_array($status, $q_status)) {
                     if ('private' == $status) {
                         $p_stati_expression->addExpression(new Lift_Expression_Field('post_status', $status));
                     } else {
                         $r_stati_expression->addExpression(new Lift_Expression_Field('post_status', $status));
                     }
                 }
             }
         }
         if (empty($q['perm']) || 'readable' != $q['perm']) {
             foreach ($p_stati_expression->sub_expressions as $expression) {
                 $r_stati_expression->addExpression($expression);
             }
             unset($p_stati_expression);
         }
         if (isset($r_stati_expression) && count($r_stati_expression)) {
             if (!empty($q['perm']) && 'editable' == $q['perm'] && !current_user_can($edit_others_cap)) {
                 $tmp_expression = new Lift_Expression_Set('and', array(new Lift_Expression_Field('post_author', $user_ID, false), $r_stati_expression));
                 $stati_expression->addExpression($tmp_expression);
             } else {
                 $stati_expression->addExpression($r_stati_expression);
             }
         }
         if (!empty($p_stati_expression)) {
             if (!empty($q['perm']) && 'readable' == $q['perm'] && !current_user_can($read_private_cap)) {
                 $tmp_expression = new Lift_Expression_Set('and', array(new Lift_Expression_Field('post_author', $user_ID, false), $p_stati_expression));
                 $stati_expression->addExpression($tmp_expression);
             } else {
                 $stati_expression->addExpression($p_stati_expression);
             }
         }
     } elseif (!$wp_query->is_singular) {
         $stati_expression = new Lift_Expression_Set();
         // Add public states.
         $public_states = get_post_stati(array('public' => true));
         foreach ((array) $public_states as $state) {
             $stati_expression->addExpression(new Lift_Expression_Field('post_status', $state));
         }
         if ($wp_query->is_admin) {
             // Add protected states that should show in the admin all list.
             $admin_all_states = get_post_stati(array('protected' => true, 'show_in_admin_all_list' => true));
             foreach ((array) $admin_all_states as $state) {
                 $stati_expression->addExpression(new Lift_Expression_Field('post_status', $state));
             }
         }
         if (is_user_logged_in()) {
             // Add private states that are limited to viewing by the author of a post or someone who has caps to read private states.
             $private_states = get_post_stati(array('private' => true));
             foreach ((array) $private_states as $state) {
                 if (current_user_can($read_private_cap)) {
                     $stati_expression->addExpression(new Lift_Expression_Field('post_status', $state));
                 } else {
                     $tmp_expression = new Lift_Expression_Set('and', array(new Lift_Expression_Field('post_author', $user_ID, false), new Lift_Expression_Field('post_status', $state)));
                     $stati_expression->addExpression($tmp_expression);
                 }
             }
         }
     }
     $params[] = (string) $stati_expression;
     return $params;
 }
/**
 * Get a taxonomy post type.
 *
 * @since 1.0.0
 * @package GeoDirectory
 * @global object $wp_query WordPress Query object.
 * @param string $taxonomy The WordPress taxonomy string.
 * @return bool|string Post type on success. false on failure.
 */
function geodir_get_taxonomy_posttype($taxonomy = '')
{
    global $wp_query;
    $post_type = array();
    $taxonomies = array();
    if (!empty($taxonomy)) {
        $taxonomies[] = $taxonomy;
    } elseif ($wp_query->tax_query->queries) {
        $taxonomies = wp_list_pluck($wp_query->tax_query->queries, 'taxonomy');
    }
    if (!empty($taxonomies)) {
        foreach (geodir_get_posttypes() as $pt) {
            $object_taxonomies = $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies($pt);
            if (array_intersect($taxonomies, $object_taxonomies)) {
                $post_type[] = $pt;
            }
        }
    }
    if (!empty($post_type)) {
        return $post_type[0];
    } else {
        return false;
    }
}