WPApi\AbstractApiCall

Complexity

Total Complexity

16

Size/Duplication

Total Lines	171
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	6
Bugs	0	Features	2

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	author()	0	6	1
A	browse()	0	6	1
A	search()	0	6	1
A	slug()	0	6	1
A	tag()	0	6	1
A	makeApiCall()	0	11	1
A	mapResponseToCollection()	0	14	3
A	mapResponseToModel()	0	7	1
A	mapResponse()	0	8	2
A	getAction()	0	8	2
A	getUri()	0	4	1
	getType()	0	1	?
	createModel()	0	1	?

<?php

namespace WPApi;

use Goutte\Client;
use WPApi\Interfaces\ApiInterface;
use AutoMapper\AutoMapper;
use WPApi\Model\Collection;

abstract class AbstractApiCall implements ApiInterface
{
    /**
     * Goutte Client.
     *
     * @var Client
     */
    protected $client;

    /**
     * auto mapper.
     *
     * @var AutoMapper
     */
    protected $automapper;

    public function __construct()
    {
        $this->client = new Client();
        $this->automapper = new AutoMapper();
    }

    /**
     * {@inheritdoc}
     */
    public function author($name)
    {
        return $this->makeApiCall('query', [
            'author' => $name,
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function browse($type)
    {
        return $this->makeApiCall('query', [
            'browse' => $type,
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function search($keywords)
    {
        return $this->makeApiCall('query', [
            'search' => $keywords,
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function slug($slug)
    {
        return $this->makeApiCall('information', [
            'slug' => $slug,
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function tag($tag)
    {
        return $this->makeApiCall('query', [
            'tag' => $tag,
        ]);
    }

    /**
     * make the actual API call.
     *
     * @param string $type      information or query
     * @param array  $arguments arguments to query
     *
     * @return mixed
     */
    protected function makeApiCall($type, array $arguments)
    {
        $body = [
            'action' => $this->getAction($type),
            'request' => serialize((object) $arguments),
        ];
        $this->client->request('POST', $this->getUri(), $body);
        $content = $this->client->getResponse()->getContent();

        return $this->mapResponse(unserialize($content));
    }

    protected function mapResponseToCollection(\stdClass $response)
    {
        $type = $this->getType();
        if (!property_exists($response, $type)) {
            throw new \Exception("Property {$type} does not exist.");
        }
        $collection = new Collection();
        foreach ($response->$type as $key => $value) {
            $model = $this->mapResponseToModel($value);
            $collection->add($model);
        }

        return $collection;
    }

    protected function mapResponseToModel(\stdClass $response)
    {
        $model = $this->createModel();
        $this->automapper->map($response, $model);

        return $model;
    }

    /**
     * map response to model.
     *
     * @param \stdClass $response
     *
     * @return mixed
     */
    protected function mapResponse(\stdClass $response)
    {
        try {
            return $this->mapResponseToCollection($response);
        } catch (\Exception $e) {
            return $this->mapResponseToModel($response);
        }
    }

    /**
     * get API action.
     *
     * @param string $type
     *
     * @return string formatted action
     */
    protected function getAction($type)
    {
        if ($type == 'information') {
            return rtrim($this->getType(), 's')."_{$type}";
        }

        return "{$type}_{$this->getType()}";
    }

    /**
     * get URI of API.
     *
     * @return string
     */
    protected function getUri()
    {
        return "http://api.wordpress.org/{$this->getType()}/info/1.0/";
    }

    /**
     * get the type of object to query.
     *
     * @return string
     */
    abstract protected function getType();

    /**
     * create model.
     *
     * @return mixed
     */
    abstract protected function createModel();
}