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

Code Duplication Length = 190-214 lines in 8 locations

local/devel/Repositories/CacheVisitsRepository.php 1 location


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

class CacheVisitsRepository
{
    const TABLE = 'cache_visits';

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

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

    /**
     * @return GeoCacheVisitsEntity[]
     */
    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;
    }

    /**
     * @return GeoCacheVisitsEntity
     */
    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);
    }

    /**
     * @return GeoCacheVisitsEntity[]
     */
    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;
    }

    /**
     * @return GeoCacheVisitsEntity
     */
    public function create(GeoCacheVisitsEntity $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;
    }

    /**
     * @return GeoCacheVisitsEntity
     */
    public function update(GeoCacheVisitsEntity $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;
    }

    /**
     * @return GeoCacheVisitsEntity
     */
    public function remove(GeoCacheVisitsEntity $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;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheVisitsEntity $entity)
    {
        return [
            'cache_id' => $entity->cacheId,
            'user_id_ip' => $entity->userIdIp,
            'count' => $entity->count,
            'last_modified' => $entity->lastModified,
        ];
    }

    /**
     * @return GeoCacheVisitsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheVisitsEntity();
        $entity->cacheId = (int) $data['cache_id'];
        $entity->userIdIp = (string) $data['user_id_ip'];
        $entity->count = $data['count'];
        $entity->lastModified = new DateTime($data['last_modified']);

        return $entity;
    }
}


local/devel/Repositories/NutsLayerRepository.php 1 location


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

class NutsLayerRepository
{
    const TABLE = 'nuts_layer';

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

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

    /**
     * @return NutsLayerEntity[]
     */
    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;
    }

    /**
     * @return NutsLayerEntity
     */
    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);
    }

    /**
     * @return NutsLayerEntity[]
     */
    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;
    }

    /**
     * @return NutsLayerEntity
     */
    public function create(NutsLayerEntity $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;
    }

    /**
     * @return NutsLayerEntity
     */
    public function update(NutsLayerEntity $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;
    }

    /**
     * @return NutsLayerEntity
     */
    public function remove(NutsLayerEntity $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;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(NutsLayerEntity $entity)
    {
        return [
            'id' => $entity->id,
            'level' => $entity->level,
            'code' => $entity->code,
            'shape' => $entity->shape,
        ];
    }

    /**
     * @return NutsLayerEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new NutsLayerEntity();
        $entity->id = (int) $data['id'];
        $entity->level = (int) $data['level'];
        $entity->code = (string) $data['code'];
        $entity->shape = $data['shape'];

        return $entity;
    }
}


local/devel/Repositories/OkapiCacheRepository.php 1 location


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

class OkapiCacheRepository
{
    const TABLE = 'okapi_cache';

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

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

    /**
     * @return OkapiCacheEntity[]
     */
    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;
    }

    /**
     * @return OkapiCacheEntity
     */
    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);
    }

    /**
     * @return OkapiCacheEntity[]
     */
    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;
    }

    /**
     * @return OkapiCacheEntity
     */
    public function create(OkapiCacheEntity $entity)
    {
        if (!$entity->isNew()) {
            throw new RecordAlreadyExistsException('The entity does already exist.');
        }

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(OkapiCacheEntity $entity)
    {
        return [
            'key' => $entity->key,
            'score' => $entity->score,
            'expires' => $entity->expires,
            'value' => $entity->value,
        ];
    }

    /**
     * @return OkapiCacheEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new OkapiCacheEntity();
        $entity->key = (string) $data['key'];
        $entity->score = $data['score'];
        $entity->expires = new DateTime($data['expires']);
        $entity->value = (string) $data['value'];

        return $entity;
    }
}


local/devel/Repositories/OkapiSearchSetsRepository.php 1 location


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

class OkapiSearchSetsRepository
{
    const TABLE = 'okapi_search_sets';

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

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

    /**
     * @return OkapiSearchSetsEntity[]
     */
    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;
    }

    /**
     * @return OkapiSearchSetsEntity
     */
    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);
    }

    /**
     * @return OkapiSearchSetsEntity[]
     */
    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;
    }

    /**
     * @return OkapiSearchSetsEntity
     */
    public function create(OkapiSearchSetsEntity $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;
    }

    /**
     * @return OkapiSearchSetsEntity
     */
    public function update(OkapiSearchSetsEntity $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;
    }

    /**
     * @return OkapiSearchSetsEntity
     */
    public function remove(OkapiSearchSetsEntity $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;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(OkapiSearchSetsEntity $entity)
    {
        return [
            'id' => $entity->id,
            'params_hash' => $entity->paramsHash,
            'date_created' => $entity->dateCreated,
            'expires' => $entity->expires,
        ];
    }

    /**
     * @return OkapiSearchSetsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new OkapiSearchSetsEntity();
        $entity->id = (int) $data['id'];
        $entity->paramsHash = (string) $data['params_hash'];
        $entity->dateCreated = new DateTime($data['date_created']);
        $entity->expires = new DateTime($data['expires']);

        return $entity;
    }
}


local/devel/Repositories/SysLoginsRepository.php 1 location


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

class SysLoginsRepository
{
    const TABLE = 'sys_logins';

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

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

    /**
     * @return SysLoginsEntity[]
     */
    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;
    }

    /**
     * @return SysLoginsEntity
     */
    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);
    }

    /**
     * @return SysLoginsEntity[]
     */
    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;
    }

    /**
     * @return SysLoginsEntity
     */
    public function create(SysLoginsEntity $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;
    }

    /**
     * @return SysLoginsEntity
     */
    public function update(SysLoginsEntity $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;
    }

    /**
     * @return SysLoginsEntity
     */
    public function remove(SysLoginsEntity $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;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(SysLoginsEntity $entity)
    {
        return [
            'id' => $entity->id,
            'date_created' => $entity->dateCreated,
            'remote_addr' => $entity->remoteAddr,
            'success' => $entity->success,
        ];
    }

    /**
     * @return SysLoginsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new SysLoginsEntity();
        $entity->id = (int) $data['id'];
        $entity->dateCreated = new DateTime($data['date_created']);
        $entity->remoteAddr = (string) $data['remote_addr'];
        $entity->success = (int) $data['success'];

        return $entity;
    }
}


local/devel/Repositories/SysSessionsRepository.php 1 location


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

class SysSessionsRepository
{
    const TABLE = 'sys_sessions';

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

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

    /**
     * @return SysSessionsEntity[]
     */
    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;
    }

    /**
     * @return SysSessionsEntity
     */
    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);
    }

    /**
     * @return SysSessionsEntity[]
     */
    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;
    }

    /**
     * @return SysSessionsEntity
     */
    public function create(SysSessionsEntity $entity)
    {
        if (!$entity->isNew()) {
            throw new RecordAlreadyExistsException('The entity does already exist.');
        }

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(SysSessionsEntity $entity)
    {
        return [
            'uuid' => $entity->uuid,
            'user_id' => $entity->userId,
            'permanent' => $entity->permanent,
            'last_login' => $entity->lastLogin,
        ];
    }

    /**
     * @return SysSessionsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new SysSessionsEntity();
        $entity->uuid = (string) $data['uuid'];
        $entity->userId = (int) $data['user_id'];
        $entity->permanent = (int) $data['permanent'];
        $entity->lastLogin = new DateTime($data['last_login']);

        return $entity;
    }
}


local/devel/Repositories/SysTransTextRepository.php 1 location


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

class SysTransTextRepository
{
    const TABLE = 'sys_trans_text';

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

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

    /**
     * @return SysTransTextEntity[]
     */
    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;
    }

    /**
     * @return SysTransTextEntity
     */
    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);
    }

    /**
     * @return SysTransTextEntity[]
     */
    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;
    }

    /**
     * @return SysTransTextEntity
     */
    public function create(SysTransTextEntity $entity)
    {
        if (!$entity->isNew()) {
            throw new RecordAlreadyExistsException('The entity does already exist.');
        }

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(SysTransTextEntity $entity)
    {
        return [
            'trans_id' => $entity->transId,
            'lang' => $entity->lang,
            'text' => $entity->text,
            'last_modified' => $entity->lastModified,
        ];
    }

    /**
     * @return SysTransTextEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new SysTransTextEntity();
        $entity->transId = (int) $data['trans_id'];
        $entity->lang = (string) $data['lang'];
        $entity->text = (string) $data['text'];
        $entity->lastModified = new DateTime($data['last_modified']);

        return $entity;
    }
}


htdocs_symfony/src/Repository/CacheReportReasonsRepository.php 1 location


use Oc\Repository\Exception\RecordsNotFoundException;


class CacheReportReasonsRepository
{
    const TABLE = 'cache_report_reasons';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

    /**
     * @param GeoCacheReportReasonsEntity $entity
     *
     * @return GeoCacheReportReasonsEntity
     * @throws RecordAlreadyExistsException
     * @throws \Doctrine\DBAL\DBALException
     */
    public function create(GeoCacheReportReasonsEntity $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 GeoCacheReportReasonsEntity $entity
     *
     * @return GeoCacheReportReasonsEntity
     * @throws RecordNotPersistedException
     * @throws \Doctrine\DBAL\DBALException
     */
    public function update(GeoCacheReportReasonsEntity $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 GeoCacheReportReasonsEntity $entity
     *
     * @return GeoCacheReportReasonsEntity
     * @throws RecordNotPersistedException
     * @throws \Doctrine\DBAL\DBALException
     * @throws \Doctrine\DBAL\Exception\InvalidArgumentException
     */
    public function remove(GeoCacheReportReasonsEntity $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 GeoCacheReportReasonsEntity $entity
     *
     * @return array
     */
    public function getDatabaseArrayFromEntity(GeoCacheReportReasonsEntity $entity)
    {
        return [
            'id' => $entity->id,
            'name' => $entity->name,
            'trans_id' => $entity->transId,
            'order' => $entity->order,
        ];
    }

    /**
     * @param array $data
     *
     * @return GeoCacheReportReasonsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheReportReasonsEntity();
        $entity->id = (int) $data['id'];
        $entity->name = (string) $data['name'];
        $entity->transId = (int) $data['trans_id'];
        $entity->order = (int) $data['order'];

        return $entity;
    }
}


		@@ 9-198 (lines=190) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class CacheVisitsRepository
10		{
11		const TABLE = 'cache_visits';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return GeoCacheVisitsEntity[]
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		* @return GeoCacheVisitsEntity
48		*/
49		public function fetchOneBy(array $where = [])
50		{
51		$queryBuilder = $this->connection->createQueryBuilder()
52		->select('*')
53		->from(self::TABLE)
54		->setMaxResults(1);
55
56		if (count($where) > 0) {
57		foreach ($where as $column => $value) {
58		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
59		}
60		}
61
62		$statement = $queryBuilder->execute();
63
64		$result = $statement->fetch();
65
66		if ($statement->rowCount() === 0) {
67		throw new RecordNotFoundException('Record with given where clause not found');
68		}
69
70		return $this->getEntityFromDatabaseArray($result);
71		}
72
73		/**
74		* @return GeoCacheVisitsEntity[]
75		*/
76		public function fetchBy(array $where = [])
77		{
78		$queryBuilder = $this->connection->createQueryBuilder()
79		->select('*')
80		->from(self::TABLE);
81
82		if (count($where) > 0) {
83		foreach ($where as $column => $value) {
84		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
85		}
86		}
87
88		$statement = $queryBuilder->execute();
89
90		$result = $statement->fetchAll();
91
92		if ($statement->rowCount() === 0) {
93		throw new RecordsNotFoundException('No records with given where clause found');
94		}
95
96		$entities = [];
97
98		foreach ($result as $item) {
99		$entities[] = $this->getEntityFromDatabaseArray($item);
100		}
101
102		return $entities;
103		}
104
105		/**
106		* @return GeoCacheVisitsEntity
107		*/
108		public function create(GeoCacheVisitsEntity $entity)
109		{
110		if (!$entity->isNew()) {
111		throw new RecordAlreadyExistsException('The entity does already exist.');
112		}
113
114		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
115
116		$this->connection->insert(
117		self::TABLE,
118		$databaseArray
119		);
120
121		$entity->cacheId = (int) $this->connection->lastInsertId();
122
123		return $entity;
124		}
125
126		/**
127		* @return GeoCacheVisitsEntity
128		*/
129		public function update(GeoCacheVisitsEntity $entity)
130		{
131		if ($entity->isNew()) {
132		throw new RecordNotPersistedException('The entity does not exist.');
133		}
134
135		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
136
137		$this->connection->update(
138		self::TABLE,
139		$databaseArray,
140		['cache_id' => $entity->cacheId]
141		);
142
143		return $entity;
144		}
145
146		/**
147		* @return GeoCacheVisitsEntity
148		*/
149		public function remove(GeoCacheVisitsEntity $entity)
150		{
151		if ($entity->isNew()) {
152		throw new RecordNotPersistedException('The entity does not exist.');
153		}
154
155		$this->connection->delete(
156		self::TABLE,
157		['cache_id' => $entity->cacheId]
158		);
159
160		$entity->cacheId = null;
161
162		return $entity;
163		}
164
165		/**
166		* @return []
167		*/
168		public function getDatabaseArrayFromEntity(GeoCacheVisitsEntity $entity)
169		{
170		return [
171		'cache_id' => $entity->cacheId,
172		'user_id_ip' => $entity->userIdIp,
173		'count' => $entity->count,
174		'last_modified' => $entity->lastModified,
175		];
176		}
177
178		/**
179		* @return GeoCacheVisitsEntity
180		*/
181		public function getEntityFromDatabaseArray(array $data)
182		{
183		$entity = new GeoCacheVisitsEntity();
184		$entity->cacheId = (int) $data['cache_id'];
185		$entity->userIdIp = (string) $data['user_id_ip'];
186		$entity->count = $data['count'];
187		$entity->lastModified = new DateTime($data['last_modified']);
188
189		return $entity;
190		}
191		}
192

		@@ 9-198 (lines=190) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class NutsLayerRepository
10		{
11		const TABLE = 'nuts_layer';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return NutsLayerEntity[]
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		* @return NutsLayerEntity
48		*/
49		public function fetchOneBy(array $where = [])
50		{
51		$queryBuilder = $this->connection->createQueryBuilder()
52		->select('*')
53		->from(self::TABLE)
54		->setMaxResults(1);
55
56		if (count($where) > 0) {
57		foreach ($where as $column => $value) {
58		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
59		}
60		}
61
62		$statement = $queryBuilder->execute();
63
64		$result = $statement->fetch();
65
66		if ($statement->rowCount() === 0) {
67		throw new RecordNotFoundException('Record with given where clause not found');
68		}
69
70		return $this->getEntityFromDatabaseArray($result);
71		}
72
73		/**
74		* @return NutsLayerEntity[]
75		*/
76		public function fetchBy(array $where = [])
77		{
78		$queryBuilder = $this->connection->createQueryBuilder()
79		->select('*')
80		->from(self::TABLE);
81
82		if (count($where) > 0) {
83		foreach ($where as $column => $value) {
84		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
85		}
86		}
87
88		$statement = $queryBuilder->execute();
89
90		$result = $statement->fetchAll();
91
92		if ($statement->rowCount() === 0) {
93		throw new RecordsNotFoundException('No records with given where clause found');
94		}
95
96		$entities = [];
97
98		foreach ($result as $item) {
99		$entities[] = $this->getEntityFromDatabaseArray($item);
100		}
101
102		return $entities;
103		}
104
105		/**
106		* @return NutsLayerEntity
107		*/
108		public function create(NutsLayerEntity $entity)
109		{
110		if (!$entity->isNew()) {
111		throw new RecordAlreadyExistsException('The entity does already exist.');
112		}
113
114		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
115
116		$this->connection->insert(
117		self::TABLE,
118		$databaseArray
119		);
120
121		$entity->id = (int) $this->connection->lastInsertId();
122
123		return $entity;
124		}
125
126		/**
127		* @return NutsLayerEntity
128		*/
129		public function update(NutsLayerEntity $entity)
130		{
131		if ($entity->isNew()) {
132		throw new RecordNotPersistedException('The entity does not exist.');
133		}
134
135		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
136
137		$this->connection->update(
138		self::TABLE,
139		$databaseArray,
140		['id' => $entity->id]
141		);
142
143		return $entity;
144		}
145
146		/**
147		* @return NutsLayerEntity
148		*/
149		public function remove(NutsLayerEntity $entity)
150		{
151		if ($entity->isNew()) {
152		throw new RecordNotPersistedException('The entity does not exist.');
153		}
154
155		$this->connection->delete(
156		self::TABLE,
157		['id' => $entity->id]
158		);
159
160		$entity->cacheId = null;
161
162		return $entity;
163		}
164
165		/**
166		* @return []
167		*/
168		public function getDatabaseArrayFromEntity(NutsLayerEntity $entity)
169		{
170		return [
171		'id' => $entity->id,
172		'level' => $entity->level,
173		'code' => $entity->code,
174		'shape' => $entity->shape,
175		];
176		}
177
178		/**
179		* @return NutsLayerEntity
180		*/
181		public function getEntityFromDatabaseArray(array $data)
182		{
183		$entity = new NutsLayerEntity();
184		$entity->id = (int) $data['id'];
185		$entity->level = (int) $data['level'];
186		$entity->code = (string) $data['code'];
187		$entity->shape = $data['shape'];
188
189		return $entity;
190		}
191		}
192

		@@ 9-198 (lines=190) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class OkapiCacheRepository
10		{
11		const TABLE = 'okapi_cache';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return OkapiCacheEntity[]
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		* @return OkapiCacheEntity
48		*/
49		public function fetchOneBy(array $where = [])
50		{
51		$queryBuilder = $this->connection->createQueryBuilder()
52		->select('*')
53		->from(self::TABLE)
54		->setMaxResults(1);
55
56		if (count($where) > 0) {
57		foreach ($where as $column => $value) {
58		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
59		}
60		}
61
62		$statement = $queryBuilder->execute();
63
64		$result = $statement->fetch();
65
66		if ($statement->rowCount() === 0) {
67		throw new RecordNotFoundException('Record with given where clause not found');
68		}
69
70		return $this->getEntityFromDatabaseArray($result);
71		}
72
73		/**
74		* @return OkapiCacheEntity[]
75		*/
76		public function fetchBy(array $where = [])
77		{
78		$queryBuilder = $this->connection->createQueryBuilder()
79		->select('*')
80		->from(self::TABLE);
81
82		if (count($where) > 0) {
83		foreach ($where as $column => $value) {
84		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
85		}
86		}
87
88		$statement = $queryBuilder->execute();
89
90		$result = $statement->fetchAll();
91
92		if ($statement->rowCount() === 0) {
93		throw new RecordsNotFoundException('No records with given where clause found');
94		}
95
96		$entities = [];
97
98		foreach ($result as $item) {
99		$entities[] = $this->getEntityFromDatabaseArray($item);
100		}
101
102		return $entities;
103		}
104
105		/**
106		* @return OkapiCacheEntity
107		*/
108		public function create(OkapiCacheEntity $entity)
109		{
110		if (!$entity->isNew()) {
111		throw new RecordAlreadyExistsException('The entity does already exist.');
112		}
113
114		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
115
116		$this->connection->insert(
117		self::TABLE,
118		$databaseArray
119		);
120
121		$entity->key = (int) $this->connection->lastInsertId();
122
123		return $entity;
124		}
125
126		/**
127		* @return OkapiCacheEntity
128		*/
129		public function update(OkapiCacheEntity $entity)
130		{
131		if ($entity->isNew()) {
132		throw new RecordNotPersistedException('The entity does not exist.');
133		}
134
135		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
136
137		$this->connection->update(
138		self::TABLE,
139		$databaseArray,
140		['key' => $entity->key]
141		);
142
143		return $entity;
144		}
145
146		/**
147		* @return OkapiCacheEntity
148		*/
149		public function remove(OkapiCacheEntity $entity)
150		{
151		if ($entity->isNew()) {
152		throw new RecordNotPersistedException('The entity does not exist.');
153		}
154
155		$this->connection->delete(
156		self::TABLE,
157		['key' => $entity->key]
158		);
159
160		$entity->cacheId = null;
161
162		return $entity;
163		}
164
165		/**
166		* @return []
167		*/
168		public function getDatabaseArrayFromEntity(OkapiCacheEntity $entity)
169		{
170		return [
171		'key' => $entity->key,
172		'score' => $entity->score,
173		'expires' => $entity->expires,
174		'value' => $entity->value,
175		];
176		}
177
178		/**
179		* @return OkapiCacheEntity
180		*/
181		public function getEntityFromDatabaseArray(array $data)
182		{
183		$entity = new OkapiCacheEntity();
184		$entity->key = (string) $data['key'];
185		$entity->score = $data['score'];
186		$entity->expires = new DateTime($data['expires']);
187		$entity->value = (string) $data['value'];
188
189		return $entity;
190		}
191		}
192

		@@ 9-198 (lines=190) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class OkapiSearchSetsRepository
10		{
11		const TABLE = 'okapi_search_sets';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return OkapiSearchSetsEntity[]
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		* @return OkapiSearchSetsEntity
48		*/
49		public function fetchOneBy(array $where = [])
50		{
51		$queryBuilder = $this->connection->createQueryBuilder()
52		->select('*')
53		->from(self::TABLE)
54		->setMaxResults(1);
55
56		if (count($where) > 0) {
57		foreach ($where as $column => $value) {
58		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
59		}
60		}
61
62		$statement = $queryBuilder->execute();
63
64		$result = $statement->fetch();
65
66		if ($statement->rowCount() === 0) {
67		throw new RecordNotFoundException('Record with given where clause not found');
68		}
69
70		return $this->getEntityFromDatabaseArray($result);
71		}
72
73		/**
74		* @return OkapiSearchSetsEntity[]
75		*/
76		public function fetchBy(array $where = [])
77		{
78		$queryBuilder = $this->connection->createQueryBuilder()
79		->select('*')
80		->from(self::TABLE);
81
82		if (count($where) > 0) {
83		foreach ($where as $column => $value) {
84		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
85		}
86		}
87
88		$statement = $queryBuilder->execute();
89
90		$result = $statement->fetchAll();
91
92		if ($statement->rowCount() === 0) {
93		throw new RecordsNotFoundException('No records with given where clause found');
94		}
95
96		$entities = [];
97
98		foreach ($result as $item) {
99		$entities[] = $this->getEntityFromDatabaseArray($item);
100		}
101
102		return $entities;
103		}
104
105		/**
106		* @return OkapiSearchSetsEntity
107		*/
108		public function create(OkapiSearchSetsEntity $entity)
109		{
110		if (!$entity->isNew()) {
111		throw new RecordAlreadyExistsException('The entity does already exist.');
112		}
113
114		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
115
116		$this->connection->insert(
117		self::TABLE,
118		$databaseArray
119		);
120
121		$entity->id = (int) $this->connection->lastInsertId();
122
123		return $entity;
124		}
125
126		/**
127		* @return OkapiSearchSetsEntity
128		*/
129		public function update(OkapiSearchSetsEntity $entity)
130		{
131		if ($entity->isNew()) {
132		throw new RecordNotPersistedException('The entity does not exist.');
133		}
134
135		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
136
137		$this->connection->update(
138		self::TABLE,
139		$databaseArray,
140		['id' => $entity->id]
141		);
142
143		return $entity;
144		}
145
146		/**
147		* @return OkapiSearchSetsEntity
148		*/
149		public function remove(OkapiSearchSetsEntity $entity)
150		{
151		if ($entity->isNew()) {
152		throw new RecordNotPersistedException('The entity does not exist.');
153		}
154
155		$this->connection->delete(
156		self::TABLE,
157		['id' => $entity->id]
158		);
159
160		$entity->cacheId = null;
161
162		return $entity;
163		}
164
165		/**
166		* @return []
167		*/
168		public function getDatabaseArrayFromEntity(OkapiSearchSetsEntity $entity)
169		{
170		return [
171		'id' => $entity->id,
172		'params_hash' => $entity->paramsHash,
173		'date_created' => $entity->dateCreated,
174		'expires' => $entity->expires,
175		];
176		}
177
178		/**
179		* @return OkapiSearchSetsEntity
180		*/
181		public function getEntityFromDatabaseArray(array $data)
182		{
183		$entity = new OkapiSearchSetsEntity();
184		$entity->id = (int) $data['id'];
185		$entity->paramsHash = (string) $data['params_hash'];
186		$entity->dateCreated = new DateTime($data['date_created']);
187		$entity->expires = new DateTime($data['expires']);
188
189		return $entity;
190		}
191		}
192

		@@ 9-198 (lines=190) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class SysLoginsRepository
10		{
11		const TABLE = 'sys_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 SysLoginsEntity[]
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		* @return SysLoginsEntity
48		*/
49		public function fetchOneBy(array $where = [])
50		{
51		$queryBuilder = $this->connection->createQueryBuilder()
52		->select('*')
53		->from(self::TABLE)
54		->setMaxResults(1);
55
56		if (count($where) > 0) {
57		foreach ($where as $column => $value) {
58		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
59		}
60		}
61
62		$statement = $queryBuilder->execute();
63
64		$result = $statement->fetch();
65
66		if ($statement->rowCount() === 0) {
67		throw new RecordNotFoundException('Record with given where clause not found');
68		}
69
70		return $this->getEntityFromDatabaseArray($result);
71		}
72
73		/**
74		* @return SysLoginsEntity[]
75		*/
76		public function fetchBy(array $where = [])
77		{
78		$queryBuilder = $this->connection->createQueryBuilder()
79		->select('*')
80		->from(self::TABLE);
81
82		if (count($where) > 0) {
83		foreach ($where as $column => $value) {
84		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
85		}
86		}
87
88		$statement = $queryBuilder->execute();
89
90		$result = $statement->fetchAll();
91
92		if ($statement->rowCount() === 0) {
93		throw new RecordsNotFoundException('No records with given where clause found');
94		}
95
96		$entities = [];
97
98		foreach ($result as $item) {
99		$entities[] = $this->getEntityFromDatabaseArray($item);
100		}
101
102		return $entities;
103		}
104
105		/**
106		* @return SysLoginsEntity
107		*/
108		public function create(SysLoginsEntity $entity)
109		{
110		if (!$entity->isNew()) {
111		throw new RecordAlreadyExistsException('The entity does already exist.');
112		}
113
114		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
115
116		$this->connection->insert(
117		self::TABLE,
118		$databaseArray
119		);
120
121		$entity->id = (int) $this->connection->lastInsertId();
122
123		return $entity;
124		}
125
126		/**
127		* @return SysLoginsEntity
128		*/
129		public function update(SysLoginsEntity $entity)
130		{
131		if ($entity->isNew()) {
132		throw new RecordNotPersistedException('The entity does not exist.');
133		}
134
135		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
136
137		$this->connection->update(
138		self::TABLE,
139		$databaseArray,
140		['id' => $entity->id]
141		);
142
143		return $entity;
144		}
145
146		/**
147		* @return SysLoginsEntity
148		*/
149		public function remove(SysLoginsEntity $entity)
150		{
151		if ($entity->isNew()) {
152		throw new RecordNotPersistedException('The entity does not exist.');
153		}
154
155		$this->connection->delete(
156		self::TABLE,
157		['id' => $entity->id]
158		);
159
160		$entity->cacheId = null;
161
162		return $entity;
163		}
164
165		/**
166		* @return []
167		*/
168		public function getDatabaseArrayFromEntity(SysLoginsEntity $entity)
169		{
170		return [
171		'id' => $entity->id,
172		'date_created' => $entity->dateCreated,
173		'remote_addr' => $entity->remoteAddr,
174		'success' => $entity->success,
175		];
176		}
177
178		/**
179		* @return SysLoginsEntity
180		*/
181		public function getEntityFromDatabaseArray(array $data)
182		{
183		$entity = new SysLoginsEntity();
184		$entity->id = (int) $data['id'];
185		$entity->dateCreated = new DateTime($data['date_created']);
186		$entity->remoteAddr = (string) $data['remote_addr'];
187		$entity->success = (int) $data['success'];
188
189		return $entity;
190		}
191		}
192

		@@ 13-226 (lines=214) @@
10		use Oc\Repository\Exception\RecordsNotFoundException;
11
12
13		class CacheReportReasonsRepository
14		{
15		const TABLE = 'cache_report_reasons';
16
17		/**
18		* @var Connection
19		*/
20		private $connection;
21
22		/**
23		* CacheReportReasonsRepository constructor.
24		*
25		* @param Connection $connection
26		*/
27		public function __construct(Connection $connection)
28		{
29		$this->connection = $connection;
30		}
31
32		/**
33		* @return array
34		* @throws RecordsNotFoundException
35		*/
36		public function fetchAll()
37		{
38		$statement = $this->connection->createQueryBuilder()
39		->select('*')
40		->from(self::TABLE)
41		->execute();
42
43		$result = $statement->fetchAll();
44
45		if ($statement->rowCount() === 0) {
46		throw new RecordsNotFoundException('No records found');
47		}
48
49		$records = [];
50
51		foreach ($result as $item) {
52		$records[] = $this->getEntityFromDatabaseArray($item);
53		}
54
55		return $records;
56		}
57
58		/**
59		* @param array $where
60		*
61		* @return GeoCacheReportReasonsEntity
62		* @throws RecordNotFoundException
63		*/
64		public function fetchOneBy(array $where = [])
65		{
66		$queryBuilder = $this->connection->createQueryBuilder()
67		->select('*')
68		->from(self::TABLE)
69		->setMaxResults(1);
70
71		if (count($where) > 0) {
72		foreach ($where as $column => $value) {
73		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
74		}
75		}
76
77		$statement = $queryBuilder->execute();
78
79		$result = $statement->fetch();
80
81		if ($statement->rowCount() === 0) {
82		throw new RecordNotFoundException('Record with given where clause not found');
83		}
84
85		return $this->getEntityFromDatabaseArray($result);
86		}
87
88		/**
89		* @param array $where
90		*
91		* @return array
92		* @throws RecordsNotFoundException
93		*/
94		public function fetchBy(array $where = [])
95		{
96		$queryBuilder = $this->connection->createQueryBuilder()
97		->select('*')
98		->from(self::TABLE);
99
100		if (count($where) > 0) {
101		foreach ($where as $column => $value) {
102		$queryBuilder->andWhere($column . ' = ' . $queryBuilder->createNamedParameter($value));
103		}
104		}
105
106		$statement = $queryBuilder->execute();
107
108		$result = $statement->fetchAll();
109
110		if ($statement->rowCount() === 0) {
111		throw new RecordsNotFoundException('No records with given where clause found');
112		}
113
114		$entities = [];
115
116		foreach ($result as $item) {
117		$entities[] = $this->getEntityFromDatabaseArray($item);
118		}
119
120		return $entities;
121		}
122
123		/**
124		* @param GeoCacheReportReasonsEntity $entity
125		*
126		* @return GeoCacheReportReasonsEntity
127		* @throws RecordAlreadyExistsException
128		* @throws \Doctrine\DBAL\DBALException
129		*/
130		public function create(GeoCacheReportReasonsEntity $entity)
131		{
132		if (!$entity->isNew()) {
133		throw new RecordAlreadyExistsException('The entity does already exist.');
134		}
135
136		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
137
138		$this->connection->insert(
139		self::TABLE,
140		$databaseArray
141		);
142
143		$entity->id = (int) $this->connection->lastInsertId();
144
145		return $entity;
146		}
147
148		/**
149		* @param GeoCacheReportReasonsEntity $entity
150		*
151		* @return GeoCacheReportReasonsEntity
152		* @throws RecordNotPersistedException
153		* @throws \Doctrine\DBAL\DBALException
154		*/
155		public function update(GeoCacheReportReasonsEntity $entity)
156		{
157		if ($entity->isNew()) {
158		throw new RecordNotPersistedException('The entity does not exist.');
159		}
160
161		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
162
163		$this->connection->update(
164		self::TABLE,
165		$databaseArray,
166		['id' => $entity->id]
167		);
168
169		return $entity;
170		}
171
172		/**
173		* @param GeoCacheReportReasonsEntity $entity
174		*
175		* @return GeoCacheReportReasonsEntity
176		* @throws RecordNotPersistedException
177		* @throws \Doctrine\DBAL\DBALException
178		* @throws \Doctrine\DBAL\Exception\InvalidArgumentException
179		*/
180		public function remove(GeoCacheReportReasonsEntity $entity)
181		{
182		if ($entity->isNew()) {
183		throw new RecordNotPersistedException('The entity does not exist.');
184		}
185
186		$this->connection->delete(
187		self::TABLE,
188		['id' => $entity->id]
189		);
190
191		$entity->cacheId = null;
192
193		return $entity;
194		}
195
196		/**
197		* @param GeoCacheReportReasonsEntity $entity
198		*
199		* @return array
200		*/
201		public function getDatabaseArrayFromEntity(GeoCacheReportReasonsEntity $entity)
202		{
203		return [
204		'id' => $entity->id,
205		'name' => $entity->name,
206		'trans_id' => $entity->transId,
207		'order' => $entity->order,
208		];
209		}
210
211		/**
212		* @param array $data
213		*
214		* @return GeoCacheReportReasonsEntity
215		*/
216		public function getEntityFromDatabaseArray(array $data)
217		{
218		$entity = new GeoCacheReportReasonsEntity();
219		$entity->id = (int) $data['id'];
220		$entity->name = (string) $data['name'];
221		$entity->transId = (int) $data['trans_id'];
222		$entity->order = (int) $data['order'];
223
224		return $entity;
225		}
226		}
227

OpencachingDeutschland / oc-server3

Code Duplication Length = 190-214 lines in 8 locations

local/devel/Repositories/CacheVisitsRepository.php 1 location

local/devel/Repositories/NutsLayerRepository.php 1 location

local/devel/Repositories/OkapiCacheRepository.php 1 location

local/devel/Repositories/OkapiSearchSetsRepository.php 1 location

local/devel/Repositories/SysLoginsRepository.php 1 location

local/devel/Repositories/SysSessionsRepository.php 1 location

local/devel/Repositories/SysTransTextRepository.php 1 location

htdocs_symfony/src/Repository/CacheReportReasonsRepository.php 1 location