Retorna o valor de juros e mora.
769609
public function getValorMoraMulta()
    {
        if (\Cnab\Banco::CEF == $this->_codigo_banco) {
            return $this->valor_juros + $this->valor_multa;
        } else {
            return $this->valor_mora_multa;
        }
    }
1158035
function(name, value) {

			var temp = arguments.length;

			// Si no hay parámetros

			if (!temp) {

				// Devolvemos una copia sin referencias de los atributos actuales

				var buffer = {};

				for (temp in this._attributes)

					buffer[temp] = _toString(this._attributes[temp]);

				return buffer;

			// Si hay un parámetro

			} else if (temp === 1) {

				// Si es una cadena de texto

				if ((temp = typeof name) === 'string') { // get()

					name = name.toLowerCase();

					if (name === 'query')

						name = 'search';

					// Devolvemos el valor del atributo en formato literal

					return _toString(this._attributes[name.toLowerCase()]);

				// Si es un objeto

				} else if (name && (temp = typeof name) === 'object') { // set(object)

					// Recorremos sus propiedades y las establecemos una a una

					for (temp in name)

						this.attr(temp, name[(temp || '').toLowerCase()]);

				}

			// Si hay dos parámetros y el nombre del atributo es una cadena de texto

			} else if (temp === 2 && typeof name === 'string' && (temp = name.toLowerCase())) { // set(name, value)

				// Si el atributo existe y el valor es válido

				if (((function(index) {

						while(index--)

							if (Public.attributes[index] === name)

								return true;

					})(Public.attributes.length))) {

						// Si se trata del atributo `host` o `hostname`

						if (name === 'host' || name === 'hostname' || name === 'port') {

							// Si el atributo es `host` actualizamos el `hostname` y el `port` (hostname:port)
							// Si el atributo es `hostname` actualizamos el `host` y dejamos el `port` intacto
							// Si el atributo es `port` actualizaremos `host` y `hostname`

							if (name === 'port') {

								temp = {

									hostname: this._attributes.hostname,
									port: Public.normalize.port(value)

								};

							} else {

								temp = Public.normalize.host(

									_toString(value) + (

										(name === 'hostname' && this._attributes.port) ? (':' + this._attributes.port) : ''

									)

								);

							}

							this._attributes.host = temp.hostname + (temp.port ? (':' + temp.port) : '');
							this._attributes.hostname = temp.hostname;
							this._attributes.port = temp.port;

						} else {

							if (name === 'query')

								name = 'search';

							// Establecemos el nuevo valor normalizado del atributo

							this._attributes[name] = Public.normalize[name](value);

						}

				}

			}

			return this;

		}
355351
public function validate($value, array $arguments = [])
    {
        $isNumeric = is_numeric($value);
        $min = Arr::get($arguments, 'min', false);
        $max = Arr::get($arguments, 'max', false);
        $float = Arr::get($arguments, 'float', false);
        $inArray = Arr::get($arguments, 'in_array', false);
        $filter = Arr::get($arguments, 'filter', false);

        if (!$isNumeric) {
            throw new Exception("O atributo '{$this->getAttribute()}' não é um número!");
        }

        if ($float) {
            $value = $value + 0;
            $value = (float)$value;
        } else {
            $value = (int)$value;
        }

        if ($min) {
            $min = $min + 0;
        } else {
            $min = false;
        }

        if ($max) {
            $max = $max + 0;
        } else {
            $max = false;
        }

        if ($min) {

            if ($value < $min) {
                throw new Exception("O atributo '{$this->getAttribute()}' deve ser maior ou igual a '{$min}'!");
            } elseif ($max && $value > $max) {
                throw new Exception("O atributo '{$this->getAttribute()}' deve ser menor ou igual a '{$max}'!");
            }
        }

        if ($inArray && !in_array($value, $inArray)) {
            throw new Exception("O atributo '{$this->getAttribute()}' não pertence ao conjunto de dados!");
        }

        if ($filter && $filter instanceof \Closure) {
            $value = $filter($value);
        } elseif ($filter) {
            $value = call_user_func($filter, $value);
        }

        return $value;
    }
604970
public function retornaComentariosAtributos($object)
    {
        $arrAttrNames = self::pegaAtributosDoObjeto($object);
        $arrAttrComm  = array();
        
        $iterator = 0;
        $limit    = count($arrAttrNames);
        for ($iterator; $iterator < $limit; $iterator++) {

            $reflectionAttr = new ReflectionProperty($object, $arrAttrNames[$iterator]);

            $arrAttrComm[$arrAttrNames[$iterator]] = $reflectionAttr->getDocComment();
        }

        /**
         * @todo FAZER O FOR PARA PEGAR TODOS ATRIBUTOS, PASSAR NO SEGUNDO PARAMETRO;
         */
        return $arrAttrComm;
    }
817070
public static function fatorVencimento($vencimento)
    {
        // Quando o vencimento for vazio ou não informado deve retornar o fator ZERO, para os casos de cartão de credito...
        if (($vencimento === null) || ($vencimento === '')) {
            return 0;
        }

        $base = Carbon::createFromFormat('d.m.Y', '07.10.1997');
        if (! ($vencimento instanceof \DateTime)) {
            $vencimento = Carbon::createFromTimestamp($vencimento);
        }

        return $base->diffInDays() - $vencimento->diffInDays();
    }
624759
private function clause($column, $operator, $value, $scape_quote, $clause, $logicaOperator) {
      $str     = "";
      $closure = false;
      $logicaOperator = strtoupper($logicaOperator);
      $clauseUpper = strtoupper($clause);
      $clauseLower = strtolower($clause);
      $this->connection();


      if ( is_array($column) ) {
         foreach ($column as $key => $val) {
            // $this->operators
            if (preg_match('/([\.a-zA-Z0-9_-]+) *(.*)/i', $key,$match)) {
               if (trim($match[2])) {
                  $this->clause(trim($match[1]), trim($match[2]), $val, $scape_quote, $clause, $logicaOperator);
               }
               else {
                  $this->clause(trim($match[1]), $val, $value, $scape_quote, $clause, $logicaOperator);
               }
            }
         }
         return;
      }

      // si es un closure lo ejecutamos
      if ( $column===NULL )
         $column = ' NULL ' ;
      elseif ( gettype( $column )==='boolean' )
         $column = $column ? ' TRUE ' : ' FALSE ' ;
      elseif ($column instanceof \Closure) {
         // el resultado resuelto es almacenado en la variable $_ENV para luego terminar de agruparlo
         $column(new \Daniia\Daniia(true));
         if (preg_match("/^CASE/", $_ENV['daniia_daniia']->case)) {
            $str = '( '.$_ENV['daniia_daniia']->case.' '.$_ENV['daniia_daniia']->when.' '.$_ENV['daniia_daniia']->else.' END )';
            $_ENV['daniia_daniia']->case = NULL;
         }
         else {
            if ( $clauseLower==='on' ) {
               $column = $_ENV['daniia_daniia']->{$clauseLower}.")";
               $closure = TRUE;
            }
            else {
               $column = $_ENV['daniia_daniia']->get_sql();
            }
            $_ENV['daniia_daniia'] = null;
         }
      }


      // si no es un operador valido
      if ( $operator instanceof \Closure )
         list($operator, $value, $scape_quote) = ['=', $operator, $value];
      elseif ( is_array($operator) )
         list($operator, $value, $scape_quote) = ['in', $operator, $value];
      elseif ( !in_array(strtolower(trim($operator)), $this->operators, true) ) {
         list($operator, $value, $scape_quote) = ['=', $operator, $value];
         if ( $scape_quote==='' && $clauseLower==='on' ) {
            $scape_quote = FALSE;
         }
         elseif ( $scape_quote==='' && $clauseLower!=='on' ) {
            $scape_quote = TRUE;
         }
      }


      if ( $value===NULL ) {
         $scape_quote = FALSE;
         $value = ' NULL ' ;
      }
      elseif ( gettype($value)==='boolean' ) {
         $scape_quote = FALSE;
         $value = $value ? ' TRUE ' : ' FALSE ' ;
      }
      elseif ($value instanceof \Closure) {
         // el resultado resuelto es almacenado en la variable $_ENV para luego terminar de agruparlo
         $value(new \Daniia\Daniia());
         
         if (preg_match("/^CASE/", $_ENV['daniia_daniia']->case)) {
            $value = '( '.$_ENV['daniia_daniia']->case.' '.$_ENV['daniia_daniia']->when.' '.$_ENV['daniia_daniia']->else.' END )';
            $_ENV['daniia_daniia']->case = NULL;
         }
         else {
            $value = $_ENV['daniia_daniia']->get_sql();
            $_ENV['daniia_daniia'] = null;
         }
         
         $scape_quote = false;
      }
      elseif (is_array($value) && (strtolower($operator)=='between'||strtolower($operator)=='not between') ) {
         $scape_quote = FALSE;
         $value = ' '.$this->id_conn->quote($value[0]).' AND '.$this->id_conn->quote($value[1]).' ';
      }
      elseif( is_array($value) ) {
         $in = [];
         foreach($value as $val){
            if ( $val===NULL ) {
               $in[] = ' NULL ' ;
            }
            elseif ( gettype($val)==='boolean' ) {
               $in[] = $val ? ' TRUE ' : ' FALSE ' ;
            }
            else {
               $in[] = $this->id_conn->quote($val);
            }
         }
         $scape_quote = FALSE;
         $value = ' ('.implode(',',$in).') ';
      }


      if ( $this->table && !preg_match("/,/", $this->table) ) {
         $this->columns();
      }


      if(gettype( $column )==='string' || gettype( $column )==='integer' || gettype( $column )==='double') {
         if($closure || $value==='') {
            if ( @preg_match("/\( +SELECT +\* +\(/", $column) ) {
               $str = preg_replace("/\( +SELECT +\* +\(/", '(', $column);
            }
            else {
               $str = $column;
            }
         }
         else {
            if ( in_array(strtolower(trim($value)), $this->columnsData, true) ) {
               $str = $column.' '.strtoupper($operator).' '.$value." ";
            }
            else {
               $str = $column.' '.strtoupper($operator).' '.($scape_quote===true?$this->id_conn->quote($value):$value)." ";
            }
         }
      }


      if ($this->bool_group) {
         if (preg_match('/\(/', $this->{$clauseLower})) {
            $this->{$clauseLower} .= " {$logicaOperator} {$str} ";
         }
         else {
            $this->{$clauseLower} .= " ({$str} ";
         }
      }
      else {
         if (preg_match("/".$clauseUpper."/", $this->{$clauseLower})) {
            $this->{$clauseLower} .= " {$logicaOperator} {$str} ";
         }
         else {
            $this->{$clauseLower} = " {$clauseUpper} {$str} ";
         }
      }

      $this->find_first_data = FALSE;

      if ( preg_match("/^CASE/", $this->case) ) {
         $_ENV['daniia_daniia']->case = $this->case;
         $_ENV['daniia_daniia']->when = $this->when;
         $_ENV['daniia_daniia']->else = $this->else;
         $this->get_instance();
         return $str;
      }

      $this->get_instance();
      return $this;
   }
1297288
def ConsultarTributos(self, sep="||"):
        ""
        ret = self.client.consultarTributos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('tributo', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
948708
public function execute(\PhpSigep\Model\CalcPrecoPrazo $params)
    {
        $larguraMinima     = 0;
        $alturaMinima      = 0;
        $comprimentoMinimo = 16;
        $diametroMinimo    = 0;

        $tipoEmbalagem = $params->getDimensao()->getTipo();
        $ehEnvelope    = false;
        if ($tipoEmbalagem == Dimensao::TIPO_ENVELOPE) {
            $ehEnvelope       = true;
            $formatoEncomenda = 3;
            $larguraMinima    = 11;
        } else if ($tipoEmbalagem == Dimensao::TIPO_PACOTE_CAIXA) {
            $formatoEncomenda = 1;
            $alturaMinima     = 2;
            $larguraMinima    = 11;
        } else {
            if ($tipoEmbalagem == Dimensao::TIPO_ROLO_CILINDRO) {
                $formatoEncomenda  = 2;
                $comprimentoMinimo = 18;
                $diametroMinimo    = 5;
            } else {
                throw new Exception('Tipo de embalagem "' . $tipoEmbalagem . '" não reconhecido.');
            }
        }

        $maoPropria         = false;
        $valorDeclarado     = 0;
        $avisoRecebimento   = false;
        $servicosAdicionais = $params->getServicosAdicionais();
        $servicosAdicionais = ($servicosAdicionais ? $servicosAdicionais : array());
        foreach ($servicosAdicionais as $servicoAdicional) {
            if ($servicoAdicional->is(ServicoAdicional::SERVICE_MAO_PROPRIA)) {
                $maoPropria = true;
            } else if ($servicoAdicional->is(ServicoAdicional::SERVICE_VALOR_DECLARADO_SEDEX) || $servicoAdicional->is(ServicoAdicional::SERVICE_VALOR_DECLARADO_PAC)) {
                if (!$servicoAdicional->getValorDeclarado()) {
                    throw new Exception('Para usar o serviço "valor declarado" é necessário declarar o valor da mercadoria.');
                }
                $valorDeclarado = $servicoAdicional->getValorDeclarado();
            } else if ($servicoAdicional->is(ServicoAdicional::SERVICE_AVISO_DE_RECEBIMENTO)) {
                $avisoRecebimento = true;
            }
        }

        $servivosDePostagem = array();
        /** @var $servivoDePostagem ServicoDePostagem */
        foreach ($params->getServicosPostagem() as $servivoDePostagem) {
            $servivosDePostagem[] = $servivoDePostagem->getCodigo();
        }

        $ajustarDimensaoMinima = $params->getAjustarDimensaoMinima();

        $comprimento = (int)$params->getDimensao()->getComprimento();
        $comprimento = $comprimento < $comprimentoMinimo && $ajustarDimensaoMinima ? $comprimentoMinimo : $comprimento;
        $altura      = $ehEnvelope ? 0 : ((int)$params->getDimensao()->getAltura());
        $altura      = $altura < $alturaMinima && $ajustarDimensaoMinima ? $alturaMinima : $altura;
        $largura     = (int)$params->getDimensao()->getLargura();
        $largura     = $largura < $larguraMinima && $ajustarDimensaoMinima ? $larguraMinima : $largura;
        $diametro    = (int)$params->getDimensao()->getDiametro();
        $diametro    = $diametro < $diametroMinimo && $ajustarDimensaoMinima ? $diametroMinimo : $largura;

        $soapArgs = array(
            'nCdEmpresa'          => $params->getAccessData()->getCodAdministrativo(),
            'sDsSenha'            => $params->getAccessData()->getSenha(),
            'nCdServico'          => implode(',', $servivosDePostagem),
            'sCepOrigem'          => str_replace('-', '', $params->getCepOrigem()),
            'sCepDestino'         => str_replace('-', '', $params->getCepDestino()),
            'nVlPeso'             => $params->getPeso(),
            'nCdFormato'          => $formatoEncomenda,
            'nVlComprimento'      => $comprimento,
            'nVlAltura'           => $altura,
            'nVlLargura'          => $largura,
            'nVlDiametro'         => $diametro,
            'sCdMaoPropria'       => ($maoPropria ? 'S' : 'N'),
            'nVlValorDeclarado'   => $valorDeclarado,
            'sCdAvisoRecebimento' => ($avisoRecebimento ? 'S' : 'N'),
        );

        $cacheKey = md5(serialize($soapArgs));
        $cache    = Bootstrap::getConfig()->getCacheInstance();
        if ($cachedResult = $cache->getItem($cacheKey)) {
            return unserialize($cachedResult);
        }

        $result = new Result();
        try {
            $r = SoapClientFactory::getSoapCalcPrecoPrazo()->calcPrecoPrazo($soapArgs);
        } catch (\Exception $e) {
            $message = $e->getMessage();
            if ($message == 'Service Unavailable') {
                if (!self::$calcPrecosPrazosServiceUnavailable) {
                    //Tenta mais uma vez
                    self::$calcPrecosPrazosServiceUnavailable = true;
                    sleep(1);

                    return $this->calcPrecoPrazo($params);
                }
            }
            if ($e instanceof \SoapFault) {
                $result->setIsSoapFault(true);
                $result->setErrorCode($e->getCode());
                $result->setErrorMsg(SoapClientFactory::convertEncoding($e->getMessage()));
            } else {
                $result->setErrorCode($e->getCode());
                $result->setErrorMsg($e->getMessage());
            }
        }

        if (class_exists('\StaLib_Logger',false)) {
            \StaLib_Logger::log('Retorno SIGEP: ' . print_r($r, true));
        }

        $retorno = array();
        if (is_object($r) && property_exists($r, 'CalcPrecoPrazoResult') && is_object($r->CalcPrecoPrazoResult)
            && $r->CalcPrecoPrazoResult->Servicos && is_object($r->CalcPrecoPrazoResult->Servicos)
        ) {
            if ($r->CalcPrecoPrazoResult->Servicos->cServico) {
                $servicos = $r->CalcPrecoPrazoResult->Servicos->cServico;
                $servicos = (is_array($servicos) ? $servicos : array($servicos));

                foreach ($servicos as $servico) {
                    $valor                 = (float)str_replace(',', '.', str_replace('.', '', $servico->Valor));
                    $valorMaoPropria       = str_replace('.', '', $servico->ValorMaoPropria);
                    $valorMaoPropria       = (float)str_replace(',', '.', $valorMaoPropria);
                    $valorAvisoRecebimento = str_replace('.', '', $servico->ValorAvisoRecebimento);
                    $valorAvisoRecebimento = (float)str_replace(',', '.', $valorAvisoRecebimento);
                    $valorValorDeclarado   = str_replace('.', '', $servico->ValorValorDeclarado);
                    $valorValorDeclarado   = (float)str_replace(',', '.', $valorValorDeclarado);

                    $item = new \PhpSigep\Model\CalcPrecoPrazoResposta(array(
                        'servico'               => new \PhpSigep\Model\ServicoDePostagem($servico->Codigo),
                        'valor'                 => $valor,
                        'prazoEntrega'          => (int)$servico->PrazoEntrega,
                        'valorMaoPropria'       => $valorMaoPropria,
                        'valorAvisoRecebimento' => $valorAvisoRecebimento,
                        'valorValorDeclarado'   => $valorValorDeclarado,
                        'entregaDomiciliar'     => ($servico->EntregaDomiciliar == 'S'),
                        'entregaSabado'         => ($servico->EntregaSabado == 'S'),
                    ));

                    $item->setErroCodigo($servico->Erro);
                    if ($item->getErroCodigo() && ($item->getErroCodigo() != 10 || !$item->getValor())) {
                        // Se entrar aqui significa que tem Erro e que esse Erro é diferente de 10 ou o Erro é 10 mas não
                        // não foi retornando o Valor.
                        // O erro "10" é mais um aviso do que um erro. Se for erro 10 e tiver valor, não considera um erro.
                        $msgErro = $servico->MsgErro;
                        $msgErro = SoapClientFactory::convertEncoding($msgErro);
                        $item->setErroMsg($msgErro);
                    } else {
                        $item->setErroCodigo(null);
                    }
                    $retorno[] = $item;
                }
            } else {
                $result->setErrorCode(0);
                $result->setErrorMsg('A resposta do Correios não está no formato esperado. Detalhes do problema: "Faltando a entrada \'cServico\'."');
            }
        } else {
            $result->setErrorCode(0);
            if (is_object($r)) {
                $result->setErrorMsg('A resposta do Correios não está no formato esperado. Detalhes do problema: "A resposta recebida é um objeto, mas este objeto não possui todos as entradas necessárias."');
            } else {
                $result->setErrorMsg('A resposta do Correios não está no formato esperado. Resposta recebida: "' .
                    $r . '"');
            }
        }

        $retornoIterator = new \PhpSigep\Model\CalcPrecoPrazoRespostaIterator($retorno);
        $result->setResult($retorno);

        if (!$result->hasError()) {
            if ($retornoIterator->todosTemErro()) {
                $erros = array();
                /** @var $retItem \PhpSigep\Model\CalcPrecoPrazoResposta */
                foreach ($retornoIterator as $retItem) {
                    $erros[$retItem->getErroCodigo()] = $retItem;
                }
                /** @var $exception \PhpSigep\Model\CalcPrecoPrazoResposta */
                $exception         = null;
                $errosPrioritarios = array('999', '-3', '-2', '-4', '-33', '7');
                foreach ($errosPrioritarios as $erroPrioritario) {
                    if (isset($erros[$erroPrioritario])) {
                        $exception = $erros[$erroPrioritario];
                        break;
                    }
                }
                if (!$exception) {
                    $exception = reset($erros);
                }
                $result->setErrorCode($exception->getErroCodigo());
                $result->setErrorMsg($exception->getErroMsg());
            } else {
                $cache->setItem($cacheKey, serialize($result));
            }
        }

        return $result;
    }
314267
def CrearLiquidacion(self, tipo_cbte, pto_vta, nro_cbte, fecha, periodo,
                         iibb_adquirente=None, domicilio_sede=None,
                         inscripcion_registro_publico=None, 
                         datos_adicionales=None, alicuota_iva=None, **kwargs):
        ""
        # creo el diccionario con los campos generales de la liquidación:
        liq = {'tipoComprobante': tipo_cbte, 'puntoVenta': pto_vta,
                'nroComprobante': nro_cbte, 'fechaComprobante': fecha, 
                'periodo': periodo, 'iibbAdquirente': iibb_adquirente, 
                'domicilioSede': domicilio_sede, 
                'inscripcionRegistroPublico': inscripcion_registro_publico, 
                'datosAdicionales': datos_adicionales, 
                'alicuotaIVA': alicuota_iva, 
              }
        liq["condicionVenta"] = []
        self.solicitud = dict(liquidacion=liq,
                              bonificacionPenalizacion=[],
                              otroImpuesto=[],
                              remito=[]
                             )
        return True
1344301
function formatarValor($valor, $formato)
    {
        $tamanhoValor = strlen($valor);
        $tamanhoFormato = substr_count($formato, '#');

        if ($tamanhoValor < $tamanhoFormato) {
            $diferenca = $tamanhoFormato - $tamanhoValor;
            $valor = $valor . str_repeat('#', $diferenca);
        }

        if ($tamanhoValor > $tamanhoFormato) {
            $valor = substr($valor, 0, $tamanhoFormato);
        }

        $formato = str_replace('#', '%s', $formato);
        return vsprintf($formato, str_split($valor));
    }
314016
public function ___get($prop)
    {
        // retorna o valor da propriedade
        if (isset($this->meta[$prop])) {
            $metaData = (isset($this->meta[$prop])) ? $this->meta[$prop] : null;
            switch ($metaData['tipo']) {
                case 'decimal':
                    return ($this->data[$prop]) ? number_format($this->data[$prop], $metaData['precision'], ',', '.') : '';
                case 'int':
                    return (isset($this->data[$prop])) ? abs($this->data[$prop]) : '';
                case 'alfa':
                    return ($this->data[$prop]) ? $this->prepareText($this->data[$prop]) : '';
                case $metaData['tipo'] == 'date' && $metaData['tamanho'] == 6:
                    return ($this->data[$prop]) ? date("d/m/y", strtotime($this->data[$prop])) : '';
                case $metaData['tipo'] == 'date' && $metaData['tamanho'] == 8:
                    return ($this->data[$prop]) ? date("d/m/Y", strtotime($this->data[$prop])) : '';
                default:
                    return null;
            }
        }
    }
829432
private static function checkType(Meta $m)
    {
        if (in_array($m->getType(), ["tinyint", "smallint", "mediumint", "int", "bigint"])) {
            if (!is_numeric($m->getValue())) {
                if ($m->getDefault() === false)
                    $m->setError("número inválido");
                else
                    $m->setValue("", !1);
            }

        } elseif (in_array($m->getType(), array("double", "real", "float"))) {
            if (!is_numeric($m->getValue())) {
                if ($m->getDefault() === false)
                    $m->setError("valor não é um número");
                else
                    $m->setValue("", !1);
            }

        } elseif (in_array($m->getType(), array("bit", "boolean", "serial"))) {
            if (!is_bool($m->getValue())) {
                if ($m->getDefault() === false)
                    $m->setError("valor boleano inválido. (true ou false)");
                else
                    $m->setValue("", !1);
            }

        } elseif (in_array($m->getType(), array("datetime", "timestamp"))) {
            if (!preg_match('/\d{4}-\d{2}-\d{2}[T\s]+\d{2}:\d{2}/i', $m->getValue())) {
                if ($m->getDefault() === false)
                    $m->setError("formato de data inválido ex válido:(2017-08-23 21:58:00)");
                else
                    $m->setValue("", !1);
            }

        } elseif ($m->getType() === "date") {
            if (!preg_match('/\d{4}-\d{2}-\d{2}/i', $m->getValue())) {
                if ($m->getDefault() === false)
                    $m->setError("formato de data inválido ex válido:(2017-08-23)");
                else
                    $m->setValue("", !1);
            }

        } elseif ($m->getType() === "time") {
            if (!preg_match('/\d{2}:\d{2}/i', $m->getValue())) {
                if ($m->getDefault() === false)
                    $m->setError("formato de tempo inválido ex válido:(21:58)");
                else
                    $m->setValue("", !1);
            }

        } elseif ($m->getType() === "json" && !is_array($m->getValue())) {
            if ($m->getDefault() === false)
                $m->setError("formato json inválido");
            else
                $m->setValue("", !1);
        }
    }
174976
public function getText()
    {
        $retorno = '';
        foreach ($this->meta as $key => $value) {
            $retorno .= $this->$key;
        }
        RemessaAbstract::$retorno[] = $retorno;
        if ($this->children) {
            // percorre todos objetos filhos
            foreach ($this->children as $child) {
                $child->getText();
            }
        }
    }
375853
def posicion (pos)
		 	if @inicio.nil?
		 		raise RuntimeError, "La lista esta vacia"
		 	end

		 	if pos<0 || pos>tamano-1
		 		raise RuntimeError, "La posicion no es correcta"
		 	end

	 		contador=0
	 		copia=@inicio
				while contador<pos && !copia.nil?
					copia2 = copia[:sig]
		 			copia = copia2
		 			contador += 1
		 		end
		 	
			return copia[:valor]
		end
958020
public function gerarBoleto()
    {
        if (count($this->boleto) == 0) {
            throw new \Exception('Nenhum Boleto adicionado');
        }

        return $this->getBlade()->make('BoletoHtmlRender::boleto', [
            'boletos' => $this->boleto,
            'css' => $this->writeCss(),
            'imprimir_carregamento' => (bool) $this->print,
            'mostrar_instrucoes' => (bool) $this->showInstrucoes,
        ])->render();
    }
1105820
def GetParametro(self, clave, clave1=None, clave2=None, clave3=None, clave4=None):
        ""
        # útil para parámetros de salida (por ej. campos de TransaccionPlainWS)
        valor = self.params_out.get(clave)
        # busco datos "anidados" (listas / diccionarios)
        for clave in (clave1, clave2, clave3, clave4):
            if clave is not None and valor is not None:
                if isinstance(clave1, basestring) and clave.isdigit():
                    clave = int(clave)
                try:
                    valor = valor[clave]
                except (KeyError, IndexError):
                    valor = None
        if valor is not None:
            if isinstance(valor, basestring):
                return valor
            else:
                return str(valor)
        else:
            return ""
43611
def CrearLiquidacion(self, nro_orden=None, cuit_comprador=None, 
               nro_act_comprador=None, nro_ing_bruto_comprador=None,
               cod_tipo_operacion=None,
               es_liquidacion_propia=None, es_canje=None,
               cod_puerto=None, des_puerto_localidad=None, cod_grano=None,
               cuit_vendedor=None, nro_ing_bruto_vendedor=None,
               actua_corredor=None, liquida_corredor=None, cuit_corredor=None,
               comision_corredor=None, nro_ing_bruto_corredor=None,
               fecha_precio_operacion=None,
               precio_ref_tn=None, cod_grado_ref=None, cod_grado_ent=None,
               factor_ent=None, precio_flete_tn=None, cont_proteico=None,
               alic_iva_operacion=None, campania_ppal=None,
               cod_localidad_procedencia=None,
               datos_adicionales=None, pto_emision=1, cod_prov_procedencia=None, 
               peso_neto_sin_certificado=None, val_grado_ent=None,
               cod_localidad_procedencia_sin_certificado=None,
               cod_prov_procedencia_sin_certificado=None,
               nro_contrato=None,
               **kwargs
               ):
        ""

        # limpio los campos especiales (segun validaciones de AFIP)
        if alic_iva_operacion == 0:
            alic_iva_operacion = None   # no informar alicuota p/ monotributo
        if val_grado_ent == 0:
            val_grado_ent = None
        # borrando datos corredor si no corresponden
        if actua_corredor == "N":
            cuit_corredor = None
            comision_corredor = None
            nro_ing_bruto_corredor = None
        
        # si no corresponde elimino el peso neto certificado campo opcional
        if not peso_neto_sin_certificado or not int(peso_neto_sin_certificado):
            peso_neto_sin_certificado = None
        
        if cod_puerto and int(cod_puerto) != 14:
            des_puerto_localidad = None             # validacion 1630

        # limpio los campos opcionales para no enviarlos si no corresponde:
        if cod_grado_ref == "":
            cod_grado_ref = None
        if cod_grado_ent == "":
            cod_grado_ent = None
        if val_grado_ent == 0:
            val_grado_ent = None

        # creo el diccionario con los campos generales de la liquidación:
        self.liquidacion = dict(
                            ptoEmision=pto_emision,
                            nroOrden=nro_orden,
                            cuitComprador=cuit_comprador,
                            nroActComprador=nro_act_comprador,
                            nroIngBrutoComprador=nro_ing_bruto_comprador,
                            codTipoOperacion=cod_tipo_operacion,
                            esLiquidacionPropia=es_liquidacion_propia,
                            esCanje=es_canje,
                            codPuerto=cod_puerto,
                            desPuertoLocalidad=des_puerto_localidad,
                            codGrano=cod_grano,
                            cuitVendedor=cuit_vendedor,
                            nroIngBrutoVendedor=nro_ing_bruto_vendedor,
                            actuaCorredor=actua_corredor,
                            liquidaCorredor=liquida_corredor,
                            cuitCorredor=cuit_corredor,
                            comisionCorredor=comision_corredor,
                            nroIngBrutoCorredor=nro_ing_bruto_corredor,
                            fechaPrecioOperacion=fecha_precio_operacion,
                            precioRefTn=precio_ref_tn,
                            codGradoRef=cod_grado_ref,
                            codGradoEnt=cod_grado_ent,
                            valGradoEnt=val_grado_ent,
                            factorEnt=factor_ent,
                            precioFleteTn=precio_flete_tn,
                            contProteico=cont_proteico,
                            alicIvaOperacion=alic_iva_operacion,
                            campaniaPPal=campania_ppal,
                            codLocalidadProcedencia=cod_localidad_procedencia,
                            codProvProcedencia=cod_prov_procedencia,
                            datosAdicionales=datos_adicionales,
                            pesoNetoSinCertificado=peso_neto_sin_certificado,
                            numeroContrato=nro_contrato or None,
                            certificados=[],
            )
        # para compatibilidad hacia atras, "copiar" los campos si no hay cert:
        if peso_neto_sin_certificado:
            if cod_localidad_procedencia_sin_certificado is None:
                cod_localidad_procedencia_sin_certificado = cod_localidad_procedencia
            if cod_prov_procedencia_sin_certificado is None:
                cod_prov_procedencia_sin_certificado = cod_prov_procedencia
            self.liquidacion.update(dict(
                codLocalidadProcedenciaSinCertificado=cod_localidad_procedencia_sin_certificado,
                codProvProcedenciaSinCertificado=cod_prov_procedencia_sin_certificado,
                ))

        # inicializo las listas que contentran las retenciones y deducciones:
        self.retenciones = []
        self.deducciones = []
        self.percepciones = []
        self.opcionales = []        # para anticipo
        # limpio las estructuras internas no utilizables en este caso
        self.certificacion = None
        return True