GenerateAdminMenu::handle()   B
last analyzed

Complexity

Conditions 5
Paths 2

Size

Total Lines 105
Code Lines 77

Duplication

Lines 0
Ratio 0 %

Importance

Changes 2
Bugs 0 Features 0
Metric Value
cc 5
eloc 77
nc 2
nop 2
dl 0
loc 105
rs 8.1463
c 2
b 0
f 0

How to fix   Long Method   

Long Method

Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.

For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.

Commonly applied refactorings include:

1
<?php
2
3
namespace Yajra\CMS\Http\Middleware;
4
5
use Caffeinated\Menus\Builder;
6
use Caffeinated\Menus\Facades\Menu;
7
use Closure;
8
9
class GenerateAdminMenu
10
{
11
    /**
12
     * Handle an incoming request.
13
     *
14
     * @param  \Illuminate\Http\Request $request
15
     * @param  \Closure $next
16
     * @return mixed
17
     */
18
    public function handle($request, Closure $next)
19
    {
20
        if (auth()->check() && $request->is(admin_prefix() . '*')) {
0 ignored issues
show
Bug introduced by
The method check does only exist in Illuminate\Contracts\Auth\Guard, but not in Illuminate\Contracts\Auth\Factory.

It seems like the method you are trying to call exists only in some of the possible types.

Let’s take a look at an example:

class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

Available Fixes

  1. Add an additional type-check:

    /**
     * @param A|B $x
     */
    function someFunction($x)
    {
        $x->foo();
    
        if ($x instanceof B) {
            $x->bar();
        }
    }
    
  2. Only allow a single type to be passed if the variable comes from a parameter:

    function someFunction(B $x) { /** ... */ }
    
Loading history...
21
            Menu::make('admin', function (Builder $menu) {
22
                $menu->add('Dashboard', route('administrator.index'))->icon('home');
23
24
                $navs = app('navigation')->getPublished();
25
                if ($navs->count()) {
26
                    $nav = $menu->add('Navigation', '#')->icon('sitemap')
27
                                ->data('permission', 'navigation.view');
28
                    $nav->add('Manage', route('administrator.navigation.index'))
29
                        ->icon('cogs')
30
                        ->data([
31
                            'permission' => 'navigation.view',
32
                            'append'     => route('administrator.navigation.create'),
33
                        ]);
34
                    $navs->each(function ($item) use ($nav) {
35
                        $nav->add($item->title, route('administrator.navigation.menu.index', $item->id))
36
                            ->icon('link')
37
                            ->data([
38
                                'permission' => 'navigation.view',
39
                                'append'     => route('administrator.navigation.menu.create', $item->id),
40
                            ]);
41
                    });
42
                } else {
43
                    $menu->add('Navigation', route('administrator.navigation.index'))->icon('link')
44
                         ->data(['permission' => 'navigation.view']);
45
                }
46
47
                $contents = $menu->add('Contents', '#')->icon('files-o');
48
                $contents->add('Articles', route('administrator.articles.index'))
49
                         ->icon('files-o')
50
                         ->data([
51
                             'permission' => 'article.view',
52
                             'append'     => route('administrator.articles.create'),
53
                         ]);
54
                $contents->add('Categories', route('administrator.categories.index'))
55
                         ->icon('file-text')
56
                         ->data([
57
                             'permission' => 'category.view',
58
                             'append'     => route('administrator.categories.create'),
59
                         ]);
60
                $contents->add('Widgets', route('administrator.widgets.index'))->icon('plug')
61
                         ->data([
62
                             'permission' => 'widget.view',
63
                             'append'     => route('administrator.widgets.create'),
64
                         ]);
65
                $contents->add('Media', route('administrator.media.index'))->icon('image')
66
                         ->data('permission', 'media.view');
67
68
                $modules = $menu->add('Modules', '#')->icon('cubes')->data('permission', 'module.view');
69
                $modules->add('Manage', route('administrator.modules.index'))->icon('cogs')->data('permission', 'module.view');
70
                event('admin.menu.build', $modules);
71
72
                $menu->add('Themes', route('administrator.themes.index'))
73
                     ->icon('windows')
74
                     ->data(['permission' => 'theme.view']);
75
76
                $users = $menu->add('Users', '#')->icon('key')
77
                              ->data([
78
                                  'permission' => ['user.view', 'role.view', 'permission.view']
79
                              ]);
80
                $users->add('Manage', route('administrator.users.index'))->icon('users')
81
                      ->data([
82
                          'permission' => 'user.view',
83
                          'append'     => route('administrator.users.create'),
84
                      ]);
85
                $users->add('Roles', route('administrator.roles.index'))->icon('shield')
86
                      ->data([
87
                          'permission' => 'role.view',
88
                          'append'     => route('administrator.roles.create'),
89
                      ]);
90
                $users->add('Permissions', route('administrator.permissions.index'))->icon('tag')
91
                      ->data([
92
                          'permission' => 'permission.view',
93
                          'append'     => route('administrator.permissions.create'),
94
                      ]);
95
96
                $config = $menu->add('Configurations', '#')->icon('gears')
97
                               ->data([
98
                                   'permission' => ['extension.view', 'utilities.config']
99
                               ]);
100
                $config->add('Extensions', route('administrator.extension.index'))->icon('plug')
101
                       ->data('permission', 'extension.view');
102
                $config->add('Global', route('administrator.configuration.index'))->icon('globe')
103
                       ->data('permission', 'utilities.config');
104
105
                $menu->add('Utilities', route('administrator.utilities.index'))->icon('wrench')
106
                     ->data('permission', 'utilities.view');
107
108
                $menu->add('Logout', route('administrator.logout'))->icon('power-off')->attribute(['name' => 'logout']);
109
            })->filter(function ($item) {
110
                $permissions = (array) $item->data('permission');
111
                if (! $permissions) {
0 ignored issues
show
Bug Best Practice introduced by
The expression $permissions of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent.

Consider making the comparison explicit by using empty(..) or ! empty(...) instead.

Loading history...
112
                    return true;
113
                }
114
115
                return current_user()->canAtLeast($permissions);
0 ignored issues
show
Bug introduced by
The method canAtLeast() does not seem to exist on object<Illuminate\Contracts\Auth\Authenticatable>.

This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces.

This is most likely a typographical error or the method has been renamed.

Loading history...
116
            });
117
        }
118
119
        $response = $next($request);
120
121
        return $response;
122
    }
123
}
124