FlexiBee::performRequest() - Code Metrics - Inspection of "Create unique & Delete WebHook" - Spoje-NET/FlexiPeeHP - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 28949e...af97ad )

by Vítězslav
created 2016-05-23 17:39 UTC
FlexiBee::performRequest() F

↳ Parent: FlexiBee
Complexity

Conditions	18
Paths	232
Size

Total Lines	95
Code Lines	64
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	50
CRAP Score	21.9833
Importance

Changes	7
Bugs	0	Features	1
Metric	Value
cc	18
eloc	64
c	7
b	0
f	1
nc	232
nop	3
dl	0
loc	95
ccs	50
cts	65
cp	0.7692
crap	21.9833
rs	3.9723
How to fix Long Method Complexity

<?php
/**
 * FlexiPeeHP - Třída pro práci s FlexiBee.
 *
 * @author     Vítězslav Dvořák <[email protected]>
 * @copyright  (C) 2015,2016 Spoje.Net
 */

namespace FlexiPeeHP;

class FlexiBee extends \Ease\Brick
{
    /**
     * Základní namespace pro komunikaci s FlexiBEE.
     *
     * @var string Jmený prostor datového bloku odpovědi
     */
    public $nameSpace = 'winstrom';

    /**
     * Datový blok v poli odpovědi.
     *
     * @var string
     */
    public $resultField = 'results';

    /**
     * Verze protokolu použitého pro komunikaci.
     *
     * @var string Verze použitého API
     */
    public $protoVersion = '1.0';

    /**
     * Evidence užitá objektem.
     *
     * @var string
     */
    public $evidence = null;

    /**
     * Výchozí formát pro komunikaci.
     *
     * @link https://www.flexibee.eu/api/dokumentace/ref/format-types Přehled možných formátů
     *
     * @var string json|xml|...
     */
    public $format = 'json';

    /**
     * Curl Handle.
     *
     * @var resource
     */
    public $curl = null;

    /**
     * @var type
     */
    public $company = FLEXIBEE_COMPANY;

    /**
     * @var string
     */
    public $url = FLEXIBEE_URL;

    /**
     * @var string
     */
    public $user = FLEXIBEE_LOGIN;

    /**
     * @var string
     */
    public $password = FLEXIBEE_PASSWORD;

    /**
     * Identifikační řetězec.
     *
     * @var string
     */
    public $init = null;

    /**
     * Sloupeček s názvem.
     *
     * @var string
     */
    public $nameColumn = 'nazev';

    /**
     * Sloupeček obsahující datum vložení záznamu do shopu.
     *
     * @var string
     */
    public $myCreateColumn = 'false';

    /**
     * Slopecek obsahujici datum poslení modifikace záznamu do shopu.
     *
     * @var string
     */
    public $myLastModifiedColumn = 'lastUpdate';

    /**
     * Klíčový idendifikátor záznamu.
     *
     * @var string
     */
    public $fbKeyColumn = 'id';

    /**
     * Informace o posledním HTTP requestu.
     *
     * @var array
     */
    public $info;

    /**
     * Informace o poslední HTTP chybě.
     *
     * @var array
     */
    public $error;

    /**
     * Used codes storage.
     *
     * @var array
     */
    public $codes = null;

    /**
     * Last Inserted ID.
     *
     * @var int
     */
    public $lastInsertedID = null;

    /**
     * Default Line Prefix.
     *
     * @var string
     */
    public $prefix = '/c/';

    /**
     * HTTP Response code of last request
     * 
     * @var int
     */
    public $lastResponseCode = null;

    /**
     * Třída pro práci s FlexiBee.
     *
     * @param string $init výchozí selektor dat
     */
    public function __construct($init = null)
    {
        $this->init = $init;

        parent::__construct();
        $this->curlInit();
    }

    public function curlInit()
    {
        $this->curl = \curl_init(); // create curl resource
        curl_setopt($this->curl, CURLOPT_RETURNTRANSFER, true); // return content as a string from curl_exec
        curl_setopt($this->curl, CURLOPT_FOLLOWLOCATION, true); // follow redirects (compatibility for future changes in FlexiBee)
        curl_setopt($this->curl, CURLOPT_HTTPAUTH, true);       // HTTP authentication
        curl_setopt($this->curl, CURLOPT_SSL_VERIFYPEER, false); // FlexiBee by default uses Self-Signed certificates
        curl_setopt($this->curl, CURLOPT_SSL_VERIFYHOST, false);
        curl_setopt($this->curl, CURLOPT_VERBOSE, true); // For debugging
        curl_setopt($this->curl, CURLOPT_USERPWD,
            $this->user.':'.$this->password); // set username and password
    }

    /**
     * Nastaví Agendu pro Komunikaci.
     *
     * @param string $evidence
     */
    public function setEvidence($evidence)
    {
        $this->evidence = $evidence;
    }

    /**
     * Převede rekurzivně Objekt na pole.
     *
     * @param object|array $object
     *
     * @return array
     */
    public static function object2array($object)
    {
        $result = null;
        if (is_object($object)) {
            $objectData = get_object_vars($object);
            if (is_array($objectData) && count($objectData)) {
                $result = array_map('self::object2array', $objectData);
            }
        } else {
            if (is_array($object)) {
                foreach ($object as $item => $value) {
                    $result[$item] = self::object2array($value);
                }
            } else {
                $result = $object;
            }
        }

        return $result;
    }

    /**
     * Funkce, která provede I/O operaci a vyhodnotí výsledek.
     *
     * @param string $urlSuffix část URL za identifikátorem firmy.
     * @param string $method    HTTP/REST metoda
     * @param string $format    Requested format
     */
    public function performRequest($urlSuffix = null, $method = 'GET',
                                   $format = null)
    {
        if (is_null($format)) {
            $format = $this->format;
        }
        if (is_null($urlSuffix)) {
            $urlSuffix = $this->evidence.'.'.$format;
        }
        $url = $this->url.$this->prefix.$this->company.'/'.$urlSuffix;
        curl_setopt($this->curl, CURLOPT_URL, $url);
// Nastavení samotné operace
        curl_setopt($this->curl, CURLOPT_CUSTOMREQUEST, $method);

// Proveď samotnou operaci
        $response = curl_exec($this->curl);

        $this->info = curl_getinfo($this->curl);


        $this->lastResponseCode = curl_getinfo($this->curl, CURLINFO_HTTP_CODE);

        if ($this->lastResponseCode != 200 && $this->lastResponseCode != 201) {
            $this->error = curl_error($this->curl);

            switch ($format) {
                case 'json':
                    $response = preg_replace_callback('/\\\\u([0-9a-fA-F]{4})/',
                        function ($match) {
                        return mb_convert_encoding(pack('H*', $match[1]),
                            'UTF-8', 'UCS-2BE');
                    }, $response);
                    $response = (json_encode(json_decode($response, true, 10),
                            JSON_PRETTY_PRINT));
                    break;
                case 'xml':
                    $response = self::xml2array($response);
                    break;
            }

            if (is_array($response)) {
                $result = http_build_query($response);
            } else {
                $result = http_build_query(self::object2array(current(json_decode($response))));
            }

            if ($this->lastResponseCode == 400) {
                $this->logResult($result);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            } else {
                $this->addStatusMessage(sprintf('Error (HTTP %d): <pre>%s</pre> %s',
                        curl_getinfo($this->curl, CURLINFO_HTTP_CODE), $result,
                        $this->error), 'error');
                $this->addStatusMessage($url);
            }
            if ($response == 'null') {
                if ($this->lastResponseCode == 200) {
                    $response = true;
                } else {
                    $response = null;
                }
            } else {
                if (is_string($response)) {
                    $response = self::object2array(current(json_decode($response)));
                }
            }
            return $response;
        }

        // Parse response
        switch ($format) {
            case 'json':
                $decoded = json_decode($response, true, 10);
                if (($method == 'PUT') && isset($decoded[$this->nameSpace][$this->resultField][0]['id'])) {
                    $this->lastInsertedID = $decoded[$this->nameSpace][$this->resultField][0]['id'];
                } else {
                    $this->lastInsertedID = null;
                }
//                $decodeError = json_last_error_msg();

//                $this->addStatusMessage($decodeError);

                break;
            case 'xml':
                if (strlen($response)) {
                    $decoded = self::xml2array($response);
                } else {
                    $decoded = null;
                }
                break;
        }

        // Get response body root automatically
        if (isset($decoded[$this->nameSpace])) {
            $decoded = $decoded[$this->nameSpace];
        }

        return $decoded;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
    }

    /**
     * Give you last inserted record ID.
     * 
     * @return int
     */
    public function getLastInsertedId()
    {
        return $this->lastInsertedID;
    }

    /**
     * Convert XML to array.
     * 
     * @param string $xml
     *
     * @return array
     */
    public static function xml2array($xml)
    {
        $arr = [];

        if (is_string($xml)) {
            $xml = simplexml_load_string($xml);
        }

        foreach ($xml->children() as $r) {
            $t = [];
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            if (count($r->children()) == 0) {
                $arr[$r->getName()] = strval($r);
            } else {
                $arr[$r->getName()][] = self::xml2array($r);
            }
        }

        return $arr;
    }

    /**
     * Odpojení od FlexiBee.
     */
    public function disconnect()
    {
        if (is_resource($this->curl)) {
            curl_close($this->curl);
        }
        $this->curl = null;
    }

    public function __destruct()
    {
        $this->disconnect();
    }

    /**
     * Načte data z FlexiBee.
     *
     * @param string $suffix dotaz
     */
    public function loadFlexiData($suffix = null)
    {
        return $this->takeData($this->getFlexiData($suffix));
    }

    /**
     * Načte řádek dat z FlexiBee.
     *
     * @param int $recordID id požadovaného záznamu
     *
     * @return array
     */
    public function getFlexiRow($recordID)
    {
        $record   = null;
        $response = $this->performRequest($this->evidence.'/'.$recordID.'.json');
        if (isset($response[$this->evidence])) {
            $record = $response[$this->evidence][0];
        }

        return $record;
    }

    /**
     * Načte data z FlexiBee.
     *
     * @param string $suffix     dotaz
     * @param string $conditions Volitelný filtrovací výraz
     */
    public function getFlexiData($suffix = null, $conditions = null)
    {
        if (!is_null($conditions)) {
            if ($conditions[0] != '/') {
                $conditions = '/'.rawurlencode('('.($conditions).')');
            }
        } else {
            $conditions = '';
        }
        if ($suffix) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $transactions = $this->performRequest($this->evidence.$conditions.'.'.$this->format.'?'.$suffix,
                'GET');
        } else {
            $transactions = $this->performRequest($this->evidence.$conditions.'.'.$this->format,
                'GET');
        }
        if (isset($transactions[$this->evidence])) {
            $result = $transactions[$this->evidence];
        } else {
            $result = $transactions;
        }

        return $result;
    }

    /**
     * Načte záznam z FlexiBee.
     *
     * @param int $id ID záznamu
     *
     * @return int počet načtených položek
     */
    public function loadFromFlexiBee($id = null)
    {
        if (is_null($id)) {
            $id = $this->getMyKey();
        }

        return $this->takeData($this->getFlexiData('/'.$id));
    }

    /**
     * Uloží data do FlexiBee.
     *
     * @param array $data
     *
     * @return array výsledek
     */
    public function saveToFlexiBee($data = null)

    {
        if (is_null($data)) {
            $data = $this->getData();
        }

        $jsonizedData = $this->jsonizeData($data);

        curl_setopt($this->curl, CURLOPT_POSTFIELDS, $jsonizedData);

        return $this->performRequest($this->evidence.'.'.$this->format, 'PUT');
    }

    /**
     * Převede data do Json formátu pro FlexiBee.
     *
     * @param array $data
     *
     * @return string
     */
    public function jsonizeData($data)
    {
        $jsonize = [
            $this->nameSpace => [
                '@version' => $this->protoVersion,
                $this->evidence => $data,
            ],
        ];

        return json_encode($jsonize);
    }

    /**
     * Uloží záznam.
     *
     * @param array $data
     *
     * @return array odpověď
     */
    public function insertToFlexiBee($data = null)

    {
        if (is_null($data)) {
            $data = $this->getData();
        }
        $jsonizedData = $this->jsonizeData($data);
        curl_setopt($this->curl, CURLOPT_POSTFIELDS, $jsonizedData);

        return $this->performRequest($this->evidence.'.'.$this->format, 'PUT');
    }

    /**
     * Test if given record ID exists in FlexiBee.
     *
     * @param string|int $identifer
     */
    public function idExists($identifer = null)
    {
        if (is_null($identifer)) {
            $identifer = $this->getMyKey();
        }
        $flexiData = $this->getFlexiData(
            'detail=custom:'.$this->getmyKeyColumn(), $identifer);

        return $flexiData;
    }

    /**
     * Test if given record exists in FlexiBee.
     *
     * @param array $data
     */
    public function recordExists($data = null)
    {
        if (is_null($data)) {
            $data = $this->getData();
        }

        $res = $this->getColumnsFromFlexibee([$this->myKeyColumn],
            self::flexiUrl($data));

        return $res;
    }

    /**
     * Vrací z FlexiBee sloupečky podle podmínek.
     *
     * @param array|int|string $conditions pole podmínek nebo ID záznamu
     * @param array|string     $orderBy    třídit dle
     * @param string           $indexBy    klice vysledku naplnit hodnotou ze
     *                                     sloupečku
     * @param int              $limit      maximální počet vrácených záznamů
     *
     * @return array
     */
    public function getAllFromFlexibee($conditions = null, $orderBy = null,

                                       $indexBy = null, $limit = null)

    {
        if (is_int($conditions)) {
            $conditions = [$this->getmyKeyColumn() => $conditions];
        }

        $flexiData = $this->getFlexiData('', $conditions);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        if ($indexBy) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $flexiData2 = [];
            foreach ($flexiData as $dataID => $data) {
                $flexiData2[$data[$indexBy]] = $data;
            }
            $flexiData = $flexiData2;
        }

        return $flexiData;
    }

    /**
     * Vrací z FlexiBee sloupečky podle podmínek.
     *
     * @param string[]         $columnsList seznam položek
     * @param array|int|string $conditions  pole podmínek nebo ID záznamu
     * @param array|string     $orderBy     třídit dle
     * @param string           $indexBy     klice vysledku naplnit hodnotou ze
     *                                      sloupečku
     * @param int              $limit       maximální počet vrácených záznamů
     *
     * @return array
     */
    public function getColumnsFromFlexibee($columnsList, $conditions = null,
                                           $orderBy = null, $indexBy = null,

                                           $limit = null)

    {
        if (($columnsList != '*') && !count($columnsList)) {
            $this->error('getColumnsFromFlexiBee: Missing ColumnList');

            return;
        }

        if (is_int($conditions)) {
            $conditions = [$this->getmyKeyColumn() => $conditions];
        }

        if (is_array($columnsList)) {
            $columns = implode(',', array_unique($columnsList));
        } else {
            $columns = $columnsList;
        }

        $flexiData = $this->getFlexiData('detail=custom:'.$columns, $conditions);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        if ($indexBy) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $flexiData2 = [];
            foreach ($flexiData as $dataID => $data) {
                $flexiData2[$data[$indexBy]] = $data;
            }
            $flexiData = $flexiData2;
        }

        return $flexiData;
    }

    /**
     * Vrací kód záznamu.
     *
     * @param mixed $data
     *
     * @todo papat i string
     *
     * @return string
     */
    public function getKod($data = null, $unique = true)
    {
        $kod = null;

        if (is_null($data)) {
            $data = $this->getData();
        }

        if (is_string($data)) {
            $data = [$this->nameColumn => $data];
        }

        if (isset($data['kod'])) {
            $kod = $data['kod'];
        } else {
            if (isset($data[$this->nameColumn])) {
                $kod = preg_replace('/[^a-zA-Z0-9]/', '',
                    \Ease\Sand::rip($data[$this->nameColumn]));
            } else {
                if (isset($data[$this->myKeyColumn])) {
                    $kod = \Ease\Sand::rip($data[$this->myKeyColumn]);
                }
            }
        }

        if (!strlen($kod)) {
            $kod = 'NOTSET';
        }

        if (strlen($kod) > 18) {
            $kodfinal = strtoupper(substr($kod, 0, 18));
        } else {
            $kodfinal = strtoupper($kod);
        }

        if ($unique) {
            $counter = 0;
            if ($this->codes) {

                foreach ($this->codes as $codesearch => $keystring) {
                    if (strstr($codesearch, $kodfinal)) {
                        ++$counter;
                    }
                }
            }
            if ($counter) {
                $kodfinal = $kodfinal.$counter;
            }

            $this->codes[$kodfinal] = $kod;
        }

        return $kodfinal;
    }

    /**
     * Vyhledavani v záznamech objektu FlexiBee.
     *
     * @param string $what hledaný výraz
     *
     * @return array pole výsledků
     */
    public function searchString($what)
    {
        $results   = [];
        $conds     = [];
        $columns[] = $this->myKeyColumn;
foreach ($collection as $item) {
    $myArray['foo'] = $item->getFoo();

    if ($item->hasBar()) {
        $myArray['bar'] = $item->getBar();
    }

    // do something with $myArray
}
        foreach ($this->useKeywords as $keyword => $keywordInfo) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            if (isset($this->keywordsInfo[$keyword]['virtual']) && ($this->keywordsInfo[$keyword]['virtual']
class MyClass { }

$x = new MyClass();
$x->foo = true;
                == true)) {
                if ($keyword == $this->nameColumn) {
                    $this->nameColumn = $this->myKeyColumn;
                }
                continue;
            }
            switch ($keywordInfo) {
                case 'INT':
                case 'FLOAT':

                    if (is_numeric($what)) {
                        $conds[]   = "($keyword = ".$what.')';
                        $columns[] = "$keyword";
                    }
                    break;
                case 'TEXT':
                case 'STRING':

                    if (is_string($what)) {
                        $conds[]   = "( $keyword like '".$what."')";
                        $columns[] = "$keyword";
                    }
                    break;
                default:
                    break;
            }
        }

//        $res = \Ease\Shared::db()->queryToArray('SELECT ' . implode(',', $columns) . ',' . $this->nameColumn . ' FROM ' . $this->myTable . ' WHERE ' . implode(' OR ', $conds) . ' ORDER BY ' . $this->nameColumn, $this->myKeyColumn);


        $res = $this->getColumnsFromFlexibee($columns, implode(' or ', $conds));

        foreach ($res as $result) {
            $occurences = '';
            foreach ($result as $key => $value) {
                if (is_array($value)) {
                    continue;
                }
                if (mb_stristr($value, $what)) {
                    $occurences .= '('.$key.': '.$value.')';
                }
            }
            $results[$result[$this->myKeyColumn]] = [$this->nameColumn => $result[$this->nameColumn],
                'what' => $occurences,];
        }

        return $results;
    }

    /**
     * Write Operation Result.
     * 
     * @param array  $resultData
     * @param string $url        URL
     */
    public function logResult($resultData, $url = null)
    {
        if ($url) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $this->logger->addStatusMessage($url);
        }

        if (isset($resultData['results'])) {
            $status = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            if ($resultData['success'] == 'false') {
                $status = 'error';
            } else {
                $status = 'success';
            }
            foreach ($resultData['results'] as $result) {
                if (isset($result['request-id'])) {
                    $rid = $result['request-id'];
                } else {
                    $rid = '';
                }
                if (isset($result['errors'])) {
                    foreach ($result['errors'] as $error) {
                        $message = $error['message'];
                        if (isset($error['for'])) {
                            $message.=' for: '.$error['for'];
                        }
                        if (isset($error['value'])) {
                            $message.=' value:'.$error['value'];
                        }
                        if (isset($error['code'])) {
                            $message.=' code:'.$error['code'];
                        }
                        $this->logger->addStatusMessage($rid.': '.$message,
                            $status);
                    }
                }
            }
        }
        if (is_object($this->logger)) {
            $this->logger->flush(get_class($this));
        }
    }

    /**
     * Generuje fragment url pro filtrování.
     *
     * @see https://www.flexibee.eu/api/dokumentace/ref/filters
     *
     * @param array  $data
     * @param string $operator and/or
     *
     * @return string
     */
    public static function flexiUrl(array $data, $operator = 'and')
    {
        $flexiUrl = '';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $parts    = [];

        foreach ($data as $column => $value) {
            if (is_numeric($data[$column])) {
                $parts[$column] = $column.' = '.$data[$column];
            } else {
                $parts[$column] = $column." = '".$data[$column]."'";
            }
        }

        $flexiUrl = implode(' '.$operator.' ', $parts);

        return $flexiUrl;
    }

    /**
     * Smaže záznam
     *
     * @param int|string $id identifikátor záznamu
     */
    public function deleteFromFlexiBee($id)
    {
        $this->performRequest($this->evidence.'/'.$id.'.'.$this->format,
            'DELETE');
    }
}
1			<?php
2			/**
3			* FlexiPeeHP - Třída pro práci s FlexiBee.
4			*
5			* @author Vítězslav Dvořák <[email protected]>
6			* @copyright (C) 2015,2016 Spoje.Net
7			*/
8
9			namespace FlexiPeeHP;
10
11			class FlexiBee extends \Ease\Brick
12			{
13			/**
14			* Základní namespace pro komunikaci s FlexiBEE.
15			*
16			* @var string Jmený prostor datového bloku odpovědi
17			*/
18			public $nameSpace = 'winstrom';
19
20			/**
21			* Datový blok v poli odpovědi.
22			*
23			* @var string
24			*/
25			public $resultField = 'results';
26
27			/**
28			* Verze protokolu použitého pro komunikaci.
29			*
30			* @var string Verze použitého API
31			*/
32			public $protoVersion = '1.0';
33
34			/**
35			* Evidence užitá objektem.
36			*
37			* @var string
38			*/
39			public $evidence = null;
40
Spoje-NET / FlexiPeeHP

Push — master ( 28949e...af97ad )

FlexiBee::performRequest() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Duplication Side-by-Side

Filter issues like
