crocodicstudio\crudbooster\helpers\CB

Complexity

Total Complexity

101

Size/Duplication

Total Lines	511
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

36 Methods

Rating	Name	Duplication	Size	Complexity
B	resizeImage()	0	41	9
A	update()	0	5	1
A	getAdminPath()	0	2	1
A	getRoleByName()	0	2	1
A	updateCompact()	0	6	2
A	getAppName()	0	2	1
A	fcm()	0	2	1
A	getLogoutUrl()	0	2	1
B	uploadFileProcess()	0	31	6
A	uploadFile()	0	13	4
A	sidebar()	0	2	1
A	getAdminUrl()	0	3	2
A	getDeveloperUrl()	0	3	2
A	htmlHelper()	0	2	1
A	uploadBase64()	0	15	5
A	getLoginUrl()	0	2	1
A	getProfileUrl()	0	2	1
A	session()	0	2	1
A	listAllTable()	0	7	2
A	redirect()	0	6	2
A	validation()	0	16	4
A	stringBetween()	0	11	2
A	pk()	0	3	1
A	routeGroupDeveloper()	0	6	1
A	find()	0	22	5
A	routePost()	0	5	1
A	findPrimaryKey()	0	7	2
A	routeGroupBackend()	0	6	1
B	routeController()	0	38	9
A	routeGet()	0	5	1
B	getUrlParameters()	0	28	8
A	redirectBack()	0	7	2
B	urlFilterColumn()	0	24	7
A	listAllColumns()	0	7	2
A	getCurrentMethod()	0	7	1
B	findAll()	0	33	9

<?php

namespace crocodicstudio\crudbooster\helpers;

use Illuminate\Http\File;
use Illuminate\Support\Facades\Cache;
use crocodicstudio\crudbooster\exceptions\CBValidationException;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Config;
use Illuminate\Validation\ValidationException;
use Image;
use Request;
use Route;
use Illuminate\Support\Facades\Schema;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\Storage;
use Validator;

class CB
{

    public function htmlHelper() {
        return (new HTMLHelper());
    }

    public function getRoleByName($roleName) {
        return $this->find("cb_roles",['name'=>$roleName]);
    }

    public function fcm() {
        return new FCM();
    }

    public function sidebar() {
        return new SidebarMenus();
    }

    public function session() {
        return new UserSession();
    }

    public function getDeveloperUrl($path = null) {
        $path = ($path)?"/".trim($path,"/"):null;
        return url("developer/".getSetting("developer_path")).$path;
    }

    public function getProfileUrl() {
        return $this->getAdminUrl()."/profile";
    }

    public function getLogoutUrl() {
        return $this->getAdminUrl()."/logout";
    }

    public function getLoginUrl() {
        return $this->getAdminUrl("login");
    }

    public function getAdminPath() {
        return getSetting("ADMIN_PATH","admin");
    }

    public function getAdminUrl($path = null) {
        $path = ($path)?"/".trim($path,"/"):null;
        return url($this->getAdminPath()).$path;

Are you sure url($this->getAdminPath()) of type Illuminate\Contracts\Routing\UrlGenerator|string can be used in concatenation?

    }

    public function getAppName() {
        return getSetting("APP_NAME", env("APP_NAME","CRUDBOOSTER"));
    }

    /**
     * @param $filename
     * @param $extension
     * @param $file
     * @param null $resize_width

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

     * @param null $resize_height

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

     * @return string
     * @throws \Exception
     */
    private function uploadFileProcess($filename, $extension, $file, $encrypt = true, $resize_width = null, $resize_height = null)
    {
        if(in_array($extension,cbConfig("UPLOAD_FILE_EXTENSION_ALLOWED"))) {
            $file_path = cbConfig("UPLOAD_PATH_FORMAT");
            $file_path = str_replace("{Y}",date('Y'), $file_path);
            $file_path = str_replace("{m}", date('m'), $file_path);
            $file_path = str_replace("{d}", date("d"), $file_path);

            //Create Directory Base On Template
            Storage::makeDirectory($file_path);
            Storage::put($file_path."/index.html"," ","public");
            Storage::put($file_path."/.gitignore","!.gitignore","public");

            if ($encrypt == true) {
                $filename = md5(strRandom(5)).'.'.$extension;
            } else {
                $filename = slug($filename, '_').'.'.$extension;
            }

            if($resize_width || $resize_height) {

$resize_height is of type null, thus it always evaluated to false.

                $this->resizeImage($file, $file_path.'/'.$filename, $resize_width, $resize_height);
                return $file_path.'/'.$filename;
            }else{
                if (Storage::putFileAs($file_path, $file, $filename, 'public')) {
                    return $file_path.'/'.$filename;
                } else {
                    throw new \Exception("Something went wrong, file can't upload!");
                }
            }
        }else{
            throw new \Exception("The file format is not allowed!");
        }
    }

    /**
     * @param $base64_value
     * @param bool $encrypt
     * @param null $resize_width

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

     * @param null $resize_height

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

     * @throws \Exception
     */
    public function uploadBase64($filename, $base64_value, $encrypt = true, $resize_width = null, $resize_height = null)
    {
        $fileData = base64_decode($base64_value);
        $mime_type = finfo_buffer(finfo_open(), $fileData, FILEINFO_MIME_TYPE);
        if($mime_type) {
            if($mime_type = explode('/', $mime_type)) {
                $ext = $mime_type[1];
                if($filename && $ext) {
                    return $this->uploadFileProcess($filename, $ext, $fileData, $encrypt, $resize_width, $resize_height);
                }
            }else {
                throw new \Exception("Mime type not found");
            }
        }else{
            throw new \Exception("Mime type not found");
        }
    }

    /**
     * @param $name
     * @param bool $encrypt
     * @param int $resize_width
     * @param null $resize_height

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

     * @return string
     * @throws \Exception
     */
    public function uploadFile($name, $encrypt = true, $resize_width = null, $resize_height = null)
    {
        if (request()->hasFile($name)) {
            $file = request()->file($name);
            $filename = $file->getClientOriginalName();
            $ext = strtolower($file->getClientOriginalExtension());

            if($filename && $ext) {
                return $this->uploadFileProcess($filename, $ext, $file, $encrypt, $resize_width, $resize_height);

It seems like $resize_width can also be of type integer; however, parameter $resize_width of crocodicstudio\crudbooster\helpers\CB::uploadFileProcess() does only seem to accept null, maybe add an additional type check?

            }

        } else {
            throw new \Exception("There is no file send to server!");
        }
    }

    /**
     * @param $file
     * @param $fullFilePath
     * @param null $resize_width

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

     * @param null $resize_height

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

     * @param int $qty
     * @param int $thumbQty
     * @throws \Exception
     */
    public function resizeImage($file, $fullFilePath, $resize_width = null, $resize_height = null, $qty = 100, $thumbQty = 75)

The parameter $thumbQty is not used and could be removed.

    {
        $images_ext = cbConfig("UPLOAD_IMAGE_EXTENSION_ALLOWED");

        $filename = basename($fullFilePath);
        $file_path = trim(str_replace($filename, '', $fullFilePath), '/');

The assignment to $file_path is dead and can be removed.

        $ext = pathinfo($fullFilePath, PATHINFO_EXTENSION);

        if (in_array(strtolower($ext), $images_ext)) {

            // Upload file
            $img = Image::make($file);
            $img->encode($ext, $qty);

            if ($resize_width && $resize_height) {

$resize_width is of type null, thus it always evaluated to false.

                $img->fit($resize_width, $resize_height);

            } elseif ($resize_width && ! $resize_height) {

$resize_width is of type null, thus it always evaluated to false.

                $img->resize($resize_width, null, function ($constraint) {
                    $constraint->aspectRatio();
                });

            } elseif (! $resize_width && $resize_height) {

$resize_width is of type null, thus it always evaluated to false.

$resize_height is of type null, thus it always evaluated to false.

                $img->resize(null, $resize_height, function ($constraint) {
                    $constraint->aspectRatio();
                });

            } else {

                if ($img->width() > cbConfig("DEFAULT_IMAGE_MAX_WIDTH_RES")) {
                    $img->resize(cbConfig("DEFAULT_IMAGE_MAX_WIDTH_RES"), null, function ($constraint) {
                        $constraint->aspectRatio();
                    });
                }
            }

            Storage::put($fullFilePath, $img, 'public');
        }else{
            throw new \Exception("The file format is not allowed!");
        }
    }

    public function update($table, $id, $data)
    {
        DB::table($table)
            ->where($this->pk($table), $id)
            ->update($data);
    }

    public function updateCompact($table, $id, $params) {
        $data = [];
        foreach ($params as $param) {
            $data[$param] = request($param);
        }
        $this->update($table, $id, $data);
    }

    public function find($table, $id)
    {
        if (is_array($id)) {
            $idHash = md5("find".$table.serialize($id));
            if(miscellanousSingleton()->hasData($idHash)) return miscellanousSingleton()->getData($idHash);

            $first = DB::table($table);
            foreach ($id as $k => $v) {
                $first->where($k, $v);
            }

            $data = $first->first();
            miscellanousSingleton()->setData($idHash,$data);
            return $data;
        } else {
            $idHash = md5("find".$table.$id);
            if(miscellanousSingleton()->hasData($idHash)) return miscellanousSingleton()->getData($idHash);

            $pk = $this->pk($table);
            $data = DB::table($table)->where($pk, $id)->first();
            miscellanousSingleton()->setData($idHash,$data);
            return $data;
        }
    }

    /**
     * @param $table
     * @param callable|string|null $conditionOrCallback
     * @return \Illuminate\Support\Collection|mixed
     */
    public function findAll($table, $conditionOrCallback = null)
    {
        $data = [];
        $idHash = null;

        if(is_array($conditionOrCallback)) {
            $idHash = md5("findAll".$table.serialize($conditionOrCallback));
            if(miscellanousSingleton()->hasData($idHash)) return miscellanousSingleton()->getData($idHash);

            $data = DB::table($table)->where($conditionOrCallback)->get();
        } elseif (is_callable($conditionOrCallback)) {
            $idHash = "findAll".$table.spl_object_hash($conditionOrCallback);

It seems like $conditionOrCallback can also be of type callable and string; however, parameter $obj of spl_object_hash() does only seem to accept object, maybe add an additional type check?

            if(miscellanousSingleton()->hasData($idHash)) return miscellanousSingleton()->getData($idHash);

            $data = DB::table($table);
            $data = call_user_func($conditionOrCallback, $data);
            $data = $data->get();
        } else {
            $idHash = md5("findAll".$table.$conditionOrCallback);

Are you sure $conditionOrCallback of type callable|null|string can be used in concatenation?

            if(miscellanousSingleton()->hasData($idHash)) return miscellanousSingleton()->getData($idHash);

            $data = DB::table($table);
            if($conditionOrCallback) {
                $data = $data->whereRaw($conditionOrCallback);

It seems like $conditionOrCallback can also be of type callable; however, parameter $sql of Illuminate\Database\Query\Builder::whereRaw() does only seem to accept string, maybe add an additional type check?

            }
            $data = $data->get();
        }

        if($idHash && $data) {
            miscellanousSingleton()->setData($idHash, $data);
        }

        return $data;
    }

    public function listAllTable()
    {
        $idHash = md5("listAllTable");
        if(miscellanousSingleton()->hasData($idHash)) return miscellanousSingleton()->getData($idHash);
        $data = DB::connection()->getDoctrineSchemaManager()->listTableNames();
        miscellanousSingleton()->setData($idHash, $data);
        return $data;
    }

    public function listAllColumns($table)
    {
        $idHash = md5("listAllColumns".$table);
        if(miscellanousSingleton()->hasData($idHash)) return miscellanousSingleton()->getData($idHash);
        $data = Schema::getColumnListing($table);
        miscellanousSingleton()->setData($idHash, $data);
        return $data;
    }

    public function redirectBack($message, $type = 'warning')
    {
        if (request()->ajax()) {
            return response()->json(['message' => $message, 'message_type' => $type, 'redirect_url' => $_SERVER['HTTP_REFERER']]);
        } else {
            return redirect()->back()->withInput()
                ->with(['message'=> $message, 'message_type'=> $type]);
        }
    }

    public function redirect($to, $message, $type = 'warning')
    {
        if (Request::ajax()) {
            return response()->json(['message' => $message, 'message_type' => $type, 'redirect_url' => $to]);
        } else {
            return redirect($to)->with(['message' => $message, 'message_type' => $type]);
        }
    }


    public function getCurrentMethod()
    {
        $action = str_replace("App\Http\Controllers", "", Route::currentRouteAction());
        $atloc = strpos($action, '@') + 1;
        $method = substr($action, $atloc);

        return $method;
    }

    public function stringBetween($string, $start, $end)
    {
        $string = ' '.$string;
        $ini = strpos($string, $start);
        if ($ini == 0) {
            return '';
        }
        $ini += strlen($start);
        $len = strpos($string, $end, $ini) - $ini;

        return substr($string, $ini, $len);
    }

    /**
     * @param array $rules
     * @param array $messages
     * @throws CBValidationException
     */
    public function validation($rules = [], $messages = [])
    {
        $input_arr = request()->all();

        foreach ($rules as $a => $b) {
            if (is_int($a)) {
                $rules[$b] = 'required';
            } else {
                $rules[$a] = $b;
            }
        }

        $validator = Validator::make($input_arr, $rules, $messages);
        if ($validator->fails()) {
            $message = $validator->errors()->all();
            throw new CBValidationException(implode("; ",$message));
        }
    }

    public function pk($table)
    {
        return $this->findPrimaryKey($table);
    }

    public function findPrimaryKey($table)
    {
        $pk = DB::getDoctrineSchemaManager()->listTableDetails($table)->getPrimaryKey();
        if(!$pk) {
            return null;
        }
        return $pk->getColumns()[0];
    }

    public function urlFilterColumn($key, $type, $value = '', $singleSorting = true)
    {
        $params = Request::all();
        $mainpath = trim(self::mainpath(), '/');

The method mainpath() does not exist on crocodicstudio\crudbooster\helpers\CB.

        $key = sanitizeXSS($key);
        $type = sanitizeXSS($type);
        $value = sanitizeXSS($value);

        if ($params['filter_column'] && $singleSorting) {
            foreach ($params['filter_column'] as $k => $filter) {
                foreach ($filter as $t => $val) {
                    if ($t == 'sorting') {
                        unset($params['filter_column'][$k]['sorting']);
                    }
                }
            }
        }

        $params['filter_column'][$key][$type] = $value;

        if (isset($params)) {
            return $mainpath.'?'.http_build_query($params);
        } else {
            return $mainpath.'?filter_column['.$key.']['.$type.']='.$value;
        }
    }


    public function getUrlParameters($exception = null)
    {
        $get = request()->all();
        $inputhtml = '';

        if ($get) {

The expression $get 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.

            if (is_array($exception)) {
                foreach ($exception as $e) {
                    unset($get[$e]);
                }
            }
            $string_parameters = http_build_query($get);
            $string_parameters_array = explode('&', $string_parameters);
            foreach ($string_parameters_array as $s) {
                $part = explode('=', $s);
                if(isset($part[0]) && isset($part[1])) {
                    $name = htmlspecialchars(urldecode($part[0]));
                    $name = strip_tags($name);
                    $value = htmlspecialchars(urldecode($part[1]));
                    $value = strip_tags($value);
                    if ($name) {
                        $inputhtml .= "<input type='hidden' name='$name' value='$value'/>\n";
                    }
                }
            }
        }

        return $inputhtml;
    }


    public function routeGet($prefix, $controller) {
        $alias = str_replace("@"," ", $controller);
        $alias = ucwords($alias);
        $alias = str_replace(" ","",$alias);
        Route::get($prefix, ['uses' => $controller, 'as' => $alias]);
    }

    public function routePost($prefix, $controller) {
        $alias = str_replace("@"," ", $controller);
        $alias = ucwords($alias);
        $alias = str_replace(" ","",$alias);
        Route::post($prefix, ['uses' => $controller, 'as' => $alias]);
    }

    public function routeGroupBackend(callable $callback, $namespace = 'crocodicstudio\crudbooster\controllers') {
        Route::group([
            'middleware' => ['web', \crocodicstudio\crudbooster\middlewares\CBBackend::class],
            'prefix' => cb()->getAdminPath(),
            'namespace' => $namespace,
        ], $callback);
    }

    public function routeGroupDeveloper(callable $callback, $namespace = 'crocodicstudio\crudbooster\controllers') {
        Route::group([
            'middleware' => ['web', \crocodicstudio\crudbooster\middlewares\CBDeveloper::class],
            'prefix' => "developer/".getSetting('developer_path'),
            'namespace' => $namespace,
        ], $callback);
    }

    /*
    | --------------------------------------------------------------------------------------------------------------
    | Alternate route for Laravel Route::controller
    | --------------------------------------------------------------------------------------------------------------
    | $prefix       = path of route
    | $controller   = controller name
    |
    */
    public function routeController($prefix, $controller)
    {

        $prefix = trim($prefix, '/').'/';

        if(substr($controller,0,1) != "\\") {
            $controller = "\App\Http\Controllers\\".$controller;
        }

        $exp = explode("\\", $controller);
        $controller_name = end($exp);

        try {
            Route::get($prefix, ['uses' => $controller.'@getIndex', 'as' => $controller_name.'GetIndex']);

            $controller_class = new \ReflectionClass($controller);
            $controller_methods = $controller_class->getMethods(\ReflectionMethod::IS_PUBLIC);
            $wildcards = '/{one?}/{two?}/{three?}/{four?}/{five?}';
            foreach ($controller_methods as $method) {

                if ($method->class != 'Illuminate\Routing\Controller' && $method->name != 'getIndex') {
                    if (substr($method->name, 0, 3) == 'get') {
                        $method_name = substr($method->name, 3);
                        $slug = array_filter(preg_split('/(?=[A-Z])/', $method_name));

It seems like preg_split('/(?=[A-Z])/', $method_name) can also be of type false; however, parameter $input of array_filter() does only seem to accept array, maybe add an additional type check?

                        $slug = strtolower(implode('-', $slug));
                        $slug = ($slug == 'index') ? '' : $slug;
                        Route::get($prefix.$slug.$wildcards, ['uses' => $controller.'@'.$method->name, 'as' => $controller_name.'Get'.$method_name]);
                    } elseif (substr($method->name, 0, 4) == 'post') {
                        $method_name = substr($method->name, 4);
                        $slug = array_filter(preg_split('/(?=[A-Z])/', $method_name));
                        Route::post($prefix.strtolower(implode('-', $slug)).$wildcards, [
                            'uses' => $controller.'@'.$method->name,
                            'as' => $controller_name.'Post'.$method_name,
                        ]);
                    }
                }
            }
        } catch (\Exception $e) {

Consider adding a comment why this CATCH block is empty.

        }
    }
}