ByJG\MicroOrm\Repository

Complexity

Total Complexity

23

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

95.51%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getMapper()	0	4	1
A	getDbDriver()	0	4	1
A	get()	0	10	2
A	delete()	0	9	1
A	deleteByQuery()	0	10	1
A	limit()	0	7	1
A	top()	0	7	1
A	getByFilter()	0	12	2
C	getByQuery()	0	34	7
A	save()	0	16	3
A	insert()	0	6	1
A	update()	0	9	1

<?php
/**
 * Created by PhpStorm.
 * User: jg
 * Date: 21/06/16
 * Time: 16:17
 */

namespace ByJG\MicroOrm;


use ByJG\AnyDataset\DbDriverInterface;
use ByJG\Serializer\BinderObject;

class Repository
{

    /**
     * @var Mapper
     */
    protected $mapper;

    /**
     * @var DbDriverInterface
     */
    protected $dbDriver = null;

    protected $limitStart = null;
    protected $limitEnd = null;
    protected $top = null;

    /**
     * Repository constructor.
     * @param DbDriverInterface $dbDataset
     * @param Mapper $mapper
     */
    public function __construct(DbDriverInterface $dbDataset, Mapper $mapper)
    {
        $this->dbDriver = $dbDataset;
        $this->mapper = $mapper;
    }

    /**
     * @return Mapper
     */
    public function getMapper()
    {
        return $this->mapper;
    }

    /**
     * @return DbDriverInterface
     */
    protected function getDbDriver()
    {
        return $this->dbDriver;
    }

    /**
     * @param array|string $id
     * @return mixed|null
     */
    public function get($id)
    {
        $result = $this->getByFilter($this->mapper->getPrimaryKey() . ' = [[id]]', ['id' => $id]);

        if (count($result) === 1) {
            return $result[0];
        }

        return null;
    }

    /**
     * @param array $id
     * @return mixed|null
     */
    public function delete($id)
    {
        $params = ['id' => $id];
        $query = new Query();
        $query->table($this->mapper->getTable())
            ->where($this->mapper->getPrimaryKey() . ' = [[id]]', $params);

        return $this->deleteByQuery($query);
    }

    /**
     * @param $query
     * @return bool
     */
    public function deleteByQuery($query)
    {
        $delete = $query->getDelete();
        $sql = $delete['sql'];
        $params = $delete['params'];

        $this->getDbDriver()->execute($sql, $params);

        return true;
    }

    public function limit($start, $end)
    {
        $this->limitStart = $start;
        $this->limitEnd = $end;
        $this->top = null;
        return $this;
    }

    public function top($top)
    {
        $this->top = $top;
        $this->limitStart = $this->limitEnd = null;

        return $this;
    }

    /**
     * @param string $filter
     * @param array $params
     * @param bool $forUpdate
     * @return array
     */
    public function getByFilter($filter, array $params, $forUpdate = false)
    {
        $query = new Query();
        $query->table($this->mapper->getTable())
            ->where($filter, $params);
        
        if ($forUpdate) {
            $query->forUpdate();
        }

        return $this->getByQuery($query);
    }

    /**
     * @param Query $query
     * @param Mapper[] $mapper
     * @return array
     */
    public function getByQuery(Query $query, array $mapper = [])
    {
        $mapper = array_merge([$this->mapper], $mapper);
        $query = $query->getSelect();

        if (!empty($this->top)) {
            $query['sql'] = $this->getDbDriver()->getDbHelper()->top($query['sql'], $this->top);
        }

        if (!empty($this->limitStart)) {
            $query['sql'] = $this->getDbDriver()->getDbHelper()->limit($query['sql'], $this->limitStart, $this->limitEnd);
        }

        $result = [];
        $iterator = $this->getDbDriver()->getIterator($query['sql'], $query['params']);

        foreach ($iterator as $row) {
            $collection = [];
            foreach ($mapper as $item) {
                $instance = $item->getEntity();
                BinderObject::bindObject($row->toArray(), $instance);

                foreach ((array)$item->getFieldMap() as $property => $fieldName) {
                    $instance->$property = $row->getField($fieldName);
                }
                $collection[] = $instance;
            }
            $result[] = count($collection) === 1 ? $collection[0] : $collection;
        }

        $this->limitStart = $this->limitEnd = $this->top = null;

        return $result;
    }

    /**
     * @param mixed $instance
     */
    public function save($instance)
    {
        $array = BinderObject::toArrayFrom($instance, true);

        $query = new Query();
        $query->table($this->mapper->getTable())
            ->fields(array_keys($array));

        if (empty($array[$this->mapper->getPrimaryKey()]) || count($this->get($array[$this->mapper->getPrimaryKey()])) === 0)  {
            $array[$this->mapper->getPrimaryKey()] = $this->insert($query, $array);
            BinderObject::bindObject($array, $instance);
        } else {
            $this->update($query, $array);
        }

    }

    /**
     * @param Query $query
     * @param array $params
     * @return int
     * @throws \Exception
     */
    protected function insert(Query $query, array $params)
    {
        $sql = $query->getInsert();
        $dbFunctions = $this->getDbDriver()->getDbHelper();
        return $dbFunctions->executeAndGetInsertedId($this->getDbDriver(), $sql, $params);
    }

    /**
     * @param Query $query
     * @param array $params
     * @throws \Exception
     */
    protected function update(Query $query, array $params)
    {
        $params = array_merge($params, ['_id' => $params[$this->mapper->getPrimaryKey()]]);
        $query->where($this->mapper->getPrimaryKey() . ' = [[_id]] ', ['_id' => $params['_id']]);
        $update = $query->getUpdate();
        $sql = $update['sql'];
        
        $this->getDbDriver()->execute($sql, $params);
    }
}