SoliDry\Helpers\Json

Complexity

Total Complexity

40

Size/Duplication

Total Lines	249
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	getRelationships()	0	3	2
A	getRelations()	0	25	6
A	outputErrors()	0	13	4
A	getBulkAttributes()	0	3	2
A	getAttributes()	0	3	2
A	getData()	0	3	2
A	unsetArray()	0	7	5
A	decode()	0	3	1
A	encode()	0	3	1
A	prepareSerializedData()	0	17	3
A	unsetObject()	0	5	3
A	prepareSerializedRelations()	0	9	1
A	getResource()	0	16	3
A	getErrors()	0	8	2
A	getSelectedData()	0	16	3

<?php

namespace SoliDry\Helpers;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\Request;

This use statement conflicts with another class in this namespace, SoliDry\Helpers\Request. Consider defining an alias.

use League\Fractal\Manager;
use League\Fractal\Resource\Collection;
use League\Fractal\Resource\Item;
use League\Fractal\Resource\ResourceInterface;
use League\Fractal\Serializer\JsonApiSerializer;
use SoliDry\Types\ModelsInterface;
use SoliDry\Types\PhpInterface;
use SoliDry\Types\ApiInterface;
use SoliDry\Extension\BaseFormRequest;
use SoliDry\Extension\JSONApiInterface;
use SoliDry\Transformers\DefaultTransformer;

class Json
{
    /**
     * @param array $jsonApiArr
     *
     * @return array
     */
    public static function getAttributes(array $jsonApiArr) : array
    {
        return empty($jsonApiArr[ApiInterface::RAML_DATA][ApiInterface::RAML_ATTRS]) ? [] : $jsonApiArr[ApiInterface::RAML_DATA][ApiInterface::RAML_ATTRS];
    }

    /**
     * Returns an array of bulk attributes for each element
     *
     * @param array $jsonApiArr
     * @return array
     */
    public static function getBulkAttributes(array $jsonApiArr) : array
    {
        return empty($jsonApiArr[ApiInterface::RAML_DATA]) ? [] : $jsonApiArr[ApiInterface::RAML_DATA];
    }

    /**
     * @param array $jsonApiArr
     *
     * @return array
     */
    public static function getRelationships(array $jsonApiArr) : array
    {
        return empty($jsonApiArr[ApiInterface::RAML_DATA][ApiInterface::RAML_RELATIONSHIPS]) ? [] : $jsonApiArr[ApiInterface::RAML_DATA][ApiInterface::RAML_RELATIONSHIPS];
    }

    /**
     * @param array $jsonApiArr
     *
     * @return array
     */
    public static function getData(array $jsonApiArr) : array
    {
        return empty($jsonApiArr[ApiInterface::RAML_DATA]) ? [] : $jsonApiArr[ApiInterface::RAML_DATA];
    }

    /**
     * @param $relations      \Illuminate\Database\Eloquent\Collection
     * @param string $entity
     * @return array JSON API rels compatible array
     */
    public static function getRelations($relations, string $entity) : array
    {
        $jsonArr = [];
        if ($relations instanceof \Illuminate\Database\Eloquent\Collection) {
            $cnt = count($relations);
            if ($cnt > 1) {
                foreach ($relations as $v) {
                    $attrs     = $v->getAttributes();
                    $jsonArr[] = [ApiInterface::RAML_TYPE => $entity,
                                  ApiInterface::RAML_ID   => $attrs[ApiInterface::RAML_ID]];
                }
            } else {
                foreach ($relations as $v) {
                    $attrs   = $v->getAttributes();
                    $jsonArr = [ApiInterface::RAML_TYPE => $entity,
                                ApiInterface::RAML_ID   => $attrs[ApiInterface::RAML_ID]];
                }
            }
        } elseif ($relations instanceof Model) {
            $attrs   = $relations->getAttributes();
            $jsonArr = [ApiInterface::RAML_TYPE => $entity,
                        ApiInterface::RAML_ID   => $attrs[ApiInterface::RAML_ID]];
        }

        return $jsonArr;
    }

    /**
     * Output errors in JSON API compatible format
     * @param array $errors
     * @param bool $return
     * @return string
     */
    public static function outputErrors(array $errors, bool $return = false)
    {
        $arr[JSONApiInterface::CONTENT_ERRORS] = [];

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

        if (empty($errors) === false) {
            $arr[JSONApiInterface::CONTENT_ERRORS] = $errors;
        }
        // errors and codes must be clear with readable json
        $encoded = self::encode($arr, JSON_NUMERIC_CHECK | JSON_PRETTY_PRINT);
        if (false === $return && env('APP_ENV') !== 'dev') {
            echo $encoded;
            exit(JSONApiInterface::EXIT_STATUS_ERROR);

Using exit here is not recommended.

        }
        return $encoded;
    }

    /**
     *
     * @param array $errors
     * @return string
     */
    public function getErrors(array $errors) : string
    {
        $arr[JSONApiInterface::CONTENT_ERRORS] = [];

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

        if (empty($errors) === false) {
            $arr[JSONApiInterface::CONTENT_ERRORS] = $errors;
        }

        return self::encode($arr, JSON_NUMERIC_CHECK | JSON_PRETTY_PRINT);
    }

    /**
     * Returns composition of relations
     *
     * @param Request $request
     * @param array $data
     * @return string
     */
    public static function prepareSerializedRelations(Request $request, array $data) : string
    {
        $arr[JSONApiInterface::CONTENT_LINKS] = [

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

            JSONApiInterface::CONTENT_SELF => $request->getUri(),
        ];

        $arr[JSONApiInterface::CONTENT_DATA] = $data;

        return self::encode($arr);
    }

    /**
     * @param BaseFormRequest $formRequest
     * @param                 $model
     * @param string $entity
     * @param bool $isCollection
     *
     * @param array $meta
     * @return Collection|Item
     */
    public static function getResource(BaseFormRequest $formRequest, $model, string $entity, bool $isCollection = false, array $meta = [])
    {
        $transformer = new DefaultTransformer($formRequest);
        if ($isCollection === true) {
            $collection = new Collection($model, $transformer, strtolower($entity));
            if (empty($meta) === false) {
                $collection->setMeta($meta);
            }

            return $collection;
        }

        $item = new Item($model, $transformer, strtolower($entity));
        $item->setMeta($meta);

        return $item;
    }

    /**
     * @param ResourceInterface $resource
     * @param array $data
     * @return string
     */
    public static function prepareSerializedData(ResourceInterface $resource, $data = ModelsInterface::DEFAULT_DATA) : string
    {
        if (empty($resource->getData())) { // preventing 3d party libs (League etc) from crash on empty data
            return self::encode([
                ModelsInterface::PARAM_DATA => []
            ]);
        }

        $host    = $_SERVER['HTTP_HOST'];
        $manager = new Manager();

        if (isset($_GET['include'])) {
            $manager->parseIncludes($_GET['include']);
        }

        $manager->setSerializer(new JsonApiSerializer($host));
        return self::getSelectedData($manager->createData($resource)->toJson(), $data);
    }

    /**
     * @param array $array
     * @param int $opts
     * @return string
     */
    public static function encode(array $array, int $opts = 0)
    {
        return json_encode($array, $opts);
    }

    /**
     * @param mixed $json
     * @return mixed
     */
    public static function decode($json)
    {
        return json_decode($json, true);
    }

    /**
     * @param string $json
     * @param array $data
     * @return string
     */
    private static function getSelectedData(string $json, array $data) : string
    {
        if (current($data) === PhpInterface::ASTERISK) {// do nothing - grab all fields
            return $json;
        }

        $jsonArr = self::decode($json);
        $current = current($jsonArr[ApiInterface::RAML_DATA]);

        if (empty($current[JSONApiInterface::CONTENT_ATTRIBUTES]) === false) {// this is an array of values
            self::unsetArray($jsonArr, $data);
        } else {// this is just one element
            self::unsetObject($jsonArr, $data);
        }

        return self::encode($jsonArr);
    }

    /**
     *
     * @param array &$json
     * @param array $data
     */
    private static function unsetArray(array &$json, array $data) : void
    {
        foreach ($json as &$jsonObject) {
            foreach ($jsonObject as &$v) {
                foreach ($v[JSONApiInterface::CONTENT_ATTRIBUTES] as $key => $attr) {
                    if (in_array($key, $data) === false) {
                        unset($v[JSONApiInterface::CONTENT_ATTRIBUTES][$key]);
                    }
                }
            }
        }
    }

    /**
     * @param array $json
     * @param array $data
     */
    private static function unsetObject(array &$json, array $data) : void
    {
        foreach ($json[JSONApiInterface::CONTENT_DATA][JSONApiInterface::CONTENT_ATTRIBUTES] as $k => $v) {
            if (in_array($k, $data) === false) {
                unset($json[JSONApiInterface::CONTENT_DATA][JSONApiInterface::CONTENT_ATTRIBUTES][$k]);
            }
        }
    }
}