Biscolab\UpDown\Objects\CrudObject

Complexity

Total Complexity

17

Size/Duplication

Total Lines	183
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	update()	0	15	2
A	prepareApiPath()	0	10	2
A	create()	0	14	2
A	delete()	0	14	2
A	getEndpoint()	0	4	1
A	__construct()	0	10	2
A	getStaticEndpoint()	0	4	1
A	read()	0	10	1
A	getId()	0	4	1
A	all()	0	14	2
A	getPrimaryKey()	0	4	1

<?php
/**
 * Copyright (c) 2019 - present
 * updown - CrudObject.php
 * author: Roberto Belotti - roby.belotti@gmail.com
 * web : robertobelotti.com, github.com/biscolab
 * Initial version created on: 15/2/2019
 * MIT license: https://github.com/biscolab/updown-php/blob/master/LICENSE
 */

namespace Biscolab\UpDown\Objects;

use Biscolab\UpDown\Abstracts\AbstractCollection;
use Biscolab\UpDown\Abstracts\AbstractObject;
use Biscolab\UpDown\UpDown;

/**
 * Class CrudObject
 * @package Biscolab\UpDown\Abstracts
 */
class CrudObject extends AbstractObject
{

    /**
     * @var string
     */
    protected static $endpoint = '';

    /**
     * @var string
     */
    protected static $collection_type = '';

    /**
     * @var string
     */
    protected $key = '';

    /**
     * CrudObject constructor.
     *
     * @param mixed $args
     */
    public function __construct($args = [])
    {

        if (!is_array($args)) {
            $args_[self::getPrimaryKey()] = $args;

$args_ was never initialized. Although not strictly required by PHP, it is generally a good practice to add $args_ = array(); before regardless.

        } else {
            $args_ = $args;
        }

        parent::__construct($args_);
    }

    /**
     * @return string
     */
    public static function getPrimaryKey(): string
    {

        return 'token';
    }

    /**
     * @return null|AbstractCollection
     */
    public function all(): AbstractCollection
    {

        $path = static::getEndpoint();

        $response = $this->updown->get($path);

The method get() does not exist on null.

        if (static::$collection_type) {
            $collection_type = static::$collection_type;

            return new $collection_type($response->getResult()->getData());
        }

        return null;

The expression return null returns the type null which is incompatible with the type-hinted return Biscolab\UpDown\Abstracts\AbstractCollection.

    }

    /**
     * @return string
     */
    protected static function getEndpoint(): string
    {

        return UpDown::API_URL . static::$endpoint;
    }

    /**
     * @param array|null $params
     *
     * @return AbstractObject
     */
    public function create(?array $params = []): AbstractObject
    {

        if (empty($params)) {
            $params = $this->attributes;
        }

        $path = $this->prepareApiPath(false);

        $response = $this->updown->post($path, $params);

        $this->setArgs($response->getResult()->getData());

        return $this;
    }

    /**
     * @param bool|null $with_id
     *
     * @return string
     */
    public function prepareApiPath(?bool $with_id = true): string
    {

        $path = static::getEndpoint();

        if ($with_id) {
            $path .= '/' . $this->getId();
        }

        return $path;
    }

    /**
     * @return mixed
     */
    public function getId()
    {

        return $this->{static::getPrimaryKey()};

    }

    /**
     * @return AbstractObject
     */
    public function read(): AbstractObject
    {

        $path = $this->prepareApiPath();

        $response = $this->updown->get($path);

        $this->setArgs($response->getResult()->getData());

        return $this;
    }

    /**
     * @param $params
     *
     * @return AbstractObject
     */
    public function update(?array $params = []): AbstractObject
    {

        if (empty($params)) {
            $params = $this->attributes;
            $this->setArgs($params);
        }

        $path = $this->prepareApiPath();

        $response = $this->updown->put($path, $params);

        $this->setArgs($response->getResult()->getData());

        return $this;
    }

    /**
     * @return bool
     */
    public function delete(): bool
    {

        $path = $this->prepareApiPath();

        $response = $this->updown->delete($path);

        $result = $response->getResult()->getData();

        if ($result['deleted']) {
            return $result['deleted'];
        }

        return false;
    }

    /**
     * @return string
     */
    public function getStaticEndpoint(): string
    {

        return static::getEndpoint();
    }

}