DataTrait::remove() - Code Metrics - Inspection of "abstração de metodo mountdata" - hnrazevedo/Datamanager - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ae9656...8b853b )

by Henri
created 2020-08-07 16:27 UTC
DataTrait::remove() A

↳ Parent: DataTrait
Complexity

Conditions	3
Paths	3
Size

Total Lines	19
Code Lines	10
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	3
eloc	10
c	1
b	0
f	0
nc	3
nop	1
dl	0
loc	19
rs	9.9332
<?php

namespace HnrAzevedo\Datamanager;

use Exception;

trait DataTrait{
    protected ?string $table = null;
    protected ?string $primary = null;

    protected ?string $order = null;
    protected ?string $limit = null;
    protected ?int $offset = null;
    protected array $excepts = [];
    protected int $count = 0;
    protected array $select = [];
    protected ?string $query = null;

    protected function create(string $table, string $primary): Datamanager
    {
        $this->table = $table;
        $this->primary = $primary;
        $describe = $this->describe();
        $describe = $this->describe();
        
        $this->check_fail();
               check_fail();

        $this->mountData($describe);
               mountData($describe);
        $this->full = true;

        return $this;

    }

    public function __set(string $prop,$value): Datamanager
    {

        if(is_array($value)){
            $attr = array_keys($value)[0];
            $this->data[$prop][$attr] = $value[$attr];

            return $this;

        }

        if($this->full && !array_key_exists($prop,$this->data)){
            throw new Exception("{$prop} field does not exist in the table {$this->table}.");
        }

        $this->data[$prop]['changed'] = true;
        $this->data[$prop]['value'] = $value;
        
        return $this;

    }

    public function getData(): ?array
    {
        return $this->data;
    }

    public function __get(string $field)
    {
        if($this->full && !array_key_exists($field,$this->data)){
            throw new Exception("{$field} field does not exist in the table {$this->table}.");
        }

        return $this->data[$field]['value'];
    }

    public function getCount(): int
    {
        return $this->count;
    }

    public function except($deniable): Datamanager
    {
        $deniable = (is_array($deniable)) ? $deniable : [$deniable];

        foreach ($deniable as $field) {
            if(!array_key_exists($field,$this->data)){
                throw new Exception("{$field} field does not exist in the table {$this->table}.");
            }

            $this->excepts[$field] = true;
        }

        return $this;

    }

    public function deny(): Datamanager
    {
        foreach ($this->excepts as $field => $value) {
            unset($this->select[$field]);
        }
        return $this;

    }

    public function orderBy(string $field, string $ord = 'ASC'): Datamanager
    {
        if(!array_key_exists(str_replace(['asc','ASC','desc','DESC',' '],'',$field),$this->data) && $this->full){
            throw new Exception("{$field} field does not exist in the table {$this->table}.");
        }

        if(strpos(strtolower($field),'asc') || strpos(strtolower($field),'desc')){
            $ord = '';
        }

        $this->order = " ORDER BY {$field} {$ord} ";
        return $this;

    }

    public function only($params): Datamanager
    {
        $params = (is_array($params)) ? $params : [$params];
        $this->select = [];

        foreach ($params as $field) {

            if(!array_key_exists($field,$this->data) && $this->full){
                throw new Exception("{$field} field does not exist in the table {$this->table}.");
            }

            $this->select[$field] = true;
        }
        $this->select[$this->primary] = true;

        return $this;

    }

    public function where(array $where): Datamanager
    {
        $this->where['AND'] = (array_key_exists('AND',$this->where)) ?? '';

        $w = [];
        foreach ($where as $condition => $values) {

            if(!is_array($values)){
                $w['AND'][] = $values;
                continue;
            }

            $this->check_where_array($values);
                   check_where_array($values);

            $w[(is_int($condition) ? 'AND' : $condition)][] = $values;
                       
        }

        $this->where = array_merge($this->where,$w);

        return $this;

    }

    public function limit(string $limit): Datamanager
    {
        $this->limit = $limit;
        return $this;

    }

    public function offset(int $offset): Datamanager
    {
        if(is_null($this->limit)){
            throw new Exception("The limit must be set before the offset.");
        }

        $this->offset = $offset;
        return $this;

    }

    public function result(): array
    {
        return $this->result;
    }

    public function first(): Datamanager
    {
        return  (count($this->result) > 0) ? $this->setByDatabase($this->result[0]) : $this;

    }

    public function setByDatabase(array $arrayValues): Datamanager
    {
        $clone = clone $this;
        
        $clone->result = [

            0 => $this->result[0]
        ];

        $clone->count = 1;

        foreach ($arrayValues as $key => $value) {

            if(!array_key_exists($key,$this->data)){
                throw new Exception("{$key} field does not exist in the table {$this->table}.");
            }

            $clone->data[$key]['value'] = $value;

        }
        return $clone;

    }

    public function toJson(): string
    {
        $string = '';
        foreach ($this->data as $key => $value) {

            if(gettype($value)==='object'){
                $value = $value->getData()[$this->primary]['value'];
            }

            $string .= '"'.$key.'"'.':"'.$value.'",';
        }
        return str_replace(',}', '}', '{'.$string.'}');
    }

    public function remove(?bool $exec = false): Datamanager
    {
        if(!$exec){
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
            $this->clause = 'remove';    

            return $this;

        }

        $this->clause = null;

        if(count($this->where) == 1){
            $this->removeById();
            return $this;

        }

        $this->delete($this->mountRemove()['where'], substr( $this->mountRemove()['data'] ,0,-1) );
               delete($this->mountRemove()['where'], substr( $this->mountRemove()['data'] ,0,-1) );

        $this->check_fail();
            
        return $this;

    }

    private function removeById(): bool
    {
        $delete = $this->delete("{$this->primary}=:{$this->primary}","{$this->primary}={$this->getData()[$this->primary]['value']}");

        $this->check_fail();

        return $delete;
    }

    public function persist(): Datamanager
    {
        $columns = '';
        $values = '';
        $data = [];

        foreach ($this->data as $key => $value) {
            if(strstr($this->data[$key]['extra'],'auto_increment')){
                continue;
            }

            if(strlen($value['value']) > $value['maxlength']){
                throw new Exception("The information provided for column {$key} of table {$this->table} exceeded that allowed.");
            }

            $columns .= $key.',';
            $values .= ':'.$key.',';
            $data[$key] = $value['value'];
        }

        $this->transaction('begin');
               transaction('begin');
        try{
           
            $id = $this->insert($data);
            $id = $this->insert($data);

            $this->check_fail();

            $this->getData()[$this->primary]['value'] = $id;
            
            $this->transaction('commit');

        }catch(Exception $er){
            $this->transaction('rollback');
            throw $er;
        }

        return $this;

    }

    public function toEntity()
    {
        if($this->getCount() === 0){
            return null;
        }

        $entity = $this->setByDatabase($this->result[0]);

        if(count($this->result) > 1){
            $entity = [];
            foreach ($this->result as $key => $value) {
                $entity[] = $this->setByDatabase($value);
            }
        }

        return $entity;
    }

    public function findById($id): Datamanager
    {
        $this->where([$this->primary,'=',$id]);
        return $this;

    }

    public function execute(): Datamanager
    {
        if(!is_null($this->clause) && $this->clause == 'remove'){
            return $this->remove(true);
        }

        $this->deny();
        
        $this->mountSelect();
               mountSelect();
        
        $where = substr($this->mountWhereExec()['where'],0,-1);
        $where = substr($this->/** @scrutinizer ignore-call */ mountWhereExec()['where'],0,-1);
        $this->query .= " WHERE {$where} ";

        $this->query .= $this->order;
       
        $this->mountLimit();
               mountLimit();
        $this->mountOffset();
               mountOffset();

        $this->result = $this->select($this->query, $this->mountWhereExec()['data']);
        $this->result = $this->select($this->query, $this->mountWhereExec()['data']);

        $this->check_fail();

        $this->count = count($this->result);
        $this->query = null;

        return $this;

    }

    public function find(?int $key = null): Datamanager
    {
        $this->query = " SELECT * FROM {$this->table} ";

        if(is_int($key)){
            return $this->findById($key);
        }

        return $this;

    }

}
hnrazevedo / Datamanager

Push — master ( ae9656...8b853b )

DataTrait::remove() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
