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

Code Duplication Length = 188-212 lines in 14 locations

local/devel/Repositories/CacheListBookmarksRepository.php 1 location


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

class CacheListBookmarksRepository
{
    const TABLE = 'cache_list_bookmarks';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheListBookmarksEntity $entity)
    {
        return [
            'cache_list_id' => $entity->cacheListId,
            'user_id' => $entity->userId,
            'password' => $entity->password,
        ];
    }

    /**
     * @return GeoCacheListBookmarksEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeoCacheListBookmarksEntity();
        $entity->cacheListId = (int) $data['cache_list_id'];
        $entity->userId = (int) $data['user_id'];
        $entity->password = (string) $data['password'];

        return $entity;
    }
}


local/devel/Repositories/CacheReportStatusRepository.php 1 location


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

class CacheReportStatusRepository
{
    const TABLE = 'cache_report_status';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeoCacheReportStatusEntity $entity)
    {
        return [
            'id' => $entity->id,
            'name' => $entity->name,
            'trans_id' => $entity->transId,
        ];
    }

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

        return $entity;
    }
}


local/devel/Repositories/GeodbTypeNamesRepository.php 1 location


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

class GeodbTypeNamesRepository
{
    const TABLE = 'geodb_type_names';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(GeodbTypeNamesEntity $entity)
    {
        return [
            'type_id' => $entity->typeId,
            'type_locale' => $entity->typeLocale,
            'name' => $entity->name,
        ];
    }

    /**
     * @return GeodbTypeNamesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new GeodbTypeNamesEntity();
        $entity->typeId = (int) $data['type_id'];
        $entity->typeLocale = (string) $data['type_locale'];
        $entity->name = (string) $data['name'];

        return $entity;
    }
}


local/devel/Repositories/HelppagesRepository.php 1 location


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

class HelppagesRepository
{
    const TABLE = 'helppages';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(HelppagesEntity $entity)
    {
        return [
            'ocpage' => $entity->ocpage,
            'language' => $entity->language,
            'helppage' => $entity->helppage,
        ];
    }

    /**
     * @return HelppagesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new HelppagesEntity();
        $entity->ocpage = (string) $data['ocpage'];
        $entity->language = (string) $data['language'];
        $entity->helppage = (string) $data['helppage'];

        return $entity;
    }
}


local/devel/Repositories/LogentriesTypesRepository.php 1 location


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

class LogentriesTypesRepository
{
    const TABLE = 'logentries_types';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(LogentriesTypesEntity $entity)
    {
        return [
            'id' => $entity->id,
            'module' => $entity->module,
            'eventname' => $entity->eventname,
        ];
    }

    /**
     * @return LogentriesTypesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new LogentriesTypesEntity();
        $entity->id = (int) $data['id'];
        $entity->module = (string) $data['module'];
        $entity->eventname = (string) $data['eventname'];

        return $entity;
    }
}


local/devel/Repositories/OkapiAuthorizationsRepository.php 1 location


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

class OkapiAuthorizationsRepository
{
    const TABLE = 'okapi_authorizations';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(OkapiAuthorizationsEntity $entity)
    {
        return [
            'consumer_key' => $entity->consumerKey,
            'user_id' => $entity->userId,
            'last_access_token' => $entity->lastAccessToken,
        ];
    }

    /**
     * @return OkapiAuthorizationsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new OkapiAuthorizationsEntity();
        $entity->consumerKey = (string) $data['consumer_key'];
        $entity->userId = (int) $data['user_id'];
        $entity->lastAccessToken = new DateTime($data['last_access_token']);

        return $entity;
    }
}


local/devel/Repositories/OkapiNoncesRepository.php 1 location


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

class OkapiNoncesRepository
{
    const TABLE = 'okapi_nonces';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(OkapiNoncesEntity $entity)
    {
        return [
            'consumer_key' => $entity->consumerKey,
            'nonce_hash' => $entity->nonceHash,
            'timestamp' => $entity->timestamp,
        ];
    }

    /**
     * @return OkapiNoncesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new OkapiNoncesEntity();
        $entity->consumerKey = (string) $data['consumer_key'];
        $entity->nonceHash = (string) $data['nonce_hash'];
        $entity->timestamp = (int) $data['timestamp'];

        return $entity;
    }
}


local/devel/Repositories/OkapiSubmittedObjectsRepository.php 1 location


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

class OkapiSubmittedObjectsRepository
{
    const TABLE = 'okapi_submitted_objects';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(OkapiSubmittedObjectsEntity $entity)
    {
        return [
            'object_type' => $entity->objectType,
            'object_id' => $entity->objectId,
            'consumer_key' => $entity->consumerKey,
        ];
    }

    /**
     * @return OkapiSubmittedObjectsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new OkapiSubmittedObjectsEntity();
        $entity->objectType = (int) $data['object_type'];
        $entity->objectId = (int) $data['object_id'];
        $entity->consumerKey = (string) $data['consumer_key'];

        return $entity;
    }
}


local/devel/Repositories/ReplicationNotimportedRepository.php 1 location


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

class ReplicationNotimportedRepository
{
    const TABLE = 'replication_notimported';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(ReplicationNotimportedEntity $entity)
    {
        return [
            'id' => $entity->id,
            'object_uuid' => $entity->objectUuid,
            'object_type' => $entity->objectType,
        ];
    }

    /**
     * @return ReplicationNotimportedEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new ReplicationNotimportedEntity();
        $entity->id = (int) $data['id'];
        $entity->objectUuid = (string) $data['object_uuid'];
        $entity->objectType = (int) $data['object_type'];

        return $entity;
    }
}


local/devel/Repositories/SearchDoublesRepository.php 1 location


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

class SearchDoublesRepository
{
    const TABLE = 'search_doubles';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(SearchDoublesEntity $entity)
    {
        return [
            'hash' => $entity->hash,
            'word' => $entity->word,
            'simple' => $entity->simple,
        ];
    }

    /**
     * @return SearchDoublesEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new SearchDoublesEntity();
        $entity->hash = (int) $data['hash'];
        $entity->word = (string) $data['word'];
        $entity->simple = (string) $data['simple'];

        return $entity;
    }
}


local/devel/Repositories/SysTransRefRepository.php 1 location


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

class SysTransRefRepository
{
    const TABLE = 'sys_trans_ref';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(SysTransRefEntity $entity)
    {
        return [
            'trans_id' => $entity->transId,
            'resource_name' => $entity->resourceName,
            'line' => $entity->line,
        ];
    }

    /**
     * @return SysTransRefEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new SysTransRefEntity();
        $entity->transId = (int) $data['trans_id'];
        $entity->resourceName = (string) $data['resource_name'];
        $entity->line = (int) $data['line'];

        return $entity;
    }
}


local/devel/Repositories/SysTransRepository.php 1 location


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

class SysTransRepository
{
    const TABLE = 'sys_trans';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

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

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

        return $entity;
    }
}


local/devel/Repositories/UserStatpicRepository.php 1 location


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

class UserStatpicRepository
{
    const TABLE = 'user_statpic';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return []
     */
    public function getDatabaseArrayFromEntity(UserStatpicEntity $entity)
    {
        return [
            'user_id' => $entity->userId,
            'lang' => $entity->lang,
            'date_created' => $entity->dateCreated,
        ];
    }

    /**
     * @return UserStatpicEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new UserStatpicEntity();
        $entity->userId = (int) $data['user_id'];
        $entity->lang = (string) $data['lang'];
        $entity->dateCreated = new DateTime($data['date_created']);

        return $entity;
    }
}


htdocs_symfony/src/Repository/CacheReportStatusRepository.php 1 location


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

class CacheReportStatusRepository
{
    const TABLE = 'cache_report_status';

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

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

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

        $result = $statement->fetchAll();

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

        $records = [];

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

        return $records;
    }

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

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

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

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

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

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

        $entities = [];

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

        return $entities;
    }

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

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

        return $entity;
    }
}


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

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

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

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

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

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

OpencachingDeutschland / oc-server3

Code Duplication Length = 188-212 lines in 14 locations

local/devel/Repositories/CacheListBookmarksRepository.php 1 location

local/devel/Repositories/CacheReportStatusRepository.php 1 location

local/devel/Repositories/GeodbTypeNamesRepository.php 1 location

local/devel/Repositories/HelppagesRepository.php 1 location

local/devel/Repositories/LogentriesTypesRepository.php 1 location

local/devel/Repositories/OkapiAuthorizationsRepository.php 1 location

local/devel/Repositories/OkapiNoncesRepository.php 1 location

local/devel/Repositories/OkapiSubmittedObjectsRepository.php 1 location

local/devel/Repositories/ReplicationNotimportedRepository.php 1 location

local/devel/Repositories/SearchDoublesRepository.php 1 location

local/devel/Repositories/SysTransRefRepository.php 1 location

local/devel/Repositories/SysTransRepository.php 1 location

local/devel/Repositories/UserStatpicRepository.php 1 location

htdocs_symfony/src/Repository/CacheReportStatusRepository.php 1 location