Merodiro\Friendships\Friendable

Complexity

Total Complexity

18

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	1	Features	3

11 Methods

Rating	Name	Duplication	Size	Complexity
A	deleteFriend()	0	12	2
B	checkFriendship()	0	18	5
A	addFriend()	0	14	2
A	acceptFriend()	0	17	2
A	friendsIds()	0	14	1
A	friends()	0	6	1
A	friendRequestsReceived()	0	5	1
A	friendRequestsSent()	0	5	1
A	isFriendsWith()	0	6	1
A	mutualFriendsCount()	0	7	1
A	mutualFriends()	0	9	1

<?php

namespace Merodiro\Friendships;

trait Friendable
{
    public function checkFriendship($user)
    {
        if ($this->id == $user->id) {

The property id does not exist. Did you maybe forget to declare it?

            return 'same_user';
        }

        $friendship = Friendship::betweenUsers($this, $user);

        if ($friendship->count() == 0) {
            return 'not_friends';
        } elseif ($friendship->count() == 2) {
            return 'friends';
        } elseif ($friendship->first()->user_id == $this->id) {
            return 'waiting';
        } else {
            return 'pending';
        }
    }

    public function addFriend($recipient)
    {
        $friendshipStatus = $this->checkFriendship($recipient);

        if ($friendshipStatus == 'not_friends') {
            Friendship::create([
                'user_id' => $this->id,
                'friend_id' => $recipient->id,
            ]);
            event('friendrequest.sent', [$this, $recipient]);
        }

        return $friendshipStatus == 'waiting';
    }

    public function acceptFriend($sender)
    {
        $friendshipStatus = $this->checkFriendship($sender);

        if ($friendshipStatus == 'pending') {
            Friendship::create([
                'user_id' => $this->id,
                'friend_id' => $sender->id,
                'status' => 1
            ]);
            Friendship::betweenUsers($this, $sender)
                ->update(['status' => 1]);
            event('friendrequest.accepted', [$this, $sender]);
        }

        return $friendshipStatus == 'friends';
    }

    public function deleteFriend($user)
    {
        $friendshipStatus = $this->checkFriendship($user);

        if ($friendshipStatus != 'not_friends') {
            Friendship::betweenUsers($this, $user)
                ->delete();
            event('friendship.deleted', [$this, $user]);
        }

        return $friendshipStatus != 'not_friends';
    }

    public function friendsIds()
    {
        $friendsIds = Friendship::where(function ($query) {
            $query->whereSender($this);
        })->orWhere(function ($query) {
            $query->whereRecipient($this);
        })->accepted(1)->get(['friend_id', 'user_id'])->toArray();

        $friendsIds = collect($friendsIds)->flatten()->unique()->reject(function ($id) {
            return $id == $this->id;
        });

        return $friendsIds;
    }

    public function friends()
    {

        return $this->belongsToMany('User', 'friendships', 'user_id', 'friend_id')

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

            ->where('status', 1);
    }

    public function friendRequestsReceived()
    {
        return $this->belongsToMany('User', 'friendships', 'friend_id', 'user_id')

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

            ->where('status', 0);
    }

    public function friendRequestsSent()
    {
        return $this->belongsToMany('User', 'friendships', 'user_id', 'friend_id')

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

            ->where('status', 0);
    }

    public function isFriendsWith($user)
    {
        $friendshipStatus = $this->checkFriendship($user);

        return $friendshipStatus === 'friends';
    }

    public function mutualFriendsCount($user)
    {
        $userFriends = $user->friendsIds();
        $friends = $this->friendsIds();

        return $userFriends->intersect($friends)->count();
    }

    public function mutualFriends($user)
    {
        $userFriends = $user->friendsIds();
        $friends = $this->friendsIds();

        $mutualIds = $userFriends->intersect($friends);

        return static::whereIn('id', $mutualIds)->get();
    }
}