NotificationRepository - Code Metrics - Inspection of "Issue 103" - fenos/Notifynder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#135)

by Fabrizio

created 2016-06-08 15:33 UTC

NotificationRepository A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	401
Duplicated Lines	26.18 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	12
Bugs	7	Features	4

Metric	Value
wmc	35
c	12
b	7
f	4
lcom	1
cbo	1
dl	105
loc	401
rs	9

18 Methods

Rating	Name	Duplication	Size	Complexity
A	deleteByCategory()	0	15	2
A	getLastNotification()	9	9	1
A	getLastNotificationByCategory()	11	11	1
A	applyFilter()	0	10	2
A	__construct()	0	7	1
A	find()	0	4	1
A	storeSingle()	0	4	1
B	getStack()	24	24	5
A	storeMultiple()	0	16	2
A	readOne()	0	10	2
A	readLimit()	0	11	1
A	readAll()	0	6	1
A	delete()	0	4	1
A	deleteAll()	0	9	1
A	deleteLimit()	0	16	2
B	getNotRead()	26	26	5
B	getAll()	25	25	5
A	countNotRead()	10	10	1

How to fix Duplicated Code

<?php

namespace Fenos\Notifynder\Notifications;

use Closure;
use Fenos\Notifynder\Contracts\NotificationDB;
use Fenos\Notifynder\Models\Notification;
use Illuminate\Database\DatabaseManager;
use Illuminate\Database\Connection;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Query\Builder as BuilderDB;

/**
 * Class NotificationRepository.
 */
class NotificationRepository implements NotificationDB
{
    /**
     * @var Notification | Builder | BuilderDB
     */
    protected $notification;

    /**
     * @var DatabaseManager | Connection
     */
    protected $db;

    /**
     * @param Notification                         $notification
     * @param \Illuminate\Database\DatabaseManager $db
     */
    public function __construct(
        Notification $notification,
        DatabaseManager $db
    ) {
        $this->notification = $notification;
        $this->db = $db;
    }

    /**
     * Find notification by id.
     *
     * @param $notificationId
     * @return \Illuminate\Database\Eloquent\Collection|\Illuminate\Database\Eloquent\Model|static
     */
    public function find($notificationId)
    {
        return $this->notification->find($notificationId);
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /**
     * Save a single notification sent.
     *
     * @param  array $info
     * @return Notification
     */
    public function storeSingle(array $info)
    {
        return $this->notification->create($info);
    }

    /**
     * Save multiple notifications sent
     * at once.
     *
     * @param  array $notifications
     * @return mixed
     */
    public function storeMultiple(array $notifications)
    {
        $this->db->beginTransaction();
        $stackId = $this->db->table(
            $this->notification->getTable()
        )->max('stack_id') + 1;
        foreach ($notifications as $key => $notification) {
            $notifications[$key]['stack_id'] = $stackId;
        }
        $insert = $this->db->table(
            $this->notification->getTable()
        )->insert($notifications);
        $this->db->commit();

        return $insert;
    }

    /**
     * Make Read One Notification.
     *
     * @param  Notification $notification
     * @return bool|Notification
     */
    public function readOne(Notification $notification)
    {
        $notification->read = 1;

        if ($notification->save()) {
            return $notification;
        }

        return false;
    }

    /**
     * Read notifications in base the number
     * Given.
     *
     * @param $toId
     * @param $entity
     * @param $numbers
     * @param $order
     * @return int
     */
    public function readLimit($toId, $entity, $numbers, $order)
    {
        $notifications = $this->notification->withNotRead()

            ->wherePolymorphic($toId, $entity)
            ->limit($numbers)
            ->orderBy('id', $order)
            ->lists('id');

        return $this->notification->whereIn('id', $notifications)
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->update(['read' => 1]);
    }

    /**
     * Make read all notification not read.
     *
     * @param $toId
     * @param $entity
     * @return int
     */
    public function readAll($toId, $entity)
    {
        return $this->notification->withNotRead()

            ->wherePolymorphic($toId, $entity)
            ->update(['read' => 1]);
    }

    /**
     * Delete a notification giving the id
     * of it.
     *
     * @param $notificationId
     * @return bool
     */
    public function delete($notificationId)
    {
        return $this->notification->where('id', $notificationId)->delete();
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
    }

    /**
     * Delete All notifications about the
     * current user.
     *
     * @param $toId int
     * @param $entity
     * @return bool
     */
    public function deleteAll($toId, $entity)
    {
        $query = $this->db->table(
            $this->notification->getTable()
        );

        return $this->notification->scopeWherePolymorphic($query, $toId, $entity)
            ->delete();
    }

    /**
     * Delete All notifications from a
     * defined category.
     *
     * @param $categoryName int
     * @param $expired       Bool
     * @return bool
     */
    public function deleteByCategory($categoryName, $expired = false)
    {
        $query = $this->notification->whereHas(
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            'body',
            function ($query) use ($categoryName) {
                $query->where('name', $categoryName);
            }
        );

        if ($expired == true) {

            return $query->onlyExpired()->delete();
        }

        return $query->delete();
    }

    /**
     * Delete numbers of notifications equals
     * to the number passing as 2 parameter of
     * the current user.
     *
     * @param $userId    int
     * @param $entity
     * @param $number     int
     * @param $order      string
     * @return int
     * @throws \Exception
     */
    public function deleteLimit($userId, $entity, $number, $order)
    {
        $notificationsIds = $this->notification

            ->wherePolymorphic($userId, $entity)
            ->orderBy('id', $order)
            ->select('id')
            ->limit($number)
            ->lists('id');

        if (count($notificationsIds) == 0) {
            return false;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        return $this->notification->whereIn('id', $notificationsIds)
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            ->delete();
    }

    /**
     * Retrieve notifications not Read
     * You can also limit the number of
     * Notification if you don't it will get all.
     *
     * @param              $toId
     * @param              $entity
     * @param  int|null    $limit
     * @param  int|null    $paginate
     * @param  string      $orderDate
     * @param Closure|null $filterScope
     * @return mixed
     */
    public function getNotRead(

        $toId,
        $entity,
        $limit = null,
        $paginate = null,
        $orderDate = 'desc',
        Closure $filterScope = null
    ) {
        $query = $this->notification->with('body', 'from')
            ->wherePolymorphic($toId, $entity)
            ->withNotRead()
            ->orderBy('read', 'ASC')
            ->orderBy('created_at', $orderDate);

        if ($limit && ! $paginate) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $query->limit($limit);
        }

        $query = $this->applyFilter($filterScope, $query);

        if (is_int(intval($paginate)) && $paginate) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            return $query->paginate($limit);
        }

        return $query->get();
    }

    /**
     * Retrieve all notifications, not read
     * in first.
     * You can also limit the number of
     * Notifications if you don't, it will get all.
     *
     * @param           $toId
     * @param           $entity
     * @param  null     $limit
     * @param  int|null $paginate
     * @param  string   $orderDate
     * @param Closure   $filterScope
     * @return mixed
     */
    public function getAll(

        $toId,
        $entity,
        $limit = null,
        $paginate = null,
        $orderDate = 'desc',
        Closure $filterScope = null
    ) {
        $query = $this->notification->with('body', 'from')
            ->wherePolymorphic($toId, $entity)
            ->orderBy('read', 'ASC')
            ->orderBy('created_at', $orderDate);

        if ($limit && ! $paginate) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $query->limit($limit);
        }

        $query = $this->applyFilter($filterScope, $query);

        if (is_int(intval($paginate)) && $paginate) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            return $query->paginate($limit);
        }

        return $query->get();
    }

    /**
     * get number Notifications
     * not read.
     *
     * @param         $toId
     * @param         $entity
     * @param Closure $filterScope
     * @return mixed
     */
    public function countNotRead($toId, $entity, Closure $filterScope = null)

    {
        $query = $this->notification->wherePolymorphic($toId, $entity)

            ->withNotRead()
            ->select($this->db->raw('Count(*) as notRead'));

        $query = $this->applyFilter($filterScope, $query);

        return $query->count();
    }

    /**
     * Get last notification of the current
     * entity.
     *
     * @param         $toId
     * @param         $entity
     * @param Closure $filterScope
     * @return mixed
     */
    public function getLastNotification($toId, $entity, Closure $filterScope = null)

    {
        $query = $this->notification->wherePolymorphic($toId, $entity)

            ->orderBy('created_at', 'DESC');

        $query = $this->applyFilter($filterScope, $query);

        return $query->first();
    }

    /**
     * Get last notification of the current
     * entity of a specific category.
     *
     * @param         $category
     * @param         $toId
     * @param         $entity
     * @param Closure $filterScope
     * @return mixed
     */
    public function getLastNotificationByCategory($category, $toId, $entity, Closure $filterScope = null)

    {
        $query = $this->notification

            ->wherePolymorphic($toId, $entity)
            ->byCategory($category)
            ->orderBy('created_at', 'desc');

        $query = $this->applyFilter($filterScope, $query);

        return $query->first();
    }

    /**
     * Apply scope filters.
     *
     * @param Closure $filterScope
     * @param         $query
     */
    protected function applyFilter(Closure $filterScope = null, $query)
    {
        if (! $filterScope) {
            return $query;
        }

        $filterScope($query);

        return $query;
    }

    /**
     * Retrive all notifications, in a stack.
     * You can also limit the number of
     * Notifications if you don't, it will get all.
     *
     * @param           $stackId
     * @param  null     $limit
     * @param  int|null $paginate
     * @param  string   $orderDate
     * @param Closure   $filterScope
     * @return mixed
     */
    public function getStack(

        $stackId,
        $limit = null,
        $paginate = null,
        $orderDate = 'desc',
        Closure $filterScope = null
    ) {
        $query = $this->notification->with('body', 'from', 'to')
            ->byStack($stackId)
            ->orderBy('read', 'ASC')
            ->orderBy('created_at', $orderDate);

        if ($limit && ! $paginate) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $query->limit($limit);
        }

        $query = $this->applyFilter($filterScope, $query);

        if (is_int(intval($paginate)) && $paginate) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            return $query->paginate($limit);
        }

        return $query->get();
    }
}


1			<?php
2
3			namespace Fenos\Notifynder\Notifications;
4
5			use Closure;
6			use Fenos\Notifynder\Contracts\NotificationDB;
7			use Fenos\Notifynder\Models\Notification;
8			use Illuminate\Database\DatabaseManager;
9			use Illuminate\Database\Connection;
10			use Illuminate\Database\Eloquent\Builder;
11			use Illuminate\Database\Query\Builder as BuilderDB;
12
13			/**
14			* Class NotificationRepository.
15			*/
16			class NotificationRepository implements NotificationDB
17			{
18			/**
19			* @var Notification \| Builder \| BuilderDB
20			*/
21			protected $notification;
22
23			/**
24			* @var DatabaseManager \| Connection
25			*/
26			protected $db;
27
28			/**
29			* @param Notification $notification
30			* @param \Illuminate\Database\DatabaseManager $db
31			*/
32			public function __construct(
33			Notification $notification,
34			DatabaseManager $db
35			) {
36			$this->notification = $notification;
37			$this->db = $db;
38			}
39
40			/**

fenos / Notifynder

Pull Request — master (#135)

NotificationRepository A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like