JsonApiBaseController::index() - Code Metrics - limoncello-php-dist/flute - Measure and Improve Code Quality continuously with Scrutinizer

JsonApiBaseController::index() A
last analyzed 2019-06-17 07:44 UTC

↳ Parent: JsonApiBaseController
Complexity

Conditions	1
Paths	1
Size

Total Lines
Duplication

Lines	18
Ratio	100 %
Code Coverage

Tests	11
CRAP Score	1
Importance

Changes
Metric	Value
dl	18
loc	18
ccs	11
cts	11
cp	1
rs	9.6666
c	0
b	0
f	0
cc	1
nc	1
nop	3
crap	1
<?php declare (strict_types = 1);

namespace Limoncello\Flute\Http;

/**
 * Copyright 2015-2019 [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;

    /** @var string|null API class name */
    const API_CLASS = null;

    /** @var string|null JSON API Schema class name */
    const SCHEMA_CLASS = null;

    /** @var string|null @var string|null JSON API query validation rules class */
    const ON_INDEX_QUERY_VALIDATION_RULES_CLASS = null;

    /** @var string|null @var string|null JSON API query validation rules class */
    const ON_READ_QUERY_VALIDATION_RULES_CLASS = null;

    /** @var string|null @var string|null JSON API data validation rules class */
    const ON_CREATE_DATA_VALIDATION_RULES_CLASS = null;

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

JsonApiBaseController::index() A last analyzed 2019-06-17 07:44 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

JsonApiBaseController::index() A
last analyzed 2019-06-17 07:44 UTC
