Método que agrega un recibo
@param datos Arreglo con los datos del recibo
@author Esteban De La Fuente Rubio, DeLaF (esteban[at]sasco.cl)
@version 2016-08-06
340965
public function agregar(array $datos)
    {
        $this->recibos[] = [
            '@attributes' => [
                'version' => '1.0',
            ],
            'DocumentoRecibo' => array_merge([
                '@attributes' => [
                    'ID' => 'LibreDTE_T'.$datos['TipoDoc'].'F'.$datos['Folio'],
                ],
                'TipoDoc' => false,
                'Folio' => false,
                'FchEmis' => false,
                'RUTEmisor' => false,
                'RUTRecep' => false,
                'MntTotal' => false,
                'Recinto' => false,
                'RutFirma' => false,
                'Declaracion' => 'El acuse de recibo que se declara en este acto, de acuerdo a lo dispuesto en la letra b) del Art. 4, y la letra c) del Art. 5 de la Ley 19.983, acredita que la entrega de mercaderias o servicio(s) prestado(s) ha(n) sido recibido(s).',
                'TmstFirmaRecibo' => date('Y-m-d\TH:i:s'),
            ], $datos)
        ];
        return true;
    }
183194
def AgregarVehiculo(self, dominio_vehiculo=None, dominio_acoplado=None, **kwargs):
        ""
        self.remito['viaje']['vehiculo'] = {'dominioVehiculo': dominio_vehiculo, 'dominioAcoplado': dominio_acoplado}
        return True
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]
36157
public function setDatos(array $datos)
    {
        if (!empty($datos['MontoCesion'])) {
            $this->datos['Cesion']['DocumentoCesion']['MontoCesion'] = $datos['MontoCesion'];
        }
        if (!empty($datos['UltimoVencimiento'])) {
            $this->datos['Cesion']['DocumentoCesion']['UltimoVencimiento'] = $datos['UltimoVencimiento'];
        }
        if (!empty($datos['OtrasCondiciones'])) {
            $this->datos['Cesion']['DocumentoCesion']['OtrasCondiciones'] = $datos['OtrasCondiciones'];
        }
        if (!empty($datos['eMailDeudor'])) {
            $this->datos['Cesion']['DocumentoCesion']['eMailDeudor'] = $datos['eMailDeudor'];
        }
    }
558740
public function actualizarObjetoLdap(){
        if ($this->existe) {
            $dn = $this->entrada['dn'];
            $cambios = array();
            foreach ($this->cambios as $atributos) {
                $cambios[$atributos] = $this->entrada[$atributos];
            }
            return $this->modificarEntradaLdap($dn, $cambios);
        }else{
            $this->configurarErrorLdap('Actualizacion', 'Esa entrada no existe');
            return false;
        }
    }
795652
public function agregarCabecera($nombre, $valor)
    {
        if (isset($this->cabeceras[$nombre])) {
            $this->cabeceras[$nombre][] = $valor;
        } else {
            $this->cabeceras[$nombre] = [$valor];
        }

    }
966044
private function normalizar_52(array &$datos)
    {
        // completar con nodos por defecto
        $datos = \sasco\LibreDTE\Arreglo::mergeRecursiveDistinct([
            'Encabezado' => [
                'IdDoc' => false,
                'Emisor' => false,
                'Receptor' => false,
                'RUTSolicita' => false,
                'Transporte' => false,
                'Totales' => [
                    'MntNeto' => 0,
                    'MntExe' => false,
                    'TasaIVA' => \sasco\LibreDTE\Sii::getIVA(),
                    'IVA' => 0,
                    'ImptoReten' => false,
                    'CredEC' => false,
                    'MntTotal' => 0,
                ]
            ],
        ], $datos);
        // si es traslado interno se copia el emisor en el receptor sólo si el
        // receptor no está definido o bien si el receptor tiene RUT diferente
        // al emisor
        if ($datos['Encabezado']['IdDoc']['IndTraslado']==5) {
            if (!$datos['Encabezado']['Receptor'] or $datos['Encabezado']['Receptor']['RUTRecep']!=$datos['Encabezado']['Emisor']['RUTEmisor']) {
                $datos['Encabezado']['Receptor'] = [];
                $cols = [
                    'RUTEmisor'=>'RUTRecep',
                    'RznSoc'=>'RznSocRecep',
                    'GiroEmis'=>'GiroRecep',
                    'Telefono'=>'Contacto',
                    'CorreoEmisor'=>'CorreoRecep',
                    'DirOrigen'=>'DirRecep',
                    'CmnaOrigen'=>'CmnaRecep',
                ];
                foreach ($cols as $emisor => $receptor) {
                    if (!empty($datos['Encabezado']['Emisor'][$emisor])) {
                        $datos['Encabezado']['Receptor'][$receptor] = $datos['Encabezado']['Emisor'][$emisor];
                    }
                }
                if (!empty($datos['Encabezado']['Receptor']['GiroRecep'])) {
                    $datos['Encabezado']['Receptor']['GiroRecep'] = mb_substr($datos['Encabezado']['Receptor']['GiroRecep'], 0, 40);
                }
            }
        }
        // normalizar datos
        $this->normalizar_detalle($datos);
        $this->normalizar_aplicar_descuentos_recargos($datos);
        $this->normalizar_impuesto_retenido($datos);
        $this->normalizar_agregar_IVA_MntTotal($datos);
        $this->normalizar_transporte($datos);
    }
758562
def GenerarRemito(self, id_req, archivo="qr.png"):
        ""
        if not self.remito['arrayContingencias']:
            del self.remito['arrayContingencias']
        response = self.client.generarRemito(
                                authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit},
                                idReq=id_req, remito=self.remito) 
        ret = response.get("generarRemitoReturn")
        if ret:
            self.__analizar_errores(ret)
            self.__analizar_observaciones(ret)
            self.__analizar_evento(ret)
            self.AnalizarRemito(ret, archivo)
        return bool(self.CodRemito)
480618
def AgregarPercepcion(self, codigo_concepto=None, detalle_aclaratoria=None,
                               base_calculo=None, alicuota=None, importe_final=None,
                               **kwargs):
        ""
        # liquidación secundaria (sin importe final)
        self.percepciones.append(dict(
                                percepcion=dict(
                                    detalleAclaratoria=detalle_aclaratoria,
                                    baseCalculo=base_calculo,
                                    alicuota=alicuota,
                                    importeFinal=importe_final,
                                ))
                        )            
        return True
1100171
public function validate(){
        if(count($this->fieldsState) == 0){
            //Si no hay datos devuelve TRUE
            return TRUE;
        }
        else{
            //Si hay datos valida sus reglas            
            //El formulario empieza siendo valido
            $form_valid= TRUE;            
            //Recorro todos los datos y sus reglas
            foreach ($this->fieldsState as $fieldState) {
                $valid= TRUE;                
                //Recorro cada regla del dato
                foreach ($fieldState['rules'] as $rule) {
                    //Ve el tipo de regla, con o sin parametros
                    if (count(explode('[', $rule)) > 1){
                        //Si hay reglas con parametros, separa la regla y su parametro               
                        $vars= explode('[', $rule);
                        $rule= $vars[0];
                        $var= explode(']', $vars[1]);
                        $var= $var[0];
                        //Realiza el llamado a la funcion correspondiente
                        $valid= call_user_func_array(array($this, $rule), array($fieldState['name'], $fieldState['value'], $var));
                    }
                    else{
                        //Regla sin parametros
                        //Realiza el llamado a la funcion correspondiente
                        $valid= call_user_func_array(array($this, $rule), array($fieldState['name'], $fieldState['value']));
                    }
                    
                    //Si una regla ya no es valida, no reviso las demas
                    if(!$valid){
                        //Asigno al campo Valido del dato FALSE
                        $name= $fieldState['name'];
                        $this->fieldsState["$name"]['valid']= FALSE;
                        break;
                    }
                }                
                //Actualizo el valor de formulario_valido de manera que si ya es falso se mantiene en falso
                $form_valid= $form_valid && $valid;
            }            
            return $form_valid;
        }
    }
104021
public static function stack(array $datasets) : self
    {
        $samples = $labels = [];

        foreach ($datasets as $dataset) {
            if (!$dataset instanceof self) {
                throw new InvalidArgumentException('Dataset must be'
                    . ' an instance of Labeled, ' . get_class($dataset)
                    . ' given.');
            }

            $samples = array_merge($samples, $dataset->samples());
            $labels = array_merge($labels, $dataset->labels());
        }

        return self::quick($samples, $labels);
    }
735855
def AgregarPrecioClase(self, clase_tabaco, precio, total_kilos=None, total_fardos=None, **kwargs):
        ""
        precioclase = dict(claseTabaco=clase_tabaco, precio=precio,
                           totalKilos=total_kilos, totalFardos=total_fardos)
        self.solicitud['precioClase'].append(precioclase)
        return True
505050
def BuscarLocalidades(self, cod_prov, cod_localidad=None, consultar=True):
        ""
        # si no se especifíca cod_localidad, es util para reconstruir la cache
        import wslpg_datos as datos
        if not str(cod_localidad) in datos.LOCALIDADES and consultar:
            d = self.ConsultarLocalidadesPorProvincia(cod_prov, sep=None)
            try:
                # actualizar el diccionario persistente (shelve)
                datos.LOCALIDADES.update(d)
            except Exception, e:
                print "EXCEPCION CAPTURADA", e
                # capturo errores por permisos (o por concurrencia)
                datos.LOCALIDADES = d
        return datos.LOCALIDADES.get(str(cod_localidad), "")
1241153
def verifica(ver_list, res_dict, difs):
    ""
    for k, v in ver_list.items():
        # normalizo a float para poder comparar numericamente:
        if isinstance(v, (Decimal, int, long)):
            v = float(v)
        if isinstance(res_dict.get(k), (Decimal, int, long)):
            res_dict[k] = float(res_dict[k])
        if isinstance(v, list):
            # verifico que ambas listas tengan la misma cantidad de elementos:
            if v and not k in res_dict and v:
                difs.append("falta tag %s: %s %s" % (k, repr(v), repr(res_dict.get(k))))
            elif len(res_dict.get(k, []))!=len(v or []):
                difs.append("tag %s len !=: %s %s" % (k, repr(v), repr(res_dict.get(k))))
            else:
                # ordeno las listas para poder compararlas si vienen mezcladas
                rl = sorted(res_dict.get(k, []))
                # comparo los elementos uno a uno:
                for i, vl in enumerate(sorted(v)):
                    verifica(vl, rl[i], difs)
        elif isinstance(v, dict):
            # comparo recursivamente los elementos:
            verifica(v, res_dict.get(k, {}), difs)
        elif res_dict.get(k) is None or v is None:
            # alguno de los dos es nulo, verifico si ambos lo son o faltan
            if v=="":
                v = None
            r = res_dict.get(k)
            if r=="":
                r = None
            if not (r is None and v is None):
                difs.append("%s: nil %s!=%s" % (k, repr(v), repr(r)))
        elif type(res_dict.get(k)) == type(v):
            # tipos iguales, los comparo directamente
            if res_dict.get(k) != v:
                difs.append("%s: %s!=%s" % (k, repr(v), repr(res_dict.get(k))))
        elif isinstance(v, float) or isinstance(res_dict.get(k), float):
            # comparar numericamente
            if float(res_dict.get(k)) != float(v):
                difs.append("%s: %s!=%s" % (k, repr(v), repr(res_dict.get(k))))
        elif unicode(res_dict.get(k)) != unicode(v):
            # tipos diferentes, comparo la representación  
            difs.append("%s: str %s!=%s" % (k, repr(v), repr(res_dict.get(k))))
        else:
            pass
348794
function gastos_pagos(){
            $gastosDeuda = $this->Gasto->enDeuda();
            $gastosSeleccionados = $this->data['Gasto']['Gasto'];

            foreach ($gastosSeleccionados as $gs){
                if (in_array($gs, $gastosDeuda)){
                    return false;
                }
            }
            return true;
        }
653476
public static function prepararArchivos(array $archivos, $inicio = true)
    {
        $final = [];
        foreach ($archivos as $nombre => $archivo) {
            // Definimos sub nombre
            $subNombre = $nombre;
            if ($inicio) {
                $subNombre = $archivo['name'];
            }

            $final[$nombre] = $archivo;
            if (is_array($subNombre)) {
                foreach (array_keys($subNombre) as $llave) {
                    $final[$nombre][$llave] = array(
                        'name' => $archivo['name'][$llave],
                        'type' => $archivo['type'][$llave],
                        'tmp_name' => $archivo['tmp_name'][$llave],
                        'error' => $archivo['error'][$llave],
                        'size' => $archivo['size'][$llave],
                    );
                    $final[$nombre] = self::prepararArchivos($final[$nombre], false);
                }
            }
        }

        return $final;
    }
1250036
public function obtenerAtributosObjetos($atributo){
        $base = $this->cfgDominio['base'][$this->objeto];
        $filtro = "(objectClass=$this->objeto)";
        $datos = $this->busqueda($base, $filtro, array($atributo), 0);
        $atributos = array();
        foreach ($datos as $attr) {
            $atributos[] = $attr[$atributo];
        }
        return $atributos;
    }