Tmilos\ScimSchema\Model\Resource

Complexity

Total Complexity

27

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getExtensions()	0	3	1
B	addExtension()	0	17	7
A	getId()	0	3	1
A	getMeta()	0	3	1
B	deserializeCommonAttributes()	0	19	8
A	__construct()	0	5	1
A	getSchemas()	0	3	1
A	getExternalId()	0	3	1
A	serializeObject()	0	24	6

<?php

/*
 * This file is part of the tmilos/scim-schema package.
 *
 * (c) Milos Tomic <tmilos@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Tmilos\ScimSchema\Model;

abstract class Resource extends SchemaBase implements SerializableInterface, DeserializableInterface
{
    /** @var string */
    protected $id;

    /** @var string */
    protected $schemaId;

    /** @var string */
    protected $externalId;

    /** @var Meta */
    protected $meta;

    /** @var array|ResourceExtension[] schemaId => extension */
    private $extensions = [];

    /**
     * @param string $id
     */
    public function __construct($id)
    {
        $this->id = $id;
        $this->schemaId = $this->getSchemaId();
        $this->meta = new Meta($this->getResourceType());
    }

    /**
     * @return string
     */
    abstract public function getResourceType();

    /**
     * @return \string[]
     */
    public function getSchemas()
    {
        return array_merge([static::getSchemaId()], array_keys($this->extensions));

The method Tmilos\ScimSchema\Model\SchemaBase::getSchemaId() is not static, but was called statically.

    }

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

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

    /**
     * @return Meta
     */
    public function getMeta()
    {
        return $this->meta;
    }

    /**
     * @return array|ResourceExtension[] schemaId => extension
     */
    public function getExtensions()
    {
        return $this->extensions;
    }

    /**
     * @param array|ResourceExtension $extension
     * @param string                  $schemaId
     */
    public function addExtension($extension, $schemaId = null)
    {
        if (!($extension instanceof ResourceExtension || is_array($extension))) {

The condition is_array($extension) is always true.

            throw new \InvalidArgumentException('Resource extension must extend ResourceExtension or be an array');
        }

        if ($extension instanceof ResourceExtension) {
            $schemaId = $extension->getSchemaId();
        } elseif (is_array($extension) && !$schemaId) {
            throw new \InvalidArgumentException('SchemaId must be specified if extension is added as array');
        }

        if ($schemaId === static::getSchemaId()) {

The method Tmilos\ScimSchema\Model\SchemaBase::getSchemaId() is not static, but was called statically.

            throw new \InvalidArgumentException(sprintf('Resource already has such main schema "%s"', $schemaId));
        }

        $this->extensions[$schemaId] = $extension;
    }

    /**
     * @return array
     */
    public function serializeObject()
    {
        $result = [
            'schemas' => $this->getSchemas(),
            'id' => $this->getId(),
        ];
        if ($this->getExternalId()) {
            $result['externalId'] = $this->getExternalId();
        }
        $result['meta'] = $this->getMeta()->serializeObject();
        foreach ($this->extensions as $schemaId => $extension) {
            if (!$extension) {
                continue;
            }
            if ($extension instanceof ResourceExtension) {
                $result[$schemaId] = $extension->serializeObject();

The method serializeObject() does not exist on Tmilos\ScimSchema\Model\ResourceExtension.

            } elseif (is_array($extension)) {
                $result[$schemaId] = $extension;
            } else {
                throw new \InvalidArgumentException('Resource extension must extend ResourceExtension or be an array');
            }
        }

        return $result;
    }

    /**
     * @param array $data
     *
     * @return static
     */
    protected static function deserializeCommonAttributes(array $data)
    {
        $result = new static(isset($data['id']) ? $data['id'] : null);
        if ($result->getResourceType() != $data['meta']['resourceType']) {
            throw new \RuntimeException(sprintf('Error deserializing resource type "%s" into class "%s"', $data['meta']['resourceType'], get_class($result)));
        }
        $result->meta = Meta::deserializeObject($data['meta']);
        if (isset($data['externalId'])) {
            $result->externalId = $data['externalId'];
        }
        if (isset($data['schemas'])) {
            foreach ($data['schemas'] as $schemaId) {
                if ($schemaId != $result->getSchemaId()) {
                    $result->extensions[$schemaId] = isset($data[$schemaId]) ? $data[$schemaId] : null;
                }
            }
        }

        return $result;
    }
}