Oc\Repository\CachesRepository

Complexity

Total Complexity

24

Size/Duplication

Total Lines	274
Duplicated Lines	30.66 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	fetchAll()	0	21	3
A	fetchOneBy()	0	23	4
A	fetchBy()	0	28	5
A	create()	0	17	2
A	update()	0	16	2
A	remove()	0	15	2
A	getIdByWP()	0	22	3
A	getDatabaseArrayFromEntity()	41	41	1
A	getEntityFromDatabaseArray()	43	43	1

<?php

namespace Oc\Repository;

use Doctrine\DBAL\Connection;
use Oc\Entity\CachesEntity;
use Oc\Repository\Exception\RecordAlreadyExistsException;
use Oc\Repository\Exception\RecordNotFoundException;
use Oc\Repository\Exception\RecordNotPersistedException;
use Oc\Repository\Exception\RecordsNotFoundException;

class CachesRepository
{
    const TABLE = 'caches';

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

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

    /**
     * @return CachesEntity[]
     */
    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 CachesEntity
     */
    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');
        } else {
            return $this->getEntityFromDatabaseArray($result);
        }
    }

    /**
     * @return CachesEntity[]
     */
    public function fetchBy(array $where = [])
    {
        $entities = [];

        $queryBuilder = $this->connection->createQueryBuilder()
            ->select('*')
            ->from(self::TABLE);

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

        $statement = $queryBuilder->execute();

        $result = $statement->fetchAll();

        if ($statement->rowCount() === 0) {
            //            throw new RecordsNotFoundException('No records with given where clause found');
        } else {
            foreach ($result as $item) {
                $entities[] = $this->getEntityFromDatabaseArray($item);
            }
        }

        return $entities;
    }

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

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

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

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

        return $entity;
    }

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

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

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

        return $entity;
    }

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

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

        $entity->cacheId = null;

        return $entity;
    }

    /**
     * @return CachesEntity
     */
    public function getIdByWP(string $wp = '')
    {
        $queryBuilder = $this->connection->createQueryBuilder()
            ->select('*')
            ->from(self::TABLE)
            ->setMaxResults(1);

        if ($wp != '') {
            $queryBuilder->where('wp_oc = ' . $queryBuilder->createNamedParameter($wp));
            $queryBuilder->orWhere('wp_gc = ' . $queryBuilder->createNamedParameter($wp));
        }

        $statement = $queryBuilder->execute();

        $result = $statement->fetch();

        if ($statement->rowCount() === 0) {
            //            throw new RecordNotFoundException('Record with given where clause not found');
        } else {
            return $result['cache_id'];
        }
    }

    /**
     * @return []

The doc-type [] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function getDatabaseArrayFromEntity(GeoCachesEntity $entity)

This method seems to be duplicated in your project.

    {
        return [
            'cache_id' => $entity->cacheId,
            'uuid' => $entity->uuid,
            'node' => $entity->node,
            'date_created' => $entity->dateCreated,
            'is_publishdate' => $entity->isPublishdate,
            'last_modified' => $entity->lastModified,
            'okapi_syncbase' => $entity->okapiSyncbase,
            'listing_last_modified' => $entity->listingLastModified,
            'meta_last_modified' => $entity->metaLastModified,
            'user_id' => $entity->userId,
            'name' => $entity->name,
            'longitude' => $entity->longitude,
            'latitude' => $entity->latitude,
            'type' => $entity->type,
            'status' => $entity->status,
            'country' => $entity->country,
            'date_hidden' => $entity->dateHidden,
            'size' => $entity->size,
            'difficulty' => $entity->difficulty,
            'terrain' => $entity->terrain,
            'logpw' => $entity->logpw,
            'search_time' => $entity->searchTime,
            'way_length' => $entity->wayLength,
            'wp_gc' => $entity->wpGc,
            'wp_gc_maintained' => $entity->wpGcMaintained,
            'wp_nc' => $entity->wpNc,
            'wp_oc' => $entity->wpOc,
            'desc_languages' => $entity->descLanguages,
            'default_desclang' => $entity->defaultDesclang,
            'date_activate' => $entity->dateActivate,
            'need_npa_recalc' => $entity->needNpaRecalc,
            'show_cachelists' => $entity->showCachelists,
            'protect_old_coords' => $entity->protectOldCoords,
            'needs_maintenance' => $entity->needsMaintenance,
            'listing_outdated' => $entity->listingOutdated,
            'flags_last_modified' => $entity->flagsLastModified,
        ];
    }

    /**
     * @return CachesEntity
     */
    public function getEntityFromDatabaseArray(array $data)

This method seems to be duplicated in your project.

    {
        $entity = new CachesEntity();

        $entity->cacheId = (int) $data['cache_id'];
        $entity->uuid = (string) $data['uuid'];
        $entity->node = (int) $data['node'];
        $entity->dateCreated = new DateTime($data['date_created']);

It seems like new \Oc\Repository\DateTime($data['date_created']) of type object<Oc\Repository\DateTime> is incompatible with the declared type object<Oc\Entity\DateTime> of property $dateCreated.

        $entity->isPublishdate = (int) $data['is_publishdate'];
        $entity->lastModified = new DateTime($data['last_modified']);

It seems like new \Oc\Repository\DateTime($data['last_modified']) of type object<Oc\Repository\DateTime> is incompatible with the declared type object<Oc\Entity\DateTime> of property $lastModified.

        $entity->okapiSyncbase = (string) $data['okapi_syncbase'];
        $entity->listingLastModified = new DateTime($data['listing_last_modified']);

It seems like new \Oc\Repository\DateTime($data['listing_last_modified']) of type object<Oc\Repository\DateTime> is incompatible with the declared type object<Oc\Entity\DateTime> of property $listingLastModified.

        $entity->metaLastModified = new DateTime($data['meta_last_modified']);

It seems like new \Oc\Repository\DateTime($data['meta_last_modified']) of type object<Oc\Repository\DateTime> is incompatible with the declared type object<Oc\Entity\DateTime> of property $metaLastModified.

        $entity->userId = (int) $data['user_id'];
        $entity->name = (string) $data['name'];
        $entity->longitude = $data['longitude'];
        $entity->latitude = $data['latitude'];
        $entity->type = (int) $data['type'];
        $entity->status = (int) $data['status'];
        $entity->country = (string) $data['country'];
        $entity->dateHidden = new DateTime($data['date_hidden']);

It seems like new \Oc\Repository\DateTime($data['date_hidden']) of type object<Oc\Repository\DateTime> is incompatible with the declared type object<Oc\Entity\DateTime> of property $dateHidden.

        $entity->size = (int) $data['size'];
        $entity->difficulty = (int) $data['difficulty'];
        $entity->terrain = (int) $data['terrain'];
        $entity->logpw = (string) $data['logpw'];
        $entity->searchTime = $data['search_time'];
        $entity->wayLength = $data['way_length'];
        $entity->wpGc = (string) $data['wp_gc'];
        $entity->wpGcMaintained = (string) $data['wp_gc_maintained'];
        $entity->wpNc = (string) $data['wp_nc'];
        $entity->wpOc = (string) $data['wp_oc'];
        $entity->descLanguages = (string) $data['desc_languages'];
        $entity->defaultDesclang = (string) $data['default_desclang'];
        $entity->dateActivate = new DateTime($data['date_activate']);

It seems like new \Oc\Repository\DateTime($data['date_activate']) of type object<Oc\Repository\DateTime> is incompatible with the declared type object<Oc\Entity\DateTime> of property $dateActivate.

        $entity->needNpaRecalc = (int) $data['need_npa_recalc'];
        $entity->showCachelists = (int) $data['show_cachelists'];
        $entity->protectOldCoords = (int) $data['protect_old_coords'];
        $entity->needsMaintenance = (int) $data['needs_maintenance'];
        $entity->listingOutdated = (int) $data['listing_outdated'];
        $entity->flagsLastModified = new DateTime($data['flags_last_modified']);

It seems like new \Oc\Repository\DateTime($data['flags_last_modified']) of type object<Oc\Repository\DateTime> is incompatible with the declared type object<Oc\Entity\DateTime> of property $flagsLastModified.

        return $entity;
    }
}