Lan\Ebs\Sdk\Classes\Collection

Complexity

Total Complexity

19

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

52.73%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	23	4
A	setLimit()	0	8	2
A	setOffset()	0	8	2
B	load()	0	25	4
A	getIterator()	0	4	1
A	count()	0	6	1
A	getData()	0	6	1
A	reset()	0	6	1
A	createModel()	0	13	2
A	end()	0	6	1

<?php
/**
 * Created by PhpStorm.
 * User: dp
 * Date: 26.07.17
 * Time: 11:56
 */

namespace Lan\Ebs\Sdk\Classes;

use ArrayObject;
use Exception;
use Lan\Ebs\Sdk\Client;
use Lan\Ebs\Sdk\Common;
use ReflectionClass;

abstract class Collection extends ArrayObject implements Common
{
    private $client;

    private $loadStatus = 0;

    private $fields = [];

    private $class = null;

    private $limit = null;

    private $offset = null;

    /**
     * Collection constructor.
     *
     * @param  Client $client
     * @param  array $fields
     * @param  string $class
     * @param  int $limit
     * @param  int $offset
     * @throws Exception
     */
    public function __construct(Client $client, array $fields, $class, $limit, $offset)
    {
        if (!$client) {
            throw new Exception('Client not defined');
        }

        if (!is_array($fields)) {
            throw new Exception('Fields for model of collection mast be array');
        }

        $reflectionClass = new ReflectionClass($class);

        if (!$reflectionClass->isSubclassOf(Model::class)) {
            throw new Exception('Class of model collection not subclass for Model');
        }

        $this->client = $client;
        $this->fields = $fields;
        $this->class = $class;

        $this->setLimit($limit);
        $this->setOffset($offset);
    }

    /**
     * @param int $limit
     */
    public function setLimit($limit)
    {
        $this->limit = $limit;

        if ($this->loadStatus == 200) {
            $this->load(true);
        }
    }

    /**
     * @param bool $force
     * @return $this
     */
    public function load($force = false)
    {
        if ($this->loadStatus == 200 && !$force) {
            return $this;
        }

        $params = [
            'limit' => $this->limit,
            'offset' => $this->offset
        ];

        if ($this->fields) {

The expression $this->fields of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $params['fields'] = implode(',', (array)$this->fields);
        }

        $response = $this->client->getResponse($this->getUrl(__FUNCTION__), $params);

        $this->exchangeArray($response['data']);

        $this->loadStatus = $response['status'];

        unset($response);

        return $this;
    }

    /**
     * @param int $offset
     */
    public function setOffset($offset)
    {
        $this->offset = $offset;

        if ($this->loadStatus == 200) {
            $this->load(true);
        }
    }

    public function getIterator()
    {
        return new CollectionIterator($this);
    }

    public function count()
    {
        $this->load();

        return parent::count();
    }

    public function getData()
    {
        $this->load();

        return $this->getArrayCopy();
    }

    public function reset()
    {
        $this->load();

        return $this->createModel(reset($this));
    }

    /**
     * @param array $data
     * @return Model
     */
    public function createModel(array $data = null)
    {
        $class = $this->class;

        /**
         * @var Model $model
         */
        $model = new $class($this->client, $this->fields);

        $model->set($data === null ? current($this) : $data);

        return $model;
    }

    public function end()
    {
        $this->load();

        return $this->createModel(end($this));
    }
}