Tools - Code Metrics - nfephp-org/sped-esfinge - Measure and Improve Code Quality continuously with Scrutinizer

Tools B
last analyzed 2020-05-19 15:10 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	361
Duplicated Lines	26.87 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

10.49%

Importance

Changes

Metric	Value
wmc	44
lcom	2
cbo	1
dl	97
loc	361
ccs	17
cts	162
cp	0.1049
rs	8.8798
c	0
b	0
f	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setCompetencia()	0	11	4
A	getCompetencia()	0	4	1
A	getToken()	0	4	1
A	getTransferencia()	0	4	1
F	token()	60	145	26
A	getStringBetween()	0	11	2
A	obterTokenIniciarTransferencia()	0	13	4
A	servidor()	10	10	1
A	situacaoServidorFolhaPagamento()	9	9	1
A	componentesFolhaPagamento()	9	9	1
A	folhaPagamento()	9	9	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Tools often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Tools, and based on these observations, apply Extract Interface, too.

<?php

namespace NFePHP\Esfinge;

use InvalidArgumentException;
use RuntimeException;
use NFePHP\Esfinge\Response;
use NFePHP\Esfinge\Base;

class Tools extends Base
{
    const TK_OBTEM = 'O';
    const TK_INICIA = 'I';
    const TK_FINALIZA = 'F';
    const TK_CANCELA = 'C';
    const TK_STATUS = 'S';
    
    /**
     * Endereços principais dos webservices
     * @var array
     */
    protected $url = [
        '1' => 'https://esfingews.tce.sc.gov.br',
        '2' => 'https://desenv2.tce.sc.gov.br:7443',
    ];
    /**
     * Competência bimestral no formato: AAAABB, onde:
     * AAAA = ano a ser enviado os dados
     * BB = bimestre de 01 até 06
     * @var string
     */
    protected $competencia = '';
    /**
     * Token de segurança e queue
     * hash com 36 caracteres aleatórios
     * @var string
     */
    protected $tokenid = '';
    /**
     * Flag iniciar tranferencia
     * @var bool
     */
    protected $flagIniciar = false;
    /**
     * Datahora da ultima solicitação da situação do token
     * @var timestramp
     */
    protected $tsLastSitToken;
    
    /**
     * Construtor
     * @param string $configJson
     */
    public function __construct($configJson = '', $debug = false)
    {
        parent::__construct($configJson, $debug);
    }
    
    /**
     * Define o período de competência das informações
     * formado AAAABB sendo BB o bimestre de 01 até 06
     * @param string $valor
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     */
    public function setCompetencia($aaaabb)
    {
        if (!is_numeric($aaaabb)) {
            throw new InvalidArgumentException('O periodo de competência é uma informação APENAS numérica.');
        }
        $bm = intval(substr($aaaabb, -2));
        if ($bm > 6 || $bm <= 0) {
            throw new InvalidArgumentException('O bimestre pode ser de 01 até 06 APENAS.');
        }
        $this->competencia = $aaaabb;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
    }
    
    /**
     * Retorna o período de competência informado
     * @return string
     */
    public function getCompetencia()
    {
        return $this->competencia;
    }
    
    /**
     * Retorna no token ativo
     * @return string
     */
    public function getToken()
    {
        return $this->tokenid;
    }
    
    /**
     * Retorna o status de inicio de transferencia
     * @return bool
     */
    public function getTransferencia()
    {
        return $this->flagIniciar;
    }
    
    /**
     * Operações com token
     * O método pode ser:
     *   C - cancela a transferencia
     *   F - finaliza a transferencia
     *   I - inica a transferencia
     *   O - Obtem o token para realizar as operações
     *   S - Verifica a situação do token
     * @param string $method
     */
    public function token($method = self::TK_OBTEM)
    {
        $uri = $this->url[$this->tpAmb].'/esfinge/services/tokenWS';
        $namespace = 'http://token.ws.tce.sc.gov.br/';
        
        switch ($method) {
            case self::TK_CANCELA:

                //cancela as operações realizadas com um determinado token
                //se OK o token é removido e todas as operações com ele
                //realizadas são descartadas
                if ($this->flagIniciar === false) {
                    //não está iniciada a tranferencia então não dá para cancelar
                    throw new RuntimeException('A transferência não foi iniciada, então não pode ser cancelada');
                }
                $met = 'cancelarTransferencia';
                $body = "<svc:cancelarTransferencia>"
                    . "<chaveToken>$this->tokenid</chaveToken>"
                    . "</svc:cancelarTransferencia>";
                $resp = $this->envia($uri, $namespace, $body, '', $met);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                if ($resp['bStat'] && $resp['status'] == 'OK') {
                    //cancelamento aceito
                    $this->tokenid = '';
                    $this->flagIniciar = false;
                }
                break;
            case self::TK_FINALIZA:

                //Ao final da transferência caso queria confirmar todos os elementos inseridos
                //(que não retornaram erro) nesta sessão, ou seja todos os elementos ligados a
                //determinado token passado para o serviço. Uma vez executado este serviço
                //o token atual será descartado.
                if ($this->flagIniciar === false) {
                    //não está iniciada a tranferencia então não dá para finalizar
                    throw new RuntimeException('A transferência não foi iniciada, então não pode ser finalizada');
                }
                $met = 'finalizarTransferencia';
                $body = "<svc:finalizarTransferencia>"
                    . "<chaveToken>$this->tokenid</chaveToken>"
                    . "</svc:finalizarTransferencia>";
                $resp = $this->envia($uri, $namespace, $body, '', $met);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                if ($resp['bStat'] && $resp['status'] == 'OK') {
                    //finalização aceita
                    $this->tokenid = '';
                    $this->flagIniciar = false;
                }
                break;
            case self::TK_INICIA:
                //Antes de iniciar a transferência dos dados propriamente dita, será necessário executar
                //o serviço iniciarTransferencia
                if ($this->tokenid == '') {
                    //não é possivel iniciar sem um token valido
                    throw new RuntimeException('Não é possivel iniciar a transferência sem um token valido');
                }
                if ($this->flagIniciar === true) {
                    $resp = [
                        'bStat' => true,
                        'message' => 'Início de transferência liberado',
                        'status' => 'OK'
                    ];
                    break;
                }
                $met = 'iniciarTransferencia';
                $body = "<svc:iniciarTransferencia>"
                    . "<chaveToken>$this->tokenid</chaveToken>"
                    . "</svc:iniciarTransferencia>";
                $resp = $this->envia($uri, $namespace, $body, '', $met);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                if ($resp['bStat'] && $resp['status'] == 'OK') {
                    $this->flagIniciar = true;
                }
                break;
            case self::TK_OBTEM:
                //Retorna um token para a unidade gestora poder usar o serviço do TCE.
                //Permite somente um token por unidade gestora.
                if ($this->tokenid != '') {

                    $resp = [
                        'bStat' => true,
                        'message' => 'Token criado com sucesso',
                        'status' => 'OK',
                        'chaveToken' => $this->tokenid,
                        'posicao' => 2,
                        'situacao' => 'Pronto para envio ou consulta'
                    ];
                    break;
                }
                $met = 'obterToken';
                $body = "<svc:obterToken>"
                    . "<codigoUg>$this->codigoUnidadeGestora</codigoUg>"
                    . "</svc:obterToken>";
                $resp = $this->envia($uri, $namespace, $body, '', $met);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                if ($resp['bStat']
                    && $resp['chaveToken'] != ''
                    && $resp['status'] == 'OK'
                ) {
                    $this->tokenid = $resp['chaveToken'];
                }
                $resp1 = $resp;
                if ($resp['bStat'] && $resp['status'] == 'ERRO') {
                    $xPos = stripos('xx'.$resp['message'], "Sua unidade gestora já obteve o token com chave [");
                    if ($xPos !== false) {
                        $chave = $this->getStringBetween($resp['message'], '[', ']');
                        if ($chave != '') {
                            $this->tokenid = $chave;
                            $resp = [
                                'bStat' => true,
                                'message' => $resp1['message'],
                                'status' => 'OK',
                                'chaveToken' => $this->tokenid,
                                'posicao' => 2,
                                'situacao' => 'Pronto para envio ou consulta'
                            ];
                        }
                    }
                }
                $resp1 = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                break;
            case self::TK_STATUS:
                //Retorna a situação do token passado como parâmetro. Para evitar solicitações
                //indefinidas a este serviço o sistema punirá com a remoção do token da fila
                //sempre que for feita duas chamadas seguidas do serviço obterSituacaoToken
                //em menos de cinco segundos.
                if ($this->tokenid == '') {
                    //não é possivel verificar o token
                    throw new RuntimeException('Não existe um token aberto.');
                }
                //se tentativa de verificação ocorrer em menos de 2 seg
                //retorna como OK
                if ((time()-$this->tsLastSitToken) <= 2) {

                    $resp = [
                        'bStat' => true,
                        'message' => 'Situação token obtida com sucesso',
                        'status' => 'OK',
                        'posicao' => 1,
                        'situacao' => 'Pronto para envio ou consulta'
                    ];
                    break;
                }
                $met = 'obterSituacaoToken';
                $body = "<svc:obterSituacaoToken>"
                    . "<chaveToken>$this->tokenid</chaveToken>"
                    . "</svc:obterSituacaoToken>";
                $resp = $this->envia($uri, $namespace, $body, '', $met);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $this->tsLastSitToken = time();

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

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

    // $x is potentially undefined here.
    echo $x;
}
    }
    
    /**
     * Extrai os dados entre dois marcadores
     * @param string $string
     * @param string $start
     * @param string $end
     * @return string
     */
    private function getStringBetween($string, $start, $end)
    {
        $string = ' ' . $string;
        $ini = strpos($string, $start);
        if ($ini == 0) {
            return '';
        }
        $ini += strlen($start);
        $len = strpos($string, $end, $ini) - $ini;
        return substr($string, $ini, $len);
    }
    
    /**
     * Inicia o processo de tranferência de dados
     * @param array $data
     * @throws InvalidArgumentException
     * @throws RuntimeException
     */
    protected function obterTokenIniciarTransferencia($data = [], $method = 'L')
    {
        if (empty($data)) {
            throw new InvalidArgumentException('Não foram passados dados para o método');
        }
        $this->token(self::TK_OBTEM);
        if ($method == 'E') {
            $this->token(self::TK_INICIA);
        }
        if ($this->tokenid == '') {
            throw new RuntimeException("Falha token:$this->tokenid , Iniciar: $this->flagIniciar");
        }
    }

    /**
     * Servidor
     *  se ainda não tiver o TOKEN -> Obtem  (automático)
     *  se ainda não tiver iniciado -> inicia (automático)
     * @param array $data
     * @param string $method
     * @return array
     */
    public function servidor($data = [], $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data, $method);
        $uri = $this->url[$this->tpAmb].'/esfinge/services/servidorWS';
        $namespace = 'http://servidor.ws.tce.sc.gov.br/';
        $met = 'servidor'.$method;
        //envia a mensagem via cURL
        $resp = $this->envia($uri, $namespace, $data, $method, $met);
        return $resp;
    }
    
    /**
     * Situação Servidor Folha Pagamento
     *  se ainda não tiver o TOKEN -> Obtem  (automático)
     *  se ainda não tiver iniciado -> inicia (automático)
     * @param array $data
     * @param string $method
     * @return array
     */
    public function situacaoServidorFolhaPagamento($data = [], $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data, $method);
        $uri = $this->url[$this->tpAmb].'/esfinge/services/situacaoServidorFolhaPagamentoWS';
        $namespace = 'http://situacaoservidorfolhapagamento.ws.tce.sc.gov.br/';
        $met = 'situacaoServidorFolhaPagamento'.$method;
        $resp = $this->envia($uri, $namespace, $data, $method, $met);
        return $resp;
    }

    /**
     * Componentes Folha Pagamento
     *  se ainda não tiver o TOKEN -> Obtem  (automático)
     *  se ainda não tiver iniciado -> inicia (automático)
     * @param array $data
     * @param string $method
     * @return array
     */
    public function componentesFolhaPagamento($data = [], $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data, $method);
        $uri = $this->url[$this->tpAmb].'/esfinge/services/componentesFolhaPagamentoWS';
        $namespace = 'http://componentesfolhapagamento.ws.tce.sc.gov.br/';
        $met = 'componentesFolhaPagamento'.$method;
        $resp = $this->envia($uri, $namespace, $data, $method, $met);
        return $resp;
    }

    /**
     * Folha Pagamento
     *  se ainda não tiver o TOKEN -> Obtem  (automático)
     *  se ainda não tiver iniciado -> inicia (automático)
     * @param array $data
     * @param string $method
     * @return array
     */
    public function folhaPagamento($data = [], $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data, $method);
        $uri = $this->url[$this->tpAmb].'/esfinge/services/folhaPagamentoWS';
        $namespace = 'http://folhapagamento.ws.tce.sc.gov.br/';
        $met = 'folhaPagamento'.$method;
        $resp = $this->envia($uri, $namespace, $data, $method, $met);
        return $resp;
    }
}


nfephp-org / sped-esfinge

Tools B last analyzed 2020-05-19 15:10 UTC