Monta código de barras pela linha digitável.

@param $linha
@return string
505260
public static function montaCodigoPelaLinha($linha)
    {
        // Parâmetros
        $zeros = '00000000000';

        // Carregar só numero da linha
        $linha = preg_replace('/[^0-9]/', '', $linha);

        // Verificar se deve preencher com zeros
        if (strlen($linha) < 47) {
            $linha .= substr($zeros, 0, (47 - strlen($linha)));
        }

        // Validar linha
        if (strlen($linha) != 47) {
            throw new \Exception('A linha digitável esta incorreta');
        }

        // Montar barra
        $barra = substr($linha, 0, 4)
            . substr($linha, 32, 15)
            . substr($linha, 4, 5)
            . substr($linha, 10, 10)
            . substr($linha, 21, 10);

        $dv1 = self::modulo11(substr($barra, 0, 4) . substr($barra, 5, 39));
        $dv2 = substr($barra, 4, 1);

        // Validar dígito da barra com o da linha
        if ($dv1 != $dv2) {
            throw new \Exception('Dígito verificador do código de barra gerado esta incorreto');
        }

        return $barra;
    }
1060444
public static function modulo10($num)
    {
        $numtotal10 = 0;
        $fator = 2;
        $numeros = array();
        $parcial10 = array();

        // Separacao dos numeros
        for ($i = strlen($num); $i > 0; $i--) {
            // pega cada numero isoladamente
            $numeros[$i] = substr($num, $i - 1, 1);
            // Efetua multiplicacao do numero pelo (falor 10)
            // 2002-07-07 01:33:34 Macete para adequar ao Mod10 do Itau
            $temp = $numeros[$i] * $fator;
            $temp0 = 0;
            foreach (preg_split('//', $temp, -1, PREG_SPLIT_NO_EMPTY) as $k => $v) {
                $temp0 += $v;
            }
            $parcial10[$i] = $temp0;
            // monta sequencia para soma dos digitos no (modulo 10)
            $numtotal10 += $parcial10[$i];
            if ($fator == 2) {
                $fator = 1;
            } else {
                $fator = 2; // intercala fator de multiplicacao (modulo 10)
            }
        }

        // varias linhas removidas, vide funcoes original
        // Calculo do modulo 10
        $resto = $numtotal10 % 10;
        $digito = 10 - $resto;
        if ($resto == 0) {
            $digito = 0;
        }

        return $digito;
    }
51109
protected function processarDetalhe($linha)
    {
        $detail = parent::processarDetalhe($linha);
        $detail
            ->setConvenio($linha->substr(32, 6)->trim())
            ->setControle($linha->substr(38, 25)->trim())
            ->setNossoNumero($linha->substr(63, 11)->trim())
            ->setDvNossoNumero($linha->substr(74, 1)->trim())
            ->setTipoCobranca($linha->substr(75, 1)->trim())
            ->setTipoCobrancaCmd72($linha->substr(76, 1)->trim())
            ->setDiasCalculo($linha->substr(77, 4)->trim())
            ->setNatureza($linha->substr(81, 2)->trim())
            ->addUsoBanco($linha->substr(83, 3)->trim())
            ->setVariacaoCarteira($linha->substr(86, 3)->trim())
            ->setContaCaucao($linha->substr(89, 1)->trim())
            ->addUsoBanco($linha->substr(90, 5)->trim())
            ->addUsoBanco($linha->substr(95, 1)->trim())
            ->setConfirmacao($linha->substr(127, 20)->trim())
        ;
        return $detail;
    }
1290311
public function getEncoded()
    {
        $text = array();
        foreach ($this->listSegmento() as $segmento) {
            $text[] = $segmento->getEncoded();
        }

        return implode(Arquivo::QUEBRA_LINHA, $text);
    }
99307
public function getIcao() : ?string 
    {
        if ( ! $this->hasIcao()) {
            $this->setIcao($this->getDefaultIcao());
        }
        return $this->icao;
    }
1126824
public static function modulo11($numero, $peso = 2, $base = 9, $zero = 1, $um = 1)
    {
        // Pegar somente números
        $numero = preg_replace('/[^0-9]/', '', $numero);

        $soma = 0;
        $contador = (strlen($numero) - 1);
        for ($i = $contador; $i >= 0; $i--) {
            $soma += (intval($numero[$i]) * $peso);
            $peso = (($peso < $base) ? ($peso + 1) : 2);
        }

        $resto = ($soma % 11);

        // Calcular digito
        $digito = (11 - $resto);
        $digito = (($digito > $base) ? 0 : $digito);

        /* Utilizar o dígito 1(um) sempre que o resultado do cálculo padrão for igual a 0(zero), 1(um) ou 10(dez). */
        if ($digito == 0) {
            return $zero;
        }
        if ($digito == 1) {
            return $um;
        }

        return $digito;
    }
579802
protected function valida(array $a)
    {
        if ($this->tamanho_linha === false) {
            throw new \Exception('Classe remessa deve informar o tamanho da linha');
        }

        $a = array_filter($a, 'mb_strlen');
        if (count($a) != $this->tamanho_linha) {
            throw new \Exception(sprintf('$a não possui %s posições, possui: %s', $this->tamanho_linha, count($a)));
        }

        return implode('', $a);
    }
707791
public static function encode($string,$senha,$algorithm ='rijndael-256') {
      $key = md5($senha, true); // bynary raw 16 byte dimension.
      $iv_length = mcrypt_get_iv_size( $algorithm, MCRYPT_MODE_CBC );
      $iv = mcrypt_create_iv( $iv_length, MCRYPT_RAND );
      $encrypted = mcrypt_encrypt( $algorithm, $key, $string, MCRYPT_MODE_CBC, $iv );
      $result = base64_encode( $iv . $encrypted );
      return $result;
    }
125122
public function toArray()
    {
        // Planilhas do Gnumeric e Xlsx
        // possuem linha e colunas nulas na exportação de array
        // por isso, são removidas aqui

        $list = [];
        $array = $this->getActiveSheet()->toArray();

        // Linhas
        foreach($array as $row_id => $rows) {

            $line = array_filter($rows, function($v){ return !is_null($v); });
            if (!empty($line)) {
                $list[] = $line;
            }
        }

        return $list;
    }
40280
public static function StrCaseReverse($pValue = '')
    {
        if (self::getIsMbstringEnabled()) {
            $characters = self::mb_str_split($pValue);
            foreach ($characters as &$character) {
                if (self::mb_is_upper($character)) {
                    $character = mb_strtolower($character, 'UTF-8');
                } else {
                    $character = mb_strtoupper($character, 'UTF-8');
                }
            }
            return implode('', $characters);
        }
        return strtolower($pValue) ^ strtoupper($pValue) ^ $pValue;
    }
608985
public static function SYLKtoUTF8($pValue = '')
	{
		// If there is no escape character in the string there is nothing to do
		if (strpos($pValue, '') === false) {
			return $pValue;
		}

		foreach (self::$_SYLKCharacters as $k => $v) {
			$pValue = str_replace($k, $v, $pValue);
		}

		return $pValue;
	}
852041
public function index(string $url)
    {
        array_walk($this->routes[0], function($route) use ($url) {

            if (strpos($route[0], "@")) {

                //$rotaLimpa = substr($route[0], 0, strpos($route[0], "@"));
                $rotaTratada = str_replace("@", '', $route[0]);

                // obtendo quantos caracteres tem na rota
                $tamanhoDaRota = strlen($rotaTratada);

                // obtendo quantos caracteres tem na url
                $tamanhoDaUrl = strlen($url);

                // verifica se a quantidade de caracteres da url é maior que a quantidade de caracteres da rota
                if ($tamanhoDaUrl > $tamanhoDaRota) {

                    // cortando a url pelo tamanho da rota
                    $url = substr($url, 0, $tamanhoDaRota);

                    // compara se o vlaor da $url é igual ao valor da $rotaTratada
                    if (strcmp($url,$rotaTratada) === 0){

                        // substituindo o valor da rota pelo valor da url
                        $route[0] = str_replace($route[0], $url, $route[0]);

                        $this->run($url, $route);

                        exit();
                    }
                }

                $this->urlError++;

            } else {

                $this->run($url, $route);

            }

            $this->countError(count($this->routes[0]));

        });
    }
387324
public static function phoneType($number)
    {
        $number = self::reformatPhone($number);

        // Cisla s tuzemskou predvolbou
        if (self::DOMESTIC_PREFIX === mb_substr($number, 0, mb_strlen(self::DOMESTIC_PREFIX))) {
            return self::handleDomestic($number);
        }

        // Cisla odpovidajici tuzemske delce
        if (self::DOMESTIC_LENGTH === mb_strlen($number)) {
            return self::handleDomestic($number);
        }

        // Cisla s predvolbou
        if (in_array(mb_substr($number, 0, 1), explode(',', self::SPECIAL_PREFIX), true)) {
            return self::handleSpecial($number);
        }

        // Mezinarodni
        if (self::INTERNATIONAL_PREFIX === mb_substr($number, 0, mb_strlen(self::INTERNATIONAL_PREFIX))) {
            return self::TYPE_INTERNATIONAL;
        }

        // Pokud se nic nechytlo
        return self::handleOther($number);
    }
333404
public static function cnpj(string $cnpj): bool
    {
        $cnpj = preg_replace('/[^0-9]/', '', (string)$cnpj);

        // Valida tamanho
        if (strlen($cnpj) != 14)
            return false;

        // Valida primeiro dígito verificador
        for ($i = 0, $j = 5, $soma = 0; $i < 12; $i++) {
            $soma += $cnpj{$i} * $j;
            $j = ($j == 2) ? 9 : $j - 1;
        }
        $resto = $soma % 11;
        if ($cnpj{12} != ($resto < 2 ? 0 : 11 - $resto))
            return false;

        // Valida segundo dígito verificador
        for ($i = 0, $j = 6, $soma = 0; $i < 13; $i++) {
            $soma += $cnpj{$i} * $j;
            $j = ($j == 2) ? 9 : $j - 1;
        }
        $resto = $soma % 11;
        return $cnpj{13} == ($resto < 2 ? 0 : 11 - $resto);
    }
761226
protected static function readDelimFileDetDelim($fh)
	{
		$line = '';
		if ($fh) {
			while (!feof($fh)) {
				$line = trim(fgets($fh, 4096));
				if (!empty($line)) {
					break;
				}
			}
			fseek($fh, 0);		// go back to beginning of file
		}

		$delims = array(',', "\t");
		$delim_counts = array();
		foreach ($delims as $delim) {
			$delim_counts[$delim] = substr_count($line, $delim);
		}
		arsort($delim_counts);
		$keys = array_keys($delim_counts);
		$delim = reset($keys);
		return $delim;
	}
1039383
protected static function pem2Der($pemData)
    {
        $begin = 'CERTIFICATE-----';
        $end = '-----END';
        //extrai o conteúdo do certificado entre as marcas BEGIN e END
        $pemData1 = substr($pemData, strpos($pemData, $begin) + strlen($begin));
        $pemData2 = substr($pemData1, 0, strpos($pemData1, $end));
        //converte o resultado para binário obtendo um certificado em formato DER
        $derData = base64_decode((string) $pemData2);

        return $derData;
    }
32951
public static function getLinhaCamposPeloCodigo($codigo)
    {
        $codigo = preg_replace('/[^0-9]/', '', $codigo);

        // Validar codigo de barras
        if (strlen($codigo) != 44) {
            throw new \Exception('A linha do Código de Barras está incompleta!');
        }

        // Montar linha
        $campo1 = substr($codigo, 0, 4) . substr($codigo, 19, 1) . substr($codigo, 20, 4);
        $campo2 = substr($codigo, 24, 5) . substr($codigo, 29, 5);
        $campo3 = substr($codigo, 34, 5) . substr($codigo, 39, 5);
        $campo4 = substr($codigo, 4, 1); // Digito verificador
        $campo5 = substr($codigo, 5, 14); // Vencimento + Valor

        if (self::modulo11(substr($codigo, 0, 4) . substr($codigo, 5, 99)) != $campo4) {
            throw new \Exception(sprintf('Digito verificador %s esta incorreto', $campo4));
        }

        // Montar resultado
        return [
            'campo1' => $campo1 . self::modulo10($campo1),
            'campo2' => $campo2 . self::modulo10($campo2),
            'campo3' => $campo3 . self::modulo10($campo3),
            'campo4' => $campo4,
            'campo5' => $campo5,
        ];
    }