Montar o Hash da transação no padrão utilizado pelo SuperPay
508240
def to_request
      transacao = {
        numero_transacao:               self.numero_transacao,
        "IP" =>                         self.ip,
        codigo_forma_pagamento:         self.codigo_forma_pagamento,
        valor:                          self.valor,
        valor_desconto:                 self.valor_desconto,
        taxa_embarque:                  self.taxa_embarque,
        parcelas:                       self.parcelas,
        nome_titular_cartao_credito:    self.nome_titular_cartao_credito,
        numero_cartao_credito:          self.numero_cartao_credito,
        codigo_seguranca:               self.codigo_seguranca,
        data_validade_cartao:           self.data_validade_cartao,
        vencimento_boleto:              self.vencimento_boleto,
        url_redirecionamento_pago:      self.url_redirecionamento_pago,
        url_redirecionamento_nao_pago:  self.url_redirecionamento_nao_pago,
        campo_livre1:                   self.campo_livre1,
        campo_livre2:                   self.campo_livre2,
        campo_livre3:                   self.campo_livre3,
        campo_livre4:                   self.campo_livre4,
        campo_livre5:                   self.campo_livre5,
      }

      # Adicionar os parâmetros de configurações
      transacao.merge! SuperpayApi.configuracoes_to_request

      # Adicionar dados do usuário
      transacao[:dados_usuario_transacao] = self.dados_usuario_transacao.to_request unless self.dados_usuario_transacao.blank?

      # Adicionar itens do pedido
      transacao[:itens_do_pedido] = self.itens_do_pedido.collect{ |i| i.to_request } unless self.itens_do_pedido.blank?

      return transacao
    end
533360
public function transferir(
        Request $request,
        AtendimentoService $atendimentoService,
        ServicoService $servicoService,
        Atendimento $atendimento,
        TranslatorInterface $translator
    ) {
        $envelope = new Envelope();
        
        $usuario = $this->getUser();
        $unidade = $usuario->getLotacao()->getUnidade();

        $this->checkAtendimento($unidade, $atendimento, $translator);

        $data = json_decode($request->getContent(), true);

        $transferirForm = $this->createTransferirForm($request, $servicoService);
        $transferirForm->submit($data);

        if (!$transferirForm->isValid()) {
            throw new Exception($translator->trans('error.invalid_form', [], self::DOMAIN));
        }
        
        $servicoUnidade = $transferirForm->get('servico')->getData();
        $prioridade     = $transferirForm->get('prioridade')->getData();

        $atendimentoService->transferir(
            $atendimento,
            $unidade,
            $servicoUnidade->getServico(),
            $prioridade
        );

        return $this->json($envelope);
    }
247887
def build_request_estorno_de_transacao numero_transacao, valor_estorno
      # Montar os parâmetros para consulta
      params = {
        codigo_estabelecimento: SuperpayApi.estabelecimento,
        numero_transacao: numero_transacao,
        valor_estorno: valor_estorno,
      }
    end
39673
function getTransactionResult($token) {

        try {

            $getTransactionResult = new getTransactionResult();
            $getTransactionResult->tokenInput = $token;
            $getTransactionResultResponse = $this->_getTransactionResult($getTransactionResult);

            /** Validación de firma del requerimiento de respuesta enviado por Webpay */
            $xmlResponse = $this->soapClient->__getLastResponse();
            $soapValidation = new SoapValidation($xmlResponse, $this->config->getWebpayCert());
            $validationResult = $soapValidation->getValidationResult();

            if ($validationResult === TRUE) {

                $transactionResultOutput = $getTransactionResultResponse->return;

                /** Indica a Webpay que se ha recibido conforme el resultado de la transacción */
                if ($this->acknowledgeTransaction($token)) {

                    return $transactionResultOutput;

                } else {

                    $error["error"] = "Error validando conexi&oacute;n a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";
                    $error["detail"] = "No se pudo completar la conexi&oacute;n con Webpay";
                }
            }
        } catch (\Exception $e) {

            $error["error"] = "Error conectando a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";

            $replaceArray = array('<!--' => '', '-->' => '');
            $error["detail"] = str_replace(array_keys($replaceArray), array_values($replaceArray), $e->getMessage());
        }
    }
1023237
def _get_notification(self, email, token):
        '''  '''        
        url = u'{notification_url}{notification_code}?email={email}&token={token}'.format(
            notification_url=self.notification_url,
            notification_code=self.notification_code,
            email=email,
            token=token)
        req = requests.get(url)
        if req.status_code == 200:
            self.xml = req.text
            logger.debug( u'XML com informacoes da transacao recebido: {0}'.format(self.xml) )
            transaction_dict = xmltodict.parse(self.xml)
            # Validar informações recebidas
            transaction_schema(transaction_dict)
            self.transaction = transaction_dict.get('transaction')
        else:
            raise PagSeguroApiException(
                        u'Erro ao fazer request para a API de notificacao:' + 
                        ' HTTP Status=%s - Response: %s' % (req.status_code, req.text))
472336
public function getCodigoNome()
    {
        $codigo = $this->getCodigo();

        if (\Cnab\Banco::BRADESCO == $this->_codigo_banco) {
            if (2 == $codigo) {
                return 'Entrada Confirmada';
            } elseif (3 == $codigo) {
                return 'Entrada Rejeitada';
            } elseif (6 == $codigo) {
                return 'Liquidação normal';
            } elseif (9 == $codigo) {
                return 'Baixado Automat. via Arquivo';
            } elseif (10 == $codigo) {
                return 'Baixado conforme instruções da Agência';
            } elseif (11 == $codigo) {
                return 'Em Ser - Arquivo de Títulos pendentes';
            } elseif (12 == $codigo) {
                return 'Abatimento Concedido';
            } elseif (13 == $codigo) {
                return 'Abatimento Cancelado';
            } elseif (14 == $codigo) {
                return 'Vencimento Alterado';
            } elseif (15 == $codigo) {
                return 'Liquidação em Cartório';
            } elseif (16 == $codigo) {
                return 'Título Pago em Cheque – Vinculado';
            } elseif (17 == $codigo) {
                return 'Liquidação após baixa ou Título não registrado';
            } elseif (18 == $codigo) {
                return 'Acerto de Depositária (sem motivo)';
            } elseif (19 == $codigo) {
                return 'Confirmação Receb. Inst. de Protesto';
            } elseif (20 == $codigo) {
                return 'Confirmação Recebimento Instrução Sustação de Protesto';
            } elseif (21 == $codigo) {
                return 'Acerto do Controle do Participante';
            } elseif (22 == $codigo) {
                return 'Título Com Pagamento Cancelado';
            } elseif (23 == $codigo) {
                return 'Entrada do Título em Cartório';
            } elseif (24 == $codigo) {
                return 'Entrada rejeitada por CEP Irregular';
            } elseif (27 == $codigo) {
                return 'Baixa Rejeitada';
            } elseif (28 == $codigo) {
                return 'Débito de tarifas/custas';
            } elseif (30 == $codigo) {
                return 'Alteração de Outros Dados Rejeitados';
            } elseif (32 == $codigo) {
                return 'Instrução Rejeitada';
            } elseif (33 == $codigo) {
                return 'Confirmação Pedido Alteração Outros Dados';
            } elseif (34 == $codigo) {
                return 'Retirado de Cartório e Manutenção Carteira';
            } elseif (35 == $codigo) {
                return 'Desagendamento do débito automático';
            } elseif (40 == $codigo) {
                return 'Estorno de pagamento';
            } elseif (55 == $codigo) {
                return 'Sustado judicial';
            } elseif (68 == $codigo) {
                return 'Acerto dos dados do rateio de Crédito';
            } elseif (69 == $codigo) {
                return 'Cancelamento dos dados do rateio';
            }
        } elseif (\Cnab\Banco::CEF == $this->_codigo_banco) {
            if (1 == $codigo) {
                return 'Entrada Confirmada';
            } elseif (2 == $codigo) {
                return 'Baixa Confirmada';
            } elseif (3 == $codigo) {
                return 'Abatimento Concedido';
            } elseif (4 == $codigo) {
                return 'Abatimento Cancelado';
            } elseif (5 == $codigo) {
                return 'Vencimento Alterado';
            } elseif (6 == $codigo) {
                return 'Uso da Empresa Alterado';
            } elseif (7 == $codigo) {
                return 'Prazo de Protesto Alterado';
            } elseif (8 == $codigo) {
                return 'Prazo de Devolução Alterado';
            } elseif (9 == $codigo) {
                return 'Alteração Confirmada';
            } elseif (10 == $codigo) {
                return 'Alteração com Reemissão de Bloqueto Confirmada';
            } elseif (11 == $codigo) {
                return 'Alteração da Opção de Protesto para Devolução';
            } elseif (12 == $codigo) {
                return 'Alteração da Opção de Devolução para protesto';
            } elseif (20 == $codigo) {
                return 'Em Ser';
            } elseif (21 == $codigo) {
                return 'Liquidação';
            } elseif (22 == $codigo) {
                return 'Liquidação em Cartório';
            } elseif (23 == $codigo) {
                return 'Baixa por Devolução';
            } elseif (24 == $codigo) {
                return 'Baixa por Franco Pagamento';
            } elseif (25 == $codigo) {
                return 'Baixa por Protesto';
            } elseif (26 == $codigo) {
                return 'Título enviado para Cartório';
            } elseif (27 == $codigo) {
                return 'Sustação de Protesto';
            } elseif (28 == $codigo) {
                return 'Estorno de Protesto';
            } elseif (29 == $codigo) {
                return 'Estorno de Sustação de Protesto';
            } elseif (30 == $codigo) {
                return 'Alteração de Título';
            } elseif (31 == $codigo) {
                return 'Tarifa sobre Título Vencido';
            } elseif (32 == $codigo) {
                return 'Outras Tarifas de Alteração';
            } elseif (33 == $codigo) {
                return 'Estorno de Baixa/Liquidação';
            } elseif (34 == $codigo) {
                return 'Transferência de Carteira/Entrada';
            } elseif (35 == $codigo) {
                return 'Transferência de Carteira/Baixa';
            } elseif (99 == $codigo) {
                return 'Rejeição do Título – Cód. Rejeição informado nas POS 80 a 82';
            }
        } else {
            if ($codigo == 2) {
                return 'ENTRADA CONFIRMADA COM POSSIBILIDADE DE MENSAGEM (NOTA 20 – TABELA 10) ';
            } elseif ($codigo == 3) {
                return 'ENTRADA REJEITADA (NOTA 20 - TABELA 1)';
            } elseif ($codigo == 4) {
                return 'ALTERAÇÃO DE DADOS - NOVA ENTRADA OU ALTERAÇÃO/EXCLUSÃO DE DADOS ACATADA ';
            } elseif ($codigo == 5) {
                return 'ALTERAÇÃO DE DADOS – BAIXA';
            } elseif ($codigo == 6) {
                return 'LIQUIDAÇÃO NORMAL';
            } elseif ($codigo == 7) {
                return 'LIQUIDAÇÃO PARCIAL – COBRANÇA INTELIGENTE (B2B)';
            } elseif ($codigo == 8) {
                return 'LIQUIDAÇÃO EM CARTÓRIO ';
            } elseif ($codigo == 9) {
                return 'BAIXA SIMPLES';
            } elseif ($codigo == 10) {
                return 'BAIXA POR TER SIDO LIQUIDADO ';
            } elseif ($codigo == 11) {
                return 'EM SER (SÓ NO RETORNO MENSAL)';
            } elseif ($codigo == 12) {
                return 'ABATIMENTO CONCEDIDO ';
            } elseif ($codigo == 13) {
                return 'ABATIMENTO CANCELADO';
            } elseif ($codigo == 14) {
                return 'VENCIMENTO ALTERADO ';
            } elseif ($codigo == 15) {
                return 'BAIXAS REJEITADAS (NOTA 20 - TABELA 4)';
            } elseif ($codigo == 16) {
                return 'INSTRUÇÕES REJEITADAS (NOTA 20 - TABELA 3) ';
            } elseif ($codigo == 17) {
                return 'ALTERAÇÃO/EXCLUSÃO DE DADOS REJEITADOS (NOTA 20 - TABELA 2)';
            } elseif ($codigo == 18) {
                return 'COBRANÇA CONTRATUAL - INSTRUÇÕES/ALTERAÇÕES REJEITADAS/PENDENTES (NOTA 20 - TABELA 5) ';
            } elseif ($codigo == 19) {
                return 'CONFIRMA RECEBIMENTO DE INSTRUÇÃO DE PROTESTO';
            } elseif ($codigo == 20) {
                return 'CONFIRMA RECEBIMENTO DE INSTRUÇÃO DE SUSTAÇÃO DE PROTESTO /TARIFA';
            } elseif ($codigo == 21) {
                return 'CONFIRMA RECEBIMENTO DE INSTRUÇÃO DE NÃO PROTESTAR';
            } elseif ($codigo == 23) {
                return 'TÍTULO ENVIADO A CARTÓRIO/TARIFA';
            } elseif ($codigo == 24) {
                return 'INSTRUÇÃO DE PROTESTO REJEITADA / SUSTADA / PENDENTE (NOTA 20 - TABELA 7)';
            } elseif ($codigo == 25) {
                return 'ALEGAÇÕES DO SACADO (NOTA 20 - TABELA 6)';
            } elseif ($codigo == 26) {
                return 'TARIFA DE AVISO DE COBRANÇA';
            } elseif ($codigo == 27) {
                return 'TARIFA DE EXTRATO POSIÇÃO (B40X)';
            } elseif ($codigo == 28) {
                return 'TARIFA DE RELAÇÃO DAS LIQUIDAÇÕES';
            } elseif ($codigo == 29) {
                return 'TARIFA DE MANUTENÇÃO DE TÍTULOS VENCIDOS';
            } elseif ($codigo == 30) {
                return 'DÉBITO MENSAL DE TARIFAS (PARA ENTRADAS E BAIXAS)';
            } elseif ($codigo == 32) {
                return 'BAIXA POR TER SIDO PROTESTADO';
            } elseif ($codigo == 33) {
                return 'CUSTAS DE PROTESTO';
            } elseif ($codigo == 34) {
                return 'CUSTAS DE SUSTAÇÃO';
            } elseif ($codigo == 35) {
                return 'CUSTAS DE CARTÓRIO DISTRIBUIDOR';
            } elseif ($codigo == 36) {
                return 'CUSTAS DE EDITAL';
            } elseif ($codigo == 37) {
                return 'TARIFA DE EMISSÃO DE BOLETO/TARIFA DE ENVIO DE DUPLICATA';
            } elseif ($codigo == 38) {
                return 'TARIFA DE INSTRUÇÃO';
            } elseif ($codigo == 39) {
                return 'TARIFA DE OCORRÊNCIAS';
            } elseif ($codigo == 40) {
                return 'TARIFA MENSAL DE EMISSÃO DE BOLETO/TARIFA MENSAL DE ENVIO DE DUPLICATA';
            } elseif ($codigo == 41) {
                return 'DÉBITO MENSAL DE TARIFAS – EXTRATO DE POSIÇÃO (B4EP/B4OX)';
            } elseif ($codigo == 42) {
                return 'DÉBITO MENSAL DE TARIFAS – OUTRAS INSTRUÇÕES';
            } elseif ($codigo == 43) {
                return 'DÉBITO MENSAL DE TARIFAS – MANUTENÇÃO DE TÍTULOS VENCIDOS';
            } elseif ($codigo == 44) {
                return 'DÉBITO MENSAL DE TARIFAS – OUTRAS OCORRÊNCIAS';
            } elseif ($codigo == 45) {
                return 'DÉBITO MENSAL DE TARIFAS – PROTESTO';
            } elseif ($codigo == 46) {
                return 'DÉBITO MENSAL DE TARIFAS – SUSTAÇÃO DE PROTESTO';
            } elseif ($codigo == 47) {
                return 'BAIXA COM TRANSFERÊNCIA PARA DESCONTO';
            } elseif ($codigo == 48) {
                return 'CUSTAS DE SUSTAÇÃO JUDICIAL';
            } elseif ($codigo == 51) {
                return 'TARIFA MENSAL REF A ENTRADAS BANCOS CORRESPONDENTES NA CARTEIRA';
            } elseif ($codigo == 52) {
                return 'TARIFA MENSAL BAIXAS NA CARTEIRA';
            } elseif ($codigo == 53) {
                return 'TARIFA MENSAL BAIXAS EM BANCOS CORRESPONDENTES NA CARTEIRA';
            } elseif ($codigo == 54) {
                return 'TARIFA MENSAL DE LIQUIDAÇÕES NA CARTEIRA';
            } elseif ($codigo == 55) {
                return 'TARIFA MENSAL DE LIQUIDAÇÕES EM BANCOS CORRESPONDENTES NA CARTEIRA';
            } elseif ($codigo == 56) {
                return 'CUSTAS DE IRREGULARIDADE';
            } elseif ($codigo == 57) {
                return 'INSTRUÇÃO CANCELADA (NOTA 20 – TABELA 8)';
            } elseif ($codigo == 59) {
                return 'BAIXA POR CRÉDITO EM C/C ATRAVÉS DO SISPAG';
            } elseif ($codigo == 60) {
                return 'ENTRADA REJEITADA CARNÊ (NOTA 20 – TABELA 1)';
            } elseif ($codigo == 61) {
                return 'TARIFA EMISSÃO AVISO DE MOVIMENTAÇÃO DE TÍTULOS (2154)';
            } elseif ($codigo == 62) {
                return 'DÉBITO MENSAL DE TARIFA - AVISO DE MOVIMENTAÇÃO DE TÍTULOS (2154)';
            } elseif ($codigo == 63) {
                return 'TÍTULO SUSTADO JUDICIALMENTE';
            } elseif ($codigo == 64) {
                return 'ENTRADA CONFIRMADA COM RATEIO DE CRÉDITO';
            } elseif ($codigo == 69) {
                return 'CHEQUE DEVOLVIDO (NOTA 20 - TABELA 9)';
            } elseif ($codigo == 71) {
                return 'ENTRADA REGISTRADA, AGUARDANDO AVALIAÇÃO';
            } elseif ($codigo == 72) {
                return 'BAIXA POR CRÉDITO EM C/C ATRAVÉS DO SISPAG SEM TÍTULO CORRESPONDENTE';
            } elseif ($codigo == 73) {
                return 'CONFIRMAÇÃO DE ENTRADA NA COBRANÇA SIMPLES – ENTRADA NÃO ACEITA NA COBRANÇA CONTRATUAL';
            } elseif ($codigo == 76) {
                return 'CHEQUE COMPENSADO';
            } else {
                return 'Código Inexistente';
            }
        }
    }
658041
public static function modulo11(
        $number,
        $ifTen = '0',
        $ifZero = '0',
        $returnFull = false,
        $maxFactor = 9,
        $separator = '-'
    ) {
        $numLen = strlen($number) - 1;
        $sum = 0;
        $factor = 2;

        for ($i = $numLen; $i >= 0; $i--) {
            $sum += substr($number, $i, 1) * $factor;
            $factor = $factor >= $maxFactor ? 2 : $factor + 1;
        }
        #Resto da divisão
        $rest = ($sum * 10) % 11;
        #ifTen
        $rest = $rest == 10 ? $ifTen : $rest;
        #ifZero
        $rest = $rest === 0 ? $ifZero : $rest;
        #Verificando se é 0, 10
        switch ($rest) {
            case 10:
                $ifTen;
                break;
            case 0:
                $ifZero;
                break;
            default:
                $rest;
                break;
        }

        if ($returnFull === false) {
            return $rest;
        } else {
            return $number . $separator . $rest;
        }
    }
1091532
private function zDigCheck($dom, $tagid = '')
    {
        $node = $dom->getNode($tagid, 0);
        if (empty($node)) {
            throw new Exception(
                "A tag < $tagid > não existe no XML!!"
            );
        }
        if (! $this->zSignatureExists($dom)) {
            $msg = 'O xml não contêm nenhuma assinatura para ser verificada.';
            throw new Exception($msg);
        }
        //carregar o node em sua forma canonica
        $tagInf = $node->C14N(true, false, null, null);
        //calcular o hash sha1
        $hashValue = hash('sha1', $tagInf, true);
        //converter o hash para base64 para obter o digest do node
        $digestCalculado = base64_encode($hashValue);
        //pegar o digest informado no xml
        $digestInformado = $dom->getNodeValue('DigestValue');
        //compara os digests calculados e informados
        if ($digestCalculado != $digestInformado) {
            $msg = "O conteúdo do XML não confere com o Digest Value.\n
                Digest calculado [{$digestCalculado}], digest informado no XML [{$digestInformado}].\n
                O arquivo pode estar corrompido ou ter sido adulterado.";
            throw new Exception($msg);
        }

        return true;
    }
218647
function signUp()
    {
        if (isset($_POST['data'])
            && trim($_POST['data']) !== '') {
            //Decodificando RSA
            $private = file_get_contents(_CONFIG.'Key/private.key');
            $key = json_decode($_POST['data']);
            $key = base64_decode($key->enc);

            if (!openssl_private_decrypt($key,
                                        $key,
                                        openssl_pkey_get_private($private)
                                        )) {
                Ajax::send(['error'=>'Confira seu Login ou Senha!']); //exit($key);
            }

            $key = json_decode($key);

            //inicializando o usuário => User Singleton Object
            $user = User::this();
            $user->login($key->login, $key->passw);


            //Verificando se o login foi bem sucedido
            if ($user->get('login')) {
                //Gravando o novo Token no BD
                $user->saveToken($key->token);
                $userdata = json_encode(['name'=>$user->get('name'),
                             'id'=>$user->get('id'),
                             'level'=>$user->get('level')]);

                $resumo = (new Model\Xlog)->resumo($user->get('id'));

                //Encriptando o token
                Aes::size(256);
                $key = Aes::enc(json_encode(
                                     ['user'=>$userdata,
                                      'token'=>$key->token,
                                      'resumo'=>$resumo]),
                                      $key->token);

                //Retorna os dados do usuário
                Ajax::send(['error'=>false, 'key'=>$key]);
            }
        }
        //Em casos contrários, retorna erro.
        Ajax::send(['error'=>'Confira seu Login ou Senha!']);
    }
373524
public function distribuiSenhaAgendamento(
        Request $request,
        AtendimentoService $atendimentoService,
        TranslatorInterface $translator,
        Agendamento $agendamento
    ) {
        if ($agendamento->getDataConfirmacao()) {
            throw new Exception($translator->trans('error.schedule.confirmed', [], self::DOMAIN));
        }
        
        $data = $agendamento->getData()->format('Y-m-d');
        $hora = $agendamento->getHora()->format('H:i');
        $dt   = DateTime::createFromFormat('Y-m-d H:i', "{$data} {$hora}");
        $now  = new DateTime();
        $diff = $now->diff($dt);
        $mins = $diff->i + ($diff->h * 60);
        $max  = 30;
        
        if ($mins > $max) {
            throw new Exception($translator->trans('error.schedule.expired', [], self::DOMAIN));
        }
        
        $envelope   = new Envelope();
        $usuario    = $this->getUser();
        $unidade    = $agendamento->getUnidade();
        $servico    = $agendamento->getServico();
        $prioridade = 1;
        $cliente    = $agendamento->getCliente();
        
        $data = $atendimentoService->distribuiSenha($unidade, $usuario, $servico, $prioridade, $cliente, $agendamento);
        $envelope->setData($data);

        return $this->json($envelope);
    }
1023822
public function getDescricaoLiquidacao()
    {
        // @TODO: Usar YAML (cnab_yaml) para criar tabela de descrição
        $codigoLiquidacao = $this->getCodigoLiquidacao();
        $tabela = array();

        if (\Cnab\Banco::ITAU == $this->_codigo_banco) {
            $tabela = array(
                'AA' => 'CAIXA ELETRÔNICO BANCO ITAÚ',
                'AC' => 'PAGAMENTO EM CARTÓRIO AUTOMATIZADO',
                'AO' => 'ACERTO ONLINE',
                'BC' => 'BANCOS CORRESPONDENTES',
                'BF' => 'ITAÚ BANKFONE',
                'BL' => 'ITAÚ BANKLINE',
                'B0' => 'OUTROS BANCOS – RECEBIMENTO OFF-LINE',
                'B1' => 'OUTROS BANCOS – PELO CÓDIGO DE BARRAS',
                'B2' => 'OUTROS BANCOS – PELA LINHA DIGITÁVEL',
                'B3' => 'OUTROS BANCOS – PELO AUTO ATENDIMENTO',
                'B4' => 'OUTROS BANCOS – RECEBIMENTO EM CASA LOTÉRICA',
                'B5' => 'OUTROS BANCOS – CORRESPONDENTE',
                'B6' => 'OUTROS BANCOS – TELEFONE',
                'B7' => 'OUTROS BANCOS – ARQUIVO ELETRÔNICO (Pagamento Efetuado por meio de troca de arquivos)',
                'CC' => 'AGÊNCIA ITAÚ – COM CHEQUE DE OUTRO BANCO ou (CHEQUE ITAÚ)*',
                'CI' => 'CORRESPONDENTE ITAÚ',
                'CK' => 'SISPAG – SISTEMA DE CONTAS A PAGAR ITAÚ',
                'CP' => 'AGÊNCIA ITAÚ – POR DÉBITO EM CONTA CORRENTE, CHEQUE ITAÚ* OU DINHEIRO',
                'DG' => 'AGÊNCIA ITAÚ – CAPTURADO EM OFF-LINE',
                'LC' => 'PAGAMENTO EM CARTÓRIO DE PROTESTO COM CHEQUE A COMPENSAR',
                'EA' => 'TERMINAL DE CAIXA',
                'Q0' => 'AGENDAMENTO – PAGAMENTO AGENDADO VIA BANKLINE OU OUTRO CANAL ELETRÔNICO E LIQUIDADO NA DATA INDICADA',
                'RA' => 'DIGITAÇÃO – REALIMENTAÇÃO AUTOMÁTICA',
                'ST' => 'PAGAMENTO VIA SELTEC**',
            );
        }

        if (array_key_exists($codigoLiquidacao, $tabela)) {
            return $tabela[$codigoLiquidacao];
        }

        return;
    }
803415
private function cookieLogin()
    {
        $beforeDate = date('Y-m-d H:i:s', strtotime("-2 months", strtotime(date("Y-m-d H:i:s"))));
        $token = new TableCrud("usuarios");
        $token->load("token", $_COOKIE['token']);
        if ($token->exist() && $token->status === 1 && $token->token_expira > $beforeDate) {

            //Obtém os dados de login
            $_SESSION['userlogin'] = $token->getDados();

            //Atualiza tempo de expiração do Token no banco
            $token->token_expira = date("Y-m-d H:i:s");
            $token->save();

            //seta cookies para 2 meses de validade
            setcookie("token", $token, time() + (86400 * 30 * 3), "/"); // 2 meses de cookie

            //redireciona para dashboard
            header("Location: " . HOME . "dashboard");

        } else {

            //remove cookie não integro
            $this->unsetCookie();
        }
    }
1190504
function capture($authorizationCode, $captureAmount, $buyOrder) {

        try {

            $CaptureInput = new CaptureInput();

            /** Código de autorización de la transacción que se requiere capturar */
            $CaptureInput->authorizationCode = $authorizationCode; // string

            /** Orden de compra de la transacción que se requiere capturar */
            $CaptureInput->buyOrder = $buyOrder; // string

            /** Monto que se desea capturar */
            $CaptureInput->captureAmount = $captureAmount; // decimal

            /** Código de comercio o tienda mall que realizó la transacción */
            $CaptureInput->commerceId = floatval($this->config->getCommerceCode());

            $captureResponse = $this->_capture(
                array("captureInput" => $CaptureInput)
            );

            /** Validación de firma del requerimiento de respuesta enviado por Webpay */
            $xmlResponse = $this->soapClient->__getLastResponse();
            $soapValidation = new SoapValidation($xmlResponse, $this->config->getWebpayCert());
            $validationResult = $soapValidation->getValidationResult();

            /** Valida conexion a Webpay */
            if ($validationResult === TRUE) {

                $wsCaptureOutput = $captureResponse->return;
                return $wsCaptureOutput;

            } else {
                $error["error"] = "Error validando conexión a Webpay";
                $error["error"] = "No se pudo completar la conexión con Webpay";
            }
        } catch (\Exception $e) {

            $error["error"] = "Error conectando a Webpay (Verificar que la informaci&oacute;n del certificado sea correcta)";

            $replaceArray = array('<!--' => '', '-->' => '');
            $error["detail"] = str_replace(array_keys($replaceArray), array_values($replaceArray), $e->getMessage());

        }

        return $error;
    }
358673
public function redirecionar(
        Request $request,
        AtendimentoService $atendimentoService,
        TranslatorInterface $translator
    ) {
        $envelope = new Envelope();
        $data     = json_decode($request->getContent());

        $usuario     = $this->getUser();
        $unidade     = $usuario->getLotacao()->getUnidade();
        $servico     = (int) $data->servico;
        $novoUsuario = null;
        $atual       = $atendimentoService->atendimentoAndamento($usuario->getId(), $unidade);

        if (!$atual) {
            throw new Exception(
                $translator->trans('error.attendance.not_in_process', [], self::DOMAIN)
            );
        }
        
        if (isset($data->usuario)) {
            $novoUsuario = $this
                ->getDoctrine()
                ->getManager()
                ->getRepository(Usuario::class)
                ->find($data->usuario);
        }

        $redirecionado = $atendimentoService->redirecionar($atual, $unidade, $servico, $novoUsuario);
        if (!$redirecionado->getId()) {
            throw new Exception(
                $translator->trans(
                    'error.attendance.redirect',
                    [
                        '%atendimento%' => $atual->getId(),
                        '%servico%'     => $servico,
                    ],
                    self::DOMAIN
                )
            );
        }

        return $this->json($envelope);
    }
560353
protected function zCleanPubKey()
    {
        //inicializa variavel
        $data = '';
        //carregar a chave publica
        $pubKey = $this->pubKey;
        //carrega o certificado em um array usando o LF como referencia
        $arCert = explode("\n", $pubKey);
        foreach ($arCert as $curData) {
            //remove a tag de inicio e fim do certificado
            if (strncmp($curData, '-----BEGIN CERTIFICATE', 22) != 0 &&
                    strncmp($curData, '-----END CERTIFICATE', 20) != 0) {
                //carrega o resultado numa string
                $data .= trim($curData);
            }
        }

        return $data;
    }
591161
public function distribuiSenha(Request $request, AtendimentoService $atendimentoService)
    {
        $json = json_decode($request->getContent());
        
        $envelope = new Envelope();
        $usuario = $this->getUser();
        $unidade = $usuario->getLotacao()->getUnidade();
        
        $servico    = isset($json->servico) ? (int) $json->servico : 0;
        $prioridade = isset($json->prioridade) ? (int) $json->prioridade : 0;
        
        $cliente = null;
        if (is_object($json->cliente)) {
            $cliente = new Cliente();
            $cliente->setNome($json->cliente->nome ?? '');
            $cliente->setDocumento($json->cliente->documento ?? '');
        }
        
        $data = $atendimentoService->distribuiSenha($unidade, $usuario, $servico, $prioridade, $cliente);
        $envelope->setData($data);

        return $this->json($envelope);
    }
873605
public function validarCpf($cpf)
    {
        $cpf = $this->filtrarSomenteNumeros($cpf);

        // Valida tamanho e caracteres repetidos 00000000000, 11111111111, ..., 99999999999
        if ((strlen($cpf) != 11) || (preg_match('/(\d)\1{10}/', $cpf))) {
            return false;
        }
        
        // Calcula os DVs para verificar se o CPF é verdadeiro
        for ($i = 9; $i < 11; $i++) {
            $j = 0;
            for ($k = 0; $k < $i; $k++) {
                $j += $cpf{$k} * (($i + 1) - $k);
            }
            $j = ((10 * $j) % 11) % 10;
            if ($cpf{$k} != $j) {
                return false;
            }
        }

        return true;
    }