CacheLogsArchivedRepository::__construct() - Code Metrics - Inspection of "OCC-102 show cache history in support center #done" - OpencachingDeutschland/oc-server3 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — development (#829)

unknown

created 2021-04-28 19:23 UTC

CacheLogsArchivedRepository::__construct() A

↳ Parent: CacheLogsArchivedRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	4
Ratio	100 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	1
dl	4
loc	4
rs	10
c	0
b	0
f	0

<?php

namespace Oc\Repository;

use DateTime;
use Doctrine\DBAL\Connection;
use Oc\Entity\GeoCacheLogsArchivedEntity;
use Oc\Repository\Exception\RecordAlreadyExistsException;
use Oc\Repository\Exception\RecordNotFoundException;
use Oc\Repository\Exception\RecordNotPersistedException;
use Oc\Repository\Exception\RecordsNotFoundException;

/**
 * Class CacheLogsArchivedRepository
 *
 * @package Oc\Repository
 */
class CacheLogsArchivedRepository

{
    const TABLE = 'cache_logs_archived';

    /** @var Connection */
    private $connection;

    /**
     * CacheLogsArchivedRepository constructor.
     *
     * @param Connection $connection
     */
    public function __construct(Connection $connection)
    {
        $this->connection = $connection;
    }

    /**
     * @return array
     * @throws RecordsNotFoundException
     */
    public function fetchAll()
    {
        $statement = $this->connection->createQueryBuilder()
            ->select('*')
            ->from(self::TABLE)
            ->execute();

        $result = $statement->fetchAll();

        if ($statement->rowCount() === 0) {
            throw new RecordsNotFoundException('No records found');
        }

        $records = [];

        foreach ($result as $item) {
            $records[] = $this->getEntityFromDatabaseArray($item);
        }

        return $records;
    }

    /**
     * @param array $where
     *
     * @return GeoCacheLogsArchivedEntity
     * @throws RecordNotFoundException
     */
    public function fetchOneBy(array $where = [])
    {
        $queryBuilder = $this->connection->createQueryBuilder()
            ->select('*')
            ->from(self::TABLE)
            ->setMaxResults(1);

        if (count($where) > 0) {
            foreach ($where as $column => $value) {
                $queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
            }
        }

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

        if ($statement->rowCount() === 0) {
            throw new RecordNotFoundException('Record with given where clause not found');
        }

        return $this->getEntityFromDatabaseArray($result);
    }

    /**
     * @param array $where
     *
     * @return array
     * @throws RecordsNotFoundException
     */
    public function fetchBy(array $where = [])
    {
        $queryBuilder = $this->connection->createQueryBuilder()
            ->select('*')
            ->from(self::TABLE);

        if (count($where) > 0) {
            foreach ($where as $column => $value) {
                $queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
            }
        }

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

        if ($statement->rowCount() === 0) {
//            throw new RecordsNotFoundException('No records with given where clause found');
        }

        $entities = [];

        foreach ($result as $item) {
            $entities[] = $this->getEntityFromDatabaseArray($item);
        }

        return $entities;
    }

    /**
     * @param GeoCacheLogsArchivedEntity $entity
     *
     * @return GeoCacheLogsArchivedEntity
     * @throws RecordAlreadyExistsException
     * @throws \Doctrine\DBAL\DBALException
     */
    public function create(GeoCacheLogsArchivedEntity $entity)
    {
        if (!$entity->isNew()) {
            throw new RecordAlreadyExistsException('The entity does already exist.');
        }

        $databaseArray = $this->getDatabaseArrayFromEntity($entity);

        $this->connection->insert(
            self::TABLE,
            $databaseArray
        );

        $entity->id = (int) $this->connection->lastInsertId();

        return $entity;
    }

    /**
     * @param GeoCacheLogsArchivedEntity $entity
     *
     * @return GeoCacheLogsArchivedEntity
     * @throws RecordNotPersistedException
     * @throws \Doctrine\DBAL\DBALException
     */
    public function update(GeoCacheLogsArchivedEntity $entity)
    {
        if ($entity->isNew()) {
            throw new RecordNotPersistedException('The entity does not exist.');
        }

        $databaseArray = $this->getDatabaseArrayFromEntity($entity);

        $this->connection->update(
            self::TABLE,
            $databaseArray,
            ['id' => $entity->id]
        );

        return $entity;
    }

    /**
     * @param GeoCacheLogsArchivedEntity $entity
     *
     * @return GeoCacheLogsArchivedEntity
     * @throws RecordNotPersistedException
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\DBAL\Exception\InvalidArgumentException
     */
    public function remove(GeoCacheLogsArchivedEntity $entity)
    {
        if ($entity->isNew()) {
            throw new RecordNotPersistedException('The entity does not exist.');
        }

        $this->connection->delete(
            self::TABLE,
            ['id' => $entity->id]
        );

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param GeoCacheLogsArchivedEntity $entity
     *
     * @return array
     */
    public function getDatabaseArrayFromEntity(GeoCacheLogsArchivedEntity $entity)
    {
        return [
            'id' => $entity->id,
            'uuid' => $entity->uuid,
            'node' => $entity->node,
            'date_created' => $entity->dateCreated,
            'entry_last_modified' => $entity->entryLastModified,
            'last_modified' => $entity->lastModified,
            'okapi_syncbase' => $entity->okapiSyncbase,
            'log_last_modified' => $entity->logLastModified,
            'cache_id' => $entity->cacheId,
            'user_id' => $entity->userId,
            'type' => $entity->type,
            'oc_team_comment' => $entity->ocTeamComment,
            'date' => $entity->date,
            'order_date' => $entity->orderDate,
            'needs_maintenance' => $entity->needsMaintenance,
            'listing_outdated' => $entity->listingOutdated,
            'text' => $entity->text,
            'text_html' => $entity->textHtml,
            'text_htmledit' => $entity->textHtmledit,
            'owner_notified' => $entity->ownerNotified,
            'picture' => $entity->picture,
            'deletion_date' => $entity->deletionDate,
            'deleted_by' => $entity->deletedBy,
            'restored_by' => $entity->restoredBy,
        ];
    }

    /**
     * @param array $data
     *
     * @return GeoCacheLogsArchivedEntity
     * @throws \Exception
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheLogsArchivedEntity();
        $entity->id = (int) $data['id'];
        $entity->uuid = (string) $data['uuid'];
        $entity->node = (int) $data['node'];
        $entity->dateCreated = new DateTime($data['date_created']);
        $entity->entryLastModified = new DateTime($data['entry_last_modified']);
        $entity->lastModified = new DateTime($data['last_modified']);
        $entity->okapiSyncbase = (string) $data['okapi_syncbase'];
        $entity->logLastModified = new DateTime($data['log_last_modified']);
        $entity->cacheId = (int) $data['cache_id'];
        $entity->userId = (int) $data['user_id'];
        $entity->type = (int) $data['type'];
        $entity->ocTeamComment = (int) $data['oc_team_comment'];
        $entity->date = new DateTime($data['date']);
        $entity->orderDate = new DateTime($data['order_date']);
        $entity->needsMaintenance = (int) $data['needs_maintenance'];
        $entity->listingOutdated = (int) $data['listing_outdated'];
        $entity->text = (string) $data['text'];
        $entity->textHtml = (int) $data['text_html'];
        $entity->textHtmledit = (int) $data['text_htmledit'];
        $entity->ownerNotified = (int) $data['owner_notified'];
        $entity->picture = $data['picture'];
        $entity->deletionDate = new DateTime($data['deletion_date']);
        $entity->deletedBy = (int) $data['deleted_by'];
        $entity->restoredBy = (int) $data['restored_by'];

        return $entity;
    }
}


1		<?php
2
3		namespace Oc\Repository;
4
5		use DateTime;
6		use Doctrine\DBAL\Connection;
7		use Oc\Entity\GeoCacheLogsArchivedEntity;
8		use Oc\Repository\Exception\RecordAlreadyExistsException;
9		use Oc\Repository\Exception\RecordNotFoundException;
10		use Oc\Repository\Exception\RecordNotPersistedException;
11		use Oc\Repository\Exception\RecordsNotFoundException;
12
13		/**
14		* Class CacheLogsArchivedRepository
15		*
16		* @package Oc\Repository
17		*/
18	View Code Duplication	class CacheLogsArchivedRepository
		0 ignored issues – show Duplication introduced 2021-04-28 19:27 UTC by Report Bug Copy Issue Report This class seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
19		{
20		const TABLE = 'cache_logs_archived';
21
22		/** @var Connection */
23		private $connection;
24
25		/**
26		* CacheLogsArchivedRepository constructor.
27		*
28		* @param Connection $connection
29		*/
30		public function __construct(Connection $connection)
31		{
32		$this->connection = $connection;
33		}
34
35		/**
36		* @return array
37		* @throws RecordsNotFoundException
38		*/
39		public function fetchAll()
40		{
41		$statement = $this->connection->createQueryBuilder()
42		->select('*')
43		->from(self::TABLE)
44		->execute();
45
46		$result = $statement->fetchAll();
47
48		if ($statement->rowCount() === 0) {
49		throw new RecordsNotFoundException('No records found');
50		}
51
52		$records = [];
53
54		foreach ($result as $item) {
55		$records[] = $this->getEntityFromDatabaseArray($item);
56		}
57
58		return $records;
59		}
60
61		/**
62		* @param array $where
63		*
64		* @return GeoCacheLogsArchivedEntity
65		* @throws RecordNotFoundException
66		*/
67		public function fetchOneBy(array $where = [])
68		{
69		$queryBuilder = $this->connection->createQueryBuilder()
70		->select('*')
71		->from(self::TABLE)
72		->setMaxResults(1);
73
74		if (count($where) > 0) {
75		foreach ($where as $column => $value) {
76		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
77		}
78		}
79
80		$statement = $queryBuilder->execute();
81
82		$result = $statement->fetch();
83
84		if ($statement->rowCount() === 0) {
85		throw new RecordNotFoundException('Record with given where clause not found');
86		}
87
88		return $this->getEntityFromDatabaseArray($result);
89		}
90
91		/**
92		* @param array $where
93		*
94		* @return array
95		* @throws RecordsNotFoundException
96		*/
97		public function fetchBy(array $where = [])
98		{
99		$queryBuilder = $this->connection->createQueryBuilder()
100		->select('*')
101		->from(self::TABLE);
102
103		if (count($where) > 0) {
104		foreach ($where as $column => $value) {
105		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
106		}
107		}
108
109		$statement = $queryBuilder->execute();
110
111		$result = $statement->fetchAll();
112
113		if ($statement->rowCount() === 0) {
114		// throw new RecordsNotFoundException('No records with given where clause found');
115		}
116
117		$entities = [];
118
119		foreach ($result as $item) {
120		$entities[] = $this->getEntityFromDatabaseArray($item);
121		}
122
123		return $entities;
124		}
125
126		/**
127		* @param GeoCacheLogsArchivedEntity $entity
128		*
129		* @return GeoCacheLogsArchivedEntity
130		* @throws RecordAlreadyExistsException
131		* @throws \Doctrine\DBAL\DBALException
132		*/
133		public function create(GeoCacheLogsArchivedEntity $entity)
134		{
135		if (!$entity->isNew()) {
136		throw new RecordAlreadyExistsException('The entity does already exist.');
137		}
138
139		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
140
141		$this->connection->insert(
142		self::TABLE,
143		$databaseArray
144		);
145
146		$entity->id = (int) $this->connection->lastInsertId();
147
148		return $entity;
149		}
150
151		/**
152		* @param GeoCacheLogsArchivedEntity $entity
153		*
154		* @return GeoCacheLogsArchivedEntity
155		* @throws RecordNotPersistedException
156		* @throws \Doctrine\DBAL\DBALException
157		*/
158		public function update(GeoCacheLogsArchivedEntity $entity)
159		{
160		if ($entity->isNew()) {
161		throw new RecordNotPersistedException('The entity does not exist.');
162		}
163
164		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
165
166		$this->connection->update(
167		self::TABLE,
168		$databaseArray,
169		['id' => $entity->id]
170		);
171
172		return $entity;
173		}
174
175		/**
176		* @param GeoCacheLogsArchivedEntity $entity
177		*
178		* @return GeoCacheLogsArchivedEntity
179		* @throws RecordNotPersistedException
180		* @throws \Doctrine\DBAL\DBALException
181		* @throws \Doctrine\DBAL\Exception\InvalidArgumentException
182		*/
183		public function remove(GeoCacheLogsArchivedEntity $entity)
184		{
185		if ($entity->isNew()) {
186		throw new RecordNotPersistedException('The entity does not exist.');
187		}
188
189		$this->connection->delete(
190		self::TABLE,
191		['id' => $entity->id]
192		);
193
194		$entity->cacheId = null;
195
196		return $entity;
197		}
198
199		/**
200		* @param GeoCacheLogsArchivedEntity $entity
201		*
202		* @return array
203		*/
204		public function getDatabaseArrayFromEntity(GeoCacheLogsArchivedEntity $entity)
205		{
206		return [
207		'id' => $entity->id,
208		'uuid' => $entity->uuid,
209		'node' => $entity->node,
210		'date_created' => $entity->dateCreated,
211		'entry_last_modified' => $entity->entryLastModified,
212		'last_modified' => $entity->lastModified,
213		'okapi_syncbase' => $entity->okapiSyncbase,
214		'log_last_modified' => $entity->logLastModified,
215		'cache_id' => $entity->cacheId,
216		'user_id' => $entity->userId,
217		'type' => $entity->type,
218		'oc_team_comment' => $entity->ocTeamComment,
219		'date' => $entity->date,
220		'order_date' => $entity->orderDate,
221		'needs_maintenance' => $entity->needsMaintenance,
222		'listing_outdated' => $entity->listingOutdated,
223		'text' => $entity->text,
224		'text_html' => $entity->textHtml,
225		'text_htmledit' => $entity->textHtmledit,
226		'owner_notified' => $entity->ownerNotified,
227		'picture' => $entity->picture,
228		'deletion_date' => $entity->deletionDate,
229		'deleted_by' => $entity->deletedBy,
230		'restored_by' => $entity->restoredBy,
231		];
232		}
233
234		/**
235		* @param array $data
236		*
237		* @return GeoCacheLogsArchivedEntity
238		* @throws \Exception
239		*/
240		public function getEntityFromDatabaseArray(array $data)
241		{
242		$entity = new GeoCacheLogsArchivedEntity();
243		$entity->id = (int) $data['id'];
244		$entity->uuid = (string) $data['uuid'];
245		$entity->node = (int) $data['node'];
246		$entity->dateCreated = new DateTime($data['date_created']);
247		$entity->entryLastModified = new DateTime($data['entry_last_modified']);
248		$entity->lastModified = new DateTime($data['last_modified']);
249		$entity->okapiSyncbase = (string) $data['okapi_syncbase'];
250		$entity->logLastModified = new DateTime($data['log_last_modified']);
251		$entity->cacheId = (int) $data['cache_id'];
252		$entity->userId = (int) $data['user_id'];
253		$entity->type = (int) $data['type'];
254		$entity->ocTeamComment = (int) $data['oc_team_comment'];
255		$entity->date = new DateTime($data['date']);
256		$entity->orderDate = new DateTime($data['order_date']);
257		$entity->needsMaintenance = (int) $data['needs_maintenance'];
258		$entity->listingOutdated = (int) $data['listing_outdated'];
259		$entity->text = (string) $data['text'];
260		$entity->textHtml = (int) $data['text_html'];
261		$entity->textHtmledit = (int) $data['text_htmledit'];
262		$entity->ownerNotified = (int) $data['owner_notified'];
263		$entity->picture = $data['picture'];
264		$entity->deletionDate = new DateTime($data['deletion_date']);
265		$entity->deletedBy = (int) $data['deleted_by'];
266		$entity->restoredBy = (int) $data['restored_by'];
267
268		return $entity;
269		}
270		}
271

OpencachingDeutschland / oc-server3

Pull Request — development (#829)

CacheLogsArchivedRepository::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like