Yoeunes\Voteable\Traits\Voteable

Complexity

Total Complexity

19

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	votes()	0	4	1
A	votesCount()	0	4	1
A	upVotesCount()	0	4	1
A	downVotesCount()	0	4	1
A	isUpVoted()	0	4	1
A	isDownVoted()	0	4	1
A	isVotedByUser()	0	4	1
A	isUpVotedByUser()	0	4	1
A	isDownVotedByUser()	0	4	1
A	scopeOrderByUpVotes()	0	13	1
A	scopeOrderByDownVotes()	0	4	1
A	cancelVote()	0	4	1
A	resetVotes()	0	4	1
A	cancelVotesForUser()	0	4	1
A	updateVotesForUser()	0	4	1
A	updateVote()	0	4	1
A	getVoteBuilder()	0	5	1
A	voters()	0	4	1
A	countVotesByDate()	0	6	1

<?php

namespace Yoeunes\Voteable\Traits;

use Carbon\Carbon;
use Yoeunes\Voteable\Models\Vote;
use Yoeunes\Voteable\VoteBuilder;
use Illuminate\Support\Facades\DB;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Query\JoinClause;
use Illuminate\Database\Eloquent\Relations\Relation;

trait Voteable
{
    /**
     * This model has many votes.
     *
     * @return \Illuminate\Database\Eloquent\Relations\MorphMany
     */
    public function votes()
    {
        return $this->morphMany(Vote::class, 'voteable');

It seems like morphMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    public function votesCount()
    {
        return $this->votes()->sum('amount');
    }

    /**
     * @return mixed
     */
    public function upVotesCount()
    {
        return $this->votes()->where('amount', '>=', 0)->sum('amount');
    }

    /**
     * @return mixed
     */
    public function downVotesCount()
    {
        return $this->votes()->where('amount', '<', 0)->sum('amount');
    }

    /**
     * @return bool
     */
    public function isUpVoted()
    {
        return $this->votes()->where('amount', '>=', 0)->exists();
    }

    /**
     * @return bool
     */
    public function isDownVoted()
    {
        return $this->votes()->where('amount', '<', 0)->exists();
    }

    public function isVotedByUser(int $user_id)
    {
        return $this->votes()->where('user_id', $user_id)->exists();
    }

    /**
     * @param int $user_id
     *
     * @return bool
     */
    public function isUpVotedByUser(int $user_id)
    {
        return $this->votes()->where('amount', '>=', 0)->where('user_id', $user_id)->exists();
    }

    /**
     * @param int $user_id
     *
     * @return bool
     */
    public function isDownVotedByUser(int $user_id)
    {
        return $this->votes()->where('amount', '<', 0)->where('user_id', $user_id)->exists();
    }

    /**
     * @param Builder $query
     * @param string $direction
     * @param string $type
     *
     * @return Builder
     */
    public function scopeOrderByUpVotes(Builder $query, string $direction = 'asc', string $type = '>=')
    {
        return $query
            ->leftJoin('votes', function (JoinClause $join) {
                $join
                    ->on('votes.voteable_id', $this->getTable() . '.id')

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                    ->where('votes.voteable_type', Relation::getMorphedModel(__CLASS__) ?? __CLASS__);
            })
            ->where('amount', $type, 0)
            ->addSelect(DB::raw('SUM(votes.value) as count_votes'))
            ->groupBy($this->getTable(). '.id')

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->orderBy('count_votes', $direction);
    }

    /**
     * @param Builder $query
     * @param string $direction
     *
     * @return Builder
     */
    public function scopeOrderByDownVotes(Builder $query, string $direction = 'asc')
    {
        return $this->scopeOrderByUpVotes($query, $direction, '<');
    }

    /**
     * @param int $vote_id
     *
     * @return mixed
     */
    public function cancelVote(int $vote_id)
    {
        return $this->votes()->where('id', $vote_id)->delete();
    }

    /**
     * @return mixed
     */
    public function resetVotes()
    {
        return $this->votes()->delete();
    }

    /**
     * @param int $user_id
     *
     * @return mixed
     */
    public function cancelVotesForUser(int $user_id)
    {
        return $this->votes()->where('user_id', $user_id)->delete();
    }

    /**
     * @param int $user_id
     * @param int $amount
     *
     * @return int
     */
    public function updateVotesForUser(int $user_id, int $amount)
    {
        return $this->votes()->where('user_id', $user_id)->update(['amount' => $amount]);
    }

    /**
     * @param int $vote_id
     * @param int $amount
     *
     * @return int
     */
    public function updateVote(int $vote_id, int $amount)
    {
        return $this->votes()->where('id', $vote_id)->update(['amount' => $amount]);
    }

    /**
     * @return VoteBuilder
     *
     * @throws \Throwable
     */
    public function getVoteBuilder()
    {
        return (new VoteBuilder())
            ->voteable($this);
    }

    public function voters()
    {
        return $this->morphToMany(config('voteable.user'), 'voteable', 'votes');

It seems like morphToMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    public function countVotesByDate($from, $to)
    {
        $range = [(new Carbon($from))->startOfDay(), (new Carbon($to))->endOfDay()];

        return $this->votes()->whereBetween('created_at', $range)->sum('amount');
    }
}