SleepingOwl\Admin\Http\Controllers\DisplayController

Complexity

Total Complexity

21

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	11

Test Coverage

Coverage

0%

Importance

Changes	4
Bugs	1	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
C	async()	0	50	15
A	treeReorder()	0	19	3
A	renderFindedTable()	0	12	3

<?php

namespace SleepingOwl\Admin\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\JsonResponse;
use Illuminate\Routing\Controller;
use SleepingOwl\Admin\Form\FormElements;
use SleepingOwl\Admin\Display\DisplayTree;
use SleepingOwl\Admin\Form\Columns\Column;
use SleepingOwl\Admin\Display\DisplayTabbed;
use Illuminate\Contracts\Foundation\Application;
use SleepingOwl\Admin\Display\DisplayDatatablesAsync;
use SleepingOwl\Admin\Contracts\ModelConfigurationInterface;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

class DisplayController extends Controller
{
    /**
     * @param ModelConfigurationInterface $model
     * @param Request $request
     * @param Application $application
     * @param null $name
     * @throws NotFoundHttpException
     *
     * @return JsonResponse
     */
    public function async(ModelConfigurationInterface $model, Request $request, Application $application, $name = null)
    {
        $payload = $request->payload ?: [];

        $display = $model->fireDisplay($payload);

The call to ModelConfigurationInterface::fireDisplay() has too many arguments starting with $payload.

        if ($display instanceof DisplayTabbed) {
            $tabs = $display->getTabs();

            foreach ($tabs as $tab) {
                $content = $tab->getContent();

                if ($content instanceof FormElements) {
                    foreach ($content->getElements() as $element) {

                        //Return data-table if inside FormElements
                        if ($element instanceof DisplayDatatablesAsync) {
                            if ($element->getName() == $name) {
                                return $this->renderFindedTable($element, $application, $request);

The expression $this->renderFindedTable($element, $application, $request); of type array<string,string|array|integer>|Illuminate\Http\JsonResponse adds the type array<string,string|array|integer> to the return on line 46 which is incompatible with the return type documented by SleepingOwl\Admin\Http\Controllers\DisplayController::async of type Illuminate\Http\JsonResponse|null.

                            }
                        }

                        //Try to find data table in columns
                        if ($element instanceof Column) {
                            foreach ($element->getElements() as $columnElement) {
                                if ($columnElement instanceof DisplayDatatablesAsync) {
                                    if ($columnElement->getName() == $name) {
                                        return $this->renderFindedTable($columnElement, $application, $request);

The expression $this->renderFindedTable($columnElement, $application, $request); of type array<string,string|array|integer>|Illuminate\Http\JsonResponse adds the type array<string,string|array|integer> to the return on line 55 which is incompatible with the return type documented by SleepingOwl\Admin\Http\Controllers\DisplayController::async of type Illuminate\Http\JsonResponse|null.

                                    }
                                }
                            }
                        }
                    }
                }

                //Finded trully in content-tab
                if ($content instanceof DisplayDatatablesAsync) {
                    if ($content->getName() == $name) {
                        return $this->renderFindedTable($content, $application, $request);

The expression $this->renderFindedTable($content, $application, $request); of type array<string,string|array|integer>|Illuminate\Http\JsonResponse adds the type array<string,string|array|integer> to the return on line 66 which is incompatible with the return type documented by SleepingOwl\Admin\Http\Controllers\DisplayController::async of type Illuminate\Http\JsonResponse|null.

                    }
                }
            }
        }

        if ($display instanceof DisplayDatatablesAsync) {
            return $this->renderFindedTable($display, $application, $request);

The expression $this->renderFindedTable($display, $application, $request); of type array<string,string|array|integer>|Illuminate\Http\JsonResponse adds the type array<string,string|array|integer> to the return on line 73 which is incompatible with the return type documented by SleepingOwl\Admin\Http\Controllers\DisplayController::async of type Illuminate\Http\JsonResponse|null.

        }

        abort(404);
    }

    /**
     * @param ModelConfigurationInterface $model
     * @param Request $request
     */
    public function treeReorder(ModelConfigurationInterface $model, Request $request)
    {
        $display = $model->fireDisplay();

        if ($display instanceof DisplayTabbed) {
            $display->getTabs()->each(function ($tab) use ($request) {
                $content = $tab->getContent();
                if ($content instanceof DisplayTree) {
                    $content->getRepository()->reorder(
                        $request->input('data')

It seems like $request->input('data') targeting Illuminate\Http\Concerns\InteractsWithInput::input() can also be of type string; however, SleepingOwl\Admin\Contracts\Repositories\TreeRepositoryInterface::reorder() does only seem to accept array, maybe add an additional type check?

                    );
                }
            });
        } else {
            $display->getRepository()->reorder(
                $request->input('data')
            );
        }
    }

    /**
     * @param DisplayDatatablesAsync $datatable
     * @param Application $application
     * @param Request $request
     * @return array|JsonResponse
     */
    protected function renderFindedTable(DisplayDatatablesAsync $datatable, Application $application, Request $request)
    {
        try {
            return $datatable->renderAsync($request);
        } catch (\Exception $exception) {
            return new JsonResponse([
                'message' => $application->isLocal()
                    ? $exception->getMessage()
                    : trans('sleeping_owl::lang.table.error'),
            ], 403);
        }
    }
}