Helix\Asana\Base\AbstractEntity

Complexity

Total Complexity

26

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Importance

Changes	8
Bugs	1	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__set()	0	5	5
A	_cache()	0	2	1
A	_addWithPost()	0	5	2
A	_setWithPost()	0	11	3
A	_delete()	0	3	1
A	reload()	0	18	4
A	_get()	0	5	3
A	getCacheKeys()	0	2	1
A	_save()	0	14	3
A	_removeWithPost()	0	8	3

<?php

namespace Helix\Asana\Base;

use Closure;
use Helix\Asana\Api\Cache;
use LogicException;
use RuntimeException;

/**
 * A resource with a GID.
 *
 * @method string   getGid          ()
 * @method bool     hasGid          ()
 * @method string   getResourceType ()
 */
abstract class AbstractEntity extends Data {

    /**
     * `GET/PUT/DELETE` path.
     *
     * @return string
     */
    abstract public function __toString (): string;

    /**
     * Maps lazy-loaded / reloadable mapped {@see Data} to their proper expanded field expression.
     *
     * If not set here, the field name is used alone.
     *
     * @var string[]
     */
    protected static $optFields = [];

    /**
     * This is only provided for internal functionality related to the cache.
     *
     * Merges fresher data into the pooled instance.
     *
     * @param string $from
     * @param AbstractEntity $entity
     * @internal
     */
    public function __set (string $from, self $entity) {
        if ($from === Cache::class and $entity !== $this) {
            foreach ($entity->data as $field => $value) {
                if (!isset($this->diff[$field])) {
                    $this->data[$field] = $value;
                }
            }
        }
    }

    /**
     * @param string $addPath
     * @param array $data
     * @param string $field
     * @param array $diff
     * @return $this
     * @internal
     */
    protected function _addWithPost (string $addPath, array $data, string $field, array $diff) {
        if ($this->hasGid()) {
            return $this->_setWithPost($addPath, $data, $field);
        }
        return $this->_set($field, array_merge($this->data[$field] ?? [], array_values($diff)));
    }

    /**
     * Shortcut to update the cache.
     *
     * @internal
     */
    protected function _cache (): void {
        $this->api->getCache()->add($this);
    }

    /**
     * Activated by trait.
     *
     * @internal
     */
    protected function _delete (): void {
        $this->api->delete($this);
        $this->api->getCache()->remove($this);
    }

    /**
     * Lazy-loads missing fields.
     *
     * @param string $field
     * @return mixed
     */
    protected function _get (string $field) {
        if (!array_key_exists($field, $this->data) and isset($this->data['gid'])) {
            $this->reload($field);
        }
        return parent::_get($field);
    }

    /**
     * @param string $rmPath
     * @param array $data
     * @param string $field
     * @param array|Closure $diff An array to diff, or a filter closure.
     * @return $this
     * @internal
     */
    protected function _removeWithPost (string $rmPath, array $data, string $field, $diff) {
        if ($this->hasGid()) {
            return $this->_setWithPost($rmPath, $data, $field);
        }
        elseif (is_array($diff)) {
            return $this->_set($field, array_values(array_diff($this->data[$field] ?? [], $diff)));
        }
        return $this->_set($field, array_values(array_filter($this->data[$field] ?? [], $diff)));
    }

    /**
     * Called by create/update traits.
     *
     * @param string $dir `POST` directory for creation.
     * @return $this
     * @internal
     */
    protected function _save (string $dir = null) {
        if (isset($dir)) {
            $remote = $this->api->post($dir, $this->getDiff(), ['expand' => 'this']);
        }
        elseif ($this->isDiff()) {
            $remote = $this->api->put($this, $this->getDiff(), ['expand' => 'this']);
        }
        else {
            return $this;
        }
        /** @var array $remote */
        $this->_setData($remote);
        $this->_cache();
        return $this;
    }

    /**
     * Sets/reloads data via `POST` for existing entities. Otherwise stages a value.
     *
     * @param string $path
     * @param array $data
     * @param string $field
     * @param mixed $value Ignored for existing entities.
     * @return $this
     * @internal
     */
    protected function _setWithPost (string $path, array $data, string $field, $value = null) {
        if ($this->hasGid()) {
            /** @var array $remote */
            $remote = $this->api->post($path, $data, ['fields' => static::$optFields[$field] ?? $field]);
            if (array_key_exists($field, $this->data)) {
                $this->_setMapped($field, $remote[$field]);
                $this->_cache();
            }
            return $this;
        }
        return $this->_set($field, $value);
    }

    /**
     * Cache keys for the entity.
     *
     * @return string[]
     */
    public function getCacheKeys () {
        return [$this->getGid(), (string)$this];
    }

    /**
     * Reloads a specific field, or the whole entity.
     *
     * @depends after-create
     * @param string $field
     * @return $this
     */
    public function reload (string $field = null) {
        if (!$this->hasGid()) {
            throw new LogicException(static::class . " has no GID, it can't be reloaded.");
        }
        if (isset($field)) {
            $optField = static::$optFields[$field] ?? $field;
            $value = $this->api->get($this, [], ['fields' => $optField])[$field] ?? null;
            $this->_setMapped($field, $value);
        }
        elseif ($remote = $this->api->get($this, [], ['expand' => 'this'])) {
            $this->_setData($remote);
        }
        else { // deleted upstream.
            $this->api->getCache()->remove($this);
            throw new RuntimeException("{$this} was deleted upstream.");
        }
        $this->_cache();
        return $this;
    }

}