ApiAbstract::delete() - Code Metrics - Inspection of "Api base controller moved out of Admin" - abterphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 932fc1...a9416d )

by Peter
created 2019-06-21 19:30 UTC
ApiAbstract::delete() A

↳ Parent: ApiAbstract
Complexity

Conditions	3
Paths	5
Size

Total Lines	16
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	9
nc	5
nop	1
dl	0
loc	16
rs	9.9666
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace AbterPhp\Framework\Http\Controllers;

use AbterPhp\Framework\Databases\Queries\FoundRows;
use AbterPhp\Framework\Domain\Entities\IStringerEntity;
use AbterPhp\Framework\Domain\Entities\IToJsoner;
filter:
    dependency_paths: ["lib/*"]
use AbterPhp\Framework\Http\Service\Execute\RepoServiceAbstract;
use Opulence\Http\Requests\UploadedFile;
use Opulence\Http\Responses\Response;
use Opulence\Http\Responses\ResponseHeaders;
use Opulence\Orm\OrmException;
use Opulence\Routing\Controller;
use Psr\Log\LoggerInterface;

abstract class ApiAbstract extends Controller
{
    const LOG_MSG_CREATE_FAILURE = 'Creating %1$s failed.';
    const LOG_MSG_UPDATE_FAILURE = 'Updating %1$s with id "%2$s" failed.';
    const LOG_MSG_DELETE_FAILURE = 'Deleting %1$s with id "%2$s" failed.';
    const LOG_MSG_GET_FAILURE    = 'Retrieving %1$s with id "%2$s" failed.';
    const LOG_MSG_LIST_FAILURE   = 'Retrieving %1$s failed.';

    const LOG_CONTEXT_EXCEPTION  = 'Exception';
    const LOG_PREVIOUS_EXCEPTION = 'Previous exception #%d';

    const ENTITY_SINGULAR = '';
    const ENTITY_PLURAL   = '';

    /** @var LoggerInterface */
    protected $logger;

    /** @var RepoService */
filter:
    dependency_paths: ["lib/*"]
    protected $repoService;

    /** @var FoundRows */
    protected $foundRows;

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

    /**
     * ApiAbstract constructor.
     *
     * @param LoggerInterface     $logger
     * @param RepoServiceAbstract $repoService
     * @param FoundRows           $foundRows
     * @param string              $problemBaseUrl
     */
    public function __construct(
        LoggerInterface $logger,
        RepoServiceAbstract $repoService,
        FoundRows $foundRows,
        string $problemBaseUrl
    ) {
        $this->logger         = $logger;
        $this->repoService    = $repoService;

        $this->foundRows      = $foundRows;
        $this->problemBaseUrl = $problemBaseUrl;
    }

    /**
     * @param string $entityId
     *
     * @return Response
     */
    public function get(string $entityId): Response
    {
        try {
            $entity = $this->repoService->retrieveEntity($entityId);
        } catch (\Exception $e) {
            $msg = sprintf(static::LOG_MSG_GET_FAILURE, static::ENTITY_SINGULAR);

            return $this->handleException($msg, $e);
        }

        return $this->handleGetSuccess($entity);
    }

    /**
     * @return Response
     */
    public function list(): Response
    {
        $query = $this->request->getQuery();

        $offset = (int)$query->get('offset', 0);
        $limit  = (int)$query->get('limit', 100);

        try {
            $entities = $this->repoService->retrieveList($offset, $limit, [], [], []);
        } catch (\Exception $e) {
            $msg = sprintf(static::LOG_MSG_LIST_FAILURE, static::ENTITY_PLURAL);

            return $this->handleException($msg, $e);
        }

        $maxCount = $this->foundRows->get();

        return $this->handleListSuccess($entities, $maxCount);
    }

    /**
     * @return Response
     */
    public function create(): Response
    {
        try {
            $data = $this->getCreateData();

            $errors = $this->repoService->validateForm($data);

            if (count($errors) > 0) {
                $msg = sprintf(static::LOG_MSG_CREATE_FAILURE, static::ENTITY_SINGULAR);

                return $this->handleErrors($msg, $errors);
            }

            $fileData = $this->getFileData($data);
            $entity   = $this->repoService->create($data, $fileData);
        } catch (\Exception $e) {
            $msg = sprintf(static::LOG_MSG_CREATE_FAILURE, static::ENTITY_SINGULAR);

            return $this->handleException($msg, $e);
        }

        return $this->handleCreateSuccess($entity);
    }

    /**
     * @param string $entityId
     *
     * @return Response
     */
    public function update(string $entityId): Response
    {
        try {
            $data = $this->getUpdateData();

            $errors = $this->repoService->validateForm($data);

            if (count($errors) > 0) {
                $msg = sprintf(static::LOG_MSG_UPDATE_FAILURE, static::ENTITY_SINGULAR, $entityId);

                return $this->handleErrors($msg, $errors);
            }

            $fileData = $this->getFileData($data);
            $entity   = $this->repoService->retrieveEntity($entityId);
            $this->repoService->update($entity, $data, $fileData);
        } catch (\Exception $e) {
            if ($this->isEntityNotFound($e)) {
                return $this->handleNotFound();
            }

            $msg = sprintf(static::LOG_MSG_UPDATE_FAILURE, static::ENTITY_SINGULAR, $entityId);

            return $this->handleException($msg, $e);
        }

        return $this->handleUpdateSuccess($entity);
    }

    /**
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     *
     * @param array $data
     *
     * @return UploadedFile[]
     */
    protected function getFileData(array $data): array
    protected function getFileData(/** @scrutinizer ignore-unused */ array $data): array
    {
        return [];
    }

    /**
     * @param string $entityId
     *
     * @return Response
     */
    public function delete(string $entityId): Response
    {
        try {
            $entity = $this->repoService->retrieveEntity($entityId);
            $this->repoService->delete($entity);
        } catch (\Exception $e) {
            if ($this->isEntityNotFound($e)) {
                return $this->handleNotFound();
            }

            $msg = sprintf(static::LOG_MSG_DELETE_FAILURE, static::ENTITY_SINGULAR, $entityId);

            return $this->handleException($msg, $e);
        }

        return $this->handleDeleteSuccess();
    }

    /**
     * @param \Exception $e
     *
     * @return bool
     */
    protected function isEntityNotFound(\Exception $e): bool
    {
        if (!($e instanceof OrmException)) {
            return false;
        }

        return $e->getMessage() === 'Failed to find entity';
    }

    /**
     * @return array
     */
    public function getCreateData(): array
    {
        return $this->getSharedData();
    }

    /**
     * @return array
     */
    public function getUpdateData(): array
    {
        return $this->getSharedData();
    }

    /**
     * @return array
     */
    public function getSharedData(): array
    {
        return $this->request->getJsonBody();
    }

    /**
     * @param string $msg
     * @param array  $errors
     *
     * @return Response
     */
    protected function handleErrors(string $msg, array $errors): Response
    {
        $this->logger->debug($msg);

        $detail = [];
        foreach ($errors as $key => $keyErrors) {
            foreach ($keyErrors as $keyError) {
                $detail[] = sprintf('%s: %s', $key, $keyError);
            }
        }

        $status  = ResponseHeaders::HTTP_BAD_REQUEST;
        $content = [
            'type'   => sprintf('%sbad-request', $this->problemUrlBase),

            'title'  => 'Bad Request',
            'status' => $status,
            'detail' => implode("\n", $detail),
        ];

        $response = new Response();
        $response->setStatusCode($status);
        $response->setContent(json_encode($content));

        return $response;
    }

    /**
     * @param string     $msg
     * @param \Exception $exception
     *
     * @return Response
     */
    protected function handleException(string $msg, \Exception $exception): Response
    {
        $this->logger->error($msg, $this->getExceptionContext($exception));

        $status  = ResponseHeaders::HTTP_INTERNAL_SERVER_ERROR;
        $content = [
            'type'   => sprintf('%sinternal-server-error', $this->problemUrlBase),

            'title'  => 'Internal Server Error',
            'status' => $status,
            'detail' => $exception->getMessage(),
        ];

        $response = new Response();
        $response->setStatusCode($status);
        $response->setContent(json_encode($content));

        return $response;
    }

    /**
     * @param \Exception $exception
     *
     * @return array
     */
    protected function getExceptionContext(\Exception $exception): array
    {
        $result = [static::LOG_CONTEXT_EXCEPTION => $exception->getMessage()];

        $i = 1;
        while ($exception = $exception->getPrevious()) {
            $result[sprintf(static::LOG_PREVIOUS_EXCEPTION, $i++)] = $exception->getMessage();
        }

        return $result;
    }

    /**
     * @param IStringerEntity $entity
     *
     * @return Response
     */
    protected function handleGetSuccess(IStringerEntity $entity): Response
    {
        $response = new Response();
        $response->setStatusCode(ResponseHeaders::HTTP_OK);
        $response->setContent($entity->toJSON());

        return $response;
    }

    /**
     * @param array $entities
     * @param int   $total
     *
     * @return Response
     */
    protected function handleListSuccess(array $entities, int $total): Response
    {
        $data = [];
        foreach ($entities as $entity) {
            $data[] = $entity->toJSON();
        }
        $content = sprintf('{"total":%d,"data":[%s]}', $total, implode(',', $data));

        $response = new Response();
        $response->setStatusCode(ResponseHeaders::HTTP_OK);
        $response->setContent($content);

        return $response;
    }

    /**
     * @param IStringerEntity $entity
     *
     * @return Response
     */
    protected function handleCreateSuccess(IStringerEntity $entity): Response
    {
        $response = new Response();
        $response->setStatusCode(ResponseHeaders::HTTP_CREATED);
        $response->setContent($entity->toJSON());

        return $response;
    }

    /**
     * @param IStringerEntity $entity
     *
     * @return Response
     */
    protected function handleUpdateSuccess(IStringerEntity $entity): Response
    {
        $response = new Response();
        $response->setStatusCode(ResponseHeaders::HTTP_OK);
        $response->setContent($entity->toJSON());

        return $response;
    }

    /**
     * @return Response
     */
    protected function handleDeleteSuccess(): Response
    {
        $response = new Response();
        $response->setStatusCode(ResponseHeaders::HTTP_NO_CONTENT);

        return $response;
    }

    /**
     * @return Response
     */
    protected function handleNotFound(): Response
    {
        $response = new Response();
        $response->setStatusCode(ResponseHeaders::HTTP_NOT_FOUND);

        return $response;
    }
}

abterphp / framework

Push — master ( 932fc1...a9416d )

ApiAbstract::delete() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
