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

Code Duplication Length = 196-196 lines in 6 locations

local/devel/Repositories/EmailUserRepository.php 1 location


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

class EmailUserRepository
{
    const TABLE = 'email_user';

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

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

    /**
     * @return EmailUserEntity[]
     */
    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 EmailUserEntity
     */
    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 EmailUserEntity[]
     */
    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 EmailUserEntity $entity
     * @return EmailUserEntity
     */
    public function create(EmailUserEntity $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 EmailUserEntity $entity
     * @return EmailUserEntity
     */
    public function update(EmailUserEntity $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 EmailUserEntity $entity
     * @return EmailUserEntity
     */
    public function remove(EmailUserEntity $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 EmailUserEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(EmailUserEntity $entity)
    {
        return [
        'id' => $entity->id,
        'date_created' => $entity->dateCreated,
        'ipaddress' => $entity->ipaddress,
        'from_user_id' => $entity->fromUserId,
        'from_email' => $entity->fromEmail,
        'to_user_id' => $entity->toUserId,
        'to_email' => $entity->toEmail,
        ];
    }

    /**
     * @param array $data
     * @return EmailUserEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new EmailUserEntity();
        $entity->id = $data['id'];
        $entity->dateCreated = $data['date_created'];
        $entity->ipaddress = $data['ipaddress'];
        $entity->fromUserId = $data['from_user_id'];
        $entity->fromEmail = $data['from_email'];
        $entity->toUserId = $data['to_user_id'];
        $entity->toEmail = $data['to_email'];

        return $entity;
    }
}


local/devel/Repositories/OkapiConsumersRepository.php 1 location


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

class OkapiConsumersRepository
{
    const TABLE = 'okapi_consumers';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param OkapiConsumersEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(OkapiConsumersEntity $entity)
    {
        return [
        'key' => $entity->key,
        'name' => $entity->name,
        'secret' => $entity->secret,
        'url' => $entity->url,
        'email' => $entity->email,
        'date_created' => $entity->dateCreated,
        'bflags' => $entity->bflags,
        ];
    }

    /**
     * @param array $data
     * @return OkapiConsumersEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new OkapiConsumersEntity();
        $entity->key = $data['key'];
        $entity->name = $data['name'];
        $entity->secret = $data['secret'];
        $entity->url = $data['url'];
        $entity->email = $data['email'];
        $entity->dateCreated = $data['date_created'];
        $entity->bflags = $data['bflags'];

        return $entity;
    }
}


local/devel/Repositories/PageRepository.php 1 location


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

class PageRepository
{
    const TABLE = 'page';

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

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

    /**
     * @return PageEntity[]
     */
    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 PageEntity
     */
    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 PageEntity[]
     */
    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 PageEntity $entity
     * @return PageEntity
     */
    public function create(PageEntity $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 PageEntity $entity
     * @return PageEntity
     */
    public function update(PageEntity $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 PageEntity $entity
     * @return PageEntity
     */
    public function remove(PageEntity $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 PageEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(PageEntity $entity)
    {
        return [
        'id' => $entity->id,
        'slug' => $entity->slug,
        'meta_keywords' => $entity->metaKeywords,
        'meta_description' => $entity->metaDescription,
        'meta_social' => $entity->metaSocial,
        'updated_at' => $entity->updatedAt,
        'active' => $entity->active,
        ];
    }

    /**
     * @param array $data
     * @return PageEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new PageEntity();
        $entity->id = $data['id'];
        $entity->slug = $data['slug'];
        $entity->metaKeywords = $data['meta_keywords'];
        $entity->metaDescription = $data['meta_description'];
        $entity->metaSocial = $data['meta_social'];
        $entity->updatedAt = $data['updated_at'];
        $entity->active = $data['active'];

        return $entity;
    }
}


local/devel/Repositories/StatCacheLogsRepository.php 1 location


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

class StatCacheLogsRepository
{
    const TABLE = 'stat_cache_logs';

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

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

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @param StatCacheLogsEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(StatCacheLogsEntity $entity)
    {
        return [
        'cache_id' => $entity->cacheId,
        'user_id' => $entity->userId,
        'found' => $entity->found,
        'notfound' => $entity->notfound,
        'note' => $entity->note,
        'will_attend' => $entity->willAttend,
        'maintenance' => $entity->maintenance,
        ];
    }

    /**
     * @param array $data
     * @return StatCacheLogsEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new StatCacheLogsEntity();
        $entity->cacheId = $data['cache_id'];
        $entity->userId = $data['user_id'];
        $entity->found = $data['found'];
        $entity->notfound = $data['notfound'];
        $entity->note = $data['note'];
        $entity->willAttend = $data['will_attend'];
        $entity->maintenance = $data['maintenance'];

        return $entity;
    }
}


local/devel/Repositories/StatUserRepository.php 1 location


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

class StatUserRepository
{
    const TABLE = 'stat_user';

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

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

    /**
     * @return StatUserEntity[]
     */
    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 StatUserEntity
     */
    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 StatUserEntity[]
     */
    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 StatUserEntity $entity
     * @return StatUserEntity
     */
    public function create(StatUserEntity $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;
    }

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

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

    /**
     * @param StatUserEntity $entity
     * @return []
     */
    public function getDatabaseArrayFromEntity(StatUserEntity $entity)
    {
        return [
        'user_id' => $entity->userId,
        'found' => $entity->found,
        'notfound' => $entity->notfound,
        'note' => $entity->note,
        'hidden' => $entity->hidden,
        'will_attend' => $entity->willAttend,
        'maintenance' => $entity->maintenance,
        ];
    }

    /**
     * @param array $data
     * @return StatUserEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new StatUserEntity();
        $entity->userId = $data['user_id'];
        $entity->found = $data['found'];
        $entity->notfound = $data['notfound'];
        $entity->note = $data['note'];
        $entity->hidden = $data['hidden'];
        $entity->willAttend = $data['will_attend'];
        $entity->maintenance = $data['maintenance'];

        return $entity;
    }
}


local/devel/Repositories/WatchesWaitingRepository.php 1 location


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

class WatchesWaitingRepository
{
    const TABLE = 'watches_waiting';

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

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

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

    /**
     * @param array $data
     * @return WatchesWaitingEntity
     */
    public function getEntityFromDatabaseArray(array $data)
    {
        $entity = new WatchesWaitingEntity();
        $entity->id = $data['id'];
        $entity->userId = $data['user_id'];
        $entity->objectId = $data['object_id'];
        $entity->objectType = $data['object_type'];
        $entity->dateCreated = $data['date_created'];
        $entity->watchtext = $data['watchtext'];
        $entity->watchtype = $data['watchtype'];

        return $entity;
    }
}


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

OpencachingDeutschland / oc-server3

Code Duplication Length = 196-196 lines in 6 locations

local/devel/Repositories/EmailUserRepository.php 1 location

local/devel/Repositories/OkapiConsumersRepository.php 1 location

local/devel/Repositories/PageRepository.php 1 location

local/devel/Repositories/StatCacheLogsRepository.php 1 location

local/devel/Repositories/StatUserRepository.php 1 location

local/devel/Repositories/WatchesWaitingRepository.php 1 location