crocodicstudio\crudbooster\controllers\Helpers\IndexImport

Complexity

Total Complexity

23

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	uploadImportData()	0	12	1
A	validateForImport()	0	3	1
A	doneImport()	0	7	1
A	handleImportProgress()	0	11	2
C	InsertToDB()	0	36	8
C	readAndInsert()	0	45	8
A	resolveController()	0	10	2

<?php

namespace crocodicstudio\crudbooster\controllers\Helpers;

use crocodicstudio\crudbooster\helpers\DbInspector;
use crocodicstudio\crudbooster\helpers\CRUDBooster;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;
use Maatwebsite\Excel\Facades\Excel;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Cache;


class IndexImport
{
    /**
     * @return mixed
     */
    public function doneImport()
    {
        $data = [];
        $data['page_title'] = trans('crudbooster.import_page_title', ['module' => \CRUDBooster::getCurrentModule()->name]);

The type CRUDBooster was not found. Maybe you did not declare it correctly or list all dependencies?

        session()->put('select_column', request('select_column'));

        return view('crudbooster::import', $data);
    }


    /**
     * @param $file_md5
     * @return mixed
     */
    public function handleImportProgress($file_md5)
    {
        $total = session('total_data_import') * 100;
        $prog = intval(cache('success_'.$file_md5)) / $total;
        $prog = round($prog, 2);

        if ($prog >= 100) {
            cache()->forget('success_'.$file_md5);
        }

        return response()->json(['progress' => $prog, 'last_error' => cache('error_'.$file_md5)]);

The method json() does not exist on Symfony\Component\HttpFoundation\Response. It seems like you code against a sub-type of Symfony\Component\HttpFoundation\Response such as Illuminate\Http\Response or Illuminate\Http\JsonResponse or Illuminate\Http\RedirectResponse.

    }

    /**
     * @param $file
     * @return string
     */
    public function uploadImportData($file)
    {
        $dir = 'uploads/'.date('Y-m');
        $filename = md5(str_random(5)).'.'. $file->getClientOriginalExtension();

        //Create Directory Monthly
        Storage::makeDirectory($dir);

        //Move file to storage
        Storage::putFileAs($dir, $file, $filename);

        return CRUDBooster::mainpath('import-data').'?file='.base64_encode($dir.'/'.$filename);
    }

    /**
     * @param $file
     * @return array
     */
    public function validateForImport($file)
    {
        return Validator::make(['extension' => $file->getClientOriginalExtension(),], ['extension' => 'in:xls,xlsx,csv']);

The expression return Illuminate\Support\Facades\Validator::make(array('extension' => $file->getClientOriginalExtension()), array('extension' => 'in:xls,xlsx,csv')) returns the type Illuminate\Contracts\Validation\Validator which is incompatible with the documented return type array.

    }


    /**
     * @param $file_md5
     * @param $table
     * @param $titleField
     */
    public function InsertToDB($file_md5, $table, $titleField)
    {
        $select_column = array_filter(session('select_column'));

It seems like session('select_column') can also be of type Illuminate\Session\Store and Illuminate\Session\SessionManager; however, parameter $input of array_filter() does only seem to accept array, maybe add an additional type check?

        $table_columns = DB::getSchemaBuilder()->getColumnListing($table);

        $file = base64_decode(request('file'));

It seems like request('file') can also be of type array; however, parameter $data of base64_decode() does only seem to accept string, maybe add an additional type check?

        $file = 'storage'.DIRECTORY_SEPARATOR.'app'.DIRECTORY_SEPARATOR.$file;
        $rows = Excel::load($file, function ($reader) {

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

        })->get();

        //$data_import_column = [];
        foreach ($rows as $value) {
            $a = $this->readAndInsert($select_column, $table_columns, $value);

            $has_title_field = true;
            foreach ($a as $k => $v) {
                if ($k == $titleField && $v == '') {
                    $has_title_field = false;
                    break;
                }
            }

            if ($has_title_field == false) {
                continue;
            }

            try {
                if (\Schema::hasColumn($table, 'created_at')) {
                    $a['created_at'] = date('Y-m-d H:i:s');
                }

                \DB::table($table)->insert($a);
                Cache::increment('success_'.$file_md5);
            } catch (\Exception $e) {
                $e = (string) $e;
                Cache::put('error_'.$file_md5, $e, 500);
            }
        }
    }

    /**
     * @param $select_column
     * @param $table_columns
     * @param $value
     * @return array
     */
    private function readAndInsert($select_column, $table_columns, $value)
    {
        $a = [];
        foreach ($select_column as $sk => $s) {
            $colname = $table_columns[$sk];

            if (! DbInspector::isForeignKey($colname) || intval($value->$s)) {
                $a[$colname] = $value->$s;
                continue;
            }

            //Skip if value is empty
            if ($value->$s == '') {
                continue;
            }

            $relation_table = DbInspector::getTableForeignKey($colname);
            $relation_class = $this->resolveController($relation_table);
            $relation_class->genericLoader();

            $title_field = $relation_class->title_field;

The property title_field does not exist on string.

            $relation_insert_data = [];
            $relation_insert_data[$title_field] = $value->$s;

            if (\Schema::hasColumn($relation_table, 'created_at')) {
                $relation_insert_data['created_at'] = date('Y-m-d H:i:s');
            }

            try {
                $relation_exists = DB::table($relation_table)->where($title_field, $value->$s)->first();
                if ($relation_exists) {
                    $relation_primary_key = $relation_class->primaryKey;

The property primaryKey does not exist on string.

                    $relation_id = $relation_exists->$relation_primary_key;
                } else {
                    $relation_id = DB::table($relation_table)->insertGetId($relation_insert_data);
                }

                $a[$colname] = $relation_id;
            } catch (\Exception $e) {
                exit($e);

Using exit here is not recommended.

            }
        }

        return $a;
    }

    /**
     * @param $relation_table
     * @return string
     */
    private function resolveController($relation_table)
    {
        $relation_moduls = DB::table('cms_moduls')->where('table_name', $relation_table)->first();

        $relation_class = __NAMESPACE__.'\\'.$relation_moduls->controller;
        if (! class_exists($relation_class)) {
            $relation_class = ctrlNamespace().'\\'.$relation_moduls->controller;
        }

        return new $relation_class;

The expression return new $relation_class() returns the type object which is incompatible with the documented return type string.

    }
}