Code Duplication - OpencachingDeutschland/oc-server3 - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 198-198 lines in 3 locations

local/devel/Repositories/GeodbFloatdataRepository.php 1 location


use Oc\Repository\Exception\RecordNotPersistedException;
use Oc\Repository\Exception\RecordsNotFoundException;

class GeodbFloatdataRepository
{
    const TABLE = 'geodb_floatdata';

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

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

    /**
     * @return GeodbFloatdataEntity[]
     */
    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 GeodbFloatdataEntity
     */
    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 GeodbFloatdataEntity[]
     */
    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 GeodbFloatdataEntity $entity
     * @return GeodbFloatdataEntity
     */
    public function create(GeodbFloatdataEntity $entity)
    {
        if (!$entity->isNew()) {
            throw new RecordAlreadyExistsException('The entity does already exist.');
        }

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

    /**
     * @param GeodbFloatdataEntity $entity
     * @return GeodbFloatdataEntity
     */
    public function remove(GeodbFloatdataEntity $entity)
    {
        if ($entity->isNew()) {
            throw new RecordNotPersistedException('The entity does not exist.');
        }

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param GeodbFloatdataEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeodbFloatdataEntity $entity)
    {
        return [
            'loc_id' => $entity->locId,
            'float_val' => $entity->floatVal,
            'float_type' => $entity->floatType,
            'float_subtype' => $entity->floatSubtype,
            'valid_since' => $entity->validSince,
            'date_type_since' => $entity->dateTypeSince,
            'valid_until' => $entity->validUntil,
            'date_type_until' => $entity->dateTypeUntil,
        ];
    }

    /**
     * @param array $data
     * @return GeodbFloatdataEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeodbFloatdataEntity();
        $entity->locId = (int) $data['loc_id'];
        $entity->floatVal = $data['float_val'];
        $entity->floatType = (int) $data['float_type'];
        $entity->floatSubtype = (int) $data['float_subtype'];
        $entity->validSince = new DateTime($data['valid_since']);
        $entity->dateTypeSince = (int) $data['date_type_since'];
        $entity->validUntil = new DateTime($data['valid_until']);
        $entity->dateTypeUntil = (int) $data['date_type_until'];

        return $entity;
    }
}


local/devel/Repositories/GeodbIntdataRepository.php 1 location


use Oc\Repository\Exception\RecordNotPersistedException;
use Oc\Repository\Exception\RecordsNotFoundException;

class GeodbIntdataRepository
{
    const TABLE = 'geodb_intdata';

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

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

    /**
     * @return GeodbIntdataEntity[]
     */
    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 GeodbIntdataEntity
     */
    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 GeodbIntdataEntity[]
     */
    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 GeodbIntdataEntity $entity
     * @return GeodbIntdataEntity
     */
    public function create(GeodbIntdataEntity $entity)
    {
        if (!$entity->isNew()) {
            throw new RecordAlreadyExistsException('The entity does already exist.');
        }

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

    /**
     * @param GeodbIntdataEntity $entity
     * @return GeodbIntdataEntity
     */
    public function remove(GeodbIntdataEntity $entity)
    {
        if ($entity->isNew()) {
            throw new RecordNotPersistedException('The entity does not exist.');
        }

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param GeodbIntdataEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeodbIntdataEntity $entity)
    {
        return [
            'loc_id' => $entity->locId,
            'int_val' => $entity->intVal,
            'int_type' => $entity->intType,
            'int_subtype' => $entity->intSubtype,
            'valid_since' => $entity->validSince,
            'date_type_since' => $entity->dateTypeSince,
            'valid_until' => $entity->validUntil,
            'date_type_until' => $entity->dateTypeUntil,
        ];
    }

    /**
     * @param array $data
     * @return GeodbIntdataEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeodbIntdataEntity();
        $entity->locId = (int) $data['loc_id'];
        $entity->intVal = (int) $data['int_val'];
        $entity->intType = (int) $data['int_type'];
        $entity->intSubtype = (int) $data['int_subtype'];
        $entity->validSince = new DateTime($data['valid_since']);
        $entity->dateTypeSince = (int) $data['date_type_since'];
        $entity->validUntil = new DateTime($data['valid_until']);
        $entity->dateTypeUntil = (int) $data['date_type_until'];

        return $entity;
    }
}


local/devel/Repositories/Map2ResultRepository.php 1 location


use Oc\Repository\Exception\RecordNotPersistedException;
use Oc\Repository\Exception\RecordsNotFoundException;

class Map2ResultRepository
{
    const TABLE = 'map2_result';

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

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

    /**
     * @return Map2ResultEntity[]
     */
    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 Map2ResultEntity
     */
    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 Map2ResultEntity[]
     */
    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 Map2ResultEntity $entity
     * @return Map2ResultEntity
     */
    public function create(Map2ResultEntity $entity)
    {
        if (!$entity->isNew()) {
            throw new RecordAlreadyExistsException('The entity does already exist.');
        }

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

    /**
     * @param Map2ResultEntity $entity
     * @return Map2ResultEntity
     */
    public function remove(Map2ResultEntity $entity)
    {
        if ($entity->isNew()) {
            throw new RecordNotPersistedException('The entity does not exist.');
        }

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param Map2ResultEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(Map2ResultEntity $entity)
    {
        return [
            'result_id' => $entity->resultId,
            'slave_id' => $entity->slaveId,
            'sqlchecksum' => $entity->sqlchecksum,
            'sqlquery' => $entity->sqlquery,
            'shared_counter' => $entity->sharedCounter,
            'request_counter' => $entity->requestCounter,
            'date_created' => $entity->dateCreated,
            'date_lastqueried' => $entity->dateLastqueried,
        ];
    }

    /**
     * @param array $data
     * @return Map2ResultEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new Map2ResultEntity();
        $entity->resultId = (int) $data['result_id'];
        $entity->slaveId = (int) $data['slave_id'];
        $entity->sqlchecksum = (int) $data['sqlchecksum'];
        $entity->sqlquery = (string) $data['sqlquery'];
        $entity->sharedCounter = (int) $data['shared_counter'];
        $entity->requestCounter = (int) $data['request_counter'];
        $entity->dateCreated = new DateTime($data['date_created']);
        $entity->dateLastqueried = new DateTime($data['date_lastqueried']);

        return $entity;
    }
}


		@@ 9-206 (lines=198) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class GeodbFloatdataRepository
10		{
11		const TABLE = 'geodb_floatdata';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return GeodbFloatdataEntity[]
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 GeodbFloatdataEntity
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 GeodbFloatdataEntity[]
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 GeodbFloatdataEntity $entity
109		* @return GeodbFloatdataEntity
110		*/
111		public function create(GeodbFloatdataEntity $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->locId = (int) $this->connection->lastInsertId();
125
126		return $entity;
127		}
128
129		/**
130		* @param GeodbFloatdataEntity $entity
131		* @return GeodbFloatdataEntity
132		*/
133		public function update(GeodbFloatdataEntity $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		['loc_id' => $entity->locId]
145		);
146
147		return $entity;
148		}
149
150		/**
151		* @param GeodbFloatdataEntity $entity
152		* @return GeodbFloatdataEntity
153		*/
154		public function remove(GeodbFloatdataEntity $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		['loc_id' => $entity->locId]
163		);
164
165		$entity->cacheId = null;
166
167		return $entity;
168		}
169
170		/**
171		* @param GeodbFloatdataEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(GeodbFloatdataEntity $entity)
175		{
176		return [
177		'loc_id' => $entity->locId,
178		'float_val' => $entity->floatVal,
179		'float_type' => $entity->floatType,
180		'float_subtype' => $entity->floatSubtype,
181		'valid_since' => $entity->validSince,
182		'date_type_since' => $entity->dateTypeSince,
183		'valid_until' => $entity->validUntil,
184		'date_type_until' => $entity->dateTypeUntil,
185		];
186		}
187
188		/**
189		* @param array $data
190		* @return GeodbFloatdataEntity
191		*/
192		public function getEntityFromDatabaseArray(array $data)
193		{
194		$entity = new GeodbFloatdataEntity();
195		$entity->locId = (int) $data['loc_id'];
196		$entity->floatVal = $data['float_val'];
197		$entity->floatType = (int) $data['float_type'];
198		$entity->floatSubtype = (int) $data['float_subtype'];
199		$entity->validSince = new DateTime($data['valid_since']);
200		$entity->dateTypeSince = (int) $data['date_type_since'];
201		$entity->validUntil = new DateTime($data['valid_until']);
202		$entity->dateTypeUntil = (int) $data['date_type_until'];
203
204		return $entity;
205		}
206		}
207

OpencachingDeutschland / oc-server3

Code Duplication Length = 198-198 lines in 3 locations

local/devel/Repositories/GeodbFloatdataRepository.php 1 location

local/devel/Repositories/GeodbIntdataRepository.php 1 location

local/devel/Repositories/Map2ResultRepository.php 1 location