Tools::__construct() - Code Metrics - Inspection of "Merge pull request #17 from robmachado/master" - nfephp-org/sped-esfinge - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( b1cbf9...c194c3 )

by Roberto
created 2016-07-11 20:51 UTC
Tools::__construct() A

↳ Parent: Tools
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	3
CRAP Score	1
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
c	3
b	0
f	0
dl	0
loc	4
ccs	3
cts	3
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1
<?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 = '')
    {
        parent::__construct($configJson);
    }
    
    /**
     * 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;
    }
    
    /**
     * 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 tranferencia 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);
                //$retorno = $this->oSoap->send($uri, $namespace, $this->header, $body, $met);

                //$resp =  Response::readReturn($met, $retorno);

                if ($resp['bStat']) {
                    //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 tranferencia 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);
                //$retorno = $this->oSoap->send($uri, $namespace, $this->header, $body, $met);

                //$resp =  Response::readReturn($met, $retorno);

                if ($resp['bStat']) {
                    //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 tranferência sem um token valido');
                    //$this->token(self::TK_O);

                }
                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);
                //$retorno = $this->oSoap->send($uri, $namespace, $this->header, $body, $met);

                //$resp =  Response::readReturn($met, $retorno);

                if ($resp['bStat']) {
                    $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);
                //$retorno = $this->oSoap->send($uri, $namespace, $this->header, $body, $met);

                //$resp =  Response::readReturn($met, $retorno);

                if ($resp['bStat'] && $resp['chaveToken'] != '') {
                    $this->tokenid = $resp['chaveToken'];
                }
                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);
                //$retorno = $this->oSoap->send($uri, $namespace, $this->header, $body, $met);

                //$resp =  Response::readReturn($met, $retorno);

                $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;
}
    }
    
    /**
     * Inicia o processo de tranferência de dados
     * @param array $data
     * @throws InvalidArgumentException
     * @throws RuntimeException
     */
    protected function obterTokenIniciarTransferencia($data = array())
    {
        if (empty($data)) {
            throw new InvalidArgumentException('Não foram passados dados para o método');
        }
        $this->token(self::TK_OBTEM);
        $this->token(self::TK_INICIA);
        if ($this->tokenid == '' || $this->flagIniciar === false) {
            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 = array(), $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data);
        $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 = array(), $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data);
        $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 = array(), $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data);
        $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 = array(), $method = 'L')

    {
        $this->obterTokenIniciarTransferencia($data);
        $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;
    }
}

1			<?php
2
3			namespace NFePHP\Esfinge;
4
5			use InvalidArgumentException;
6			use RuntimeException;
7			use NFePHP\Esfinge\Response;
8			use NFePHP\Esfinge\Base;
9
10			class Tools extends Base
11			{
12			const TK_OBTEM = 'O';
13			const TK_INICIA = 'I';
14			const TK_FINALIZA = 'F';
15			const TK_CANCELA = 'C';
16			const TK_STATUS = 'S';
17
18			/**
19			* Endereços principais dos webservices
20			* @var array
21			*/
22			protected $url = [
23			'1' => 'https://esfingews.tce.sc.gov.br',
24			'2' => 'https://desenv2.tce.sc.gov.br:7443',
25			];
26			/**
27			* Competência bimestral no formato: AAAABB, onde:
28			* AAAA = ano a ser enviado os dados
29			* BB = bimestre de 01 até 06
30			* @var string
31			*/
32			protected $competencia;
33			/**
34			* Token de segurança e queue
35			* hash com 36 caracteres aleatórios
36			* @var string
37			*/
38			protected $tokenid;
39			/**
40			* Flag iniciar tranferencia
nfephp-org / sped-esfinge

Push — master ( b1cbf9...c194c3 )

Tools::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like
