PhpTek\Verifiable\Verify\VerifiableService

Complexity

Total Complexity

15

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	hash()	0	6	1
A	__construct()	0	3	1
A	getExtra()	0	3	1
A	setBackend()	0	21	4
A	write()	0	3	1
A	read()	0	3	1
A	call()	0	9	2
A	getBackend()	0	3	1
A	setExtra()	0	10	2
A	verify()	0	3	1

<?php

/**
 * @author  Russell Michell 2018 <russ@theruss.com>
 * @package silverstripe-verifiable
 */

namespace PhpTek\Verifiable\Verify;

use SilverStripe\Core\Injector\Injector;
use SilverStripe\Core\Injector\Injectable;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\ClassInfo;
use PhpTek\Verifiable\Exception\VerifiableBackendException;
use PhpTek\Verifiable\Backend\BackendProvider;

/**
 * Service class that works as an intermediary between any data model and the
 * currently selected Merkle Tree storage backend.
 *
 * @todo Handle rate-limiting by the Chainpoint network and by repeated access to this controller
 */
class VerifiableService
{
    use Injectable;
    use Configurable;

    /**
     * @var BackendProvider
     */
    protected $backend;

    /**
     *
     * @var array
     */
    protected $extra = [];

    /**
     * @return void
     * @throws VerifiableBackendException
     */
    public function __construct()
    {
        $this->setBackend();
    }

    /**
     * Wrapper around all backend methods.
     *
     * @param  string $method The name of the method to call
     * @param  mixed  $arg    The argument to pass to $method
     * @return mixed
     * @throws InvalidArgumentException
     */
    public function call($method, $arg)
    {
        if (!method_exists($this, $method)) {
            throw new \InvalidArgumentException("$method doesn't exist.");
        }

        $this->backend->setDiscoveredNodes($this->getExtra());

The method setDiscoveredNodes() does not exist on PhpTek\Verifiable\Backend\BackendProvider. It seems like you code against a sub-type of PhpTek\Verifiable\Backend\BackendProvider such as PhpTek\Verifiable\Backend\Chainpoint.

        return $this->$method($arg);
    }

    /**
     * Write a hash of data as per the "verifiable_fields" config static on each
     * {@link DataObject}.
     *
     * @param  array $data
     * @return mixed The result of this call to the backend.
     */
    protected function write(array $data)
    {
        return $this->backend->writeHash([$this->hash($data)]);
    }

    /**
     * Fetch a chainpoint proof for the passed $uuid.
     *
     * @param  string $uuid
     * @return string The JSON-LD chainpoint proof.
     */
    protected function read(string $uuid) : string
    {
        return $this->backend->getProof($uuid);
    }

    /**
     * Verify the given JSON-LD chainpoint proof against the backend.
     *
     * @param  string $proof A JSON-LD chainpoint proof.
     * @return mixed
     */
    protected function verify(string $proof)
    {
        return $this->backend->verifyProof($proof);
    }

    /**
     * @param  array $extra
     * @return VerifiableService
     */
    public function setExtra(array $extra = [])
    {
        if (!$extra) {

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

            $this->backend->setDiscoveredNodes();
            $this->extra = $this->backend->getDiscoveredNodes();

The method getDiscoveredNodes() does not exist on PhpTek\Verifiable\Backend\BackendProvider. It seems like you code against a sub-type of PhpTek\Verifiable\Backend\BackendProvider such as PhpTek\Verifiable\Backend\Chainpoint.

        } else {
            $this->extra = $extra;
        }

        return $this;
    }

    /**
     * @return array
     */
    public function getExtra()
    {
        return $this->extra;
    }

    /**
     * Set, configure and return a new Merkle Tree storage backend.
     *
     * @param  BackendProvider   $provider Optional manually passed backend.
     * @return VerifiableService
     * @throws VerifiableBackendException
     */
    public function setBackend(BackendProvider $provider = null)
    {
        if ($provider) {
            $this->backend = $provider;

            return $this;
        }

        $namedBackend = $this->config()->get('backend');
        $backends = ClassInfo::implementorsOf(BackendProvider::class);

        foreach ($backends as $backend) {
            if (singleton($backend)->name() === $namedBackend) {
                $this->backend = Injector::inst()->create($backend);

                return $this;
            }
        }

        // Cannot continue without a legit backend
        throw new VerifiableBackendException('No backend found');
    }

    /**
     * @return BackendProvider
     */
    public function getBackend()
    {
        return $this->backend;
    }

    /**
     * Hashes the data passed into the $hash param.
     *
     * @param  array  $data An array of data who's values should be hashed.
     * @return string       The resulting hashed data.
     */
    public function hash(array $data) : string
    {
        $func = $this->backend->hashFunc();
        $text = json_encode($data); // json_encode() to stringify arrays of arbitary depth

        return hash($func, $text);
    }

}