pryley / site-reviews

plugin/Database/QuerySql.php

Indentation +245 added lines, -245 removed lines

@@ -7,249 +7,249 @@
 
 trait QuerySql
 {
-    public $args;
-    public $db;
-
-    public function escFieldsForInsert(array $fields)
-    {
-        return sprintf('(`%s`)', implode('`,`', $fields));
-    }
-
-    public function escValuesForInsert(array $values)
-    {
-        $values = array_map('esc_sql', $values);
-        return sprintf("('%s')", implode("','", array_values($values)));
-    }
-
-    /**
-     * @param string $clause
-     * @return array
-     */
-    public function sqlClauses(array $values, $clause)
-    {
-        $prefix = Str::restrictTo('and, join', $clause);
-        foreach (array_keys($this->args) as $key) {
-            $method = Helper::buildMethodName($key, 'clause-'.$prefix);
-            if (method_exists($this, $method)) {
-                $values[] = call_user_func([$this, $method]);
-            }
-        }
-        return $values;
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlFrom()
-    {
-        $from = "FROM {$this->table('ratings')} r";
-        $from = glsr()->filterString('query/sql/from', $from, $this);
-        return $from;
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlGroupBy()
-    {
-        $groupBy = 'GROUP BY p.ID';
-        return glsr()->filterString('query/sql/group-by', $groupBy, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlJoin()
-    {
-        $join = [
-            "INNER JOIN {$this->db->posts} AS p ON r.review_id = p.ID",
-        ];
-        $join = glsr()->filterArray('query/sql/join', $join, $this);
-        return implode(' ', $join);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlJoinClauses()
-    {
-        $join = $this->sqlClauses([], 'join');
-        $join = glsr()->filterArray('query/sql/join-clauses', $join, $this);
-        return trim($this->sqlJoin().' '.implode(' ', $join));
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlJoinPivots()
-    {
-        $join = [
-            "LEFT JOIN {$this->table('assigned_posts')} apt on r.ID = apt.rating_id",
-            "LEFT JOIN {$this->table('assigned_terms')} att on r.ID = att.rating_id",
-            "LEFT JOIN {$this->table('assigned_users')} aut on r.ID = aut.rating_id",
-        ];
-        $join = glsr()->filterArray('query/sql/join-pivots', $join, $this);
-        return implode(' ', $join);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlLimit()
-    {
-        $limit = $this->args['per_page'] > 0
-            ? $this->db->prepare('LIMIT %d', $this->args['per_page'])
-            : '';
-        return glsr()->filterString('query/sql/limit', $limit, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlOffset()
-    {
-        $offsetBy = (($this->args['page'] - 1) * $this->args['per_page']) + $this->args['offset'];
-        $offset = ($offsetBy > 0)
-            ? $this->db->prepare('OFFSET %d', $offsetBy)
-            : '';
-        return glsr()->filterString('query/sql/offset', $offset, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlOrderBy()
-    {
-        $values = [
-            'none' => '',
-            'rand' => 'ORDER BY RAND()',
-            'relevance' => '',
-        ];
-        $order = $this->args['order'];
-        $orderby = $this->args['orderby'];
-        if (Str::startsWith('p.', $orderby)) {
-            $orderBy = "ORDER BY r.is_pinned {$order}, {$orderby} {$order}";
-        } elseif (array_key_exists($orderby, $values)) {
-            $orderBy = $orderby;
-        } else {
-            $orderBy = '';
-        }
-        return glsr()->filterString('query/sql/order-by', $orderBy, $this);
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlSelect()
-    {
-        $select = [
-            'r.*',
-            'p.post_author as author_id',
-            'p.post_date as date',
-            'p.post_content as content',
-            'p.post_title as title',
-            'p.post_status as status',
-            'GROUP_CONCAT(DISTINCT apt.post_id) as post_ids',
-            'GROUP_CONCAT(DISTINCT att.term_id) as term_ids',
-            'GROUP_CONCAT(DISTINCT aut.user_id) as user_ids',
-        ];
-        $select = glsr()->filterArray('query/sql/select', $select, $this);
-        $select = implode(', ', $select);
-        return "SELECT {$select}";
-    }
-
-    /**
-     * @return string
-     */
-    public function sqlWhere()
-    {
-        $where = [
-            $this->db->prepare('AND p.post_type = %s', glsr()->post_type),
-            "AND p.post_status = 'publish'",
-        ];
-        $where = $this->sqlClauses($where, 'and');
-        $where = glsr()->filterArray('query/sql/where', $where, $this);
-        $where = implode(' ', $where);
-        return "WHERE 1=1 {$where}";
-    }
-
-    /**
-     * @return string
-     */
-    public function table($table)
-    {
-        return glsr(SqlSchema::class)->table($table);
-    }
-
-    /**
-     * This takes care of assigned_to, category, and user.
-     * @return string
-     */
-    protected function clauseAndAssignedTo()
-    {
-        $clauses = [];
-        if ($postIds = $this->args['assigned_to']) {
-            $clauses[] = $this->db->prepare('(apt.post_id IN (%s) AND apt.is_published = 1)', implode(',', $postIds));
-        }
-        if ($termIds = $this->args['category']) {
-            $clauses[] = $this->db->prepare('(att.term_id IN (%s))', implode(',', $termIds));
-        }
-        if ($userIds = $this->args['user']) {
-            $clauses[] = $this->db->prepare('(aut.user_id IN (%s))', implode(',', $userIds));
-        }
-        if ($clauses = implode(' OR ', $clauses)) {
-            return "AND ($clauses)";
-        }
-        return '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseAndRating()
-    {
-        return $this->args['rating']
-            ? $this->db->prepare('AND r.rating > %d', --$this->args['rating'])
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseAndType()
-    {
-        return $this->args['type']
-            ? $this->db->prepare('AND r.type = %s', $this->args['type'])
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseJoinAssignedTo()
-    {
-        return !empty($this->args['assigned_to'])
-            ? "INNER JOIN {$this->table('assigned_posts')} AS apt ON r.ID = apt.rating_id"
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseJoinCategory()
-    {
-        return !empty($this->args['category'])
-            ? "INNER JOIN {$this->table('assigned_terms')} AS att ON r.ID = att.rating_id"
-            : '';
-    }
-
-    /**
-     * @return string
-     */
-    protected function clauseJoinUser()
-    {
-        return !empty($this->args['user'])
-            ? "INNER JOIN {$this->table('assigned_users')} AS aut ON r.ID = aut.rating_id"
-            : '';
-    }
+	public $args;
+	public $db;
+
+	public function escFieldsForInsert(array $fields)
+	{
+		return sprintf('(`%s`)', implode('`,`', $fields));
+	}
+
+	public function escValuesForInsert(array $values)
+	{
+		$values = array_map('esc_sql', $values);
+		return sprintf("('%s')", implode("','", array_values($values)));
+	}
+
+	/**
+	 * @param string $clause
+	 * @return array
+	 */
+	public function sqlClauses(array $values, $clause)
+	{
+		$prefix = Str::restrictTo('and, join', $clause);
+		foreach (array_keys($this->args) as $key) {
+			$method = Helper::buildMethodName($key, 'clause-'.$prefix);
+			if (method_exists($this, $method)) {
+				$values[] = call_user_func([$this, $method]);
+			}
+		}
+		return $values;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlFrom()
+	{
+		$from = "FROM {$this->table('ratings')} r";
+		$from = glsr()->filterString('query/sql/from', $from, $this);
+		return $from;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlGroupBy()
+	{
+		$groupBy = 'GROUP BY p.ID';
+		return glsr()->filterString('query/sql/group-by', $groupBy, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlJoin()
+	{
+		$join = [
+			"INNER JOIN {$this->db->posts} AS p ON r.review_id = p.ID",
+		];
+		$join = glsr()->filterArray('query/sql/join', $join, $this);
+		return implode(' ', $join);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlJoinClauses()
+	{
+		$join = $this->sqlClauses([], 'join');
+		$join = glsr()->filterArray('query/sql/join-clauses', $join, $this);
+		return trim($this->sqlJoin().' '.implode(' ', $join));
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlJoinPivots()
+	{
+		$join = [
+			"LEFT JOIN {$this->table('assigned_posts')} apt on r.ID = apt.rating_id",
+			"LEFT JOIN {$this->table('assigned_terms')} att on r.ID = att.rating_id",
+			"LEFT JOIN {$this->table('assigned_users')} aut on r.ID = aut.rating_id",
+		];
+		$join = glsr()->filterArray('query/sql/join-pivots', $join, $this);
+		return implode(' ', $join);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlLimit()
+	{
+		$limit = $this->args['per_page'] > 0
+			? $this->db->prepare('LIMIT %d', $this->args['per_page'])
+			: '';
+		return glsr()->filterString('query/sql/limit', $limit, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlOffset()
+	{
+		$offsetBy = (($this->args['page'] - 1) * $this->args['per_page']) + $this->args['offset'];
+		$offset = ($offsetBy > 0)
+			? $this->db->prepare('OFFSET %d', $offsetBy)
+			: '';
+		return glsr()->filterString('query/sql/offset', $offset, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlOrderBy()
+	{
+		$values = [
+			'none' => '',
+			'rand' => 'ORDER BY RAND()',
+			'relevance' => '',
+		];
+		$order = $this->args['order'];
+		$orderby = $this->args['orderby'];
+		if (Str::startsWith('p.', $orderby)) {
+			$orderBy = "ORDER BY r.is_pinned {$order}, {$orderby} {$order}";
+		} elseif (array_key_exists($orderby, $values)) {
+			$orderBy = $orderby;
+		} else {
+			$orderBy = '';
+		}
+		return glsr()->filterString('query/sql/order-by', $orderBy, $this);
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlSelect()
+	{
+		$select = [
+			'r.*',
+			'p.post_author as author_id',
+			'p.post_date as date',
+			'p.post_content as content',
+			'p.post_title as title',
+			'p.post_status as status',
+			'GROUP_CONCAT(DISTINCT apt.post_id) as post_ids',
+			'GROUP_CONCAT(DISTINCT att.term_id) as term_ids',
+			'GROUP_CONCAT(DISTINCT aut.user_id) as user_ids',
+		];
+		$select = glsr()->filterArray('query/sql/select', $select, $this);
+		$select = implode(', ', $select);
+		return "SELECT {$select}";
+	}
+
+	/**
+	 * @return string
+	 */
+	public function sqlWhere()
+	{
+		$where = [
+			$this->db->prepare('AND p.post_type = %s', glsr()->post_type),
+			"AND p.post_status = 'publish'",
+		];
+		$where = $this->sqlClauses($where, 'and');
+		$where = glsr()->filterArray('query/sql/where', $where, $this);
+		$where = implode(' ', $where);
+		return "WHERE 1=1 {$where}";
+	}
+
+	/**
+	 * @return string
+	 */
+	public function table($table)
+	{
+		return glsr(SqlSchema::class)->table($table);
+	}
+
+	/**
+	 * This takes care of assigned_to, category, and user.
+	 * @return string
+	 */
+	protected function clauseAndAssignedTo()
+	{
+		$clauses = [];
+		if ($postIds = $this->args['assigned_to']) {
+			$clauses[] = $this->db->prepare('(apt.post_id IN (%s) AND apt.is_published = 1)', implode(',', $postIds));
+		}
+		if ($termIds = $this->args['category']) {
+			$clauses[] = $this->db->prepare('(att.term_id IN (%s))', implode(',', $termIds));
+		}
+		if ($userIds = $this->args['user']) {
+			$clauses[] = $this->db->prepare('(aut.user_id IN (%s))', implode(',', $userIds));
+		}
+		if ($clauses = implode(' OR ', $clauses)) {
+			return "AND ($clauses)";
+		}
+		return '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseAndRating()
+	{
+		return $this->args['rating']
+			? $this->db->prepare('AND r.rating > %d', --$this->args['rating'])
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseAndType()
+	{
+		return $this->args['type']
+			? $this->db->prepare('AND r.type = %s', $this->args['type'])
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseJoinAssignedTo()
+	{
+		return !empty($this->args['assigned_to'])
+			? "INNER JOIN {$this->table('assigned_posts')} AS apt ON r.ID = apt.rating_id"
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseJoinCategory()
+	{
+		return !empty($this->args['category'])
+			? "INNER JOIN {$this->table('assigned_terms')} AS att ON r.ID = att.rating_id"
+			: '';
+	}
+
+	/**
+	 * @return string
+	 */
+	protected function clauseJoinUser()
+	{
+		return !empty($this->args['user'])
+			? "INNER JOIN {$this->table('assigned_users')} AS aut ON r.ID = aut.rating_id"
+			: '';
+	}
 }

plugin/Database/SqlQueries.php

Indentation +173 added lines, -173 removed lines

@@ -10,47 +10,47 @@ 
 
 class SqlQueries
 {
-    protected $db;
-    protected $postType;
+	protected $db;
+	protected $postType;
 
-    public function __construct()
-    {
-        global $wpdb;
-        $this->db = $wpdb;
-        $this->postType = Application::POST_TYPE;
-    }
+	public function __construct()
+	{
+		global $wpdb;
+		$this->db = $wpdb;
+		$this->postType = Application::POST_TYPE;
+	}
 
-    /**
-     * @return bool
-     */
-    public function deletePostCountMetaKeys()
-    {
-        return $this->db->query("
+	/**
+	 * @return bool
+	 */
+	public function deletePostCountMetaKeys()
+	{
+		return $this->db->query("
             DELETE
             FROM {$this->db->postmeta}
             WHERE meta_key LIKE '_glsr_%'
         ");
-    }
+	}
 
-    /**
-     * @return bool
-     */
-    public function deleteTermCountMetaKeys()
-    {
-        return $this->db->query("
+	/**
+	 * @return bool
+	 */
+	public function deleteTermCountMetaKeys()
+	{
+		return $this->db->query("
             DELETE
             FROM {$this->db->termmeta}
             WHERE meta_key LIKE '_glsr_%'
         ");
-    }
+	}
 
-    /**
-     * @param string $metaReviewId
-     * @return int
-     */
-    public function getPostIdFromReviewId($metaReviewId)
-    {
-        $postId = $this->db->get_var("
+	/**
+	 * @param string $metaReviewId
+	 * @return int
+	 */
+	public function getPostIdFromReviewId($metaReviewId)
+	{
+		$postId = $this->db->get_var("
             SELECT p.ID
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
@@ -58,18 +58,18 @@ 
             AND m.meta_key = '_review_id'
             AND m.meta_value = '{$metaReviewId}'
         ");
-        return intval($postId);
-    }
+		return intval($postId);
+	}
 
-    /**
-     * @return array
-     */
-    public function getRatings(array $args)
-    {
-        // get types
-        // get for each type
-        $table = glsr(SqlSchema::class)->table('ratings');
-        return (array) $this->db->get_results("
+	/**
+	 * @return array
+	 */
+	public function getRatings(array $args)
+	{
+		// get types
+		// get for each type
+		$table = glsr(SqlSchema::class)->table('ratings');
+		return (array) $this->db->get_results("
             SELECT r.rating AS rating, COUNT(r.rating) AS count
             FROM {$table} AS r
             {$this->getInnerJoinForRatings($args)}
@@ -77,16 +77,16 @@ 
             {$this->getAndForRatings($args)}
             GROUP BY rating
         ");
-    }
+	}
 
-    /**
-     * @param int $lastPostId
-     * @param int $limit
-     * @return array
-     */
-    public function getReviewCounts(array $args, $lastPostId = 0, $limit = 500)
-    {
-        return (array) $this->db->get_results("
+	/**
+	 * @param int $lastPostId
+	 * @param int $limit
+	 * @return array
+	 */
+	public function getReviewCounts(array $args, $lastPostId = 0, $limit = 500)
+	{
+		return (array) $this->db->get_results("
             SELECT DISTINCT p.ID, m1.meta_value AS rating, m2.meta_value AS type
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m1 ON p.ID = m1.post_id
@@ -101,17 +101,17 @@ 
             ORDER By p.ID ASC
             LIMIT {$limit}
         ");
-    }
+	}
 
-    /**
-     * @todo remove this?
-     * @param string $metaKey
-     * @return array
-     */
-    public function getReviewCountsFor($metaKey)
-    {
-        $metaKey = Str::prefix('_', $metaKey);
-        return (array) $this->db->get_results("
+	/**
+	 * @todo remove this?
+	 * @param string $metaKey
+	 * @return array
+	 */
+	public function getReviewCountsFor($metaKey)
+	{
+		$metaKey = Str::prefix('_', $metaKey);
+		return (array) $this->db->get_results("
             SELECT DISTINCT m.meta_value AS name, COUNT(*) num_posts
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
@@ -119,16 +119,16 @@ 
             AND m.meta_key = '{$metaKey}'
             GROUP BY name
         ");
-    }
+	}
 
-    /**
-     * @todo remove this?
-     * @param string $reviewType
-     * @return array
-     */
-    public function getReviewIdsByType($reviewType)
-    {
-        $results = $this->db->get_col("
+	/**
+	 * @todo remove this?
+	 * @param string $reviewType
+	 * @return array
+	 */
+	public function getReviewIdsByType($reviewType)
+	{
+		$results = $this->db->get_col("
             SELECT DISTINCT m1.meta_value AS review_id
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m1 ON p.ID = m1.post_id
@@ -138,20 +138,20 @@ 
             AND m2.meta_key = '_review_type'
             AND m2.meta_value = '{$reviewType}'
         ");
-        return array_keys(array_flip($results));
-    }
+		return array_keys(array_flip($results));
+	}
 
-    /**
-     * @param int $greaterThanId
-     * @param int $limit
-     * @return array
-     */
-    public function getReviewRatingsFromIds(array $postIds, $greaterThanId = 0, $limit = 100)
-    {
-        sort($postIds);
-        $postIds = array_slice($postIds, intval(array_search($greaterThanId, $postIds)), $limit);
-        $postIds = implode(',', $postIds);
-        return (array) $this->db->get_results("
+	/**
+	 * @param int $greaterThanId
+	 * @param int $limit
+	 * @return array
+	 */
+	public function getReviewRatingsFromIds(array $postIds, $greaterThanId = 0, $limit = 100)
+	{
+		sort($postIds);
+		$postIds = array_slice($postIds, intval(array_search($greaterThanId, $postIds)), $limit);
+		$postIds = implode(',', $postIds);
+		return (array) $this->db->get_results("
             SELECT p.ID, m.meta_value AS rating
             FROM {$this->db->posts} AS p
             INNER JOIN {$this->db->postmeta} AS m ON p.ID = m.post_id
@@ -164,20 +164,20 @@ 
             ORDER By p.ID ASC
             LIMIT {$limit}
         ");
-    }
+	}
 
-    /**
-     * @param string $key
-     * @param string $status
-     * @return array
-     */
-    public function getReviewsMeta($key, $status = 'publish')
-    {
-        $postStatusQuery = 'all' != $status && !empty($status)
-            ? "AND p.post_status = '{$status}'"
-            : '';
-        $key = Str::prefix('_', $key);
-        $values = $this->db->get_col("
+	/**
+	 * @param string $key
+	 * @param string $status
+	 * @return array
+	 */
+	public function getReviewsMeta($key, $status = 'publish')
+	{
+		$postStatusQuery = 'all' != $status && !empty($status)
+			? "AND p.post_status = '{$status}'"
+			: '';
+		$key = Str::prefix('_', $key);
+		$values = $this->db->get_col("
             SELECT DISTINCT m.meta_value
             FROM {$this->db->postmeta} m
             LEFT JOIN {$this->db->posts} p ON p.ID = m.post_id
@@ -188,87 +188,87 @@ 
             GROUP BY p.ID -- remove duplicate meta_value entries
             ORDER BY m.meta_id ASC -- sort by oldest meta_value
         ");
-        sort($values);
-        return $values;
-    }
+		sort($values);
+		return $values;
+	}
 
-    /**
-     * @param string $and
-     * @return string
-     */
-    protected function getAndForCounts(array $args, $and = '')
-    {
-        $postIds = implode(',', array_filter(Arr::get($args, 'post_ids', [])));
-        $termIds = implode(',', array_filter(Arr::get($args, 'term_ids', [])));
-        if (!empty($args['type'])) {
-            $and .= "AND m2.meta_value = '{$args['type']}' ";
-        }
-        if ($postIds) {
-            $and .= "AND m3.meta_key = '_assigned_to' AND m3.meta_value IN ({$postIds}) ";
-        }
-        if ($termIds) {
-            $and .= "AND tr.term_taxonomy_id IN ({$termIds}) ";
-        }
-        return glsr()->filter('query/and-for-counts', $and);
-    }
+	/**
+	 * @param string $and
+	 * @return string
+	 */
+	protected function getAndForCounts(array $args, $and = '')
+	{
+		$postIds = implode(',', array_filter(Arr::get($args, 'post_ids', [])));
+		$termIds = implode(',', array_filter(Arr::get($args, 'term_ids', [])));
+		if (!empty($args['type'])) {
+			$and .= "AND m2.meta_value = '{$args['type']}' ";
+		}
+		if ($postIds) {
+			$and .= "AND m3.meta_key = '_assigned_to' AND m3.meta_value IN ({$postIds}) ";
+		}
+		if ($termIds) {
+			$and .= "AND tr.term_taxonomy_id IN ({$termIds}) ";
+		}
+		return glsr()->filter('query/and-for-counts', $and);
+	}
 
-    /**
-     * @param string $and
-     * @return string
-     */
-    protected function getAndForRatings(array $args, $and = '')
-    {
-        $assignedQueries = [];
-        if ($postIds = Arr::consolidate(Arr::get($args, 'post_ids', []))) {
-            $postIds = implode(',', array_filter($postIds));
-            $assignedQueries[] = "(ap.post_id IN ({$postIds}) AND ap.is_published = 1)";
-        }
-        if ($termIds = Arr::consolidate(Arr::get($args, 'term_ids', []))) {
-            $termIds = implode(',', array_filter($termIds));
-            $assignedQueries[] = "at.term_id IN ({$termIds})";
-        }
-        if ($rating = Helper::castToInt(Arr::get($args, 'rating'))) {
-            ++$rating;
-            $and .= "AND r.rating < {$rating} ";
-        }
-        if ($type = Arr::get($args, 'type')) {
-            $and .= "AND r.type = '{$type}' ";
-        }
-        if ($assignedQuery = implode(' OR ', $assignedQueries)) {
-            $and .= "AND ($assignedQuery) ";
-        }
-        return glsr()->filter('query/and-for-ratings', $and);
-    }
+	/**
+	 * @param string $and
+	 * @return string
+	 */
+	protected function getAndForRatings(array $args, $and = '')
+	{
+		$assignedQueries = [];
+		if ($postIds = Arr::consolidate(Arr::get($args, 'post_ids', []))) {
+			$postIds = implode(',', array_filter($postIds));
+			$assignedQueries[] = "(ap.post_id IN ({$postIds}) AND ap.is_published = 1)";
+		}
+		if ($termIds = Arr::consolidate(Arr::get($args, 'term_ids', []))) {
+			$termIds = implode(',', array_filter($termIds));
+			$assignedQueries[] = "at.term_id IN ({$termIds})";
+		}
+		if ($rating = Helper::castToInt(Arr::get($args, 'rating'))) {
+			++$rating;
+			$and .= "AND r.rating < {$rating} ";
+		}
+		if ($type = Arr::get($args, 'type')) {
+			$and .= "AND r.type = '{$type}' ";
+		}
+		if ($assignedQuery = implode(' OR ', $assignedQueries)) {
+			$and .= "AND ($assignedQuery) ";
+		}
+		return glsr()->filter('query/and-for-ratings', $and);
+	}
 
-    /**
-     * @param string $innerJoin
-     * @return string
-     */
-    protected function getInnerJoinForCounts(array $args, $innerJoin = '')
-    {
-        if (!empty(Arr::get($args, 'post_ids'))) {
-            $innerJoin .= "INNER JOIN {$this->db->postmeta} AS m3 ON p.ID = m3.post_id ";
-        }
-        if (!empty(Arr::get($args, 'term_ids'))) {
-            $innerJoin .= "INNER JOIN {$this->db->term_relationships} AS tr ON p.ID = tr.object_id ";
-        }
-        return glsr()->filter('query/inner-join-for-counts', $innerJoin);
-    }
+	/**
+	 * @param string $innerJoin
+	 * @return string
+	 */
+	protected function getInnerJoinForCounts(array $args, $innerJoin = '')
+	{
+		if (!empty(Arr::get($args, 'post_ids'))) {
+			$innerJoin .= "INNER JOIN {$this->db->postmeta} AS m3 ON p.ID = m3.post_id ";
+		}
+		if (!empty(Arr::get($args, 'term_ids'))) {
+			$innerJoin .= "INNER JOIN {$this->db->term_relationships} AS tr ON p.ID = tr.object_id ";
+		}
+		return glsr()->filter('query/inner-join-for-counts', $innerJoin);
+	}
 
-    /**
-     * @param string $innerJoin
-     * @return string
-     */
-    protected function getInnerJoinForRatings(array $args, $innerJoin = '')
-    {
-        if (Arr::consolidate(Arr::get($args, 'post_ids', []))) {
-            $table = glsr(SqlSchema::class)->table('assigned_posts');
-            $innerJoin .= "INNER JOIN {$table} AS ap ON r.ID = ap.rating_id ";
-        }
-        if (Arr::consolidate(Arr::get($args, 'term_ids', []))) {
-            $table = glsr(SqlSchema::class)->table('assigned_terms');
-            $innerJoin .= "INNER JOIN {$table} AS at ON r.ID = at.rating_id ";
-        }
-        return glsr()->filter('query/inner-join-for-ratings', $innerJoin);
-    }
+	/**
+	 * @param string $innerJoin
+	 * @return string
+	 */
+	protected function getInnerJoinForRatings(array $args, $innerJoin = '')
+	{
+		if (Arr::consolidate(Arr::get($args, 'post_ids', []))) {
+			$table = glsr(SqlSchema::class)->table('assigned_posts');
+			$innerJoin .= "INNER JOIN {$table} AS ap ON r.ID = ap.rating_id ";
+		}
+		if (Arr::consolidate(Arr::get($args, 'term_ids', []))) {
+			$table = glsr(SqlSchema::class)->table('assigned_terms');
+			$innerJoin .= "INNER JOIN {$table} AS at ON r.ID = at.rating_id ";
+		}
+		return glsr()->filter('query/inner-join-for-ratings', $innerJoin);
+	}
 }

plugin/Database/TermCountsManager.php

Indentation +82 added lines, -82 removed lines

@@ -9,93 +9,93 @@
 
 class TermCountsManager
 {
-    /**
-     * @var CountsManager
-     */
-    protected $manager;
+	/**
+	 * @var CountsManager
+	 */
+	protected $manager;
 
-    public function __construct()
-    {
-        $this->manager = glsr(CountsManager::class);
-    }
+	public function __construct()
+	{
+		$this->manager = glsr(CountsManager::class);
+	}
 
-    /**
-     * @param int $termTaxonomyId
-     * @return array
-     */
-    public function build($termTaxonomyId)
-    {
-        return $this->manager->buildCounts([
-            'term_ids' => [$termTaxonomyId],
-        ]);
-    }
+	/**
+	 * @param int $termTaxonomyId
+	 * @return array
+	 */
+	public function build($termTaxonomyId)
+	{
+		return $this->manager->buildCounts([
+			'term_ids' => [$termTaxonomyId],
+		]);
+	}
 
-    /**
-     * @return void
-     */
-    public function decrease(Review $review)
-    {
-        foreach ($review->term_ids as $termId) {
-            if (empty($counts = $this->get($termId))) {
-                continue;
-            }
-            $this->update($termId,
-                $this->manager->decreaseRating($counts, $review->review_type, $review->rating)
-            );
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function decrease(Review $review)
+	{
+		foreach ($review->term_ids as $termId) {
+			if (empty($counts = $this->get($termId))) {
+				continue;
+			}
+			$this->update($termId,
+				$this->manager->decreaseRating($counts, $review->review_type, $review->rating)
+			);
+		}
+	}
 
-    /**
-     * @param int $termId
-     * @return array
-     */
-    public function get($termId)
-    {
-        return array_filter((array) get_term_meta($termId, CountsManager::META_COUNT, true));
-    }
+	/**
+	 * @param int $termId
+	 * @return array
+	 */
+	public function get($termId)
+	{
+		return array_filter((array) get_term_meta($termId, CountsManager::META_COUNT, true));
+	}
 
-    /**
-     * @return void
-     */
-    public function increase(Review $review)
-    {
-        $terms = glsr(ReviewManager::class)->normalizeTerms(implode(',', $review->term_ids));
-        foreach ($terms as $term) {
-            $counts = $this->get($term['term_id']);
-            $counts = empty($counts)
-                ? $this->build($term['term_taxonomy_id'])
-                : $this->manager->increaseRating($counts, $review->review_type, $review->rating);
-            $this->update($term['term_id'], $counts);
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function increase(Review $review)
+	{
+		$terms = glsr(ReviewManager::class)->normalizeTerms(implode(',', $review->term_ids));
+		foreach ($terms as $term) {
+			$counts = $this->get($term['term_id']);
+			$counts = empty($counts)
+				? $this->build($term['term_taxonomy_id'])
+				: $this->manager->increaseRating($counts, $review->review_type, $review->rating);
+			$this->update($term['term_id'], $counts);
+		}
+	}
 
-    /**
-     * @param int $termId
-     * @return void
-     */
-    public function update($termId, array $reviewCounts)
-    {
-        $term = get_term($termId, Application::TAXONOMY);
-        if (!isset($term->term_id)) {
-            return;
-        }
-        $ratingCounts = $this->manager->flatten($reviewCounts);
-        update_term_meta($termId, CountsManager::META_COUNT, $reviewCounts);
-        update_term_meta($termId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
-        update_term_meta($termId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
-    }
+	/**
+	 * @param int $termId
+	 * @return void
+	 */
+	public function update($termId, array $reviewCounts)
+	{
+		$term = get_term($termId, Application::TAXONOMY);
+		if (!isset($term->term_id)) {
+			return;
+		}
+		$ratingCounts = $this->manager->flatten($reviewCounts);
+		update_term_meta($termId, CountsManager::META_COUNT, $reviewCounts);
+		update_term_meta($termId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
+		update_term_meta($termId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
+	}
 
-    /**
-     * @return void
-     */
-    public function updateAll()
-    {
-        // glsr(SqlQueries::class)->deleteTermCountMetaKeys(); // @todo test this with SiteGround for race conditions
-        $terms = glsr(Database::class)->getTerms([
-            'fields' => 'all',
-        ]);
-        foreach ($terms as $term) {
-            $this->update($term->term_id, $this->build($term->term_taxonomy_id));
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function updateAll()
+	{
+		// glsr(SqlQueries::class)->deleteTermCountMetaKeys(); // @todo test this with SiteGround for race conditions
+		$terms = glsr(Database::class)->getTerms([
+			'fields' => 'all',
+		]);
+		foreach ($terms as $term) {
+			$this->update($term->term_id, $this->build($term->term_taxonomy_id));
+		}
+	}
 }

plugin/Database/PostCountsManager.php

Indentation +74 added lines, -74 removed lines

@@ -7,85 +7,85 @@
 
 class PostCountsManager
 {
-    /**
-     * @var CountsManager
-     */
-    protected $manager;
+	/**
+	 * @var CountsManager
+	 */
+	protected $manager;
 
-    public function __construct()
-    {
-        $this->manager = glsr(CountsManager::class);
-    }
+	public function __construct()
+	{
+		$this->manager = glsr(CountsManager::class);
+	}
 
-    /**
-     * @param int $postId
-     * @return array
-     */
-    public function build($postId)
-    {
-        return $this->manager->buildCounts([
-            'post_ids' => [$postId],
-        ]);
-    }
+	/**
+	 * @param int $postId
+	 * @return array
+	 */
+	public function build($postId)
+	{
+		return $this->manager->buildCounts([
+			'post_ids' => [$postId],
+		]);
+	}
 
-    /**
-     * @return void
-     */
-    public function decrease(Review $review)
-    {
-        if (empty($counts = $this->get($review->assigned_to))) {
-            return;
-        }
-        $this->update($review->assigned_to,
-            $this->manager->decreaseRating($counts, $review->review_type, $review->rating)
-        );
-    }
+	/**
+	 * @return void
+	 */
+	public function decrease(Review $review)
+	{
+		if (empty($counts = $this->get($review->assigned_to))) {
+			return;
+		}
+		$this->update($review->assigned_to,
+			$this->manager->decreaseRating($counts, $review->review_type, $review->rating)
+		);
+	}
 
-    /**
-     * @param int $postId
-     * @return array
-     */
-    public function get($postId)
-    {
-        return array_filter((array) get_post_meta($postId, CountsManager::META_COUNT, true));
-    }
+	/**
+	 * @param int $postId
+	 * @return array
+	 */
+	public function get($postId)
+	{
+		return array_filter((array) get_post_meta($postId, CountsManager::META_COUNT, true));
+	}
 
-    /**
-     * @return void
-     */
-    public function increase(Review $review)
-    {
-        if (!get_post($review->assigned_to) instanceof \WP_Post) {
-            return;
-        }
-        $counts = $this->get($review->assigned_to);
-        $counts = empty($counts)
-            ? $this->build($review->assigned_to)
-            : $this->manager->increaseRating($counts, $review->review_type, $review->rating);
-        $this->update($review->assigned_to, $counts);
-    }
+	/**
+	 * @return void
+	 */
+	public function increase(Review $review)
+	{
+		if (!get_post($review->assigned_to) instanceof \WP_Post) {
+			return;
+		}
+		$counts = $this->get($review->assigned_to);
+		$counts = empty($counts)
+			? $this->build($review->assigned_to)
+			: $this->manager->increaseRating($counts, $review->review_type, $review->rating);
+		$this->update($review->assigned_to, $counts);
+	}
 
-    /**
-     * @param int $postId
-     * @return void
-     */
-    public function update($postId, array $reviewCounts)
-    {
-        $ratingCounts = $this->manager->flatten($reviewCounts);
-        update_post_meta($postId, CountsManager::META_COUNT, $reviewCounts);
-        update_post_meta($postId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
-        update_post_meta($postId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
-    }
+	/**
+	 * @param int $postId
+	 * @return void
+	 */
+	public function update($postId, array $reviewCounts)
+	{
+		$ratingCounts = $this->manager->flatten($reviewCounts);
+		update_post_meta($postId, CountsManager::META_COUNT, $reviewCounts);
+		update_post_meta($postId, CountsManager::META_AVERAGE, glsr(Rating::class)->average($ratingCounts));
+		update_post_meta($postId, CountsManager::META_RANKING, glsr(Rating::class)->ranking($ratingCounts));
+	}
 
-    /**
-     * @return void
-     */
-    public function updateAll()
-    {
-        glsr(SqlQueries::class)->deletePostCountMetaKeys(); // @todo test this with SiteGround for race conditions
-        $postIds = glsr(SqlQueries::class)->getReviewsMeta('assigned_to');
-        foreach ($postIds as $postId) {
-            $this->update($postId, $this->build($postId));
-        }
-    }
+	/**
+	 * @return void
+	 */
+	public function updateAll()
+	{
+		glsr(SqlQueries::class)->deletePostCountMetaKeys(); // @todo test this with SiteGround for race conditions
+		$postIds = glsr(SqlQueries::class)->getReviewsMeta('assigned_to');
+		foreach ($postIds as $postId) {
+			$this->update($postId, $this->build($postId));
+		}
+	}
 }

plugin/Database/DefaultsManager.php

Indentation +52 added lines, -52 removed lines

@@ -6,60 +6,60 @@
 
 class DefaultsManager
 {
-    /**
-     * @return array
-     */
-    public function defaults()
-    {
-        $settings = $this->settings();
-        $defaults = (array) array_combine(array_keys($settings), wp_list_pluck($settings, 'default'));
-        return wp_parse_args($defaults, [
-            'version' => '',
-            'version_upgraded_from' => '',
-        ]);
-    }
+	/**
+	 * @return array
+	 */
+	public function defaults()
+	{
+		$settings = $this->settings();
+		$defaults = (array) array_combine(array_keys($settings), wp_list_pluck($settings, 'default'));
+		return wp_parse_args($defaults, [
+			'version' => '',
+			'version_upgraded_from' => '',
+		]);
+	}
 
-    /**
-     * @return array
-     */
-    public function get()
-    {
-        return Arr::convertFromDotNotation($this->defaults());
-    }
+	/**
+	 * @return array
+	 */
+	public function get()
+	{
+		return Arr::convertFromDotNotation($this->defaults());
+	}
 
-    /**
-     * @return array
-     */
-    public function set()
-    {
-        $settings = glsr(OptionManager::class)->all();
-        $currentSettings = Arr::removeEmptyValues($settings);
-        $defaultSettings = array_replace_recursive($this->get(), $currentSettings);
-        $updatedSettings = array_replace_recursive($settings, $defaultSettings);
-        update_option(OptionManager::databaseKey(), $updatedSettings);
-        return $defaultSettings;
-    }
+	/**
+	 * @return array
+	 */
+	public function set()
+	{
+		$settings = glsr(OptionManager::class)->all();
+		$currentSettings = Arr::removeEmptyValues($settings);
+		$defaultSettings = array_replace_recursive($this->get(), $currentSettings);
+		$updatedSettings = array_replace_recursive($settings, $defaultSettings);
+		update_option(OptionManager::databaseKey(), $updatedSettings);
+		return $defaultSettings;
+	}
 
-    /**
-     * @return array
-     */
-    public function settings()
-    {
-        $settings = glsr()->filterArray('addon/settings', glsr()->config('settings'));
-        return $this->normalize($settings);
-    }
+	/**
+	 * @return array
+	 */
+	public function settings()
+	{
+		$settings = glsr()->filterArray('addon/settings', glsr()->config('settings'));
+		return $this->normalize($settings);
+	}
 
-    /**
-     * @return array
-     */
-    protected function normalize(array $settings)
-    {
-        array_walk($settings, function (&$setting) {
-            if (isset($setting['default'])) {
-                return;
-            }
-            $setting['default'] = '';
-        });
-        return $settings;
-    }
+	/**
+	 * @return array
+	 */
+	protected function normalize(array $settings)
+	{
+		array_walk($settings, function (&$setting) {
+			if (isset($setting['default'])) {
+				return;
+			}
+			$setting['default'] = '';
+		});
+		return $settings;
+	}
 }

plugin/Database/NormalizeQueryArgs.php

Indentation +65 added lines, -65 removed lines

@@ -10,73 +10,73 @@
 
 class NormalizeQueryArgs extends Arguments
 {
-    public $assigned_to;
-    public $category;
-    public $offset;
-    public $order;
-    public $orderby;
-    public $page;
-    public $per_page;
-    public $post__in;
-    public $post__not_in;
-    public $rating;
-    public $type;
-    public $user;
+	public $assigned_to;
+	public $category;
+	public $offset;
+	public $order;
+	public $orderby;
+	public $page;
+	public $per_page;
+	public $post__in;
+	public $post__not_in;
+	public $rating;
+	public $type;
+	public $user;
 
-    public function __construct(array $args = [])
-    {
-        $args = glsr(ReviewsDefaults::class)->merge($args);
-        $args['assigned_to'] = Arr::uniqueInt(Arr::consolidate($args['assigned_to']));
-        $args['category'] = $this->normalizeTermIds($args['category']);
-        $args['offset'] = absint(filter_var($args['offset'], FILTER_SANITIZE_NUMBER_INT));
-        $args['order'] = Str::restrictTo('ASC,DESC,', sanitize_key($args['order']), 'DESC'); // include an empty value
-        $args['orderby'] = $this->normalizeOrderBy($args['orderby']);
-        $args['page'] = absint($args['page']);
-        $args['per_page'] = absint($args['per_page']); // "0" and "-1" = all
-        $args['post__in'] = Arr::uniqueInt(Arr::consolidate($args['post__in']));
-        $args['post__not_in'] = Arr::uniqueInt(Arr::consolidate($args['post__not_in']));
-        $args['rating'] = absint(filter_var($args['rating'], FILTER_SANITIZE_NUMBER_INT));
-        $args['type'] = sanitize_key($args['type']);
-        $args['user'] = $this->normalizeUserIds(Arr::consolidate($args['user']));
-        parent::__construct($args);
-    }
+	public function __construct(array $args = [])
+	{
+		$args = glsr(ReviewsDefaults::class)->merge($args);
+		$args['assigned_to'] = Arr::uniqueInt(Arr::consolidate($args['assigned_to']));
+		$args['category'] = $this->normalizeTermIds($args['category']);
+		$args['offset'] = absint(filter_var($args['offset'], FILTER_SANITIZE_NUMBER_INT));
+		$args['order'] = Str::restrictTo('ASC,DESC,', sanitize_key($args['order']), 'DESC'); // include an empty value
+		$args['orderby'] = $this->normalizeOrderBy($args['orderby']);
+		$args['page'] = absint($args['page']);
+		$args['per_page'] = absint($args['per_page']); // "0" and "-1" = all
+		$args['post__in'] = Arr::uniqueInt(Arr::consolidate($args['post__in']));
+		$args['post__not_in'] = Arr::uniqueInt(Arr::consolidate($args['post__not_in']));
+		$args['rating'] = absint(filter_var($args['rating'], FILTER_SANITIZE_NUMBER_INT));
+		$args['type'] = sanitize_key($args['type']);
+		$args['user'] = $this->normalizeUserIds(Arr::consolidate($args['user']));
+		parent::__construct($args);
+	}
 
-    /**
-     * @return string
-     */
-    protected function normalizeOrderBy($orderBy)
-    {
-        $orderBy = Str::restrictTo('author,comment_count,date,ID,menu_order,none,rand,relevance', $orderBy, 'date');
-        if (in_array($orderBy, ['comment_count', 'ID', 'menu_order'])) {
-            return Str::prefix('p.', $orderBy);
-        }
-        if (in_array($orderBy, ['author', 'date'])) {
-            return Str::prefix('p.post_', $orderBy);
-        }
-        return $orderBy;
-    }
+	/**
+	 * @return string
+	 */
+	protected function normalizeOrderBy($orderBy)
+	{
+		$orderBy = Str::restrictTo('author,comment_count,date,ID,menu_order,none,rand,relevance', $orderBy, 'date');
+		if (in_array($orderBy, ['comment_count', 'ID', 'menu_order'])) {
+			return Str::prefix('p.', $orderBy);
+		}
+		if (in_array($orderBy, ['author', 'date'])) {
+			return Str::prefix('p.post_', $orderBy);
+		}
+		return $orderBy;
+	}
 
-    /**
-     * @param array[]|string $termIds
-     * @return array
-     */
-    public function normalizeTermIds($termIds)
-    {
-        return glsr(ReviewManager::class)->normalizeTermIds($termIds);
-    }
+	/**
+	 * @param array[]|string $termIds
+	 * @return array
+	 */
+	public function normalizeTermIds($termIds)
+	{
+		return glsr(ReviewManager::class)->normalizeTermIds($termIds);
+	}
 
-    /**
-     * @return array
-     */
-    protected function normalizeUserIds(array $users)
-    {
-        $userIds = [];
-        foreach ($users as $userId) {
-            if (!is_numeric($userId)) {
-                $userId = Helper::castToInt(username_exists($userId));
-            }
-            $userIds[] = $userId;
-        }
-        return Arr::uniqueInt($userIds);
-    }
+	/**
+	 * @return array
+	 */
+	protected function normalizeUserIds(array $users)
+	{
+		$userIds = [];
+		foreach ($users as $userId) {
+			if (!is_numeric($userId)) {
+				$userId = Helper::castToInt(username_exists($userId));
+			}
+			$userIds[] = $userId;
+		}
+		return Arr::uniqueInt($userIds);
+	}
 }

plugin/Database/QueryBuilder.php

Indentation +151 added lines, -151 removed lines

@@ -12,164 +12,164 @@
 
 class QueryBuilder
 {
-    /**
-     * Build a WP_Query meta_query/tax_query.
-     * @return array
-     */
-    public function buildQuery(array $keys = [], array $values = [])
-    {
-        $queries = [];
-        foreach ($keys as $key) {
-            if (!array_key_exists($key, $values)) {
-                continue;
-            }
-            $methodName = Helper::buildMethodName($key, __FUNCTION__);
-            if (!method_exists($this, $methodName)) {
-                continue;
-            }
-            $query = call_user_func([$this, $methodName], $values[$key]);
-            if (is_array($query)) {
-                $queries[] = $query;
-            }
-        }
-        return $queries;
-    }
+	/**
+	 * Build a WP_Query meta_query/tax_query.
+	 * @return array
+	 */
+	public function buildQuery(array $keys = [], array $values = [])
+	{
+		$queries = [];
+		foreach ($keys as $key) {
+			if (!array_key_exists($key, $values)) {
+				continue;
+			}
+			$methodName = Helper::buildMethodName($key, __FUNCTION__);
+			if (!method_exists($this, $methodName)) {
+				continue;
+			}
+			$query = call_user_func([$this, $methodName], $values[$key]);
+			if (is_array($query)) {
+				$queries[] = $query;
+			}
+		}
+		return $queries;
+	}
 
-    /**
-     * @return string
-     */
-    public function buildSqlLines(array $values, array $conditions)
-    {
-        $string = '';
-        $values = array_filter($values);
-        foreach ($conditions as $key => $value) {
-            if (!isset($values[$key])) {
-                continue;
-            }
-            $values[$key] = implode(',', (array) $values[$key]);
-            $string.= Str::contains($value, '%s')
-                ? sprintf($value, strval($values[$key]))
-                : $value;
-        }
-        return $string;
-    }
+	/**
+	 * @return string
+	 */
+	public function buildSqlLines(array $values, array $conditions)
+	{
+		$string = '';
+		$values = array_filter($values);
+		foreach ($conditions as $key => $value) {
+			if (!isset($values[$key])) {
+				continue;
+			}
+			$values[$key] = implode(',', (array) $values[$key]);
+			$string.= Str::contains($value, '%s')
+				? sprintf($value, strval($values[$key]))
+				: $value;
+		}
+		return $string;
+	}
 
-    /**
-     * Build a SQL 'OR' string from an array.
-     * @param string|array $values
-     * @param string $sprintfFormat
-     * @return string
-     */
-    public function buildSqlOr($values, $sprintfFormat)
-    {
-        if (!is_array($values)) {
-            $values = explode(',', $values);
-        }
-        $values = array_filter(array_map('trim', (array) $values));
-        $values = array_map(function ($value) use ($sprintfFormat) {
-            return sprintf($sprintfFormat, $value);
-        }, $values);
-        return implode(' OR ', $values);
-    }
+	/**
+	 * Build a SQL 'OR' string from an array.
+	 * @param string|array $values
+	 * @param string $sprintfFormat
+	 * @return string
+	 */
+	public function buildSqlOr($values, $sprintfFormat)
+	{
+		if (!is_array($values)) {
+			$values = explode(',', $values);
+		}
+		$values = array_filter(array_map('trim', (array) $values));
+		$values = array_map(function ($value) use ($sprintfFormat) {
+			return sprintf($sprintfFormat, $value);
+		}, $values);
+		return implode(' OR ', $values);
+	}
 
-    /**
-     * Get the current page number from the global query.
-     * @param bool $isEnabled
-     * @return int
-     */
-    public function getPaged($isEnabled = true)
-    {
-        return $isEnabled
-            ? max(1, intval(filter_input(INPUT_GET, glsr()->constant('PAGED_QUERY_VAR'))))
-            : 1;
-    }
+	/**
+	 * Get the current page number from the global query.
+	 * @param bool $isEnabled
+	 * @return int
+	 */
+	public function getPaged($isEnabled = true)
+	{
+		return $isEnabled
+			? max(1, intval(filter_input(INPUT_GET, glsr()->constant('PAGED_QUERY_VAR'))))
+			: 1;
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryAssignedTo($value)
-    {
-        if (!empty($value)) {
-            $postIds = Arr::convertFromString($value, 'is_numeric');
-            return [
-                'compare' => 'IN',
-                'key' => '_assigned_to',
-                'value' => glsr(Multilingual::class)->getPostIds($postIds),
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryAssignedTo($value)
+	{
+		if (!empty($value)) {
+			$postIds = Arr::convertFromString($value, 'is_numeric');
+			return [
+				'compare' => 'IN',
+				'key' => '_assigned_to',
+				'value' => glsr(Multilingual::class)->getPostIds($postIds),
+			];
+		}
+	}
 
-    /**
-     * @param array $value
-     * @return void|array
-     */
-    protected function buildQueryCategory($value)
-    {
-        if (!empty($value)) {
-            return [
-                'field' => 'term_id',
-                'taxonomy' => Application::TAXONOMY,
-                'terms' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param array $value
+	 * @return void|array
+	 */
+	protected function buildQueryCategory($value)
+	{
+		if (!empty($value)) {
+			return [
+				'field' => 'term_id',
+				'taxonomy' => Application::TAXONOMY,
+				'terms' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryEmail($value)
-    {
-        if (!empty($value)) {
-            return [
-                'key' => '_email',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryEmail($value)
+	{
+		if (!empty($value)) {
+			return [
+				'key' => '_email',
+				'value' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryIpAddress($value)
-    {
-        if (!empty($value)) {
-            return [
-                'key' => '_ip_address',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryIpAddress($value)
+	{
+		if (!empty($value)) {
+			return [
+				'key' => '_ip_address',
+				'value' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryRating($value)
-    {
-        if (is_numeric($value)
-            && in_array(intval($value), range(1, glsr()->constant('MAX_RATING', Rating::class)))) {
-            return [
-                'compare' => '>=',
-                'key' => '_rating',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryRating($value)
+	{
+		if (is_numeric($value)
+			&& in_array(intval($value), range(1, glsr()->constant('MAX_RATING', Rating::class)))) {
+			return [
+				'compare' => '>=',
+				'key' => '_rating',
+				'value' => $value,
+			];
+		}
+	}
 
-    /**
-     * @param string $value
-     * @return void|array
-     */
-    protected function buildQueryType($value)
-    {
-        if (!in_array($value, ['', 'all'])) {
-            return [
-                'key' => '_review_type',
-                'value' => $value,
-            ];
-        }
-    }
+	/**
+	 * @param string $value
+	 * @return void|array
+	 */
+	protected function buildQueryType($value)
+	{
+		if (!in_array($value, ['', 'all'])) {
+			return [
+				'key' => '_review_type',
+				'value' => $value,
+			];
+		}
+	}
 }

plugin/Database/RatingManager.php

Indentation +22 added lines, -22 removed lines

@@ -8,26 +8,26 @@
 
 class RatingManager
 {
-    /**
-     * @param bool $flatten
-     * @return array
-     */
-    public function ratings(array $args = [])
-    {
-        $args = wp_parse_args($args, [
-            'max' => glsr()->constant('MAX_RATING', Rating::class),
-            'min' => glsr()->constant('MIN_RATING', Rating::class),
-        ]);
-        $ratings = [];
-        $results = glsr(Query::class)->ratings($args);
-        array_walk_recursive($results, function ($rating, $index) use (&$ratings) {
-            $ratings[$index] = $rating + intval(Arr::get($ratings, $index, 0));
-        });
-        foreach ($ratings as $index => &$rating) {
-            if (!Helper::inRange($index, $args['min'], $args['max'])) {
-                $rating = 0;
-            }
-        }
-        return $ratings;
-    }
+	/**
+	 * @param bool $flatten
+	 * @return array
+	 */
+	public function ratings(array $args = [])
+	{
+		$args = wp_parse_args($args, [
+			'max' => glsr()->constant('MAX_RATING', Rating::class),
+			'min' => glsr()->constant('MIN_RATING', Rating::class),
+		]);
+		$ratings = [];
+		$results = glsr(Query::class)->ratings($args);
+		array_walk_recursive($results, function ($rating, $index) use (&$ratings) {
+			$ratings[$index] = $rating + intval(Arr::get($ratings, $index, 0));
+		});
+		foreach ($ratings as $index => &$rating) {
+			if (!Helper::inRange($index, $args['min'], $args['max'])) {
+				$rating = 0;
+			}
+		}
+		return $ratings;
+	}
 }

plugin/Database/Query.php

Indentation +97 added lines, -97 removed lines

@@ -9,46 +9,46 @@ 
 
 class Query
 {
-    use QuerySql;
+	use QuerySql;
 
-    public $args;
-    public $db;
+	public $args;
+	public $db;
 
-    public function __construct()
-    {
-        global $wpdb;
-        $this->db = $wpdb;
-    }
+	public function __construct()
+	{
+		global $wpdb;
+		$this->db = $wpdb;
+	}
 
-    /**
-     * @return array
-     */
-    public function ratings(array $args)
-    {
-        $this->setArgs($args);
-        $join = implode(' ', $this->sqlClauses([], 'join'));
-        $and = implode(' ', $this->sqlClauses([], 'and'));
-        $results = $this->db->get_results("
+	/**
+	 * @return array
+	 */
+	public function ratings(array $args)
+	{
+		$this->setArgs($args);
+		$join = implode(' ', $this->sqlClauses([], 'join'));
+		$and = implode(' ', $this->sqlClauses([], 'and'));
+		$results = $this->db->get_results("
             SELECT r.rating, r.type, COUNT(r.rating) AS count
             FROM {$this->table('ratings')} AS r {$join}
             WHERE r.is_approved = 1 {$and}
             GROUP BY r.type, r.rating
         ", ARRAY_A);
-        return $this->normalizeRatings($results);
-    }
+		return $this->normalizeRatings($results);
+	}
 
-    /**
-     * @todo make sure we delete the cached review when modifying it
-     * @param int $postId
-     * @return Review
-     */
-    public function review($postId)
-    {
-        $reviewId = Helper::castToInt($postId);
-        if (($review = glsr(Cache::class)->get($reviewId, 'reviews')) instanceof Review) {
-            return $review;
-        }
-        $result = $this->db->get_row("
+	/**
+	 * @todo make sure we delete the cached review when modifying it
+	 * @param int $postId
+	 * @return Review
+	 */
+	public function review($postId)
+	{
+		$reviewId = Helper::castToInt($postId);
+		if (($review = glsr(Cache::class)->get($reviewId, 'reviews')) instanceof Review) {
+			return $review;
+		}
+		$result = $this->db->get_row("
             {$this->sqlSelect()}
             {$this->sqlFrom()}
             {$this->sqlJoin()}
@@ -56,23 +56,23 @@ 
             WHERE r.review_id = {$reviewId}
             GROUP BY r.ID
         ");
-        $review = new Review($result);
-        if (!empty($result)) {
-            glsr(Cache::class)->store($reviewId, 'reviews', $review);
-        }
-        return $review;
-    }
+		$review = new Review($result);
+		if (!empty($result)) {
+			glsr(Cache::class)->store($reviewId, 'reviews', $review);
+		}
+		return $review;
+	}
 
-    /**
-     * @return array
-     */
-    public function reviews(array $args = [], array $postIds = [])
-    {
-        $this->setArgs($args);
-        if (!empty($postIds)) {
-            $postIds = implode(',', Arr::uniqueInt($postIds));
-        } else {
-            $postIds = "SELECT ids.* FROM (
+	/**
+	 * @return array
+	 */
+	public function reviews(array $args = [], array $postIds = [])
+	{
+		$this->setArgs($args);
+		if (!empty($postIds)) {
+			$postIds = implode(',', Arr::uniqueInt($postIds));
+		} else {
+			$postIds = "SELECT ids.* FROM (
                 SELECT r.review_id
                 {$this->sqlFrom()}
                 {$this->sqlJoinClauses()}
@@ -81,8 +81,8 @@ 
                 {$this->sqlLimit()}
                 {$this->sqlOffset()}
             ) as ids";
-        }
-        $results = $this->db->get_results("
+		}
+		$results = $this->db->get_results("
             {$this->sqlSelect()}
             {$this->sqlFrom()}
             {$this->sqlJoin()}
@@ -90,65 +90,65 @@ 
             WHERE r.review_id in ({$postIds})
             GROUP BY r.ID 
         ");
-        foreach ($results as &$result) {
-            $result = new Review($result);
-            glsr(Cache::class)->store($result->ID, 'reviews', $result);
-        }
-        return $results;
-    }
+		foreach ($results as &$result) {
+			$result = new Review($result);
+			glsr(Cache::class)->store($result->ID, 'reviews', $result);
+		}
+		return $results;
+	}
 
-    /**
-     * @return int
-     */
-    public function totalReviews(array $args = [], array $reviews = [])
-    {
-        $this->setArgs($args);
-        if (empty($this->sqlLimit()) && !empty($reviews)) {
-            return count($reviews);
-        }
-        return (int) $this->db->get_var("
+	/**
+	 * @return int
+	 */
+	public function totalReviews(array $args = [], array $reviews = [])
+	{
+		$this->setArgs($args);
+		if (empty($this->sqlLimit()) && !empty($reviews)) {
+			return count($reviews);
+		}
+		return (int) $this->db->get_var("
             SELECT COUNT(*)
             {$this->sqlFrom()}
             {$this->sqlJoin()}
             {$this->sqlWhere()}
         ");
-    }
+	}
 
-    /**
-     * @param int $postId
-     * @return bool
-     */
-    public function hasRevisions($postId)
-    {
-        $revisions = (int) $this->db->get_var("
+	/**
+	 * @param int $postId
+	 * @return bool
+	 */
+	public function hasRevisions($postId)
+	{
+		$revisions = (int) $this->db->get_var("
             SELECT COUNT(*) 
             FROM {$this->db->posts}
             WHERE post_type = 'revision' AND post_parent = {$postId}
         ");
-        return $revisions > 0;
-    }
+		return $revisions > 0;
+	}
 
-    /**
-     * @return array
-     */
-    protected function normalizeRatings(array $ratings = [])
-    {
-        $normalized = [];
-        foreach ($ratings as $result) {
-            $type = $result['type'];
-            if (!array_key_exists($type, $normalized)) {
-                $normalized[$type] = glsr(Rating::class)->emptyArray();
-            }
-            $normalized[$type] = Arr::set($normalized[$type], $result['rating'], $result['count']);
-        }
-        return $normalized;
-    }
+	/**
+	 * @return array
+	 */
+	protected function normalizeRatings(array $ratings = [])
+	{
+		$normalized = [];
+		foreach ($ratings as $result) {
+			$type = $result['type'];
+			if (!array_key_exists($type, $normalized)) {
+				$normalized[$type] = glsr(Rating::class)->emptyArray();
+			}
+			$normalized[$type] = Arr::set($normalized[$type], $result['rating'], $result['count']);
+		}
+		return $normalized;
+	}
 
-    /**
-     * @return void
-     */
-    public function setArgs(array $args = [])
-    {
-        $this->args = (new NormalizeQueryArgs($args))->toArray();
-    }
+	/**
+	 * @return void
+	 */
+	public function setArgs(array $args = [])
+	{
+		$this->args = (new NormalizeQueryArgs($args))->toArray();
+	}
 }