Helix\Asana\Base\AbstractEntity

Complexity

Total Complexity

26

Size/Duplication

Total Lines	205
Duplicated Lines	0 %

Importance

Changes	11
Bugs	2	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	_save()	0	14	3
A	hasGid()	0	2	1
A	getPoolKeys()	0	2	1
A	_setData()	0	11	2
A	_addWithPost()	0	5	2
A	_setWithPost()	0	11	3
A	getGid()	0	2	1
A	getResourceType()	0	2	1
A	__merge()	0	4	1
A	reload()	0	17	4
A	_delete()	0	3	1
A	_get()	0	5	3
A	_removeWithPost()	0	8	3

<?php

namespace Helix\Asana\Base;

use Closure;
use LogicException;
use RuntimeException;

/**
 * A resource with a GID.
 */
abstract class AbstractEntity extends Data {

    /**
     * All entity classes must redeclare this to match their `resource_type`.
     */
    const TYPE = '';

    /**
     * Defines `opt_fields` expressions for lazy-loading/reloading fields.
     *
     * If not set here, the field name is used as-is.
     *
     * @var string[] `fieldName => (expression)`
     */
    const OPT_FIELDS = [];

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

    /**
     * @param self $entity
     * @return bool
     * @internal pool
     */
    final public function __merge (self $entity): bool {
        $old = $this->toArray();
        $this->data = array_merge($this->data, array_diff_key($entity->data, $this->diff));
        return $this->toArray() !== $old;
    }

    /**
     * @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)));
    }

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

    /**
     * Lazy-loads missing fields.
     *
     * @param string $field
     * @return mixed
     */
    protected function _get (string $field) {
        if (!array_key_exists($field, $this->data) and $this->hasGid()) {
            $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)) { // create()
            $remote = $this->api->post($dir, $this->getDiff(), ['expand' => 'this']);
        }
        elseif ($this->isDiff()) { // update()
            $remote = $this->api->put($this, $this->getDiff(), ['expand' => 'this']);
        }
        else { // update() but no change
            return $this;
        }
        /** @var array $remote */
        $this->_setData($remote);
        $this->api->getPool()->add($this);
        return $this;
    }

    protected function _setData (array $data): void {
        // make sure the gid is consistently null|string across all entities.
        $data['gid'] = (string)$data['gid'];
        if (empty($data['gid'])) {
            $data['gid'] = null;
        }

        // meaningless once the entity is being created. it's constant.
        unset($data['resource_type'], $data['type']);

        parent::_setData($data);
    }

    /**
     * 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::OPT_FIELDS[$field] ?? $field]);
            if (array_key_exists($field, $this->data)) {
                $this->_setMapped($field, $remote[$field]);
                $this->api->getPool()->add($this);
            }
            return $this;
        }
        return $this->_set($field, $value);
    }

    /**
     * @return null|string
     */
    final public function getGid (): ?string {
        return $this->data['gid'];
    }

    /**
     * Identifiers the entity is pooled with.
     *
     * @return string[]
     */
    public function getPoolKeys () {
        return [$this->getGid(), (string)$this];
    }

    /**
     * All entity classes must declare a `TYPE` constant.
     *
     * @return string
     */
    final public function getResourceType (): string {
        return $this::TYPE;
    }

    /**
     * @return bool
     */
    final public function hasGid (): bool {
        return isset($this->data['gid']);
    }

    /**
     * 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()) { // guards against loading a remote dir.
            throw new LogicException(static::class . " has no GID, it can't be reloaded.");
        }
        if (isset($field)) {
            $remote = $this->api->get($this, [], ['fields' => static::OPT_FIELDS[$field] ?? $field]);
            $this->_setMapped($field, $remote[$field] ?? null);
        }
        elseif ($remote = $this->api->get($this, [], ['expand' => 'this'])) {
            $this->_setData($remote);
        }
        else { // deleted upstream.
            $this->api->getPool()->remove($this->getPoolKeys());
            throw new RuntimeException("{$this} was deleted upstream.");
        }
        $this->api->getPool()->add($this);
        return $this;
    }

}