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

Code Duplication Length = 190-190 lines in 7 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;
    }

    /**
     * @param array $where
     * @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);
    }

    /**
     * @param array $where
     * @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;
    }

    /**
     * @param GeoCacheVisitsEntity $entity
     * @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;
    }

    /**
     * @param GeoCacheVisitsEntity $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;
    }

    /**
     * @param GeoCacheVisitsEntity $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;
    }

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

    /**
     * @param array $data
     * @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;
    }

    /**
     * @param array $where
     * @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);
    }

    /**
     * @param array $where
     * @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;
    }

    /**
     * @param NutsLayerEntity $entity
     * @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;
    }

    /**
     * @param NutsLayerEntity $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;
    }

    /**
     * @param NutsLayerEntity $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;
    }

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

    /**
     * @param array $data
     * @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;
    }

    /**
     * @param array $where
     * @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);
    }

    /**
     * @param array $where
     * @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;
    }

    /**
     * @param OkapiCacheEntity $entity
     * @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;
    }

    /**
     * @param OkapiCacheEntity $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;
    }

    /**
     * @param OkapiCacheEntity $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;
    }

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

    /**
     * @param array $data
     * @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;
    }

    /**
     * @param array $where
     * @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);
    }

    /**
     * @param array $where
     * @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;
    }

    /**
     * @param OkapiSearchSetsEntity $entity
     * @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;
    }

    /**
     * @param OkapiSearchSetsEntity $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;
    }

    /**
     * @param OkapiSearchSetsEntity $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;
    }

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

    /**
     * @param array $data
     * @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;
    }

    /**
     * @param array $where
     * @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);
    }

    /**
     * @param array $where
     * @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;
    }

    /**
     * @param SysLoginsEntity $entity
     * @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;
    }

    /**
     * @param SysLoginsEntity $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;
    }

    /**
     * @param SysLoginsEntity $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;
    }

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

    /**
     * @param array $data
     * @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;
    }

    /**
     * @param array $where
     * @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);
    }

    /**
     * @param array $where
     * @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;
    }

    /**
     * @param SysSessionsEntity $entity
     * @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;
    }

    /**
     * @param SysSessionsEntity $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;
    }

    /**
     * @param SysSessionsEntity $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;
    }

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

    /**
     * @param array $data
     * @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;
    }

    /**
     * @param array $where
     * @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);
    }

    /**
     * @param array $where
     * @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;
    }

    /**
     * @param SysTransTextEntity $entity
     * @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;
    }

    /**
     * @param SysTransTextEntity $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;
    }

    /**
     * @param SysTransTextEntity $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;
    }

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

    /**
     * @param array $data
     * @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;
    }
}


		@@ 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		* @param array $where
48		* @return GeoCacheVisitsEntity
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 GeoCacheVisitsEntity[]
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 GeoCacheVisitsEntity $entity
109		* @return GeoCacheVisitsEntity
110		*/
111		public function create(GeoCacheVisitsEntity $entity)
112		{
113		if (!$entity->isNew()) {
114		throw new RecordAlreadyExistsException('The entity does already exist.');
115		}
116
117		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
118
119		$this->connection->insert(
120		self::TABLE,
121		$databaseArray
122		);
123
124		$entity->cacheId = (int) $this->connection->lastInsertId();
125
126		return $entity;
127		}
128
129		/**
130		* @param GeoCacheVisitsEntity $entity
131		* @return GeoCacheVisitsEntity
132		*/
133		public function update(GeoCacheVisitsEntity $entity)
134		{
135		if ($entity->isNew()) {
136		throw new RecordNotPersistedException('The entity does not exist.');
137		}
138
139		$databaseArray = $this->getDatabaseArrayFromEntity($entity);
140
141		$this->connection->update(
142		self::TABLE,
143		$databaseArray,
144		['cache_id' => $entity->cacheId]
145		);
146
147		return $entity;
148		}
149
150		/**
151		* @param GeoCacheVisitsEntity $entity
152		* @return GeoCacheVisitsEntity
153		*/
154		public function remove(GeoCacheVisitsEntity $entity)
155		{
156		if ($entity->isNew()) {
157		throw new RecordNotPersistedException('The entity does not exist.');
158		}
159
160		$this->connection->delete(
161		self::TABLE,
162		['cache_id' => $entity->cacheId]
163		);
164
165		$entity->cacheId = null;
166
167		return $entity;
168		}
169
170		/**
171		* @param GeoCacheVisitsEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(GeoCacheVisitsEntity $entity)
175		{
176		return [
177		'cache_id' => $entity->cacheId,
178		'user_id_ip' => $entity->userIdIp,
179		'count' => $entity->count,
180		'last_modified' => $entity->lastModified,
181		];
182		}
183
184		/**
185		* @param array $data
186		* @return GeoCacheVisitsEntity
187		*/
188		public function getEntityFromDatabaseArray(array $data)
189		{
190		$entity = new GeoCacheVisitsEntity();
191		$entity->cacheId = (int) $data['cache_id'];
192		$entity->userIdIp = (string) $data['user_id_ip'];
193		$entity->count = $data['count'];
194		$entity->lastModified = new DateTime($data['last_modified']);
195
196		return $entity;
197		}
198		}
199

		@@ 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		* @param array $where
48		* @return NutsLayerEntity
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 NutsLayerEntity[]
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 NutsLayerEntity $entity
109		* @return NutsLayerEntity
110		*/
111		public function create(NutsLayerEntity $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 NutsLayerEntity $entity
131		* @return NutsLayerEntity
132		*/
133		public function update(NutsLayerEntity $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 NutsLayerEntity $entity
152		* @return NutsLayerEntity
153		*/
154		public function remove(NutsLayerEntity $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 NutsLayerEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(NutsLayerEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'level' => $entity->level,
179		'code' => $entity->code,
180		'shape' => $entity->shape,
181		];
182		}
183
184		/**
185		* @param array $data
186		* @return NutsLayerEntity
187		*/
188		public function getEntityFromDatabaseArray(array $data)
189		{
190		$entity = new NutsLayerEntity();
191		$entity->id = (int) $data['id'];
192		$entity->level = (int) $data['level'];
193		$entity->code = (string) $data['code'];
194		$entity->shape = $data['shape'];
195
196		return $entity;
197		}
198		}
199

		@@ 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		* @param array $where
48		* @return OkapiCacheEntity
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 OkapiCacheEntity[]
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 OkapiCacheEntity $entity
109		* @return OkapiCacheEntity
110		*/
111		public function create(OkapiCacheEntity $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->key = (int) $this->connection->lastInsertId();
125
126		return $entity;
127		}
128
129		/**
130		* @param OkapiCacheEntity $entity
131		* @return OkapiCacheEntity
132		*/
133		public function update(OkapiCacheEntity $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		['key' => $entity->key]
145		);
146
147		return $entity;
148		}
149
150		/**
151		* @param OkapiCacheEntity $entity
152		* @return OkapiCacheEntity
153		*/
154		public function remove(OkapiCacheEntity $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		['key' => $entity->key]
163		);
164
165		$entity->cacheId = null;
166
167		return $entity;
168		}
169
170		/**
171		* @param OkapiCacheEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(OkapiCacheEntity $entity)
175		{
176		return [
177		'key' => $entity->key,
178		'score' => $entity->score,
179		'expires' => $entity->expires,
180		'value' => $entity->value,
181		];
182		}
183
184		/**
185		* @param array $data
186		* @return OkapiCacheEntity
187		*/
188		public function getEntityFromDatabaseArray(array $data)
189		{
190		$entity = new OkapiCacheEntity();
191		$entity->key = (string) $data['key'];
192		$entity->score = $data['score'];
193		$entity->expires = new DateTime($data['expires']);
194		$entity->value = (string) $data['value'];
195
196		return $entity;
197		}
198		}
199

		@@ 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		* @param array $where
48		* @return OkapiSearchSetsEntity
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 OkapiSearchSetsEntity[]
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 OkapiSearchSetsEntity $entity
109		* @return OkapiSearchSetsEntity
110		*/
111		public function create(OkapiSearchSetsEntity $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 OkapiSearchSetsEntity $entity
131		* @return OkapiSearchSetsEntity
132		*/
133		public function update(OkapiSearchSetsEntity $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 OkapiSearchSetsEntity $entity
152		* @return OkapiSearchSetsEntity
153		*/
154		public function remove(OkapiSearchSetsEntity $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 OkapiSearchSetsEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(OkapiSearchSetsEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'params_hash' => $entity->paramsHash,
179		'date_created' => $entity->dateCreated,
180		'expires' => $entity->expires,
181		];
182		}
183
184		/**
185		* @param array $data
186		* @return OkapiSearchSetsEntity
187		*/
188		public function getEntityFromDatabaseArray(array $data)
189		{
190		$entity = new OkapiSearchSetsEntity();
191		$entity->id = (int) $data['id'];
192		$entity->paramsHash = (string) $data['params_hash'];
193		$entity->dateCreated = new DateTime($data['date_created']);
194		$entity->expires = new DateTime($data['expires']);
195
196		return $entity;
197		}
198		}
199

		@@ 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		* @param array $where
48		* @return SysLoginsEntity
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 SysLoginsEntity[]
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 SysLoginsEntity $entity
109		* @return SysLoginsEntity
110		*/
111		public function create(SysLoginsEntity $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 SysLoginsEntity $entity
131		* @return SysLoginsEntity
132		*/
133		public function update(SysLoginsEntity $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 SysLoginsEntity $entity
152		* @return SysLoginsEntity
153		*/
154		public function remove(SysLoginsEntity $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 SysLoginsEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(SysLoginsEntity $entity)
175		{
176		return [
177		'id' => $entity->id,
178		'date_created' => $entity->dateCreated,
179		'remote_addr' => $entity->remoteAddr,
180		'success' => $entity->success,
181		];
182		}
183
184		/**
185		* @param array $data
186		* @return SysLoginsEntity
187		*/
188		public function getEntityFromDatabaseArray(array $data)
189		{
190		$entity = new SysLoginsEntity();
191		$entity->id = (int) $data['id'];
192		$entity->dateCreated = new DateTime($data['date_created']);
193		$entity->remoteAddr = (string) $data['remote_addr'];
194		$entity->success = (int) $data['success'];
195
196		return $entity;
197		}
198		}
199

OpencachingDeutschland / oc-server3

Code Duplication Length = 190-190 lines in 7 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