SleepingOwl\Admin\Http\Controllers\DisplayController

Complexity

Total Complexity

21

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
C	async()	0	49	15
A	treeReorder()	0	16	3
A	renderFindedTable()	0	14	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\DisplayTab;
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

Are you sure the doc-type for parameter $name is correct as it would always require null to be passed?

     * @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 SleepingOwl\Admin\Contracts\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 return $this->renderFindedTable($element, $application, $request) also could return the type array which is incompatible with the documented return type Illuminate\Http\JsonResponse.

                            }
                        }

                        //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 return $this->renderFindedTable($columnElement, $application, $request) also could return the type array which is incompatible with the documented return type Illuminate\Http\JsonResponse.

                                    }
                                }
                            }
                        }
                    }
                }

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

The expression return $this->renderFindedTable($content, $application, $request) also could return the type array which is incompatible with the documented return type Illuminate\Http\JsonResponse.

                    }
                }
            }
        }

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

The expression return $this->renderFindedTable($display, $application, $request) also could return the type array which is incompatible with the documented return type Illuminate\Http\JsonResponse.

        }

        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 (DisplayTab $tab) use ($request) {
                $content = $tab->getContent();
                if ($content instanceof DisplayTree) {
                    $content->getRepository()->reorder(
                        $request->input('data')
                    );
                }
            });
        } else {
            $display->getRepository()->reorder(

The method getRepository() does not exist on SleepingOwl\Admin\Contracts\Display\DisplayInterface. It seems like you code against a sub-type of SleepingOwl\Admin\Contracts\Display\DisplayInterface such as SleepingOwl\Admin\Form\FormDefault or SleepingOwl\Admin\Display\Display.

                $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) {
            \Log::error('unable to render finded table!', [
                'exception' => $exception,
            ]);

            return new JsonResponse([
                'message' => $application->isLocal()
                    ? $exception->getMessage()
                    : trans('sleeping_owl::lang.table.error'),
            ], 403);
        }
    }
}