App\Classes\Library\PageLoader\Frontpage

Complexity

Total Complexity

16

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	build()	0	7	1
B	publish()	0	13	5
A	__construct()	0	5	1
A	isDisabledPage()	0	3	1
A	canBypassMaintenance()	0	3	1
B	makeBlade()	0	11	5
A	draft()	0	3	1
A	isMaintenanceMode()	0	3	1

<?php
/**
 * Created by PhpStorm.
 * User: Marky
 * Date: 31/12/2017
 * Time: 00:12.
 */

namespace App\Classes\Library\PageLoader;

use App\Model\Page;
use Illuminate\Http\Response;
use Illuminate\Support\Collection;
use App\Http\Controllers\ErrorController;
use App\Classes\Repositories\MenuRepository;
use Illuminate\Contracts\Routing\ResponseFactory;

/**
 * Class Frontpage.
 */
class Frontpage
{
    /**
     * @var Response
     */
    private $response;

    /**
     * @var Webpage
     */
    private $webpage;

    /**
     * @var Page
     */
    private $model;

    /**
     * Frontpage constructor.
     * @param Page $model
     * @param Collection $navigationRepository
     */
    public function __construct(Page $model, Collection $navigationRepository)
    {
        $this->response = app(ResponseFactory::class);

It seems like app(Illuminate\Contracts\Routing\ResponseFactory::class) of type Illuminate\Contracts\Routing\ResponseFactory is incompatible with the declared type Illuminate\Http\Response of property $response.

        $this->webpage = new Webpage($this->model = $model, $navigationRepository);
    }

    /**
     * @param string|null $template
     * @param bool $override
     * @param int $status
     * @param bool $errorResponse
     * @return Response
     */
    public function publish(string $template = null, bool $override = true, int $status = 200, bool $errorResponse = false)
    {
        if (! $errorResponse) {
            if ($this->isMaintenanceMode() && ! $this->canBypassMaintenance()) {
                return ErrorController::maintenance();
            }

            if ($this->isDisabledPage($this->model)) {
                return ErrorController::disabled();
            }
        }

        return $this->response->view($this->makeBlade($template, $override), ['webpage' => $this->webpage], $status);
    }

    /**
     * A user can disable a webpage from being viewed.
     *
     * @param Page $page
     * @return bool
     */
    private function isDisabledPage(Page $page)
    {
        return $page->enabled == false;

It seems like you are loosely comparing $page->enabled of type integer to the boolean false. If you are specifically checking for 0, consider using something more explicit like === 0 instead.

    }

    /**
     * Check if the website is in maintenance mode
     * which is set by the user on the dashboard.
     *
     * @return bool
     */
    public function isMaintenanceMode()
    {
        return settings()->getValue('maintenance_mode');
    }

    /**
     * Check if the current logged in user if exists,
     * can bypass the maintenance and view it offline.
     *
     * @return bool
     */
    public function canBypassMaintenance()
    {
        return auth()->check() == true;
    }

    /**
     * @param string|null $template
     * @param bool $override
     * @return string
     */
    private function makeBlade(string $template = null, bool $override = true)
    {
        if ($template == null) {

It seems like you are loosely comparing $template of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            $template = currentURI() == 'index' ? 'website::index' : 'website::page';
        }

        if ($override && view()->exists("website::plugin.{$this->model->slug}")) {
            $template = "website::plugin.{$this->model->slug}";
        }

        return $template;
    }

    /**
     * @param string $title
     * @param string $description
     * @param string $template
     * @param int $response
     * @return Response
     */
    public static function build(string $title, string $description, string $template, int $response)
    {
        $page = new Page(['seo_title' => $title, 'seo_description' => $description]);

        $navigation = app(MenuRepository::class)->allParentsWithChildren();

        return (new self($page, $navigation))->publish("errors::{$template}", false, $response, true);

It seems like $navigation can also be of type array<mixed,App\Classes\Repositories\MenuRepository>; however, parameter $navigationRepository of App\Classes\Library\PageLoader\Frontpage::__construct() does only seem to accept Illuminate\Support\Collection, maybe add an additional type check?

    }

    /**
     * Return a drafted page without response headers.
     *
     * @return Webpage
     */
    public function draft()
    {
        return $this->webpage;
    }
}