Prateekkarki\Laragen\Models\DataOption

Complexity

Total Complexity

46

Size/Duplication

Total Lines	230
Duplicated Lines	0 %

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	getType()	0	7	4
A	getDisplay()	0	2	1
A	processParent()	0	7	1
A	getParentModule()	0	2	2
B	__construct()	0	35	10
A	setRequired()	0	2	2
A	getFormOptions()	0	5	3
A	getTextRows()	0	5	2
A	setOptions()	0	9	2
A	getKey()	0	2	1
A	optionArray()	0	2	1
A	getParentModel()	0	2	2
A	setSize()	0	2	1
A	isUnique()	0	2	1
A	getSize()	0	2	1
A	getSchema()	0	14	6
A	getColumnType()	0	2	1
A	setUnique()	0	2	2
A	getTabs()	0	7	2
A	isRequired()	0	2	1

<?php
namespace Prateekkarki\Laragen\Models;
use Illuminate\Support\Str;

class DataOption
{
    const TYPE_PARENT = 'parent';

    const TYPE_RELATED = 'related';
    
    const COLUMN_UNIQUE = 'unique';

    const COLUMN_REQUIRED = 'required';

    protected $specialType;

    protected $uniqueFlag;

    protected $requiredFlag;

    protected $size;

    protected $column;

    /**
     * List of all types of data.
     *
     * @var array
     */
    public static $types = [
        'integer',
        'string',
        'boolean',
        'text',
        'date',
        'datetime'
    ];

    public static $fileTypes = [   
        'image',
        'file'     
    ];

    public static $specialTypes = [
        'parent',
        'related'
    ];

    public static $relatedMultiple = [
      
    ];

    /**
     * Array of data type options
     *
     * @var array
     */
    protected $optionArray;

    
    /**
     * Key to type conversion array.
     *
     * @var array
     */
    protected $keyToType = [
        'integer' =>'integer',
        'string' =>'string',
        'image' =>'string',
        'file' =>'string',
        'boolean' =>'boolean',
        'text' =>'text',
        'datetime' =>'datetime',
        'date' =>'date'
    ];

    public function __construct($columnName, $optionString)
    {
        $this->column = $columnName;
        $this->size = false;
        // dump($optionString);
        if(is_array($optionString) ){
            $this->dataType = 'multiple';

The property dataType does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            $this->multipleOptions = [];

The property multipleOptions does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            foreach($optionString as $col => $multString){
                $this->multipleOptions[] = new Self($col, $multString);
            }
            // dd($this->multipleOptions[0]);
            $column = $this->multipleOptions[0]->column;

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

            // dd($column);
            // $option = ;

        }else{
            $this->optionArray = explode('|', $optionString);
            $typePieces = array_shift($this->optionArray);
            $type = explode(':', $typePieces);
            $this->dataType = is_array($type) ? $type[0] : $type;

The condition is_array($type) is always true.

            $this->typeOption = is_array($type)&&count($type)>=2 ? $type[1] : false;

The property typeOption does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            foreach ($this->optionArray as $option) {
                if ($option == self::COLUMN_UNIQUE) {
                    $this->setUnique();
                    continue;
                }
                if ($option == self::COLUMN_REQUIRED) {
                    $this->setRequired();
                    continue;
                }
                if(Str::contains($option, ':')){
                    $optionPieces = explode(':', $option);
                    $this->setOptions($optionPieces[0], $optionPieces[1]);
                }
            }
        }    
        
        
    }

    public function getSchema()
    {
        if ($this->dataType=='parent') {
            $schema = $this->processParent();
        } else if( in_array($this->dataType, ['gallery', 'related', 'multiple']) ){
            $schema = '';
        } else {
            $schema = '$table->'.$this->getColumnType()."('{$this->column}'";
            $schema .= $this->getSize() ? ", {$this->getSize()})" : ")";
            $schema .= $this->isUnique() ? "->unique()" : "";
            $schema .= $this->isRequired() ? "" : "->nullable()";
            $schema .= ";";
        }
        return $schema;
    }

    public function getKey() {
        return $this->column;
    }

    public function getDisplay() {
        return ucfirst(str_replace('_', ' ', $this->column));
    }

    public function getType() {
        $type = $this->dataType;
        if($type=='string'){
            $type = (!$this->getSize() || $this->getSize()<=128) ? $type : 'text';
        } 
        
        return $type;
    }

    public function getSize() {
        return $this->size;
    }

    public function getParentModule() {
        return (in_array($this->dataType, self::$specialTypes)) ? $this->typeOption : '';
    }

    public function getParentModel() {
        return (in_array($this->dataType, self::$specialTypes)) ? ucfirst(camel_case(str_singular($this->typeOption))) : '';

The function camel_case() has been deprecated: Str::camel() should be used directly instead. Will be removed in Laravel 5.9.

The function str_singular() has been deprecated: Str::singular() should be used directly instead. Will be removed in Laravel 5.9.

    }

    public function isRequired() {
        return $this->requiredFlag;
    }

    public function getFormOptions() {
        $options = "";
        $options .= $this->isRequired() ? 'required="required" ' :''; 
        $options .= $this->getType()=='text' ? 'rows="'.$this->getTextRows().'" ' :''; 
        return $options;
    }


    public function getTextRows() {
        if(!$this->size)
            return 4;
        
        return floor($this->getsize()/120);
    }

    public function getTabs($number)
    {
        $schema = "";
        for ($i = 0; $i < $number; $i++) {
            $schema .= "    ";
        }
        return $schema;
    }

    public function isUnique() {
        return $this->uniqueFlag;
    }
    
    protected function getColumnType() {
        return $this->keyToType[$this->dataType];
    }

    protected function setOptions($optionType, $optionParam) {
        switch ($optionType) {
            case 'max':
                $this->setSize($optionParam);
                break;
            
            default:
                $this->$optionType = $optionParam;
                break;
        }
    }

    protected function setUnique($set = true) {
        $this->uniqueFlag = ($set === true) ? true : false;
    }

    protected function setRequired($set = true) {
        $this->requiredFlag = ($set === true) ? true : false;
    }

    protected function setSize($size = null) {
        $this->size = $size;
    }

    public function optionArray(){
        return $this->optionArray;
    }

    protected function processParent() {
        $schema = "";
        $parent = $this->typeOption;
        $schema .= "\$table->bigInteger('".str_singular($parent)."_id')->unsigned()->nullable();";

The function str_singular() has been deprecated: Str::singular() should be used directly instead. Will be removed in Laravel 5.9.

        $schema .= PHP_EOL.$this->getTabs(3);
        $schema .= "\$table->foreign('".str_singular($parent)."_id')->references('id')->on('$parent')->onDelete('set null');";

The function str_singular() has been deprecated: Str::singular() should be used directly instead. Will be removed in Laravel 5.9.

        return $schema;
    }

}