CacheLogsArchivedRepository::fetchBy() - Code Metrics - Inspection of "remove google maps type" - OpencachingDeutschland/oc-server3 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — next ( 01f675...c3ca23 )

by Thomas

created 2018-09-03 20:20 UTC

CacheLogsArchivedRepository::fetchBy() A

↳ Parent: CacheLogsArchivedRepository

Complexity

Conditions	5
Paths	6

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
nc	6
nop	1
dl	0
loc	28
rs	9.1608
c	0
b	0
f	0

<?php

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

class CacheLogsArchivedRepository
{
    const TABLE = 'cache_logs_archived';

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

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

    /**
     * @return GeoCacheLogsArchivedEntity[]
     */
    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
     */
    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 GeoCacheLogsArchivedEntity[]
     */
    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
     */
    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
     */
    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
     */
    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 []

     */
    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
     */
    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			use Doctrine\DBAL\Connection;
4			use Oc\Repository\Exception\RecordAlreadyExistsException;
5			use Oc\Repository\Exception\RecordNotFoundException;
6			use Oc\Repository\Exception\RecordNotPersistedException;
7			use Oc\Repository\Exception\RecordsNotFoundException;
8
9			class CacheLogsArchivedRepository
10			{
11			const TABLE = 'cache_logs_archived';
12
13			/** @var Connection */
14			private $connection;
15
16			public function __construct(Connection $connection)
17			{
18			$this->connection = $connection;
19			}
20
21			/**
22			* @return GeoCacheLogsArchivedEntity[]
23			*/
24			public function fetchAll()
25			{
26			$statement = $this->connection->createQueryBuilder()
27			->select('*')
28			->from(self::TABLE)
29			->execute();
30
31			$result = $statement->fetchAll();
32
33			if ($statement->rowCount() === 0) {
34			throw new RecordsNotFoundException('No records found');
35			}
36
37			$records = [];
38
39			foreach ($result as $item) {
40			$records[] = $this->getEntityFromDatabaseArray($item);
41			}
42
43			return $records;
44			}
45
46			/**
47			* @param array $where
48			* @return GeoCacheLogsArchivedEntity
49			*/
50			public function fetchOneBy(array $where = [])
51			{
52			$queryBuilder = $this->connection->createQueryBuilder()
53			->select('*')
54			->from(self::TABLE)
55			->setMaxResults(1);
56
57			if (count($where) > 0) {
58			foreach ($where as $column => $value) {
59			$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
60			}
61			}
62
63			$statement = $queryBuilder->execute();
64
65			$result = $statement->fetch();
66
67			if ($statement->rowCount() === 0) {
68			throw new RecordNotFoundException('Record with given where clause not found');
69			}
70
71			return $this->getEntityFromDatabaseArray($result);
72			}
73
74			/**
75			* @param array $where
76			* @return GeoCacheLogsArchivedEntity[]
77			*/
78			public function fetchBy(array $where = [])
79			{
80			$queryBuilder = $this->connection->createQueryBuilder()
81			->select('*')
82			->from(self::TABLE);
83
84			if (count($where) > 0) {
85			foreach ($where as $column => $value) {
86			$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
87			}
88			}
89
90			$statement = $queryBuilder->execute();
91
92			$result = $statement->fetchAll();
93
94			if ($statement->rowCount() === 0) {
95			throw new RecordsNotFoundException('No records with given where clause found');
96			}
97
98			$entities = [];
99
100			foreach ($result as $item) {
101			$entities[] = $this->getEntityFromDatabaseArray($item);
102			}
103
104			return $entities;
105			}
106
107			/**
108			* @param GeoCacheLogsArchivedEntity $entity
109			* @return GeoCacheLogsArchivedEntity
110			*/
111			public function create(GeoCacheLogsArchivedEntity $entity)
112			{
113			if (!$entity->isNew()) {
114			throw new RecordAlreadyExistsException('The entity does already exist.');
115			}
116
117			$databaseArray = $this->getDatabaseArrayFromEntity($entity);
118
119			$this->connection->insert(
120			self::TABLE,
121			$databaseArray
122			);
123
124			$entity->id = (int) $this->connection->lastInsertId();
125
126			return $entity;
127			}
128
129			/**
130			* @param GeoCacheLogsArchivedEntity $entity
131			* @return GeoCacheLogsArchivedEntity
132			*/
133			public function update(GeoCacheLogsArchivedEntity $entity)
134			{
135			if ($entity->isNew()) {
136			throw new RecordNotPersistedException('The entity does not exist.');
137			}
138
139			$databaseArray = $this->getDatabaseArrayFromEntity($entity);
140
141			$this->connection->update(
142			self::TABLE,
143			$databaseArray,
144			['id' => $entity->id]
145			);
146
147			return $entity;
148			}
149
150			/**
151			* @param GeoCacheLogsArchivedEntity $entity
152			* @return GeoCacheLogsArchivedEntity
153			*/
154			public function remove(GeoCacheLogsArchivedEntity $entity)
155			{
156			if ($entity->isNew()) {
157			throw new RecordNotPersistedException('The entity does not exist.');
158			}
159
160			$this->connection->delete(
161			self::TABLE,
162			['id' => $entity->id]
163			);
164
165			$entity->cacheId = null;
166
167			return $entity;
168			}
169
170			/**
171			* @param GeoCacheLogsArchivedEntity $entity
172			* @return []
			0 ignored issues – show Documentation introduced 2018-08-10 14:46 UTC by Report Bug Copy Issue Report The doc-type `[]` could not be parsed: Unknown type name "" at position 0. [(view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
173			*/
174			public function getDatabaseArrayFromEntity(GeoCacheLogsArchivedEntity $entity)
175			{
176			return [
177			'id' => $entity->id,
178			'uuid' => $entity->uuid,
179			'node' => $entity->node,
180			'date_created' => $entity->dateCreated,
181			'entry_last_modified' => $entity->entryLastModified,
182			'last_modified' => $entity->lastModified,
183			'okapi_syncbase' => $entity->okapiSyncbase,
184			'log_last_modified' => $entity->logLastModified,
185			'cache_id' => $entity->cacheId,
186			'user_id' => $entity->userId,
187			'type' => $entity->type,
188			'oc_team_comment' => $entity->ocTeamComment,
189			'date' => $entity->date,
190			'order_date' => $entity->orderDate,
191			'needs_maintenance' => $entity->needsMaintenance,
192			'listing_outdated' => $entity->listingOutdated,
193			'text' => $entity->text,
194			'text_html' => $entity->textHtml,
195			'text_htmledit' => $entity->textHtmledit,
196			'owner_notified' => $entity->ownerNotified,
197			'picture' => $entity->picture,
198			'deletion_date' => $entity->deletionDate,
199			'deleted_by' => $entity->deletedBy,
200			'restored_by' => $entity->restoredBy,
201			];
202			}
203
204			/**
205			* @param array $data
206			* @return GeoCacheLogsArchivedEntity
207			*/
208			public function getEntityFromDatabaseArray(array $data)
209			{
210			$entity = new GeoCacheLogsArchivedEntity();
211			$entity->id = (int) $data['id'];
212			$entity->uuid = (string) $data['uuid'];
213			$entity->node = (int) $data['node'];
214			$entity->dateCreated = new DateTime($data['date_created']);
215			$entity->entryLastModified = new DateTime($data['entry_last_modified']);
216			$entity->lastModified = new DateTime($data['last_modified']);
217			$entity->okapiSyncbase = (string) $data['okapi_syncbase'];
218			$entity->logLastModified = new DateTime($data['log_last_modified']);
219			$entity->cacheId = (int) $data['cache_id'];
220			$entity->userId = (int) $data['user_id'];
221			$entity->type = (int) $data['type'];
222			$entity->ocTeamComment = (int) $data['oc_team_comment'];
223			$entity->date = new DateTime($data['date']);
224			$entity->orderDate = new DateTime($data['order_date']);
225			$entity->needsMaintenance = (int) $data['needs_maintenance'];
226			$entity->listingOutdated = (int) $data['listing_outdated'];
227			$entity->text = (string) $data['text'];
228			$entity->textHtml = (int) $data['text_html'];
229			$entity->textHtmledit = (int) $data['text_htmledit'];
230			$entity->ownerNotified = (int) $data['owner_notified'];
231			$entity->picture = $data['picture'];
232			$entity->deletionDate = new DateTime($data['deletion_date']);
233			$entity->deletedBy = (int) $data['deleted_by'];
234			$entity->restoredBy = (int) $data['restored_by'];
235
236			return $entity;
237			}
238			}
239

OpencachingDeutschland / oc-server3

Push — next ( 01f675...c3ca23 )

CacheLogsArchivedRepository::fetchBy() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like