Friendable - Code Metrics - arubacao/friends - Measure and Improve Code Quality continuously with Scrutinizer

Friendable B
last analyzed 2018-06-12 12:49 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	368
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

96.47%

Importance

Changes

Metric	Value
wmc	38
lcom	1
cbo	2
dl	0
loc	368
rs	8.3999
c	0
b	0
f	0
ccs	164
cts	170
cp	0.9647

18 Methods

Rating	Name	Size	Complexity
A	getPendingRequestFrom()	7	1
A	friends_i_am_sender()	12	1
A	friends_i_am_recipient()	12	1
A	scopeIncludeRelationshipsWith()	15	1
A	friends()	19	1
A	incoming_friends()	13	1
A	any_friends()	13	1
B	sendFriendRequestTo()	43	6
A	acceptFriendRequestFrom()	22	3
A	denyFriendRequestFrom()	21	3
A	deleteFriend()	20	3
A	isFriendWith()	6	1
A	hasRelationshipWith()	8	2
B	getRelationshipWith()	27	4
A	hasPendingRequestFrom()	17	3
A	retrieveUserId()	11	4
A	reload()	4	1
A	mergedFriends()	9	1

<?php
/**
 * This file is part of Friends.
 *
 * (c) Christopher Lass <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Arubacao\Friends\Traits;

use Arubacao\Friends\FriendshipStatus;
use Illuminate\Support\Facades\Config;

trait Friendable
{
    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function friends_i_am_sender()
    {
        return $this->belongsToMany(
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            Config::get('friends.user_model'),
            'friends',
            'sender_id', 'recipient_id')
            ->withTimestamps()
            ->withPivot([
                'friendship_status',
            ])
            ->orderBy('friends.updated_at', 'desc');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function friends_i_am_recipient()
    {
        return $this->belongsToMany(
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            Config::get('friends.user_model'),
            'friends',
            'recipient_id', 'sender_id')
            ->withTimestamps()
            ->withPivot([
                'friendship_status',
            ])
            ->orderBy('friends.updated_at', 'desc');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeIncludeRelationshipsWith($query, $user)
    {
        $userId = $this->retrieveUserId($user);

        return $query->with([
            'friends_i_am_sender' => function ($queryIn) use ($userId) {
                $queryIn->where('friends.recipient_id', $userId)
                    ->get();
            },
            'friends_i_am_recipient' => function ($queryIn) use ($userId) {
                $queryIn->where('friends.sender_id', $userId)
                    ->get();
            },
        ]);
    }

    /**
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function friends()
    {
        $me = $this->with([
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            'friends_i_am_sender' => function ($query) {
                $query->where('friends.friendship_status', FriendshipStatus::ACCEPTED)
                    ->get();
            },
            'friends_i_am_recipient' => function ($query) {
                $query->where('friends.friendship_status', FriendshipStatus::ACCEPTED)
                    ->get();
            },
        ])
            ->where('id', '=', $this->getKey())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->first();

        $friends = $this->mergedFriends($me);

        return $friends;
    }

    /**
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function incoming_friends()
    {
        $me = $this->with([
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            'friends_i_am_recipient' => function ($query) {
                $query->where('friends.friendship_status', FriendshipStatus::PENDING)
                    ->get();
            },
        ])
            ->where('id', '=', $this->getKey())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->first();

        return $me->friends_i_am_recipient;
    }

    /**
     * @return \Illuminate\Database\Eloquent\Collection
     */
    public function any_friends()
    {
        $me = $this->with([
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            'friends_i_am_sender',
            'friends_i_am_recipient',
        ])
            ->where('id', '=', $this->getKey())
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            ->first();

        $any_friends = $this->mergedFriends($me);

        return $any_friends;
    }

    /**
     * Alias to eloquent many-to-many relation's attach() method.
     *
     * @param int|User $user
     * @return bool
     */
    public function sendFriendRequestTo($user)
    {
        $userId = $this->retrieveUserId($user);

        if ($userId == $this->getKey()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            // Method not allowed on self
            return false;
        }

        $relationship = $this->getRelationshipWith($userId, [
            FriendshipStatus::PENDING,
            FriendshipStatus::ACCEPTED,
        ]);

        if (! is_null($relationship)) {
            if ($relationship->pivot->friendship_status == FriendshipStatus::ACCEPTED) {
                // Already friends
                return false;
            }
            if ($relationship->pivot->friendship_status == FriendshipStatus::PENDING &&
                $relationship->pivot->recipient_id == $this->getKey()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
                // Recipient already sent a friend request
                // Accept pending friend request
                $relationship->pivot->friendship_status = FriendshipStatus::ACCEPTED;
                $relationship->pivot->save();
                /* @todo: fire event friend request accepted */
                $this->reload();

                return true;
            }

            return false;
        }

        $this->friends_i_am_sender()->attach($userId, [
            'friendship_status' => FriendshipStatus::PENDING,
        ]);
        /* @todo: fire event friend request sent */

        $this->reload();

        return true;
    }

    /**
     * @param int|User $user
     * @return bool
     */
    public function acceptFriendRequestFrom($user)
    {
        $userId = $this->retrieveUserId($user);

        if ($userId == $this->getKey()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            // Method not allowed on self
            return false;
        }

        $relationship = $this->getPendingRequestFrom($userId);

        if (! is_null($relationship)) {
            $relationship->pivot->friendship_status = FriendshipStatus::ACCEPTED;
            $relationship->pivot->save();
            /* @todo: fire event friend request accepted */
            $this->reload();

            return true;
        }

        return false;
    }

    /**
     * @param int|User $user
     * @return bool
     */
    public function denyFriendRequestFrom($user)
    {
        $userId = $this->retrieveUserId($user);

        if ($userId == $this->getKey()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            // Method not allowed on self
            return false;
        }

        $relationship = $this->getPendingRequestFrom($userId);

        if (! is_null($relationship)) {
            $relationship->pivot->delete();
            /* @todo: fire event friend request denied */
            $this->reload();

            return true;
        }

        return false;
    }

    /**
     * @param int|User $user
     * @return bool
     */
    public function deleteFriend($user)
    {
        $userId = $this->retrieveUserId($user);

        if ($userId == $this->getKey()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            // Method not allowed on self
            return false;
        }

        while ($relationship = $this->getRelationshipWith($userId, [
            FriendshipStatus::ACCEPTED,
            FriendshipStatus::PENDING,
        ])) {
            $relationship->pivot->delete();
            /* @todo: fire event friend deleted */
        }
        $this->reload();

        return true;
    }

    /**
     * @param int|array|User $user
     * @return bool
     */
    public function isFriendWith($user)
    {
        $userId = $this->retrieveUserId($user);

        return $this->hasRelationshipWith($userId, [FriendshipStatus::ACCEPTED]);
    }

    /**
     * @param int|array|User $user
     * @param array $status
     * @return bool
     */
    public function hasRelationshipWith($user, $status)
    {
        $userId = $this->retrieveUserId($user);

        $relationship = $this->getRelationshipWith($userId, $status);

        return (is_null($relationship)) ? false : true;
    }

    /**
     * @param int|array|User $user
     * @param array $status
     * @return mixed
     */
    public function getRelationshipWith($user, $status)
    {
        $userId = $this->retrieveUserId($user);

        if ($userId == $this->getKey()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            // Method not allowed on self
            return;
        }

        $attempt1 = $this->friends_i_am_recipient()
            ->wherePivotIn('friendship_status', $status)
            ->wherePivot('sender_id', $userId)
            ->first();

        if (! is_null($attempt1)) {
            return $attempt1;
        }

        $attempt2 = $this->friends_i_am_sender()
            ->wherePivotIn('friendship_status', $status)
            ->wherePivot('recipient_id', $userId)
            ->first();

        if (! is_null($attempt2)) {
            return $attempt2;
        }
    }

    /**
     * @param int|array|User $user
     * @return bool
     */
    public function hasPendingRequestFrom($user)
    {
        $userId = $this->retrieveUserId($user);

        if ($userId == $this->getKey()) {
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
            // Method not allowed on self
            return false;
        }

        $relationship = $this->getPendingRequestFrom($userId);

        if (! is_null($relationship)) {
            return true;
        }

        return false;
    }

    /**
     * @param int|array|User $user
     * @return int|null
     */
    private function retrieveUserId($user)
    {
        if (is_object($user)) {
            return $user->getKey();
        }
        if (is_array($user) && isset($user['id'])) {
            return $user['id'];
        }

        return $user;
    }

    /**
     * @param int $userId
     * @return mixed
     */
    private function getPendingRequestFrom($userId)
    {
        return $this->friends_i_am_recipient()
            ->wherePivot('friendship_status', FriendshipStatus::PENDING)
            ->wherePivot('sender_id', $userId)
            ->first();
    }

    /**
     * Eager load relations on the model.
     */
    private function reload()
    {
        $this->load('friends_i_am_recipient', 'friends_i_am_sender');
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
    }

    /**
     * @param User $me
     * @return \Illuminate\Database\Eloquent\Collection
     */
    private function mergedFriends($me)

    {
        $friends = collect([]);
        $friends->push($me->friends_i_am_sender);
        $friends->push($me->friends_i_am_recipient);
        $friends = $friends->flatten();

        return $friends;
    }
}


1		<?php
2		/**
3		* This file is part of Friends.
4		*
5		* (c) Christopher Lass <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		namespace Arubacao\Friends\Traits;
12
13		use Arubacao\Friends\FriendshipStatus;
14		use Illuminate\Support\Facades\Config;
15
16		trait Friendable
17		{
18		/**
19		* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
20		*/
21	22	public function friends_i_am_sender()
22		{
23	22	return $this->belongsToMany(
		0 ignored issues – show Bug introduced 2016-06-20 16:13 UTC by Report Bug Copy Issue Report It seems like `belongsToMany()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
24	22	Config::get('friends.user_model'),
25	22	'friends',
26	22	'sender_id', 'recipient_id')
27	22	->withTimestamps()
28	22	->withPivot([
29	22	'friendship_status',
30	22	])
31	22	->orderBy('friends.updated_at', 'desc');
32		}
33
34		/**
35		* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
36		*/
37	22	public function friends_i_am_recipient()
38		{
39	22	return $this->belongsToMany(

arubacao / friends

Friendable B last analyzed 2018-06-12 12:49 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

18 Methods

Duplication Side-by-Side

Filter issues like

Friendable B
last analyzed 2018-06-12 12:49 UTC