DatabaseNotificationManager::notificationEntityName() - Code Metrics - irishdan/NotificationBundle - Measure and Improve Code Quality continuously with Scrutinizer

notificationEntityName() A
last analyzed 2018-08-15 18:19 UTC

↳ Parent: DatabaseNotificationManager

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?php

namespace IrishDan\NotificationBundle;

use IrishDan\NotificationBundle\Notification\DatabaseNotificationInterface;
use IrishDan\NotificationBundle\Notification\NotifiableInterface;
use Symfony\Bridge\Doctrine\ManagerRegistry;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

/**
 * Class DatabaseNotificationManager
 *
 * @package IrishDan\NotificationBundle
 */
class DatabaseNotificationManager
{
    /**
     * @var array
     */
    protected $databaseConfiguration;
    /**
     * @var ManagerRegistry
     */
    protected $managerRegistry;
    /**
     * @var PropertyAccessor
     */
    protected $propertyAccessor;

    /**
     * DatabaseNotificationManager constructor.
     *
     * @param ManagerRegistry $managerRegistry
     * @param array           $databaseConfiguration
     */
    public function __construct(ManagerRegistry $managerRegistry, array $databaseConfiguration = [])
    {
        $this->managerRegistry = $managerRegistry;
        $this->databaseConfiguration = $databaseConfiguration;
    }

    /**
     * @return bool|\Doctrine\Common\Persistence\ObjectManager|null|object
     */
    protected function getEntityManager()
    {
        $entity = $this->notificationEntityName();
        if ($entity) {
            return $this->managerRegistry->getManagerForClass($entity);
        }

        return false;
    }

    /**
     * @param array $data
     * @return bool
     */
    public function createDatabaseNotification(array $data)
    {
        if ($this->propertyAccessor === null) {
            $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
        }

        $entityManager = $this->getEntityManager();
        if ($entityManager) {
            $entity = $this->notificationEntityName();
            $class = $entityManager->getRepository($entity)->getClassName();
            $databaseNotification = new $class();

            // Transfer values from message to databaseNotification.
            $properties = ['notifiable', 'uuid', 'type', 'body', 'title'];
            foreach ($properties as $property) {
                $value = $this->propertyAccessor->getValue($data, '[' . $property . ']');
                $this->propertyAccessor->setValue($databaseNotification, $property, $value);
            }

            // Save the notification to the database
            $entityManager->persist($databaseNotification);
            $entityManager->flush();

            return $databaseNotification;
        }

        return false;
    }

    /**
     * @param DatabaseNotificationInterface $notification
     * @param null                          $now
     * @param bool                          $flush
     */
    public function setReadAtDate(DatabaseNotificationInterface $notification, $now = null, $flush = true)
    {
        if (empty($now)) {
            $now = new \DateTime();
        }

        $notification->setReadAt($now);

        $entityManager = $this->getEntityManager();
        $entityManager->persist($notification);
        if ($flush) {
            $entityManager->flush();
        }
    }

    /**
     * @param NotifiableInterface $notifiable
     * @param null                $now
     */
    public function setUsersNotificationsAsRead(NotifiableInterface $notifiable, $now = null)

    {
        $entity = $this->notificationEntityName();
        if (!empty($entity)) {
            $options = [
                'notifiable' => $notifiable,
                'readAt' => null,
            ];

            $entityManager = $this->getEntityManager();
            $usersNotifications = $entityManager->getRepository($entity)->findBy($options);

            if (!empty($usersNotifications)) {
                $this->setNotificationsReadat($usersNotifications);
            }
            $entityManager->flush();
        }
    }

    /**
     * @param array $notifications
     */
    public function setNotificationsReadAt(array $notifications)
    {
        $entityManager = $this->getEntityManager();
        foreach ($notifications as $notification) {
            $this->setReadAtDate($notification, null, false);
        }

        $entityManager->flush();
    }

    /**
     * @param DatabaseNotifiableInterface $user
     * @return array
     */
    public function getUsersUnreadNotifications(DatabaseNotifiableInterface $user)
    {
        $entityManager = $this->getEntityManager();

        if ($entityManager) {
            $entity = $this->notificationEntityName();
            $notifications = $entityManager->getRepository($entity)->getUnreadNotifications($user);

            return $notifications;
        }

        return [];
    }

    /**
     * @param NotifiableInterface $user
     * @param string              $status
     * @return int
     */
    public function getUsersNotificationCount(NotifiableInterface $user, $status = '')
    {
        $entityManager = $this->getEntityManager();
        if ($entityManager) {
            $entity = $this->notificationEntityName();
            $count = $entityManager->getRepository($entity)->getNotificationsCount($user, $status);

            return $count;
        }

        return 0;
    }

    /**
     * @param array $options
     * @throws \Exception
     */
    public function findAndSetAsRead(array $options)
    {
        $entityManager = $this->getEntityManager();
        $entity = $this->notificationEntityName();
        $notifications = $entityManager->getRepository($entity)->findBy($options);

        try {
            $this->setNotificationsReadAt($notifications);
        } catch (\Exception $e) {
            throw new \Exception(
                $e->getMessage()
            );
        }
    }

    /**
     * @return bool|mixed
     */
    protected function notificationEntityName()
    {
        $config = $this->databaseConfiguration;
        if (!empty($config['entity'])) {
            return $config['entity'];
        }

        return false;
    }
}


1			<?php
2
3			namespace IrishDan\NotificationBundle;
4
5			use IrishDan\NotificationBundle\Notification\DatabaseNotificationInterface;
6			use IrishDan\NotificationBundle\Notification\NotifiableInterface;
7			use Symfony\Bridge\Doctrine\ManagerRegistry;
8			use Symfony\Component\PropertyAccess\PropertyAccess;
9			use Symfony\Component\PropertyAccess\PropertyAccessor;
10
11			/**
12			* Class DatabaseNotificationManager
13			*
14			* @package IrishDan\NotificationBundle
15			*/
16			class DatabaseNotificationManager
17			{
18			/**
19			* @var array
20			*/
21			protected $databaseConfiguration;
22			/**
23			* @var ManagerRegistry
24			*/
25			protected $managerRegistry;
26			/**
27			* @var PropertyAccessor
28			*/
29			protected $propertyAccessor;
30
31			/**
32			* DatabaseNotificationManager constructor.
33			*
34			* @param ManagerRegistry $managerRegistry
35			* @param array $databaseConfiguration
36			*/
37			public function __construct(ManagerRegistry $managerRegistry, array $databaseConfiguration = [])
38			{
39			$this->managerRegistry = $managerRegistry;
40			$this->databaseConfiguration = $databaseConfiguration;
41			}
42
43			/**
44			* @return bool\|\Doctrine\Common\Persistence\ObjectManager\|null\|object
45			*/
46			protected function getEntityManager()
47			{
48			$entity = $this->notificationEntityName();
49			if ($entity) {
50			return $this->managerRegistry->getManagerForClass($entity);
51			}
52
53			return false;
54			}
55
56			/**
57			* @param array $data
58			* @return bool
59			*/
60			public function createDatabaseNotification(array $data)
61			{
62			if ($this->propertyAccessor === null) {
63			$this->propertyAccessor = PropertyAccess::createPropertyAccessor();
64			}
65
66			$entityManager = $this->getEntityManager();
67			if ($entityManager) {
68			$entity = $this->notificationEntityName();
69			$class = $entityManager->getRepository($entity)->getClassName();
70			$databaseNotification = new $class();
71
72			// Transfer values from message to databaseNotification.
73			$properties = ['notifiable', 'uuid', 'type', 'body', 'title'];
74			foreach ($properties as $property) {
75			$value = $this->propertyAccessor->getValue($data, '[' . $property . ']');
76			$this->propertyAccessor->setValue($databaseNotification, $property, $value);
77			}
78
79			// Save the notification to the database
80			$entityManager->persist($databaseNotification);
81			$entityManager->flush();
82
83			return $databaseNotification;
84			}
85
86			return false;
87			}
88
89			/**
90			* @param DatabaseNotificationInterface $notification
91			* @param null $now
92			* @param bool $flush
93			*/
94			public function setReadAtDate(DatabaseNotificationInterface $notification, $now = null, $flush = true)
95			{
96			if (empty($now)) {
97			$now = new \DateTime();
98			}
99
100			$notification->setReadAt($now);
101
102			$entityManager = $this->getEntityManager();
103			$entityManager->persist($notification);
104			if ($flush) {
105			$entityManager->flush();
106			}
107			}
108
109			/**
110			* @param NotifiableInterface $notifiable
111			* @param null $now
112			*/
113			public function setUsersNotificationsAsRead(NotifiableInterface $notifiable, $now = null)
			0 ignored issues – show Unused Code introduced 2017-08-16 09:58 UTC by Report Bug Copy Issue Report The parameter `$now` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
114			{
115			$entity = $this->notificationEntityName();
116			if (!empty($entity)) {
117			$options = [
118			'notifiable' => $notifiable,
119			'readAt' => null,
120			];
121
122			$entityManager = $this->getEntityManager();
123			$usersNotifications = $entityManager->getRepository($entity)->findBy($options);
124
125			if (!empty($usersNotifications)) {
126			$this->setNotificationsReadat($usersNotifications);
127			}
128			$entityManager->flush();
129			}
130			}
131
132			/**
133			* @param array $notifications
134			*/
135			public function setNotificationsReadAt(array $notifications)
136			{
137			$entityManager = $this->getEntityManager();
138			foreach ($notifications as $notification) {
139			$this->setReadAtDate($notification, null, false);
140			}
141
142			$entityManager->flush();
143			}
144
145			/**
146			* @param DatabaseNotifiableInterface $user
147			* @return array
148			*/
149			public function getUsersUnreadNotifications(DatabaseNotifiableInterface $user)
150			{
151			$entityManager = $this->getEntityManager();
152
153			if ($entityManager) {
154			$entity = $this->notificationEntityName();
155			$notifications = $entityManager->getRepository($entity)->getUnreadNotifications($user);
156
157			return $notifications;
158			}
159
160			return [];
161			}
162
163			/**
164			* @param NotifiableInterface $user
165			* @param string $status
166			* @return int
167			*/
168			public function getUsersNotificationCount(NotifiableInterface $user, $status = '')
169			{
170			$entityManager = $this->getEntityManager();
171			if ($entityManager) {
172			$entity = $this->notificationEntityName();
173			$count = $entityManager->getRepository($entity)->getNotificationsCount($user, $status);
174
175			return $count;
176			}
177
178			return 0;
179			}
180
181			/**
182			* @param array $options
183			* @throws \Exception
184			*/
185			public function findAndSetAsRead(array $options)
186			{
187			$entityManager = $this->getEntityManager();
188			$entity = $this->notificationEntityName();
189			$notifications = $entityManager->getRepository($entity)->findBy($options);
190
191			try {
192			$this->setNotificationsReadAt($notifications);
193			} catch (\Exception $e) {
194			throw new \Exception(
195			$e->getMessage()
196			);
197			}
198			}
199
200			/**
201			* @return bool\|mixed
202			*/
203			protected function notificationEntityName()
204			{
205			$config = $this->databaseConfiguration;
206			if (!empty($config['entity'])) {
207			return $config['entity'];
208			}
209
210			return false;
211			}
212			}
213

irishdan / NotificationBundle

notificationEntityName() A last analyzed 2018-08-15 18:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

notificationEntityName() A
last analyzed 2018-08-15 18:19 UTC