Example #1
0
/**
 * Adds hidden fields with the data for use in the inline editor for posts and pages.
 *
 * @since 0.0.1
 *
 * @param HQ_Post $post Post object.
 */
function get_inline_data($post)
{
    $post_type_object = get_post_type_object($post->post_type);
    if (!current_user_can('edit_post', $post->ID)) {
        return;
    }
    $title = esc_textarea(trim($post->post_title));
    /** This filter is documented in hq-admin/edit-tag-form.php */
    echo '
<div class="hidden" id="inline_' . $post->ID . '">
	<div class="post_title">' . $title . '</div>
	<div class="post_name">' . apply_filters('editable_slug', $post->post_name) . '</div>
	<div class="post_author">' . $post->post_author . '</div>
	<div class="comment_status">' . esc_html($post->comment_status) . '</div>
	<div class="ping_status">' . esc_html($post->ping_status) . '</div>
	<div class="_status">' . esc_html($post->post_status) . '</div>
	<div class="jj">' . mysql2date('d', $post->post_date, false) . '</div>
	<div class="mm">' . mysql2date('m', $post->post_date, false) . '</div>
	<div class="aa">' . mysql2date('Y', $post->post_date, false) . '</div>
	<div class="hh">' . mysql2date('H', $post->post_date, false) . '</div>
	<div class="mn">' . mysql2date('i', $post->post_date, false) . '</div>
	<div class="ss">' . mysql2date('s', $post->post_date, false) . '</div>
	<div class="post_password">' . esc_html($post->post_password) . '</div>';
    if ($post_type_object->hierarchical) {
        echo '<div class="post_parent">' . $post->post_parent . '</div>';
    }
    if ($post->post_type == 'page') {
        echo '<div class="page_template">' . esc_html(get_post_meta($post->ID, '_hq_page_template', true)) . '</div>';
    }
    if (post_type_supports($post->post_type, 'page-attributes')) {
        echo '<div class="menu_order">' . $post->menu_order . '</div>';
    }
    $taxonomy_names = get_object_taxonomies($post->post_type);
    foreach ($taxonomy_names as $taxonomy_name) {
        $taxonomy = get_taxonomy($taxonomy_name);
        if ($taxonomy->hierarchical && $taxonomy->show_ui) {
            $terms = get_object_term_cache($post->ID, $taxonomy_name);
            if (false === $terms) {
                $terms = hq_get_object_terms($post->ID, $taxonomy_name);
                hq_cache_add($post->ID, $terms, $taxonomy_name . '_relationships');
            }
            $term_ids = empty($terms) ? array() : hq_list_pluck($terms, 'term_id');
            echo '<div class="post_category" id="' . $taxonomy_name . '_' . $post->ID . '">' . implode(',', $term_ids) . '</div>';
        } elseif ($taxonomy->show_ui) {
            echo '<div class="tags_input" id="' . $taxonomy_name . '_' . $post->ID . '">' . esc_html(str_replace(',', ', ', get_terms_to_edit($post->ID, $taxonomy_name))) . '</div>';
        }
    }
    if (!$post_type_object->hierarchical) {
        echo '<div class="sticky">' . (is_sticky($post->ID) ? 'sticky' : '') . '</div>';
    }
    if (post_type_supports($post->post_type, 'post-formats')) {
        echo '<div class="post_format">' . esc_html(get_post_format($post->ID)) . '</div>';
    }
    echo '</div>';
}
Example #2
0
 /**
  * Get a list of comments matching the query vars.
  *
  * @since 0.0.1
  * @access public
  *
  * @global hqdb $hqdb HiveQueen database abstraction object.
  *
  * @return int|array The list of comments.
  */
 public function get_comments()
 {
     global $hqdb;
     $groupby = '';
     $this->parse_query();
     // Parse meta query
     $this->meta_query = new HQ_Meta_Query();
     $this->meta_query->parse_query_vars($this->query_vars);
     /**
      * Fires before comments are retrieved.
      *
      * @since 0.0.1
      *
      * @param HQ_Comment_Query &$this Current instance of HQ_Comment_Query, passed by reference.
      */
     do_action_ref_array('pre_get_comments', array(&$this));
     // Reparse query vars, in case they were modified in a 'pre_get_comments' callback.
     $this->meta_query->parse_query_vars($this->query_vars);
     if (!empty($this->meta_query->queries)) {
         $meta_query_clauses = $this->meta_query->get_sql('comment', $hqdb->comments, 'comment_ID', $this);
     }
     // $args can include anything. Only use the args defined in the query_var_defaults to compute the key.
     $key = md5(serialize(hq_array_slice_assoc($this->query_vars, array_keys($this->query_var_defaults))));
     $last_changed = hq_cache_get('last_changed', 'comment');
     if (!$last_changed) {
         $last_changed = microtime();
         hq_cache_set('last_changed', $last_changed, 'comment');
     }
     $cache_key = "get_comments:{$key}:{$last_changed}";
     if ($cache = hq_cache_get($cache_key, 'comment')) {
         $this->comments = $cache;
         return $this->comments;
     }
     $where = array();
     // Assemble clauses related to 'comment_approved'.
     $approved_clauses = array();
     // 'status' accepts an array or a comma-separated string.
     $status_clauses = array();
     $statuses = $this->query_vars['status'];
     if (!is_array($statuses)) {
         $statuses = preg_split('/[\\s,]+/', $statuses);
     }
     // 'any' overrides other statuses.
     if (!in_array('any', $statuses)) {
         foreach ($statuses as $status) {
             switch ($status) {
                 case 'hold':
                     $status_clauses[] = "comment_approved = '0'";
                     break;
                 case 'approve':
                     $status_clauses[] = "comment_approved = '1'";
                     break;
                 case 'all':
                 case '':
                     $status_clauses[] = "( comment_approved = '0' OR comment_approved = '1' )";
                     break;
                 default:
                     $status_clauses[] = $hqdb->prepare("comment_approved = %s", $status);
                     break;
             }
         }
         if (!empty($status_clauses)) {
             $approved_clauses[] = '( ' . implode(' OR ', $status_clauses) . ' )';
         }
     }
     // User IDs or emails whose unapproved comments are included, regardless of $status.
     if (!empty($this->query_vars['include_unapproved'])) {
         $include_unapproved = $this->query_vars['include_unapproved'];
         // Accepts arrays or comma-separated strings.
         if (!is_array($include_unapproved)) {
             $include_unapproved = preg_split('/[\\s,]+/', $include_unapproved);
         }
         $unapproved_ids = $unapproved_emails = array();
         foreach ($include_unapproved as $unapproved_identifier) {
             // Numeric values are assumed to be user ids.
             if (is_numeric($unapproved_identifier)) {
                 $approved_clauses[] = $hqdb->prepare("( user_id = %d AND comment_approved = '0' )", $unapproved_identifier);
                 // Otherwise we match against email addresses.
             } else {
                 $approved_clauses[] = $hqdb->prepare("( comment_author_email = %s AND comment_approved = '0' )", $unapproved_identifier);
             }
         }
     }
     // Collapse comment_approved clauses into a single OR-separated clause.
     if (!empty($approved_clauses)) {
         if (1 === count($approved_clauses)) {
             $where[] = $approved_clauses[0];
         } else {
             $where[] = '( ' . implode(' OR ', $approved_clauses) . ' )';
         }
     }
     $order = 'ASC' == strtoupper($this->query_vars['order']) ? 'ASC' : 'DESC';
     // Disable ORDER BY with 'none', an empty array, or boolean false.
     if (in_array($this->query_vars['orderby'], array('none', array(), false), true)) {
         $orderby = '';
     } elseif (!empty($this->query_vars['orderby'])) {
         $ordersby = is_array($this->query_vars['orderby']) ? $this->query_vars['orderby'] : preg_split('/[,\\s]/', $this->query_vars['orderby']);
         $orderby_array = array();
         $found_orderby_comment_ID = false;
         foreach ($ordersby as $_key => $_value) {
             if (!$_value) {
                 continue;
             }
             if (is_int($_key)) {
                 $_orderby = $_value;
                 $_order = $order;
             } else {
                 $_orderby = $_key;
                 $_order = $_value;
             }
             if (!$found_orderby_comment_ID && 'comment_ID' === $_orderby) {
                 $found_orderby_comment_ID = true;
             }
             $parsed = $this->parse_orderby($_orderby);
             if (!$parsed) {
                 continue;
             }
             $orderby_array[] = $parsed . ' ' . $this->parse_order($_order);
         }
         // If no valid clauses were found, order by comment_date_gmt.
         if (empty($orderby_array)) {
             $orderby_array[] = "{$hqdb->comments}.comment_date_gmt {$order}";
         }
         // To ensure determinate sorting, always include a comment_ID clause.
         if (!$found_orderby_comment_ID) {
             $comment_ID_order = '';
             // Inherit order from comment_date or comment_date_gmt, if available.
             foreach ($orderby_array as $orderby_clause) {
                 if (preg_match('/comment_date(?:_gmt)*\\ (ASC|DESC)/', $orderby_clause, $match)) {
                     $comment_ID_order = $match[1];
                     break;
                 }
             }
             // If no date-related order is available, use the date from the first available clause.
             if (!$comment_ID_order) {
                 foreach ($orderby_array as $orderby_clause) {
                     if (false !== strpos('ASC', $orderby_clause)) {
                         $comment_ID_order = 'ASC';
                     } else {
                         $comment_ID_order = 'DESC';
                     }
                     break;
                 }
             }
             // Default to DESC.
             if (!$comment_ID_order) {
                 $comment_ID_order = 'DESC';
             }
             $orderby_array[] = "{$hqdb->comments}.comment_ID {$comment_ID_order}";
         }
         $orderby = implode(', ', $orderby_array);
     } else {
         $orderby = "{$hqdb->comments}.comment_date_gmt {$order}";
     }
     $number = absint($this->query_vars['number']);
     $offset = absint($this->query_vars['offset']);
     if (!empty($number)) {
         if ($offset) {
             $limits = 'LIMIT ' . $offset . ',' . $number;
         } else {
             $limits = 'LIMIT ' . $number;
         }
     } else {
         $limits = '';
     }
     if ($this->query_vars['count']) {
         $fields = 'COUNT(*)';
     } else {
         switch (strtolower($this->query_vars['fields'])) {
             case 'ids':
                 $fields = "{$hqdb->comments}.comment_ID";
                 break;
             default:
                 $fields = "*";
                 break;
         }
     }
     $join = '';
     $post_id = absint($this->query_vars['post_id']);
     if (!empty($post_id)) {
         $where[] = $hqdb->prepare('comment_post_ID = %d', $post_id);
     }
     // Parse comment IDs for an IN clause.
     if (!empty($this->query_vars['comment__in'])) {
         $where[] = "{$hqdb->comments}.comment_ID IN ( " . implode(',', hq_parse_id_list($this->query_vars['comment__in'])) . ' )';
     }
     // Parse comment IDs for a NOT IN clause.
     if (!empty($this->query_vars['comment__not_in'])) {
         $where[] = "{$hqdb->comments}.comment_ID NOT IN ( " . implode(',', hq_parse_id_list($this->query_vars['comment__not_in'])) . ' )';
     }
     // Parse comment post IDs for an IN clause.
     if (!empty($this->query_vars['post__in'])) {
         $where[] = 'comment_post_ID IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post__in'])) . ' )';
     }
     // Parse comment post IDs for a NOT IN clause.
     if (!empty($this->query_vars['post__not_in'])) {
         $where[] = 'comment_post_ID NOT IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post__not_in'])) . ' )';
     }
     if ('' !== $this->query_vars['author_email']) {
         $where[] = $hqdb->prepare('comment_author_email = %s', $this->query_vars['author_email']);
     }
     if ('' !== $this->query_vars['karma']) {
         $where[] = $hqdb->prepare('comment_karma = %d', $this->query_vars['karma']);
     }
     // Filtering by comment_type: 'type', 'type__in', 'type__not_in'.
     $raw_types = array('IN' => array_merge((array) $this->query_vars['type'], (array) $this->query_vars['type__in']), 'NOT IN' => (array) $this->query_vars['type__not_in']);
     $comment_types = array();
     foreach ($raw_types as $operator => $_raw_types) {
         $_raw_types = array_unique($_raw_types);
         foreach ($_raw_types as $type) {
             switch ($type) {
                 // An empty translates to 'all', for backward compatibility
                 case '':
                 case 'all':
                     break;
                 case 'comment':
                 case 'comments':
                     $comment_types[$operator][] = "''";
                     break;
                 case 'pings':
                     $comment_types[$operator][] = "'pingback'";
                     $comment_types[$operator][] = "'trackback'";
                     break;
                 default:
                     $comment_types[$operator][] = $hqdb->prepare('%s', $type);
                     break;
             }
         }
         if (!empty($comment_types[$operator])) {
             $types_sql = implode(', ', $comment_types[$operator]);
             $where[] = "comment_type {$operator} ({$types_sql})";
         }
     }
     if ('' !== $this->query_vars['parent']) {
         $where[] = $hqdb->prepare('comment_parent = %d', $this->query_vars['parent']);
     }
     if (is_array($this->query_vars['user_id'])) {
         $where[] = 'user_id IN (' . implode(',', array_map('absint', $this->query_vars['user_id'])) . ')';
     } elseif ('' !== $this->query_vars['user_id']) {
         $where[] = $hqdb->prepare('user_id = %d', $this->query_vars['user_id']);
     }
     if ('' !== $this->query_vars['search']) {
         $search_sql = $this->get_search_sql($this->query_vars['search'], array('comment_author', 'comment_author_email', 'comment_author_url', 'comment_author_IP', 'comment_content'));
         // Strip leading 'AND'.
         $where[] = preg_replace('/^\\s*AND\\s*/', '', $search_sql);
     }
     // If any post-related query vars are passed, join the posts table.
     $join_posts_table = false;
     $plucked = hq_array_slice_assoc($this->query_vars, array('post_author', 'post_name', 'post_parent', 'post_status', 'post_type'));
     $post_fields = array_filter($plucked);
     if (!empty($post_fields)) {
         $join_posts_table = true;
         foreach ($post_fields as $field_name => $field_value) {
             // $field_value may be an array.
             $esses = array_fill(0, count((array) $field_value), '%s');
             $where[] = $hqdb->prepare(" {$hqdb->posts}.{$field_name} IN (" . implode(',', $esses) . ')', $field_value);
         }
     }
     // Comment author IDs for an IN clause.
     if (!empty($this->query_vars['author__in'])) {
         $where[] = 'user_id IN ( ' . implode(',', hq_parse_id_list($this->query_vars['author__in'])) . ' )';
     }
     // Comment author IDs for a NOT IN clause.
     if (!empty($this->query_vars['author__not_in'])) {
         $where[] = 'user_id NOT IN ( ' . implode(',', hq_parse_id_list($this->query_vars['author__not_in'])) . ' )';
     }
     // Post author IDs for an IN clause.
     if (!empty($this->query_vars['post_author__in'])) {
         $join_posts_table = true;
         $where[] = 'post_author IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post_author__in'])) . ' )';
     }
     // Post author IDs for a NOT IN clause.
     if (!empty($this->query_vars['post_author__not_in'])) {
         $join_posts_table = true;
         $where[] = 'post_author NOT IN ( ' . implode(',', hq_parse_id_list($this->query_vars['post_author__not_in'])) . ' )';
     }
     if ($join_posts_table) {
         $join = "JOIN {$hqdb->posts} ON {$hqdb->posts}.ID = {$hqdb->comments}.comment_post_ID";
     }
     if (!empty($meta_query_clauses)) {
         $join .= $meta_query_clauses['join'];
         // Strip leading 'AND'.
         $where[] = preg_replace('/^\\s*AND\\s*/', '', $meta_query_clauses['where']);
         if (!$this->query_vars['count']) {
             $groupby = "{$hqdb->comments}.comment_ID";
         }
     }
     $date_query = $this->query_vars['date_query'];
     if (!empty($date_query) && is_array($date_query)) {
         $date_query_object = new HQ_Date_Query($date_query, 'comment_date');
         $where[] = preg_replace('/^\\s*AND\\s*/', '', $date_query_object->get_sql());
     }
     $where = implode(' AND ', $where);
     $pieces = array('fields', 'join', 'where', 'orderby', 'limits', 'groupby');
     /**
      * Filter the comment query clauses.
      *
      * @since 0.0.1
      *
      * @param array            $pieces A compacted array of comment query clauses.
      * @param HQ_Comment_Query &$this  Current instance of HQ_Comment_Query, passed by reference.
      */
     $clauses = apply_filters_ref_array('comments_clauses', array(compact($pieces), &$this));
     $fields = isset($clauses['fields']) ? $clauses['fields'] : '';
     $join = isset($clauses['join']) ? $clauses['join'] : '';
     $where = isset($clauses['where']) ? $clauses['where'] : '';
     $orderby = isset($clauses['orderby']) ? $clauses['orderby'] : '';
     $limits = isset($clauses['limits']) ? $clauses['limits'] : '';
     $groupby = isset($clauses['groupby']) ? $clauses['groupby'] : '';
     if ($where) {
         $where = 'WHERE ' . $where;
     }
     if ($groupby) {
         $groupby = 'GROUP BY ' . $groupby;
     }
     if ($orderby) {
         $orderby = "ORDER BY {$orderby}";
     }
     $this->request = "SELECT {$fields} FROM {$hqdb->comments} {$join} {$where} {$groupby} {$orderby} {$limits}";
     if ($this->query_vars['count']) {
         return $hqdb->get_var($this->request);
     }
     if ('ids' == $this->query_vars['fields']) {
         $this->comments = $hqdb->get_col($this->request);
         return array_map('intval', $this->comments);
     }
     $results = $hqdb->get_results($this->request);
     /**
      * Filter the comment query results.
      *
      * @since 0.0.1
      *
      * @param array            $results  An array of comments.
      * @param HQ_Comment_Query &$this    Current instance of HQ_Comment_Query, passed by reference.
      */
     $comments = apply_filters_ref_array('the_comments', array($results, &$this));
     hq_cache_add($cache_key, $comments, 'comment');
     if ('*' === $fields) {
         update_comment_cache($comments);
     }
     $this->comments = $comments;
     return $this->comments;
 }
Example #3
0
/**
 * Retrieve the icon for a MIME type.
 *
 * @since 0.0.1
 *
 * @param string|int $mime MIME type or attachment ID.
 * @return string|false Icon, false otherwise.
 */
function hq_mime_type_icon($mime = 0)
{
    if (!is_numeric($mime)) {
        $icon = hq_cache_get("mime_type_icon_{$mime}");
    }
    $post_id = 0;
    if (empty($icon)) {
        $post_mimes = array();
        if (is_numeric($mime)) {
            $mime = (int) $mime;
            if ($post = get_post($mime)) {
                $post_id = (int) $post->ID;
                $ext = preg_replace('/^.+?\\.([^.]+)$/', '$1', $post->guid);
                if (!empty($ext)) {
                    $post_mimes[] = $ext;
                    if ($ext_type = hq_ext2type($ext)) {
                        $post_mimes[] = $ext_type;
                    }
                }
                $mime = $post->post_mime_type;
            } else {
                $mime = 0;
            }
        } else {
            $post_mimes[] = $mime;
        }
        $icon_files = hq_cache_get('icon_files');
        if (!is_array($icon_files)) {
            /**
             * Filter the icon directory path.
             *
             * @since 0.0.1
             *
             * @param string $path Icon directory absolute path.
             */
            $icon_dir = apply_filters('icon_dir', ABSPATH . HQINC . '/images/media');
            /**
             * Filter the icon directory URI.
             *
             * @since 0.0.1
             *
             * @param string $uri Icon directory URI.
             */
            $icon_dir_uri = apply_filters('icon_dir_uri', includes_url('images/media'));
            /**
             * Filter the list of icon directory URIs.
             *
             * @since 0.0.1
             *
             * @param array $uris List of icon directory URIs.
             */
            $dirs = apply_filters('icon_dirs', array($icon_dir => $icon_dir_uri));
            $icon_files = array();
            while ($dirs) {
                $keys = array_keys($dirs);
                $dir = array_shift($keys);
                $uri = array_shift($dirs);
                if ($dh = opendir($dir)) {
                    while (false !== ($file = readdir($dh))) {
                        $file = basename($file);
                        if (substr($file, 0, 1) == '.') {
                            continue;
                        }
                        if (!in_array(strtolower(substr($file, -4)), array('.png', '.gif', '.jpg'))) {
                            if (is_dir("{$dir}/{$file}")) {
                                $dirs["{$dir}/{$file}"] = "{$uri}/{$file}";
                            }
                            continue;
                        }
                        $icon_files["{$dir}/{$file}"] = "{$uri}/{$file}";
                    }
                    closedir($dh);
                }
            }
            hq_cache_add('icon_files', $icon_files, 'default', 600);
        }
        $types = array();
        // Icon basename - extension = MIME wildcard.
        foreach ($icon_files as $file => $uri) {
            $types[preg_replace('/^([^.]*).*$/', '$1', basename($file))] =& $icon_files[$file];
        }
        if (!empty($mime)) {
            $post_mimes[] = substr($mime, 0, strpos($mime, '/'));
            $post_mimes[] = substr($mime, strpos($mime, '/') + 1);
            $post_mimes[] = str_replace('/', '_', $mime);
        }
        $matches = hq_match_mime_types(array_keys($types), $post_mimes);
        $matches['default'] = array('default');
        foreach ($matches as $match => $wilds) {
            if (isset($types[$wilds[0]])) {
                $icon = $types[$wilds[0]];
                if (!is_numeric($mime)) {
                    hq_cache_add("mime_type_icon_{$mime}", $icon);
                }
                break;
            }
        }
    }
    /**
     * Filter the mime type icon.
     *
     * @since 0.0.1
     *
     * @param string $icon    Path to the mime type icon.
     * @param string $mime    Mime type.
     * @param int    $post_id Attachment ID. Will equal 0 if the function passed
     *                        the mime type.
     */
    return apply_filters('hq_mime_type_icon', $icon, $mime, $post_id);
}