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

Code Duplication Length = 194-194 lines in 10 locations

local/devel/Repositories/CacheSizeRepository.php 1 location


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

class CacheSizeRepository
{
    const TABLE = 'cache_size';

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

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

    /**
     * @return GeoCacheSizeEntity[]
     */
    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 GeoCacheSizeEntity
     */
    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 GeoCacheSizeEntity[]
     */
    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 GeoCacheSizeEntity $entity
     * @return GeoCacheSizeEntity
     */
    public function create(GeoCacheSizeEntity $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 GeoCacheSizeEntity $entity
     * @return GeoCacheSizeEntity
     */
    public function update(GeoCacheSizeEntity $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 GeoCacheSizeEntity $entity
     * @return GeoCacheSizeEntity
     */
    public function remove(GeoCacheSizeEntity $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 GeoCacheSizeEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheSizeEntity $entity)
    {
        return [
        'id' => $entity->id,
        'name' => $entity->name,
        'trans_id' => $entity->transId,
        'ordinal' => $entity->ordinal,
        'de' => $entity->de,
        'en' => $entity->en,
        ];
    }

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

        return $entity;
    }
}


local/devel/Repositories/CoordinatesTypeRepository.php 1 location


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

class CoordinatesTypeRepository
{
    const TABLE = 'coordinates_type';

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

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

    /**
     * @return CoordinatesTypeEntity[]
     */
    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 CoordinatesTypeEntity
     */
    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 CoordinatesTypeEntity[]
     */
    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 CoordinatesTypeEntity $entity
     * @return CoordinatesTypeEntity
     */
    public function create(CoordinatesTypeEntity $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 CoordinatesTypeEntity $entity
     * @return CoordinatesTypeEntity
     */
    public function update(CoordinatesTypeEntity $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 CoordinatesTypeEntity $entity
     * @return CoordinatesTypeEntity
     */
    public function remove(CoordinatesTypeEntity $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 CoordinatesTypeEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(CoordinatesTypeEntity $entity)
    {
        return [
        'id' => $entity->id,
        'name' => $entity->name,
        'trans_id' => $entity->transId,
        'image' => $entity->image,
        'preposition' => $entity->preposition,
        'pp_trans_id' => $entity->ppTransId,
        ];
    }

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

        return $entity;
    }
}


local/devel/Repositories/CountriesOptionsRepository.php 1 location


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

class CountriesOptionsRepository
{
    const TABLE = 'countries_options';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param CountriesOptionsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(CountriesOptionsEntity $entity)
    {
        return [
        'country' => $entity->country,
        'display' => $entity->display,
        'gmLat' => $entity->gmLat,
        'gmLon' => $entity->gmLon,
        'gmZoom' => $entity->gmZoom,
        'nodeId' => $entity->nodeId,
        ];
    }

    /**
     * @param array $data
     * @return CountriesOptionsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new CountriesOptionsEntity();
        $entity->country = (string) $data['country'];
        $entity->display = (int) $data['display'];
        $entity->gmLat = $data['gmLat'];
        $entity->gmLon = $data['gmLon'];
        $entity->gmZoom = (int) $data['gmZoom'];
        $entity->nodeId = (int) $data['nodeId'];

        return $entity;
    }
}


local/devel/Repositories/FieldNoteRepository.php 1 location


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

class FieldNoteRepository
{
    const TABLE = 'field_note';

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

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

    /**
     * @return FieldNoteEntity[]
     */
    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 FieldNoteEntity
     */
    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 FieldNoteEntity[]
     */
    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 FieldNoteEntity $entity
     * @return FieldNoteEntity
     */
    public function create(FieldNoteEntity $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 FieldNoteEntity $entity
     * @return FieldNoteEntity
     */
    public function update(FieldNoteEntity $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 FieldNoteEntity $entity
     * @return FieldNoteEntity
     */
    public function remove(FieldNoteEntity $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 FieldNoteEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(FieldNoteEntity $entity)
    {
        return [
        'id' => $entity->id,
        'user_id' => $entity->userId,
        'geocache_id' => $entity->geocacheId,
        'type' => $entity->type,
        'date' => $entity->date,
        'text' => $entity->text,
        ];
    }

    /**
     * @param array $data
     * @return FieldNoteEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new FieldNoteEntity();
        $entity->id = (int) $data['id'];
        $entity->userId = (int) $data['user_id'];
        $entity->geocacheId = (int) $data['geocache_id'];
        $entity->type = $data['type'];
        $entity->date =  new DateTime($data['date']);
        $entity->text = (string) $data['text'];

        return $entity;
    }
}


local/devel/Repositories/OkapiStatsTempRepository.php 1 location


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

class OkapiStatsTempRepository
{
    const TABLE = 'okapi_stats_temp';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param OkapiStatsTempEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(OkapiStatsTempEntity $entity)
    {
        return [
        'datetime' => $entity->datetime,
        'consumer_key' => $entity->consumerKey,
        'user_id' => $entity->userId,
        'service_name' => $entity->serviceName,
        'calltype' => $entity->calltype,
        'runtime' => $entity->runtime,
        ];
    }

    /**
     * @param array $data
     * @return OkapiStatsTempEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new OkapiStatsTempEntity();
        $entity->datetime =  new DateTime($data['datetime']);
        $entity->consumerKey = (string) $data['consumer_key'];
        $entity->userId = (int) $data['user_id'];
        $entity->serviceName = (string) $data['service_name'];
        $entity->calltype = $data['calltype'];
        $entity->runtime = $data['runtime'];

        return $entity;
    }
}


local/devel/Repositories/RemovedObjectsRepository.php 1 location


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

class RemovedObjectsRepository
{
    const TABLE = 'removed_objects';

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

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

    /**
     * @return RemovedObjectsEntity[]
     */
    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 RemovedObjectsEntity
     */
    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 RemovedObjectsEntity[]
     */
    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 RemovedObjectsEntity $entity
     * @return RemovedObjectsEntity
     */
    public function create(RemovedObjectsEntity $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 RemovedObjectsEntity $entity
     * @return RemovedObjectsEntity
     */
    public function update(RemovedObjectsEntity $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 RemovedObjectsEntity $entity
     * @return RemovedObjectsEntity
     */
    public function remove(RemovedObjectsEntity $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 RemovedObjectsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(RemovedObjectsEntity $entity)
    {
        return [
        'id' => $entity->id,
        'localID' => $entity->localID,
        'uuid' => $entity->uuid,
        'type' => $entity->type,
        'removed_date' => $entity->removedDate,
        'node' => $entity->node,
        ];
    }

    /**
     * @param array $data
     * @return RemovedObjectsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new RemovedObjectsEntity();
        $entity->id = (int) $data['id'];
        $entity->localID = (int) $data['localID'];
        $entity->uuid = (string) $data['uuid'];
        $entity->type = (int) $data['type'];
        $entity->removedDate =  new DateTime($data['removed_date']);
        $entity->node = (int) $data['node'];

        return $entity;
    }
}


local/devel/Repositories/SavedTextsRepository.php 1 location


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

class SavedTextsRepository
{
    const TABLE = 'saved_texts';

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

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

    /**
     * @return SavedTextsEntity[]
     */
    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 SavedTextsEntity
     */
    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 SavedTextsEntity[]
     */
    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 SavedTextsEntity $entity
     * @return SavedTextsEntity
     */
    public function create(SavedTextsEntity $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 SavedTextsEntity $entity
     * @return SavedTextsEntity
     */
    public function update(SavedTextsEntity $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 SavedTextsEntity $entity
     * @return SavedTextsEntity
     */
    public function remove(SavedTextsEntity $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 SavedTextsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(SavedTextsEntity $entity)
    {
        return [
        'id' => $entity->id,
        'date_created' => $entity->dateCreated,
        'object_type' => $entity->objectType,
        'object_id' => $entity->objectId,
        'subtype' => $entity->subtype,
        'text' => $entity->text,
        ];
    }

    /**
     * @param array $data
     * @return SavedTextsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new SavedTextsEntity();
        $entity->id = (int) $data['id'];
        $entity->dateCreated =  new DateTime($data['date_created']);
        $entity->objectType = (int) $data['object_type'];
        $entity->objectId = (int) $data['object_id'];
        $entity->subtype = (int) $data['subtype'];
        $entity->text = (string) $data['text'];

        return $entity;
    }
}


local/devel/Repositories/StatpicsRepository.php 1 location


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

class StatpicsRepository
{
    const TABLE = 'statpics';

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

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

    /**
     * @return StatpicsEntity[]
     */
    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 StatpicsEntity
     */
    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 StatpicsEntity[]
     */
    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 StatpicsEntity $entity
     * @return StatpicsEntity
     */
    public function create(StatpicsEntity $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 StatpicsEntity $entity
     * @return StatpicsEntity
     */
    public function update(StatpicsEntity $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 StatpicsEntity $entity
     * @return StatpicsEntity
     */
    public function remove(StatpicsEntity $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 StatpicsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(StatpicsEntity $entity)
    {
        return [
        'id' => $entity->id,
        'tplpath' => $entity->tplpath,
        'previewpath' => $entity->previewpath,
        'description' => $entity->description,
        'trans_id' => $entity->transId,
        'maxtextwidth' => $entity->maxtextwidth,
        ];
    }

    /**
     * @param array $data
     * @return StatpicsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new StatpicsEntity();
        $entity->id = (int) $data['id'];
        $entity->tplpath = (string) $data['tplpath'];
        $entity->previewpath = (string) $data['previewpath'];
        $entity->description = (string) $data['description'];
        $entity->transId = (int) $data['trans_id'];
        $entity->maxtextwidth = (int) $data['maxtextwidth'];

        return $entity;
    }
}


local/devel/Repositories/TownsRepository.php 1 location


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

class TownsRepository
{
    const TABLE = 'towns';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param TownsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(TownsEntity $entity)
    {
        return [
        'country' => $entity->country,
        'name' => $entity->name,
        'trans_id' => $entity->transId,
        'coord_lat' => $entity->coordLat,
        'coord_long' => $entity->coordLong,
        'maplist' => $entity->maplist,
        ];
    }

    /**
     * @param array $data
     * @return TownsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new TownsEntity();
        $entity->country = (string) $data['country'];
        $entity->name = (string) $data['name'];
        $entity->transId = (int) $data['trans_id'];
        $entity->coordLat = $data['coord_lat'];
        $entity->coordLong = $data['coord_long'];
        $entity->maplist = (int) $data['maplist'];

        return $entity;
    }
}


local/devel/Repositories/WaypointReportsRepository.php 1 location


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

class WaypointReportsRepository
{
    const TABLE = 'waypoint_reports';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param WaypointReportsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(WaypointReportsEntity $entity)
    {
        return [
        'report_id' => $entity->reportId,
        'date_reported' => $entity->dateReported,
        'wp_oc' => $entity->wpOc,
        'wp_external' => $entity->wpExternal,
        'source' => $entity->source,
        'gcwp_processed' => $entity->gcwpProcessed,
        ];
    }

    /**
     * @param array $data
     * @return WaypointReportsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new WaypointReportsEntity();
        $entity->reportId = (int) $data['report_id'];
        $entity->dateReported =  new DateTime($data['date_reported']);
        $entity->wpOc = (string) $data['wp_oc'];
        $entity->wpExternal = (string) $data['wp_external'];
        $entity->source = (string) $data['source'];
        $entity->gcwpProcessed = (int) $data['gcwp_processed'];

        return $entity;
    }
}


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

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

		@@ 9-202 (lines=194) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class CountriesOptionsRepository
10		{
11		const TABLE = 'countries_options';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return CountriesOptionsEntity[]
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 CountriesOptionsEntity
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 CountriesOptionsEntity[]
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 CountriesOptionsEntity $entity
109		* @return CountriesOptionsEntity
110		*/
111		public function create(CountriesOptionsEntity $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->country = (int) $this->connection->lastInsertId();
125
126		return $entity;
127		}
128
129		/**
130		* @param CountriesOptionsEntity $entity
131		* @return CountriesOptionsEntity
132		*/
133		public function update(CountriesOptionsEntity $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		['country' => $entity->country]
145		);
146
147		return $entity;
148		}
149
150		/**
151		* @param CountriesOptionsEntity $entity
152		* @return CountriesOptionsEntity
153		*/
154		public function remove(CountriesOptionsEntity $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		['country' => $entity->country]
163		);
164
165		$entity->cacheId = null;
166
167		return $entity;
168		}
169
170		/**
171		* @param CountriesOptionsEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(CountriesOptionsEntity $entity)
175		{
176		return [
177		'country' => $entity->country,
178		'display' => $entity->display,
179		'gmLat' => $entity->gmLat,
180		'gmLon' => $entity->gmLon,
181		'gmZoom' => $entity->gmZoom,
182		'nodeId' => $entity->nodeId,
183		];
184		}
185
186		/**
187		* @param array $data
188		* @return CountriesOptionsEntity
189		*/
190		public function getEntityFromDatabaseArray(array $data)
191		{
192		$entity = new CountriesOptionsEntity();
193		$entity->country = (string) $data['country'];
194		$entity->display = (int) $data['display'];
195		$entity->gmLat = $data['gmLat'];
196		$entity->gmLon = $data['gmLon'];
197		$entity->gmZoom = (int) $data['gmZoom'];
198		$entity->nodeId = (int) $data['nodeId'];
199
200		return $entity;
201		}
202		}
203

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

		@@ 9-202 (lines=194) @@
6		use Oc\Repository\Exception\RecordNotPersistedException;
7		use Oc\Repository\Exception\RecordsNotFoundException;
8
9		class OkapiStatsTempRepository
10		{
11		const TABLE = 'okapi_stats_temp';
12
13		/** @var Connection */
14		private $connection;
15
16		public function __construct(Connection $connection)
17		{
18		$this->connection = $connection;
19		}
20
21		/**
22		* @return OkapiStatsTempEntity[]
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 OkapiStatsTempEntity
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 OkapiStatsTempEntity[]
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 OkapiStatsTempEntity $entity
109		* @return OkapiStatsTempEntity
110		*/
111		public function create(OkapiStatsTempEntity $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->datetime = (int) $this->connection->lastInsertId();
125
126		return $entity;
127		}
128
129		/**
130		* @param OkapiStatsTempEntity $entity
131		* @return OkapiStatsTempEntity
132		*/
133		public function update(OkapiStatsTempEntity $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		['datetime' => $entity->datetime]
145		);
146
147		return $entity;
148		}
149
150		/**
151		* @param OkapiStatsTempEntity $entity
152		* @return OkapiStatsTempEntity
153		*/
154		public function remove(OkapiStatsTempEntity $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		['datetime' => $entity->datetime]
163		);
164
165		$entity->cacheId = null;
166
167		return $entity;
168		}
169
170		/**
171		* @param OkapiStatsTempEntity $entity
172		* @return []
173		*/
174		public function getDatabaseArrayFromEntity(OkapiStatsTempEntity $entity)
175		{
176		return [
177		'datetime' => $entity->datetime,
178		'consumer_key' => $entity->consumerKey,
179		'user_id' => $entity->userId,
180		'service_name' => $entity->serviceName,
181		'calltype' => $entity->calltype,
182		'runtime' => $entity->runtime,
183		];
184		}
185
186		/**
187		* @param array $data
188		* @return OkapiStatsTempEntity
189		*/
190		public function getEntityFromDatabaseArray(array $data)
191		{
192		$entity = new OkapiStatsTempEntity();
193		$entity->datetime = new DateTime($data['datetime']);
194		$entity->consumerKey = (string) $data['consumer_key'];
195		$entity->userId = (int) $data['user_id'];
196		$entity->serviceName = (string) $data['service_name'];
197		$entity->calltype = $data['calltype'];
198		$entity->runtime = $data['runtime'];
199
200		return $entity;
201		}
202		}
203

OpencachingDeutschland / oc-server3

Code Duplication Length = 194-194 lines in 10 locations

local/devel/Repositories/CacheSizeRepository.php 1 location

local/devel/Repositories/CoordinatesTypeRepository.php 1 location

local/devel/Repositories/CountriesOptionsRepository.php 1 location

local/devel/Repositories/FieldNoteRepository.php 1 location

local/devel/Repositories/OkapiStatsTempRepository.php 1 location

local/devel/Repositories/RemovedObjectsRepository.php 1 location

local/devel/Repositories/SavedTextsRepository.php 1 location

local/devel/Repositories/StatpicsRepository.php 1 location

local/devel/Repositories/TownsRepository.php 1 location

local/devel/Repositories/WaypointReportsRepository.php 1 location