Helix\Asana\Api

Complexity

Total Complexity

47

Size/Duplication

Total Lines	446
Duplicated Lines	0 %

Importance

Changes	14
Bugs	1	Features	2

32 Methods

Rating	Name	Duplication	Size	Complexity
A	delete()	0	2	1
A	getTag()	0	2	1
B	exec()	0	38	6
A	getUser()	0	2	1
A	getAttachment()	0	2	1
A	getLogger()	0	2	1
A	getStory()	0	2	1
A	getSection()	0	2	1
A	getProject()	0	2	1
A	getMe()	0	2	1
A	__construct()	0	4	1
A	getPath()	0	2	2
A	getCache()	0	2	1
A	getPortfolio()	0	2	1
A	getCustomField()	0	2	1
A	getTeam()	0	2	1
A	getTask()	0	2	1
A	get()	0	6	2
A	factory()	0	2	1
A	jsonEncode()	0	2	1
A	getWebhookEvent()	0	7	1
A	put()	0	6	1
A	setLogger()	0	3	1
A	upload()	0	5	1
A	getWorkspaceByName()	0	7	3
A	jsonDecode()	0	2	1
A	getWorkspace()	0	2	1
A	loadAll()	0	16	4
A	sync()	0	23	3
A	setCache()	0	3	1
A	post()	0	6	1
A	load()	0	5	2

<?php

namespace Helix\Asana;

use CURLFile;
use Helix\Asana\Api\Cache;
use Helix\Asana\Api\Logger;
use Helix\Asana\Api\LoggerInterface;
use Helix\Asana\Base\AbstractEntity;
use Helix\Asana\Base\Data;
use Helix\Asana\Event\ProjectEvent;
use Helix\Asana\Event\StoryEvent;
use Helix\Asana\Event\TaskEvent;
use Helix\Asana\Project\Section;
use Helix\Asana\Task\Attachment;
use Helix\Asana\Task\Story;

/**
 * API and entity cache access.
 *
 * @see https://app.asana.com/-/developer_console
 */
class Api {

    /**
     * @var Cache
     */
    protected $cache;

    /**
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * @var string
     */
    protected $token;

    /**
     * @param string $token
     */
    public function __construct (string $token) {
        $this->token = $token;
        $this->cache = new Cache();
        $this->logger = new Logger();
    }

    /**
     * HTTP DELETE
     *
     * @param string $path
     */
    public function delete (string $path): void {
        $this->exec('DELETE', $path);
    }

    /**
     * @param string $method
     * @param string $path
     * @param null|array $opts
     * @return null|array
     * @internal
     */
    protected function exec (string $method, string $path, array $opts = null) {
        $ch = curl_init();
        curl_setopt_array($ch, [

It seems like $ch can also be of type false; however, parameter $ch of curl_setopt_array() does only seem to accept resource, maybe add an additional type check?

            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_URL => "https://app.asana.com/api/1.0/{$path}",
            CURLOPT_USERAGENT => 'hfw/asana',
            CURLOPT_FOLLOWLOCATION => false, // HTTP 201 includes Location
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HEADER => true,
        ]);
        $this->logger->log($method, $path, $opts);
        $opts[CURLOPT_HTTPHEADER][] = "Authorization: Bearer {$this->token}";
        $opts[CURLOPT_HTTPHEADER][] = 'Accept: application/json';
        $opts[CURLOPT_HTTPHEADER][] = 'Expect:'; // prevent http 100
        curl_setopt_array($ch, $opts);

It seems like $opts can also be of type null; however, parameter $options of curl_setopt_array() does only seem to accept array, maybe add an additional type check?

        RETRY:
        $response = curl_exec($ch);

It seems like $ch can also be of type false; however, parameter $ch of curl_exec() does only seem to accept resource, maybe add an additional type check?

        $info = curl_getinfo($ch);

It seems like $ch can also be of type false; however, parameter $ch of curl_getinfo() does only seem to accept resource, maybe add an additional type check?

        if ($response === false) {
            throw new Error(curl_errno($ch), curl_error($ch), $info);

It seems like $ch can also be of type false; however, parameter $ch of curl_errno() does only seem to accept resource, maybe add an additional type check?

It seems like $ch can also be of type false; however, parameter $ch of curl_error() does only seem to accept resource, maybe add an additional type check?

        }
        [$head, $body] = explode("\r\n\r\n", $response, 2);

It seems like $response can also be of type true; however, parameter $string of explode() does only seem to accept string, maybe add an additional type check?

        $info['response_headers'] = $headers = array_column(array_map(function($header) {
            return explode(': ', $header, 2);
        }, array_slice(explode("\r\n", $head), 1)), 1, 0);
        switch ($code = $info['http_code']) {
            case 200:
            case 201:
                return $this->jsonDecode($body);
            case 404:
                return null;
            case 429:
                $sleep = $headers['Retry-After'];
                $this->logger->log("Retry-After {$sleep}: {$method}", $path, null);
                sleep($sleep);
                goto RETRY;
            default:
                throw new Error($code, $body, $info);
        }
    }

    /**
     * Central point of object creation.
     *
     * Can be overridden to return subclasses.
     *
     * @param string $class
     * @param Api|Data $caller
     * @param array $data
     * @return mixed
     */
    public function factory (string $class, $caller, array $data = []) {
        return new $class($caller, $data);
    }

    /**
     * HTTP GET
     *
     * @param string $path
     * @param array $query
     * @param array $options
     * @return null|array
     */
    public function get (string $path, array $query = [], array $options = []) {
        foreach ($options as $name => $value) {
            $query["opt_{$name}"] = $value;
        }
        $response = $this->exec('GET', $this->getPath($path, $query));
        return $response['data'] ?? null;
    }

    /**
     * Loads and returns an Attachment.
     *
     * @param string $gid
     * @return null|Attachment
     */
    public function getAttachment (string $gid) {
        return $this->load(Attachment::class, $this, "attachments/{$gid}");
    }

    /**
     * @return Cache
     */
    public function getCache () {
        return $this->cache;
    }

    /**
     * Loads and returns a CustomField.
     *
     * @param string $gid
     * @return null|CustomField
     */
    public function getCustomField (string $gid) {
        return $this->load(CustomField::class, $this, "custom_fields/{$gid}");
    }

    /**
     * @return LoggerInterface
     */
    public function getLogger () {
        return $this->logger;
    }

    /**
     * Returns the authenticated User.
     *
     * @return User
     */
    public function getMe () {
        return $this->getUser('me');
    }

    /**
     * Helper to format a request path.
     *
     * @param string $path
     * @param array $query
     * @return string
     */
    protected function getPath (string $path, array $query): string {
        return $query ? $path . '?' . http_build_query($query) : $path;
    }

    /**
     * Loads and returns a Portfolio.
     *
     * @param string $gid
     * @return null|Portfolio
     */
    public function getPortfolio (string $gid) {
        return $this->load(Portfolio::class, $this, "portfolios/{$gid}");
    }

    /**
     * Loads and returns a Project.
     *
     * @param string $gid
     * @return null|Project
     */
    public function getProject (string $gid) {
        return $this->load(Project::class, $this, "projects/{$gid}");
    }

    /**
     * Loads and returns a Section.
     *
     * @param string $gid
     * @return null|Section
     */
    public function getSection (string $gid) {
        return $this->load(Section::class, $this, "sections/{$gid}");
    }

    /**
     * Loads and returns a Story.
     *
     * @param string $gid
     * @return null|Story
     */
    public function getStory (string $gid) {
        return $this->load(Story::class, $this, "stories/{$gid}");
    }

    /**
     * Loads and returns a Tag.
     *
     * @param string $gid
     * @return null|Tag
     */
    public function getTag (string $gid) {
        return $this->load(Tag::class, $this, "tags/{$gid}");
    }

    /**
     * Loads and returns a Task.
     *
     * @param string $gid
     * @return null|Task
     */
    public function getTask (string $gid) {
        return $this->load(Task::class, $this, "tasks/{$gid}");
    }

    /**
     * Loads and returns a Team.
     *
     * @param string $gid
     * @return null|Team
     */
    public function getTeam (string $gid) {
        return $this->load(Team::class, $this, "teams/{$gid}");
    }

    /**
     * Loads and returns a User.
     *
     * @param string $gid
     * @return null|User
     */
    public function getUser (string $gid) {
        return $this->load(User::class, $this, "users/{$gid}");
    }

    /**
     * Expands received webhook data as a full event object.
     *
     * @see https://developers.asana.com/docs/#tocS_WebhookEvent
     *
     * @param array $data
     * @return ProjectEvent|TaskEvent|StoryEvent
     */
    public function getWebhookEvent (array $data) {
        static $classes = [
            Project::TYPE => ProjectEvent::class,
            Task::TYPE => TaskEvent::class,
            Story::TYPE => StoryEvent::class
        ];
        return $this->factory($classes[$data['type']], $this, $data);
    }

    /**
     * @param string $gid
     * @return null|Workspace
     */
    public function getWorkspace (string $gid) {
        return $this->load(Workspace::class, $this, "workspaces/{$gid}");
    }

    /**
     * @param string $name
     * @return null|Workspace
     */
    public function getWorkspaceByName (string $name) {
        foreach ($this->getMe()->getWorkspaces() as $workspace) {
            if ($workspace->getName() === $name) {
                return $workspace;
            }
        }
        return null;
    }

    /**
     * @param string $json
     * @return null|array
     */
    protected function jsonDecode (string $json) {
        return json_decode($json, true, JSON_BIGINT_AS_STRING | JSON_THROW_ON_ERROR);
    }

    /**
     * @param array $data
     * @return string
     */
    protected function jsonEncode (array $data): string {
        return json_encode($data, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR);
    }

    /**
     * Loads the entity found at the given path + query.
     *
     * The entity is cached.
     *
     * @param string $class
     * @param Api|Data $caller
     * @param string $path
     * @param array $query
     * @return null|mixed|AbstractEntity
     */
    public function load (string $class, $caller, string $path, array $query = []) {
        $key = $this->getPath($path, $query);
        return $this->cache->get($key, $caller, function($caller) use ($class, $path, $query) {
            $data = $this->get($path, $query, ['expand' => 'this']);
            return $data ? $this->factory($class, $caller, $data) : null;
        });
    }

    /**
     * Loads entities found at the given path + query.
     *
     * The result-set is not cached, but individual entities are.
     *
     * @param string $class
     * @param Api|Data $caller
     * @param string $path
     * @param array $query `limit` can be included, or excluded to default at `100` (the maximum).
     * @param int $pages If positive, stops after this many pages have been fetched.
     * @return array|AbstractEntity[]
     */
    public function loadAll (string $class, $caller, string $path, array $query = [], int $pages = 0) {
        $query['opt_expand'] = 'this';
        $query += ['limit' => 100];
        $path = $this->getPath($path, $query);
        $pageCount = 0;
        $all = [];
        do {
            $page = $this->exec('GET', $path);
            foreach ($page['data'] ?? [] as $data) {
                $all[] = $this->cache->get($data['gid'], $caller, function($caller) use ($class, $data) {
                    return $this->factory($class, $caller, $data);
                });
            }
            $path = substr($page['next_page']['path'] ?? null, 1); // removes leading slash
        } while ($path and ++$pageCount !== $pages);
        return $all;
    }

    /**
     * HTTP POST
     *
     * @param string $path
     * @param array $data
     * @param array $options
     * @return null|array
     */
    public function post (string $path, array $data = [], array $options = []) {
        $response = $this->exec('POST', $path, [
            CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
            CURLOPT_POSTFIELDS => $this->jsonEncode(['options' => $options, 'data' => $data])
        ]);
        return $response['data'] ?? null;
    }

    /**
     * HTTP PUT
     *
     * @param string $path
     * @param array $data
     * @param array $options
     * @return null|array
     */
    public function put (string $path, array $data = [], array $options = []) {
        $response = $this->exec('PUT', $path, [
            CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
            CURLOPT_POSTFIELDS => $this->jsonEncode(['options' => $options, 'data' => $data])
        ]);
        return $response['data'] ?? null;
    }

    /**
     * @param Cache $cache
     * @return $this
     */
    public function setCache (Cache $cache) {
        $this->cache = $cache;
        return $this;
    }

    /**
     * @param LoggerInterface $logger
     * @return $this
     */
    public function setLogger (LoggerInterface $logger) {
        $this->logger = $logger;
        return $this;
    }

    /**
     * Polls for new events. This can be used as an alternative to webhooks.
     *
     * @see https://developers.asana.com/docs/#get-events-on-a-resource
     *
     * @param Project|Task $entity
     * @param string $token
     * @return ProjectEvent[]|TaskEvent[]|StoryEvent[]
     */
    public function sync ($entity, &$token) {
        try {
            $response = $this->exec('GET', $this->getPath('events', [
                'resource' => $entity->getGid(),
                'sync' => $token,
                'opt_expand' => 'this'
            ]));
        }
        catch (Error $error) {
            if ($error->getCode() !== 412) {
                throw $error;
            }
            $response = $this->jsonDecode($error->getMessage());
        }
        $token = $response['sync'];
        return array_map(function(array $each) {
            static $classes = [
                Project::TYPE => ProjectEvent::class,
                Task::TYPE => TaskEvent::class,
                Story::TYPE => StoryEvent::class
            ];
            return $this->factory($classes[$each['resource']['resource_type']], $this, $each);
        }, $response['data'] ?? []);
    }

    /**
     * HTTP POST (multipart/form-data)
     *
     * @param string $path
     * @param string $file
     * @return null|array
     */
    public function upload (string $path, string $file) {
        $response = $this->exec('POST', $path, [
            CURLOPT_POSTFIELDS => ['file' => new CURLFile(realpath($file))] // multipart/form-data
        ]);
        return $response['data'] ?? null;
    }
}