FlexiPeeHP\FlexiBee

Complexity

Total Complexity

98

Size/Duplication

Total Lines	759
Duplicated Lines	6.32 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

40.68%

Importance

Changes	9
Bugs	0	Features	1

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	curlInit()	0	12	1
A	setAgenda()	0	4	1
B	object2array()	0	20	6
C	performRequest()	0	72	12
A	getLastInsertedId()	0	4	1
A	xml2array()	0	19	4
A	disconnect()	0	7	2
A	__destruct()	0	4	1
A	loadFlexiData()	0	4	1
A	getFlexiRow()	0	10	2
B	getFlexiData()	0	24	5
A	loadFromFlexiBee()	0	8	2
A	saveToFlexiBee()	12	12	2
A	jsonizeData()	0	11	1
A	insertToFlexiBee()	10	10	2
A	idExists()	0	10	2
A	recordExists()	0	11	2
A	getAllFromFlexibee()	7	19	4
C	getColumnsFromFlexibee()	7	32	7
C	getKod()	0	48	12
C	searchString()	12	53	15
D	logResult()	0	31	9
A	flexiUrl()	0	17	3

<?php
/**
 * System.Spoje.Net - Třída pro práci s FlexiBee.
 *
 * @author     Vítězslav Dvořák <vitex@arachne.cz>
 * @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';

    /**
     * Agenda užitá objektem.
     *
     * @var string
     */
    public $agenda = 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/';

    /**
     * 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 $agenda
     */
    public function setAgenda($agenda)
    {
        $this->agenda = $agenda;
    }

    /**
     * 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->agenda.'.'.$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);

It seems like curl_getinfo($this->curl) of type * is incompatible with the declared type array of property $info.

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

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

It seems like curl_error($this->curl) of type string is incompatible with the declared type array of property $error.

            $response    = (json_encode(json_decode($response, true, 10),
                    JSON_PRETTY_PRINT));

            $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);

            if ($responseCode == 400) {
                $this->logResult(self::object2array(current(json_decode($response))));

It seems like self::object2array(current(json_decode($response))) targeting FlexiPeeHP\FlexiBee::object2array() can also be of type null; however, FlexiPeeHP\FlexiBee::logResult() does only seem to accept array, maybe add an additional type check?

            } else {
                $this->addStatusMessage(sprintf(_('Při operaci nastala chyba (HTTP %d): <pre>%s</pre> %s'),
                        curl_getinfo($this->curl, CURLINFO_HTTP_CODE),
                        stripslashes($response), $this->error), 'error');
                $this->addStatusMessage($url);
            }
            if ($response == 'null') {
                return;
            }

            return self::object2array(current(json_decode($response)));
        }

        // Parse response
        switch ($format) {
            case 'json':
                $decoded = json_decode($response, true, 10);
                if (($method == 'post') && 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();

56% of this comment could be valid code. Did you maybe forget this after debugging?

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

                break;
            case 'xml':
                $decoded = self::xml2array($response);
                break;
        }

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

        return $decoded;

The variable $decoded does not seem to be defined for all execution paths leading up to this point.

    }

    /**
     * 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 = [];

$t is not used, you could remove the assignment.

            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->agenda.'/'.$recordID.'.json');
        if (isset($response[$this->agenda])) {
            $record = $response[$this->agenda][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) {

The expression $suffix of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $transactions = $this->performRequest($this->agenda.$conditions.'.'.$this->format.'?'.$suffix,
                'GET');
        } else {
            $transactions = $this->performRequest($this->agenda.$conditions.'.'.$this->format,
                'GET');
        }
        if (isset($transactions[$this->agenda])) {
            $result = $transactions[$this->agenda];
        } 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)

This method seems to be duplicated in your project.

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

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

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

        return $this->performRequest($this->agenda.'.'.$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->agenda => $data,
            ],
        ];

        return json_encode($jsonize);
    }

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

This method seems to be duplicated in your project.

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

        return $this->performRequest($this->agenda.'.'.$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,

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

                                       $indexBy = null, $limit = null)

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

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

        $flexiData = $this->getFlexiData('', $conditions);

It seems like $conditions can also be of type array; however, FlexiPeeHP\FlexiBee::getFlexiData() does only seem to accept string|null, maybe add an additional type check?

        if ($indexBy) {

The expression $indexBy of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

This code seems to be duplicated across your project.

            $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,

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

                                           $limit = null)

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

    {
        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);

It seems like $conditions can also be of type array; however, FlexiPeeHP\FlexiBee::getFlexiData() does only seem to accept string|null, maybe add an additional type check?

        if ($indexBy) {

The expression $indexBy of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

This code seems to be duplicated across your project.

            $flexiData2 = [];
            foreach ($flexiData as $dataID => $data) {
                $flexiData2[$data[$indexBy]] = $data;
            }
            $flexiData = $flexiData2;
        }

        return $flexiData;
    }

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

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

        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) > 18) {
            $kodfinal = substr($kod, 0, 18);
        } else {
            $kodfinal = $kod;
        }

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

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

                foreach ($this->codes as $codesearch) {
                    if (!strlen($codesearch)) {
                        echo 'Error';
                    }
                    if (strstr($codesearch, $kodfinal)) {
                        ++$counter;
                    }
                }
            }
            if ($counter) {
                $kodfinal = $kodfinal.$counter;
            }

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

        return strtoupper($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;

$columns was never initialized. Although not strictly required by PHP, it is generally a good practice to add $columns = array(); before regardless.

        foreach ($this->useKeywords as $keyword => $keywordInfo) {

The property useKeywords does not exist. Did you maybe forget to declare it?

            if (isset($this->keywordsInfo[$keyword]['virtual']) && ($this->keywordsInfo[$keyword]['virtual']

The property keywordsInfo does not exist. Did you maybe forget to declare it?

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

This code seems to be duplicated across your project.

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

This code seems to be duplicated across your project.

                    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);

43% of this comment could be valid code. Did you maybe forget this after debugging?

        $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) {

The expression $url of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $this->logger->addStatusMessage($url);
        }

        if (isset($resultData['results'])) {
            $status = null;

$status is not used, you could remove the assignment.

            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) {
                        $this->logger->addStatusMessage($rid.': '.$error['message'],
                            $status);
                    }
                }
            }
        }
        if (is_object($this->logger)) {
            $this->logger->flush(get_class($this));

The method flush() does not seem to exist on object<Ease\Logger>.

        }
    }

    /**
     * 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($data, $operator = 'and')
    {
        $flexiUrl = '';

$flexiUrl is not used, you could remove the assignment.

        $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;
    }
}