Helix\Asana\Api

Complexity

Total Complexity

58

Size/Duplication

Total Lines	524
Duplicated Lines	0 %

Importance

Changes	17
Bugs	1	Features	2

37 Methods

Rating	Name	Duplication	Size	Complexity
A	getWebhookEvent()	0	2	1
A	delete()	0	2	1
A	getPool()	0	2	1
A	put()	0	6	1
A	getDefaultWorkspace()	0	2	1
A	_jsonDecode()	0	2	1
A	upload()	0	5	1
A	getWorkspaceByName()	0	7	3
A	getLog()	0	2	1
A	getTag()	0	2	1
A	setLog()	0	2	1
B	_exec()	0	42	7
A	_getPath()	0	5	2
A	getTaskList()	0	2	1
A	getUser()	0	2	1
A	getAttachment()	0	2	1
A	getStory()	0	2	1
A	getWorkspace()	0	2	1
A	loadAll()	0	2	1
A	getSection()	0	2	1
A	getProject()	0	2	1
A	getMe()	0	2	1
A	sync()	0	31	4
A	__construct()	0	3	1
A	getPortfolio()	0	2	1
A	getWebhook()	0	10	2
A	_jsonEncode()	0	2	1
A	post()	0	6	1
A	setPool()	0	2	1
A	getCustomField()	0	2	1
A	load()	0	7	2
B	loadEach()	0	14	7
A	getTeam()	0	2	1
A	getTask()	0	2	1
A	getWorkspaces()	0	2	1
A	get()	0	6	2
A	factory()	0	2	1

<?php

namespace Helix\Asana;

use CURLFile;
use Generator;
use Helix\Asana\Api\AsanaError;
use Helix\Asana\Api\Pool;
use Helix\Asana\Base\AbstractEntity;
use Helix\Asana\Base\Data;
use Helix\Asana\Project\Section;
use Helix\Asana\Task\Attachment;
use Helix\Asana\Task\Story;
use Helix\Asana\User\TaskList;
use Helix\Asana\Webhook\ProjectWebhook;
use Helix\Asana\Webhook\TaskWebhook;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

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

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

    /**
     * @var User
     */
    protected $me;

    /**
     * @var Pool
     */
    protected $pool;

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

    /**
     * @param string $token
     * @param Pool|null $pool
     */
    public function __construct (string $token, Pool $pool = null) {
        $this->token = $token;
        $this->pool = $pool ?? new Pool();
    }

    /**
     * cURL transport.
     *
     * @param string $method
     * @param string $path
     * @param array $curlOpts
     * @return null|array
     * @internal
     */
    protected function _exec (string $method, string $path, array $curlOpts = []) {
        $log = $this->getLog();
        $log->log(LOG_DEBUG, "{$method} {$path}", $curlOpts);
        /** @var resource $ch */
        $ch = curl_init();
        curl_setopt_array($ch, [
            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,
        ]);
        $curlOpts[CURLOPT_HTTPHEADER][] = "Authorization: Bearer {$this->token}";
        $curlOpts[CURLOPT_HTTPHEADER][] = 'Accept: application/json';
        $curlOpts[CURLOPT_HTTPHEADER][] = 'Expect:'; // prevent http 100
        curl_setopt_array($ch, $curlOpts);
        RETRY:
        $response = curl_exec($ch);
        $curlInfo = curl_getinfo($ch);
        if ($response === false) {
            throw new AsanaError(curl_errno($ch), curl_error($ch), $curlInfo);
        }
        /** @var string $response */
        [$head, $body] = explode("\r\n\r\n", $response, 2);
        $curlInfo['response_headers'] = $headers = array_column(array_map(function($header) {
            return explode(': ', $header, 2);
        }, array_slice(explode("\r\n", $head), 1)), 1, 0);
        switch ($curlInfo['http_code']) {
            case 200:
            case 201:
                return $this->_jsonDecode($body);
            case 404:
                return null;
            case 429:
                $log->log(LOG_DEBUG, "Retry-After: {$headers['Retry-After']}");
                sleep($headers['Retry-After']);
                goto RETRY;
            default:
                $log->log(LOG_ERR, "Asana {$curlInfo['http_code']}: {$body}", $curlInfo);
            case 412:
                throw new AsanaError($curlInfo['http_code'], $body, $curlInfo);
        }
    }

    /**
     * @param string $path
     * @param array $query
     * @return string
     * @internal
     */
    protected function _getPath (string $path, array $query): string {
        if ($query) {

The expression $query 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.

            return $path . '?' . http_build_query($query);
        }
        return $path;
    }

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

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

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

    /**
     * The central point of object creation.
     *
     * This can be overridden to return custom extensions.
     *
     * @param Api|Data $caller
     * @param string $class
     * @param array $data
     * @return mixed|Data|AbstractEntity
     */
    public function factory ($caller, string $class, array $data = []) {
        return new $class($caller, $data);
    }

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

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

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

    /**
     * Returns the first known workspace of the authorized user.
     * You should only rely on this if the authorized user is in exactly one workspace.
     *
     * @return Workspace
     */
    public function getDefaultWorkspace () {
        return $this->getMe()->getDefaultWorkspace();
    }

    /**
     * @return LoggerInterface
     */
    public function getLog () {
        return $this->log ?? $this->log = new NullLogger();
    }

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

    /**
     * @return Pool
     */
    final public function getPool () {
        return $this->pool;
    }

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

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

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

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

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

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

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

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

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

    /**
     * @param string $gid
     * @return ProjectWebhook|TaskWebhook
     */
    public function getWebhook (string $gid) {
        return $this->pool->get($gid, $this, function() use ($gid) {
            static $classes = [
                Project::TYPE => ProjectWebhook::class,
                Task::TYPE => TaskWebhook::class
            ];
            if ($remote = $this->get("webhooks/{$gid}", [], ['expand' => 'this'])) {
                return $this->factory($this, $classes[$remote['resource_type']], $remote);
            }
            return null;
        });
    }

    /**
     * Expands received webhook data as a full event object.
     *
     * @see https://developers.asana.com/docs/event
     *
     * @param array $data
     * @return Event
     */
    public function getWebhookEvent (array $data) {
        return $this->factory($this, Event::class, $data);
    }

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

    /**
     * Loads and returns a {@see Workspace} by name.
     *
     * @param string $name
     * @return null|Workspace
     */
    public function getWorkspaceByName (string $name) {
        foreach ($this->getWorkspaces() as $workspace) {
            if ($workspace->getName() === $name) {
                return $workspace;
            }
        }
        return null;
    }

    /**
     * All workspaces visible to the authorized user.
     *
     * @return Workspace[]
     */
    public function getWorkspaces () {
        return $this->getMe()->getWorkspaces();
    }

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

    /**
     * Returns all results from {@see loadEach()}
     *
     * @param Api|Data $caller
     * @param string $class
     * @param string $path
     * @param array $query
     * @return array|AbstractEntity[]
     */
    public function loadAll ($caller, string $class, string $path, array $query = []) {
        return iterator_to_array($this->loadEach(...func_get_args()));
    }

    /**
     * Loads and yields each entity found at the given path + query.
     *
     * The result-set is not pooled, but individual entities are.
     *
     * @param Api|Data $caller
     * @param string $class
     * @param string $path
     * @param array $query `limit` can exceed `100` here. Empty `limit` for all pages.
     * @return Generator|AbstractEntity[]
     */
    public function loadEach ($caller, string $class, string $path, array $query = []) {
        $query['opt_expand'] = 'this';
        if (!$i = $query['limit'] ?? 0) {
            $i = PHP_INT_MAX;
        }
        do {
            $query['limit'] = min($i, 100);
            $page = $this->_exec('GET', $this->_getPath($path, $query));
            for ($data = $page['data']; $each = current($data) and $i--; next($data)) {
                yield $this->pool->get($each['gid'], $caller, function($caller) use ($class, $each) {
                    return $this->factory($caller, $class, $each);
                });
            }
        } while ($i and $page['next_page'] and $query['offset'] = $page['next_page']['offset']);
    }

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

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

    /**
     * @param LoggerInterface $log
     */
    public function setLog (LoggerInterface $log) {
        $this->log = $log;
    }

    /**
     * @param Pool $pool
     */
    public function setPool (Pool $pool) {
        $this->pool = $pool;
    }

    /**
     * Polls for new events.
     *
     * If the given sync token expired, a `412` is thrown.
     *
     * If the given token is `null`, this returns an empty array.
     *
     * @see https://developers.asana.com/docs/get-events-on-a-resource
     *
     * @param string $gid A project or task GID.
     * @param null|string $token Updated to the new token.
     * @return Event[]
     */
    public function sync (string $gid, ?string &$token) {
        try {
            /** @var array $remote Asana throws 400 for missing entities here. */
            $remote = $this->_exec('GET', $this->_getPath('events', [
                'resource' => $gid,
                'sync' => $token,
                'opt_expand' => 'this'
            ]));
        }
        catch (AsanaError $error) {
            if ($error->getCode() === 412) {
                $remote = $this->_jsonDecode($error->getMessage());
                if (!isset($token)) {
                    // API docs say: "The response will be the same as for an expired sync token."
                    // The caller knowingly gave a null token, so we don't need to rethrow.
                    $token = $remote['sync'];
                    return [];
                }
                // Token expired. Update and rethrow.
                $token = $remote['sync'];
            }
            throw $error;
        }
        $token = $remote['sync'];
        $events = array_map(function(array $each) {
            return $this->factory($this, Event::class, $each);
        }, $remote['data']);
        usort($events, function(Event $a, Event $b) {
            return $a->getCreatedAt() <=> $b->getCreatedAt();
        });
        return $events;
    }

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