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

Code Duplication Length = 202-202 lines in 5 locations

local/devel/Repositories/CacheDescModifiedRepository.php 1 location


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

class CacheDescModifiedRepository
{
    const TABLE = 'cache_desc_modified';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param GeoCacheDescModifiedEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheDescModifiedEntity $entity)
    {
        return [
        'cache_id' => $entity->cacheId,
        'language' => $entity->language,
        'date_modified' => $entity->dateModified,
        'date_created' => $entity->dateCreated,
        'desc' => $entity->desc,
        'desc_html' => $entity->descHtml,
        'desc_htmledit' => $entity->descHtmledit,
        'hint' => $entity->hint,
        'short_desc' => $entity->shortDesc,
        'restored_by' => $entity->restoredBy,
        ];
    }

    /**
     * @param array $data
     * @return GeoCacheDescModifiedEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheDescModifiedEntity();
        $entity->cacheId = $data['cache_id'];
        $entity->language = $data['language'];
        $entity->dateModified = $data['date_modified'];
        $entity->dateCreated = $data['date_created'];
        $entity->desc = $data['desc'];
        $entity->descHtml = $data['desc_html'];
        $entity->descHtmledit = $data['desc_htmledit'];
        $entity->hint = $data['hint'];
        $entity->shortDesc = $data['short_desc'];
        $entity->restoredBy = $data['restored_by'];

        return $entity;
    }
}


local/devel/Repositories/CacheLocationRepository.php 1 location


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

class CacheLocationRepository
{
    const TABLE = 'cache_location';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param GeoCacheLocationEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheLocationEntity $entity)
    {
        return [
        'cache_id' => $entity->cacheId,
        'last_modified' => $entity->lastModified,
        'adm1' => $entity->adm1,
        'adm2' => $entity->adm2,
        'adm3' => $entity->adm3,
        'adm4' => $entity->adm4,
        'code1' => $entity->code1,
        'code2' => $entity->code2,
        'code3' => $entity->code3,
        'code4' => $entity->code4,
        ];
    }

    /**
     * @param array $data
     * @return GeoCacheLocationEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheLocationEntity();
        $entity->cacheId = $data['cache_id'];
        $entity->lastModified = $data['last_modified'];
        $entity->adm1 = $data['adm1'];
        $entity->adm2 = $data['adm2'];
        $entity->adm3 = $data['adm3'];
        $entity->adm4 = $data['adm4'];
        $entity->code1 = $data['code1'];
        $entity->code2 = $data['code2'];
        $entity->code3 = $data['code3'];
        $entity->code4 = $data['code4'];

        return $entity;
    }
}


local/devel/Repositories/CacheReportsRepository.php 1 location


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

class CacheReportsRepository
{
    const TABLE = 'cache_reports';

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

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

    /**
     * @return GeoCacheReportsEntity[]
     */
    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 GeoCacheReportsEntity
     */
    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 GeoCacheReportsEntity[]
     */
    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 GeoCacheReportsEntity $entity
     * @return GeoCacheReportsEntity
     */
    public function create(GeoCacheReportsEntity $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 GeoCacheReportsEntity $entity
     * @return GeoCacheReportsEntity
     */
    public function update(GeoCacheReportsEntity $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 GeoCacheReportsEntity $entity
     * @return GeoCacheReportsEntity
     */
    public function remove(GeoCacheReportsEntity $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 GeoCacheReportsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheReportsEntity $entity)
    {
        return [
        'id' => $entity->id,
        'date_created' => $entity->dateCreated,
        'cacheid' => $entity->cacheid,
        'userid' => $entity->userid,
        'reason' => $entity->reason,
        'note' => $entity->note,
        'status' => $entity->status,
        'adminid' => $entity->adminid,
        'lastmodified' => $entity->lastmodified,
        'comment' => $entity->comment,
        ];
    }

    /**
     * @param array $data
     * @return GeoCacheReportsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheReportsEntity();
        $entity->id = $data['id'];
        $entity->dateCreated = $data['date_created'];
        $entity->cacheid = $data['cacheid'];
        $entity->userid = $data['userid'];
        $entity->reason = $data['reason'];
        $entity->note = $data['note'];
        $entity->status = $data['status'];
        $entity->adminid = $data['adminid'];
        $entity->lastmodified = $data['lastmodified'];
        $entity->comment = $data['comment'];

        return $entity;
    }
}


local/devel/Repositories/GeodbTextdataRepository.php 1 location


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

class GeodbTextdataRepository
{
    const TABLE = 'geodb_textdata';

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

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

    /**
     * @return GeodbTextdataEntity[]
     */
    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 GeodbTextdataEntity
     */
    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 GeodbTextdataEntity[]
     */
    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 GeodbTextdataEntity $entity
     * @return GeodbTextdataEntity
     */
    public function create(GeodbTextdataEntity $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 GeodbTextdataEntity $entity
     * @return GeodbTextdataEntity
     */
    public function update(GeodbTextdataEntity $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 GeodbTextdataEntity $entity
     * @return GeodbTextdataEntity
     */
    public function remove(GeodbTextdataEntity $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 GeodbTextdataEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeodbTextdataEntity $entity)
    {
        return [
        'loc_id' => $entity->locId,
        'text_val' => $entity->textVal,
        'text_type' => $entity->textType,
        'text_locale' => $entity->textLocale,
        'is_native_lang' => $entity->isNativeLang,
        'is_default_name' => $entity->isDefaultName,
        'valid_since' => $entity->validSince,
        'date_type_since' => $entity->dateTypeSince,
        'valid_until' => $entity->validUntil,
        'date_type_until' => $entity->dateTypeUntil,
        ];
    }

    /**
     * @param array $data
     * @return GeodbTextdataEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeodbTextdataEntity();
        $entity->locId = $data['loc_id'];
        $entity->textVal = $data['text_val'];
        $entity->textType = $data['text_type'];
        $entity->textLocale = $data['text_locale'];
        $entity->isNativeLang = $data['is_native_lang'];
        $entity->isDefaultName = $data['is_default_name'];
        $entity->validSince = $data['valid_since'];
        $entity->dateTypeSince = $data['date_type_since'];
        $entity->validUntil = $data['valid_until'];
        $entity->dateTypeUntil = $data['date_type_until'];

        return $entity;
    }
}


local/devel/Repositories/GkItemRepository.php 1 location


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

class GkItemRepository
{
    const TABLE = 'gk_item';

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

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

    /**
     * @return GkItemEntity[]
     */
    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 GkItemEntity
     */
    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 GkItemEntity[]
     */
    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 GkItemEntity $entity
     * @return GkItemEntity
     */
    public function create(GkItemEntity $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 GkItemEntity $entity
     * @return GkItemEntity
     */
    public function update(GkItemEntity $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 GkItemEntity $entity
     * @return GkItemEntity
     */
    public function remove(GkItemEntity $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 GkItemEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GkItemEntity $entity)
    {
        return [
        'id' => $entity->id,
        'name' => $entity->name,
        'description' => $entity->description,
        'userid' => $entity->userid,
        'datecreated' => $entity->datecreated,
        'distancetravelled' => $entity->distancetravelled,
        'latitude' => $entity->latitude,
        'longitude' => $entity->longitude,
        'typeid' => $entity->typeid,
        'stateid' => $entity->stateid,
        ];
    }

    /**
     * @param array $data
     * @return GkItemEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GkItemEntity();
        $entity->id = $data['id'];
        $entity->name = $data['name'];
        $entity->description = $data['description'];
        $entity->userid = $data['userid'];
        $entity->datecreated = $data['datecreated'];
        $entity->distancetravelled = $data['distancetravelled'];
        $entity->latitude = $data['latitude'];
        $entity->longitude = $data['longitude'];
        $entity->typeid = $data['typeid'];
        $entity->stateid = $data['stateid'];

        return $entity;
    }
}


		@@ 9-210 (lines=202) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class CacheDescModifiedRepository
10		{
11		const TABLE = 'cache_desc_modified';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return GeoCacheDescModifiedEntity[]
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 GeoCacheDescModifiedEntity
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 GeoCacheDescModifiedEntity[]
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 GeoCacheDescModifiedEntity $entity
109		* @return GeoCacheDescModifiedEntity
110		*/
111		public function create(GeoCacheDescModifiedEntity $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->cacheId = (int) $this->connection->lastInsertId();
125
126		return $entity;
127		}
128
129		/**
130		* @param GeoCacheDescModifiedEntity $entity
131		* @return GeoCacheDescModifiedEntity
132		*/
133		public function update(GeoCacheDescModifiedEntity $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		['cache_id' => $entity->cacheId]
145		);
146
147		return $entity;
148		}
149
150		/**
151		* @param GeoCacheDescModifiedEntity $entity
152		* @return GeoCacheDescModifiedEntity
153		*/
154		public function remove(GeoCacheDescModifiedEntity $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		['cache_id' => $entity->cacheId]
163		);
164
165		$entity->cacheId = null;
166
167		return $entity;
168		}
169
170		/**
171		* @param GeoCacheDescModifiedEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(GeoCacheDescModifiedEntity $entity)
175		{
176		return [
177		'cache_id' => $entity->cacheId,
178		'language' => $entity->language,
179		'date_modified' => $entity->dateModified,
180		'date_created' => $entity->dateCreated,
181		'desc' => $entity->desc,
182		'desc_html' => $entity->descHtml,
183		'desc_htmledit' => $entity->descHtmledit,
184		'hint' => $entity->hint,
185		'short_desc' => $entity->shortDesc,
186		'restored_by' => $entity->restoredBy,
187		];
188		}
189
190		/**
191		* @param array $data
192		* @return GeoCacheDescModifiedEntity
193		*/
194		public function getEntityFromDatabaseArray(array $data)
195		{
196		$entity = new GeoCacheDescModifiedEntity();
197		$entity->cacheId = $data['cache_id'];
198		$entity->language = $data['language'];
199		$entity->dateModified = $data['date_modified'];
200		$entity->dateCreated = $data['date_created'];
201		$entity->desc = $data['desc'];
202		$entity->descHtml = $data['desc_html'];
203		$entity->descHtmledit = $data['desc_htmledit'];
204		$entity->hint = $data['hint'];
205		$entity->shortDesc = $data['short_desc'];
206		$entity->restoredBy = $data['restored_by'];
207
208		return $entity;
209		}
210		}
211

OpencachingDeutschland / oc-server3

Code Duplication Length = 202-202 lines in 5 locations

local/devel/Repositories/CacheDescModifiedRepository.php 1 location

local/devel/Repositories/CacheLocationRepository.php 1 location

local/devel/Repositories/CacheReportsRepository.php 1 location

local/devel/Repositories/GeodbTextdataRepository.php 1 location

local/devel/Repositories/GkItemRepository.php 1 location