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

Code Duplication Length = 192-192 lines in 9 locations

local/devel/Repositories/CacheCountriesRepository.php 1 location


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

class CacheCountriesRepository
{
    const TABLE = 'cache_countries';

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

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

    /**
     * @return GeoCacheCountriesEntity[]
     */
    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 GeoCacheCountriesEntity
     */
    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 GeoCacheCountriesEntity[]
     */
    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 GeoCacheCountriesEntity $entity
     * @return GeoCacheCountriesEntity
     */
    public function create(GeoCacheCountriesEntity $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 GeoCacheCountriesEntity $entity
     * @return GeoCacheCountriesEntity
     */
    public function update(GeoCacheCountriesEntity $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 GeoCacheCountriesEntity $entity
     * @return GeoCacheCountriesEntity
     */
    public function remove(GeoCacheCountriesEntity $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 GeoCacheCountriesEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheCountriesEntity $entity)
    {
        return [
        'id' => $entity->id,
        'date_created' => $entity->dateCreated,
        'cache_id' => $entity->cacheId,
        'country' => $entity->country,
        'restored_by' => $entity->restoredBy,
        ];
    }

    /**
     * @param array $data
     * @return GeoCacheCountriesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheCountriesEntity();
        $entity->id = (int) $data['id'];
        $entity->dateCreated =  new DateTime($data['date_created']);
        $entity->cacheId = (int) $data['cache_id'];
        $entity->country = (string) $data['country'];
        $entity->restoredBy = (int) $data['restored_by'];

        return $entity;
    }
}


local/devel/Repositories/GeodbChangelogRepository.php 1 location


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

class GeodbChangelogRepository
{
    const TABLE = 'geodb_changelog';

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

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

    /**
     * @return GeodbChangelogEntity[]
     */
    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 GeodbChangelogEntity
     */
    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 GeodbChangelogEntity[]
     */
    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 GeodbChangelogEntity $entity
     * @return GeodbChangelogEntity
     */
    public function create(GeodbChangelogEntity $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 GeodbChangelogEntity $entity
     * @return GeodbChangelogEntity
     */
    public function update(GeodbChangelogEntity $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 GeodbChangelogEntity $entity
     * @return GeodbChangelogEntity
     */
    public function remove(GeodbChangelogEntity $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 GeodbChangelogEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeodbChangelogEntity $entity)
    {
        return [
        'id' => $entity->id,
        'datum' => $entity->datum,
        'beschreibung' => $entity->beschreibung,
        'autor' => $entity->autor,
        'version' => $entity->version,
        ];
    }

    /**
     * @param array $data
     * @return GeodbChangelogEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeodbChangelogEntity();
        $entity->id = (int) $data['id'];
        $entity->datum =  new DateTime($data['datum']);
        $entity->beschreibung = (string) $data['beschreibung'];
        $entity->autor = (string) $data['autor'];
        $entity->version = (string) $data['version'];

        return $entity;
    }
}


local/devel/Repositories/GeodbSearchRepository.php 1 location


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

class GeodbSearchRepository
{
    const TABLE = 'geodb_search';

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

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

    /**
     * @return GeodbSearchEntity[]
     */
    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 GeodbSearchEntity
     */
    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 GeodbSearchEntity[]
     */
    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 GeodbSearchEntity $entity
     * @return GeodbSearchEntity
     */
    public function create(GeodbSearchEntity $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 GeodbSearchEntity $entity
     * @return GeodbSearchEntity
     */
    public function update(GeodbSearchEntity $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 GeodbSearchEntity $entity
     * @return GeodbSearchEntity
     */
    public function remove(GeodbSearchEntity $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 GeodbSearchEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeodbSearchEntity $entity)
    {
        return [
        'id' => $entity->id,
        'loc_id' => $entity->locId,
        'sort' => $entity->sort,
        'simple' => $entity->simple,
        'simplehash' => $entity->simplehash,
        ];
    }

    /**
     * @param array $data
     * @return GeodbSearchEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeodbSearchEntity();
        $entity->id = (int) $data['id'];
        $entity->locId = (int) $data['loc_id'];
        $entity->sort = (string) $data['sort'];
        $entity->simple = (string) $data['simple'];
        $entity->simplehash = (int) $data['simplehash'];

        return $entity;
    }
}


local/devel/Repositories/LoginsRepository.php 1 location


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

class LoginsRepository
{
    const TABLE = 'logins';

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

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

    /**
     * @return LoginsEntity[]
     */
    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 LoginsEntity
     */
    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 LoginsEntity[]
     */
    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 LoginsEntity $entity
     * @return LoginsEntity
     */
    public function create(LoginsEntity $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 LoginsEntity $entity
     * @return LoginsEntity
     */
    public function update(LoginsEntity $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 LoginsEntity $entity
     * @return LoginsEntity
     */
    public function remove(LoginsEntity $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 LoginsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(LoginsEntity $entity)
    {
        return [
        'id' => $entity->id,
        'user_id' => $entity->userId,
        'remote_addr' => $entity->remoteAddr,
        'success' => $entity->success,
        'timestamp' => $entity->timestamp,
        ];
    }

    /**
     * @param array $data
     * @return LoginsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new LoginsEntity();
        $entity->id = (int) $data['id'];
        $entity->userId = (int) $data['user_id'];
        $entity->remoteAddr = (string) $data['remote_addr'];
        $entity->success = (int) $data['success'];
        $entity->timestamp =  new DateTime($data['timestamp']);

        return $entity;
    }
}


local/devel/Repositories/LogTypesTextRepository.php 1 location


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

class LogTypesTextRepository
{
    const TABLE = 'log_types_text';

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

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

    /**
     * @return LogTypesTextEntity[]
     */
    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 LogTypesTextEntity
     */
    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 LogTypesTextEntity[]
     */
    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 LogTypesTextEntity $entity
     * @return LogTypesTextEntity
     */
    public function create(LogTypesTextEntity $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 LogTypesTextEntity $entity
     * @return LogTypesTextEntity
     */
    public function update(LogTypesTextEntity $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 LogTypesTextEntity $entity
     * @return LogTypesTextEntity
     */
    public function remove(LogTypesTextEntity $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 LogTypesTextEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(LogTypesTextEntity $entity)
    {
        return [
        'id' => $entity->id,
        'log_types_id' => $entity->logTypesId,
        'lang' => $entity->lang,
        'text_combo' => $entity->textCombo,
        'text_listing' => $entity->textListing,
        ];
    }

    /**
     * @param array $data
     * @return LogTypesTextEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new LogTypesTextEntity();
        $entity->id = (int) $data['id'];
        $entity->logTypesId = (int) $data['log_types_id'];
        $entity->lang = (string) $data['lang'];
        $entity->textCombo = (string) $data['text_combo'];
        $entity->textListing = (string) $data['text_listing'];

        return $entity;
    }
}


local/devel/Repositories/NpaAreasRepository.php 1 location


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

class NpaAreasRepository
{
    const TABLE = 'npa_areas';

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

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

    /**
     * @return NpaAreasEntity[]
     */
    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 NpaAreasEntity
     */
    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 NpaAreasEntity[]
     */
    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 NpaAreasEntity $entity
     * @return NpaAreasEntity
     */
    public function create(NpaAreasEntity $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 NpaAreasEntity $entity
     * @return NpaAreasEntity
     */
    public function update(NpaAreasEntity $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 NpaAreasEntity $entity
     * @return NpaAreasEntity
     */
    public function remove(NpaAreasEntity $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 NpaAreasEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(NpaAreasEntity $entity)
    {
        return [
        'id' => $entity->id,
        'type_id' => $entity->typeId,
        'exclude' => $entity->exclude,
        'name' => $entity->name,
        'shape' => $entity->shape,
        ];
    }

    /**
     * @param array $data
     * @return NpaAreasEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new NpaAreasEntity();
        $entity->id = (int) $data['id'];
        $entity->typeId = (string) $data['type_id'];
        $entity->exclude = (int) $data['exclude'];
        $entity->name = (string) $data['name'];
        $entity->shape = $data['shape'];

        return $entity;
    }
}


local/devel/Repositories/QueriesRepository.php 1 location


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

class QueriesRepository
{
    const TABLE = 'queries';

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

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

    /**
     * @return QueriesEntity[]
     */
    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 QueriesEntity
     */
    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 QueriesEntity[]
     */
    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 QueriesEntity $entity
     * @return QueriesEntity
     */
    public function create(QueriesEntity $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 QueriesEntity $entity
     * @return QueriesEntity
     */
    public function update(QueriesEntity $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 QueriesEntity $entity
     * @return QueriesEntity
     */
    public function remove(QueriesEntity $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 QueriesEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(QueriesEntity $entity)
    {
        return [
        'id' => $entity->id,
        'user_id' => $entity->userId,
        'name' => $entity->name,
        'options' => $entity->options,
        'last_queried' => $entity->lastQueried,
        ];
    }

    /**
     * @param array $data
     * @return QueriesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new QueriesEntity();
        $entity->id = (int) $data['id'];
        $entity->userId = (int) $data['user_id'];
        $entity->name = (string) $data['name'];
        $entity->options = (string) $data['options'];
        $entity->lastQueried =  new DateTime($data['last_queried']);

        return $entity;
    }
}


local/devel/Repositories/ReplicationOverwritetypesRepository.php 1 location


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

class ReplicationOverwritetypesRepository
{
    const TABLE = 'replication_overwritetypes';

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

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

    /**
     * @return ReplicationOverwritetypesEntity[]
     */
    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 ReplicationOverwritetypesEntity
     */
    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 ReplicationOverwritetypesEntity[]
     */
    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 ReplicationOverwritetypesEntity $entity
     * @return ReplicationOverwritetypesEntity
     */
    public function create(ReplicationOverwritetypesEntity $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 ReplicationOverwritetypesEntity $entity
     * @return ReplicationOverwritetypesEntity
     */
    public function update(ReplicationOverwritetypesEntity $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 ReplicationOverwritetypesEntity $entity
     * @return ReplicationOverwritetypesEntity
     */
    public function remove(ReplicationOverwritetypesEntity $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 ReplicationOverwritetypesEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(ReplicationOverwritetypesEntity $entity)
    {
        return [
        'id' => $entity->id,
        'table' => $entity->table,
        'field' => $entity->field,
        'uuid_fieldname' => $entity->uuidFieldname,
        'backupfirst' => $entity->backupfirst,
        ];
    }

    /**
     * @param array $data
     * @return ReplicationOverwritetypesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new ReplicationOverwritetypesEntity();
        $entity->id = (int) $data['id'];
        $entity->table = (string) $data['table'];
        $entity->field = (string) $data['field'];
        $entity->uuidFieldname = (string) $data['uuid_fieldname'];
        $entity->backupfirst = (int) $data['backupfirst'];

        return $entity;
    }
}


local/devel/Repositories/ReplicationRepository.php 1 location


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

class ReplicationRepository
{
    const TABLE = 'replication';

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

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

    /**
     * @return ReplicationEntity[]
     */
    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 ReplicationEntity
     */
    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 ReplicationEntity[]
     */
    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 ReplicationEntity $entity
     * @return ReplicationEntity
     */
    public function create(ReplicationEntity $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 ReplicationEntity $entity
     * @return ReplicationEntity
     */
    public function update(ReplicationEntity $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 ReplicationEntity $entity
     * @return ReplicationEntity
     */
    public function remove(ReplicationEntity $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 ReplicationEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(ReplicationEntity $entity)
    {
        return [
        'id' => $entity->id,
        'module' => $entity->module,
        'last_run' => $entity->lastRun,
        'use' => $entity->use,
        'prio' => $entity->prio,
        ];
    }

    /**
     * @param array $data
     * @return ReplicationEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new ReplicationEntity();
        $entity->id = (int) $data['id'];
        $entity->module = (string) $data['module'];
        $entity->lastRun =  new DateTime($data['last_run']);
        $entity->use = (int) $data['use'];
        $entity->prio = (int) $data['prio'];

        return $entity;
    }
}


		@@ 9-200 (lines=192) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class CacheCountriesRepository
10		{
11		const TABLE = 'cache_countries';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return GeoCacheCountriesEntity[]
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 GeoCacheCountriesEntity
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 GeoCacheCountriesEntity[]
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 GeoCacheCountriesEntity $entity
109		* @return GeoCacheCountriesEntity
110		*/
111		public function create(GeoCacheCountriesEntity $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 GeoCacheCountriesEntity $entity
131		* @return GeoCacheCountriesEntity
132		*/
133		public function update(GeoCacheCountriesEntity $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 GeoCacheCountriesEntity $entity
152		* @return GeoCacheCountriesEntity
153		*/
154		public function remove(GeoCacheCountriesEntity $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 GeoCacheCountriesEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(GeoCacheCountriesEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'date_created' => $entity->dateCreated,
179		'cache_id' => $entity->cacheId,
180		'country' => $entity->country,
181		'restored_by' => $entity->restoredBy,
182		];
183		}
184
185		/**
186		* @param array $data
187		* @return GeoCacheCountriesEntity
188		*/
189		public function getEntityFromDatabaseArray(array $data)
190		{
191		$entity = new GeoCacheCountriesEntity();
192		$entity->id = (int) $data['id'];
193		$entity->dateCreated = new DateTime($data['date_created']);
194		$entity->cacheId = (int) $data['cache_id'];
195		$entity->country = (string) $data['country'];
196		$entity->restoredBy = (int) $data['restored_by'];
197
198		return $entity;
199		}
200		}
201

		@@ 9-200 (lines=192) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class GeodbChangelogRepository
10		{
11		const TABLE = 'geodb_changelog';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return GeodbChangelogEntity[]
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 GeodbChangelogEntity
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 GeodbChangelogEntity[]
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 GeodbChangelogEntity $entity
109		* @return GeodbChangelogEntity
110		*/
111		public function create(GeodbChangelogEntity $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 GeodbChangelogEntity $entity
131		* @return GeodbChangelogEntity
132		*/
133		public function update(GeodbChangelogEntity $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 GeodbChangelogEntity $entity
152		* @return GeodbChangelogEntity
153		*/
154		public function remove(GeodbChangelogEntity $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 GeodbChangelogEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(GeodbChangelogEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'datum' => $entity->datum,
179		'beschreibung' => $entity->beschreibung,
180		'autor' => $entity->autor,
181		'version' => $entity->version,
182		];
183		}
184
185		/**
186		* @param array $data
187		* @return GeodbChangelogEntity
188		*/
189		public function getEntityFromDatabaseArray(array $data)
190		{
191		$entity = new GeodbChangelogEntity();
192		$entity->id = (int) $data['id'];
193		$entity->datum = new DateTime($data['datum']);
194		$entity->beschreibung = (string) $data['beschreibung'];
195		$entity->autor = (string) $data['autor'];
196		$entity->version = (string) $data['version'];
197
198		return $entity;
199		}
200		}
201

		@@ 9-200 (lines=192) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class GeodbSearchRepository
10		{
11		const TABLE = 'geodb_search';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return GeodbSearchEntity[]
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 GeodbSearchEntity
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 GeodbSearchEntity[]
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 GeodbSearchEntity $entity
109		* @return GeodbSearchEntity
110		*/
111		public function create(GeodbSearchEntity $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 GeodbSearchEntity $entity
131		* @return GeodbSearchEntity
132		*/
133		public function update(GeodbSearchEntity $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 GeodbSearchEntity $entity
152		* @return GeodbSearchEntity
153		*/
154		public function remove(GeodbSearchEntity $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 GeodbSearchEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(GeodbSearchEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'loc_id' => $entity->locId,
179		'sort' => $entity->sort,
180		'simple' => $entity->simple,
181		'simplehash' => $entity->simplehash,
182		];
183		}
184
185		/**
186		* @param array $data
187		* @return GeodbSearchEntity
188		*/
189		public function getEntityFromDatabaseArray(array $data)
190		{
191		$entity = new GeodbSearchEntity();
192		$entity->id = (int) $data['id'];
193		$entity->locId = (int) $data['loc_id'];
194		$entity->sort = (string) $data['sort'];
195		$entity->simple = (string) $data['simple'];
196		$entity->simplehash = (int) $data['simplehash'];
197
198		return $entity;
199		}
200		}
201

		@@ 9-200 (lines=192) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class LoginsRepository
10		{
11		const TABLE = 'logins';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return LoginsEntity[]
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 LoginsEntity
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 LoginsEntity[]
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 LoginsEntity $entity
109		* @return LoginsEntity
110		*/
111		public function create(LoginsEntity $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 LoginsEntity $entity
131		* @return LoginsEntity
132		*/
133		public function update(LoginsEntity $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 LoginsEntity $entity
152		* @return LoginsEntity
153		*/
154		public function remove(LoginsEntity $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 LoginsEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(LoginsEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'user_id' => $entity->userId,
179		'remote_addr' => $entity->remoteAddr,
180		'success' => $entity->success,
181		'timestamp' => $entity->timestamp,
182		];
183		}
184
185		/**
186		* @param array $data
187		* @return LoginsEntity
188		*/
189		public function getEntityFromDatabaseArray(array $data)
190		{
191		$entity = new LoginsEntity();
192		$entity->id = (int) $data['id'];
193		$entity->userId = (int) $data['user_id'];
194		$entity->remoteAddr = (string) $data['remote_addr'];
195		$entity->success = (int) $data['success'];
196		$entity->timestamp = new DateTime($data['timestamp']);
197
198		return $entity;
199		}
200		}
201

		@@ 9-200 (lines=192) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class LogTypesTextRepository
10		{
11		const TABLE = 'log_types_text';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return LogTypesTextEntity[]
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 LogTypesTextEntity
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 LogTypesTextEntity[]
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 LogTypesTextEntity $entity
109		* @return LogTypesTextEntity
110		*/
111		public function create(LogTypesTextEntity $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 LogTypesTextEntity $entity
131		* @return LogTypesTextEntity
132		*/
133		public function update(LogTypesTextEntity $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 LogTypesTextEntity $entity
152		* @return LogTypesTextEntity
153		*/
154		public function remove(LogTypesTextEntity $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 LogTypesTextEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(LogTypesTextEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'log_types_id' => $entity->logTypesId,
179		'lang' => $entity->lang,
180		'text_combo' => $entity->textCombo,
181		'text_listing' => $entity->textListing,
182		];
183		}
184
185		/**
186		* @param array $data
187		* @return LogTypesTextEntity
188		*/
189		public function getEntityFromDatabaseArray(array $data)
190		{
191		$entity = new LogTypesTextEntity();
192		$entity->id = (int) $data['id'];
193		$entity->logTypesId = (int) $data['log_types_id'];
194		$entity->lang = (string) $data['lang'];
195		$entity->textCombo = (string) $data['text_combo'];
196		$entity->textListing = (string) $data['text_listing'];
197
198		return $entity;
199		}
200		}
201

OpencachingDeutschland / oc-server3

Code Duplication Length = 192-192 lines in 9 locations

local/devel/Repositories/CacheCountriesRepository.php 1 location

local/devel/Repositories/GeodbChangelogRepository.php 1 location

local/devel/Repositories/GeodbSearchRepository.php 1 location

local/devel/Repositories/LoginsRepository.php 1 location

local/devel/Repositories/LogTypesTextRepository.php 1 location

local/devel/Repositories/NpaAreasRepository.php 1 location

local/devel/Repositories/QueriesRepository.php 1 location

local/devel/Repositories/ReplicationOverwritetypesRepository.php 1 location

local/devel/Repositories/ReplicationRepository.php 1 location