NOSQL\Dto\Model\NOSQLModelDto

Complexity

Total Complexity

36

Size/Duplication

Total Lines	178
Duplicated Lines	0 %

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setLastUpdate()	0	3	2
A	validate()	0	17	5
A	setName()	0	3	1
A	resetPk()	0	3	1
A	getLastUpdate()	0	7	2
A	getPk()	0	3	1
A	getName()	0	3	1
A	setPk()	0	6	2
A	toArray()	0	11	3
D	checkType()	0	50	18

<?php
namespace NOSQL\Dto\Model;

use MongoDB\BSON\UTCDateTime;
use NOSQL\Exceptions\NOSQLValidationException;
use NOSQL\Services\Base\NOSQLBase;
use PSFS\base\dto\Dto;
use PSFS\base\types\Api;
use PSFS\base\types\helpers\InjectorHelper;

/**
 * Class NOSQLModelDto
 * @package NOSQL\Dto\Model
 */
abstract class NOSQLModelDto extends Dto {
    /**
     * @var string
     * @label Model identifier
     */
    protected $_id;

    /**
     * @var \DateTime
     * @label Last update at
     */
    protected $_last_update;


    /**
     * @var string
     * @label List name in string
     */
    protected $__name__;

    /**
     * @return string
     */
    public function getPk()
    {
        return $this->_id;
    }

    public function resetPk() {
        $this->_id = null;
        $this->_last_update = null;
    }

    /**
     * @param string $id
     * @throws NOSQLValidationException
     */
    public function setPk(string $id)
    {
        if(!empty($this->_id)) {
            throw new NOSQLValidationException(t('Primary key already defined'), NOSQLValidationException::NOSQL_VALIDATION_ID_ALREADY_DEFINED);
        }
        $this->_id = $id;
    }

    /**
     * @param string $format
     * @return \DateTime|string
     */
    public function getLastUpdate($format = null)
    {
        $value = $this->_last_update;
        if(null !== $format) {

        }
        return $value;
    }

    /**
     * @param \DateTime|null $last_update
     * @throws \Exception
     */
    public function setLastUpdate($last_update = null)
    {
        $this->_last_update = $last_update ?: new UTCDateTime();

It seems like $last_update ?: new MongoDB\BSON\UTCDateTime() can also be of type MongoDB\BSON\UTCDateTime. However, the property $_last_update is declared as type DateTime. Maybe add an additional type check?

    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->__name__;
    }

    /**
     * @param string $_name__
     */
    public function setName($_name__)
    {
        $this->__name__ = $_name__;
    }

    /**
     * @param bool $throwException
     * @return array
     * @throws NOSQLValidationException
     * @throws \ReflectionException
     */
    public function validate($throwException = false) {
        $errors = [];
        $reflection = new \ReflectionClass(get_called_class());
        foreach($reflection->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
            $required = InjectorHelper::checkIsRequired($property->getDocComment());
            $value = $property->getValue($this);
            if($required && empty($value)) {
                if($throwException) {
                    throw new NOSQLValidationException(t('Empty value for property ') . $property->getName(), NOSQLValidationException::NOSQL_VALIDATION_REQUIRED);
                } else {
                    $errors[] = $property->getName();
                }
            } else {
                $this->checkType($throwException, $property, $value, $errors);
            }
        }
        return $errors;
    }

    public function toArray()
    {
        $array = parent::toArray();
        if(null !== $this->getPk()) {

The condition null !== $this->getPk() is always true.

            $array['_id'] = $this->getPk();
        }
        if(null !== $this->getName()) {

The condition null !== $this->getName() is always true.

            $array[Api::API_LIST_NAME_FIELD] = $this->getName();
        }
        $array['_last_update'] = $this->getLastUpdate(\DateTime::ATOM);
        return $array;
    }

    /**
     * @param $throwException
     * @param \ReflectionProperty $property
     * @param $value
     * @param array $errors
     * @throws NOSQLValidationException
     */
    private function checkType($throwException, \ReflectionProperty &$property, $value, array &$errors)
    {
        $type = InjectorHelper::extractVarType($property->getDocComment());

Are you sure the assignment to $type is correct as PSFS\base\types\helpers\InjectorHelper::extractVarType($property->getDocComment()) targeting PSFS\base\types\helpers\InjectorHelper::extractVarType() seems to always return null.

        switch (strtolower($type)) {
            case NOSQLBase::NOSQL_TYPE_LONG:
            case NOSQLBase::NOSQL_TYPE_INTEGER:
            case NOSQLBase::NOSQL_TYPE_DOUBLE:
                if (!is_numeric($value)) {
                    $errors[] = $property->getName();
                } else {
                    if(NOSQLBase::NOSQL_TYPE_INTEGER === strtolower($type)) {
                        $property->setValue($this, (integer)$value);
                    } else {
                        $property->setValue($this, (float)$value);
                    }
                }
                break;
            case NOSQLBase::NOSQL_TYPE_ENUM:
                $values = InjectorHelper::getValues($property->getDocComment());
                if (!in_array($value, $values)) {

It seems like $values can also be of type null; however, parameter $haystack of in_array() does only seem to accept array, maybe add an additional type check?

                    $errors[] = $property->getName();
                }
                break;
            case NOSQLBase::NOSQL_TYPE_OBJECT:
                $property->setValue($this, json_decode($value, true));
                break;
            case NOSQLBase::NOSQL_TYPE_ARRAY:
                if (!is_array($value)) {
                    $errors[] = $property->getName();
                }
                break;
            case NOSQLBase::NOSQL_TYPE_BOOLEAN:
                if (!in_array($value, [true, false, 0, 1])) {
                    $errors[] = $property->getName();
                }
                $property->setValue($this, (bool)$value);
                break;
            case NOSQLBase::NOSQL_TYPE_DATE:
            case NOSQLBase::NOSQL_TYPE_TIMESTAMP:
                $dateTime = new \DateTime($value, new \DateTimeZone('UTC'));
                if(!$dateTime) {

$dateTime is of type DateTime, thus it always evaluated to true.

                    $errors[] = $property->getName();
                } else {
                    $dateTime->setTimezone(new \DateTimeZone(date_default_timezone_get()));
                    $property->setValue($this, new UTCDateTime($dateTime->getTimestamp()*1000));
                }
                break;
        }
        if (in_array($property->getName(), $errors) && $throwException) {
            throw new NOSQLValidationException(t('Format not valid for property ') . $property->getName(), NOSQLValidationException::NOSQL_VALIDATION_NOT_VALID);
        }
    }
}