JsonApiBaseController::index() - Code Metrics - Inspection of "Use next version of json api library." - limoncello-php-dist/flute - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( dcfc04...3d10a6 )

by Neomerx

created 2019-01-30 21:04 UTC

JsonApiBaseController::index() A

↳ Parent: JsonApiBaseController

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	18
Ratio	100 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	18
loc	18
ccs	0
cts	11
cp	0
rs	9.6666
c	0
b	0
f	0
cc	1
nc	1
nop	3
crap	2

<?php namespace Limoncello\Flute\Http;

/**
 * Copyright 2015-2018 [email protected]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Limoncello\Contracts\Data\ModelSchemaInfoInterface;
use Limoncello\Contracts\L10n\FormatterFactoryInterface;
use Limoncello\Flute\Contracts\Encoder\EncoderInterface;
use Limoncello\Flute\Contracts\FactoryInterface;
use Limoncello\Flute\Contracts\Http\JsonApiControllerInterface;
use Limoncello\Flute\Contracts\Schema\JsonSchemasInterface;
use Limoncello\Flute\Http\Traits\DefaultControllerMethodsTrait;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

/**
 * @package Limoncello\Flute
 */
abstract class JsonApiBaseController implements JsonApiControllerInterface
{
    use DefaultControllerMethodsTrait;

    /** API class name */
    const API_CLASS = null;

    /** JSON API Schema class name */
    const SCHEMA_CLASS = null;

    /** JSON API query validation rules class */
    const ON_INDEX_QUERY_VALIDATION_RULES_CLASS = null;

    /** JSON API query validation rules class */
    const ON_READ_QUERY_VALIDATION_RULES_CLASS = null;

    /** JSON API data validation rules class */
    const ON_CREATE_DATA_VALIDATION_RULES_CLASS = null;

    /** JSON API data validation rules class */
    const ON_UPDATE_DATA_VALIDATION_RULES_CLASS = null;

    /**
     * @inheritdoc
     */
    public static function index(

        array $routeParams,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_INDEX_QUERY_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        return static::defaultIndexHandler(
            $request->getQueryParams(),
            $request->getUri(),
            static::defaultCreateQueryParser($container, static::ON_INDEX_QUERY_VALIDATION_RULES_CLASS),
            static::defaultCreateParameterMapper($container, static::SCHEMA_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(EncoderInterface::class)
        );
    }

    /**
     * @inheritdoc
     */
    public static function create(

        array $routeParams,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_CREATE_DATA_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        $response = static::defaultCreateHandler(
            $request->getUri(),
            $request->getBody(),
            static::SCHEMA_CLASS,
            $container->get(ModelSchemaInfoInterface::class),
            static::defaultCreateDataParser($container, static::ON_CREATE_DATA_VALIDATION_RULES_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(JsonSchemasInterface::class),
            $container->get(EncoderInterface::class),
            $container->get(FactoryInterface::class),
            $container->get(FormatterFactoryInterface::class)
        );

        return $response;
    }

    /**
     * @inheritdoc
     */
    public static function read(

        array $routeParams,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_READ_QUERY_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        return static::defaultReadHandler(
            $routeParams[static::ROUTE_KEY_INDEX],
            $request->getQueryParams(),
            $request->getUri(),
            static::defaultCreateQueryParser($container, static::ON_READ_QUERY_VALIDATION_RULES_CLASS),
            static::defaultCreateParameterMapper($container, static::SCHEMA_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(EncoderInterface::class)
        );
    }

    /**
     * @inheritdoc
     */
    public static function update(

        array $routeParams,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        $response = static::defaultUpdateHandler(
            $routeParams[static::ROUTE_KEY_INDEX],
            $request->getUri(),
            $request->getBody(),
            static::SCHEMA_CLASS,
            $container->get(ModelSchemaInfoInterface::class),
            static::defaultCreateDataParser($container, static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(EncoderInterface::class),
            $container->get(FactoryInterface::class),
            $container->get(FormatterFactoryInterface::class)
        );

        return $response;
    }

    /**
     * @inheritdoc
     */
    public static function delete(
        array $routeParams,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        $response = static::defaultDeleteHandler(
            $routeParams[static::ROUTE_KEY_INDEX],
            $request->getUri(),
            static::defaultCreateQueryParser($container, static::ON_READ_QUERY_VALIDATION_RULES_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(EncoderInterface::class)
        );

        return $response;
    }

    /**
     * @param string                 $index
     * @param string                 $modelRelName
     * @param string                 $queryValRulesClass
     * @param ContainerInterface     $container
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     *
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    protected static function readRelationship(

        string $index,
        string $modelRelName,
        string $queryValRulesClass,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        $api     = static::defaultCreateApi($container, static::API_CLASS);
        $handler = function () use ($api, $index, $modelRelName) {
            return $api->readRelationship($index, $modelRelName);
        };

        return static::defaultReadRelationshipWithClosureHandler(
            $index,
            $handler,
            $request->getQueryParams(),
            $request->getUri(),
            static::defaultCreateQueryParser($container, $queryValRulesClass),
            static::defaultCreateParameterMapper($container, static::SCHEMA_CLASS),
            $api,
            $container->get(EncoderInterface::class)
        );
    }

    /**
     * @param string                 $index
     * @param string                 $modelRelName
     * @param string                 $queryValRulesClass
     * @param ContainerInterface     $container
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     *
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    protected static function readRelationshipIdentifiers(

        string $index,
        string $modelRelName,
        string $queryValRulesClass,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        $api     = static::defaultCreateApi($container, static::API_CLASS);
        $handler = function () use ($api, $index, $modelRelName) {
            return $api->readRelationship($index, $modelRelName);
        };

        return static::defaultReadRelationshipIdentifiersWithClosureHandler(
            $index,
            $handler,
            $request->getQueryParams(),
            $request->getUri(),
            static::defaultCreateQueryParser($container, $queryValRulesClass),
            static::defaultCreateParameterMapper($container, static::SCHEMA_CLASS),
            $api,
            $container->get(EncoderInterface::class)
        );
    }

    /**
     * @param string                 $parentIndex
     * @param string                 $jsonRelName
     * @param string                 $modelRelName
     * @param ContainerInterface     $container
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     */
    protected static function addInRelationship(

        string $parentIndex,
        string $jsonRelName,
        string $modelRelName,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_READ_QUERY_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        return static::defaultAddInRelationshipHandler(
            $parentIndex,
            $jsonRelName,
            $modelRelName,
            $request->getUri(),
            $request->getBody(),
            static::SCHEMA_CLASS,
            $container->get(ModelSchemaInfoInterface::class),
            static::defaultCreateQueryParser($container, static::ON_READ_QUERY_VALIDATION_RULES_CLASS),
            static::defaultCreateDataParser($container, static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(EncoderInterface::class),
            $container->get(FactoryInterface::class),
            $container->get(FormatterFactoryInterface::class)
        );
    }

    /**
     * @param string                 $parentIndex
     * @param string                 $jsonRelName
     * @param string                 $modelRelName
     * @param ContainerInterface     $container
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     */
    protected static function deleteInRelationship(

        string $parentIndex,
        string $jsonRelName,
        string $modelRelName,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_READ_QUERY_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        return static::defaultDeleteInRelationshipHandler(
            $parentIndex,
            $jsonRelName,
            $modelRelName,
            $request->getUri(),
            $request->getBody(),
            static::SCHEMA_CLASS,
            $container->get(ModelSchemaInfoInterface::class),
            static::defaultCreateQueryParser($container, static::ON_READ_QUERY_VALIDATION_RULES_CLASS),
            static::defaultCreateDataParser($container, static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(EncoderInterface::class),
            $container->get(FactoryInterface::class),
            $container->get(FormatterFactoryInterface::class)
        );
    }

    /**
     * @param string                 $parentIndex
     * @param string                 $jsonRelName
     * @param string                 $modelRelName
     * @param ContainerInterface     $container
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     */
    protected static function replaceInRelationship(

        string $parentIndex,
        string $jsonRelName,
        string $modelRelName,
        ContainerInterface $container,
        ServerRequestInterface $request
    ): ResponseInterface {
        static::assertClassValueDefined(static::API_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::SCHEMA_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_READ_QUERY_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
        static::assertClassValueDefined(static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}

        return static::defaultReplaceInRelationship(
            $parentIndex,
            $jsonRelName,
            $modelRelName,
            $request->getUri(),
            $request->getBody(),
            static::SCHEMA_CLASS,
            $container->get(ModelSchemaInfoInterface::class),
            static::defaultCreateQueryParser($container, static::ON_READ_QUERY_VALIDATION_RULES_CLASS),
            static::defaultCreateDataParser($container, static::ON_UPDATE_DATA_VALIDATION_RULES_CLASS),
            static::defaultCreateApi($container, static::API_CLASS),
            $container->get(EncoderInterface::class),
            $container->get(FactoryInterface::class),
            $container->get(FormatterFactoryInterface::class)
        );
    }
}


1			<?php namespace Limoncello\Flute\Http;
2
3			/**
4			* Copyright 2015-2018 [email protected]
5			*
6			* Licensed under the Apache License, Version 2.0 (the "License");
7			* you may not use this file except in compliance with the License.
8			* You may obtain a copy of the License at
9			*
10			* http://www.apache.org/licenses/LICENSE-2.0
11			*
12			* Unless required by applicable law or agreed to in writing, software
13			* distributed under the License is distributed on an "AS IS" BASIS,
14			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15			* See the License for the specific language governing permissions and
16			* limitations under the License.
17			*/
18
19			use Limoncello\Contracts\Data\ModelSchemaInfoInterface;
20			use Limoncello\Contracts\L10n\FormatterFactoryInterface;
21			use Limoncello\Flute\Contracts\Encoder\EncoderInterface;
22			use Limoncello\Flute\Contracts\FactoryInterface;
23			use Limoncello\Flute\Contracts\Http\JsonApiControllerInterface;
24			use Limoncello\Flute\Contracts\Schema\JsonSchemasInterface;
25			use Limoncello\Flute\Http\Traits\DefaultControllerMethodsTrait;
26			use Psr\Container\ContainerExceptionInterface;
27			use Psr\Container\ContainerInterface;
28			use Psr\Container\NotFoundExceptionInterface;
29			use Psr\Http\Message\ResponseInterface;
30			use Psr\Http\Message\ServerRequestInterface;
31
32			/**
33			* @package Limoncello\Flute
34			*/
35			abstract class JsonApiBaseController implements JsonApiControllerInterface
36			{
37			use DefaultControllerMethodsTrait;
38
39			/** API class name */
40			const API_CLASS = null;

limoncello-php-dist / flute

Push — develop ( dcfc04...3d10a6 )

JsonApiBaseController::index() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like