Indica los campos para agrupación
172193
def group_by(self, *args):
        
        if len(args) == 1:
            self.raw_fields_group = args[0].split(',')
        else:
            self.raw_fields_group = list(args)
        return self
292434
def RegresarAOrigenCTGRechazado(self, numero_carta_de_porte, numero_ctg, 
                            km_a_recorrer=None, 
                            **kwargs):
        ""
        ret = self.client.regresarAOrigenCTGRechazado(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        datosRegresarAOrigenCTGRechazado=dict(
                            cartaPorte=numero_carta_de_porte, 
                            ctg=numero_ctg, kmARecorrer=km_a_recorrer,
                            )))['response']
        self.__analizar_errores(ret)
        datos = ret.get('datosResponse')
        if datos:
            self.CartaPorte = str(datos['cartaPorte'])
            self.NumeroCTG = str(datos['ctg'])
            self.FechaHora = str(datos['fechaHora'])
            self.CodigoTransaccion = str(datos['codigoOperacion'])
            self.Observaciones = ""
        return self.CodigoTransaccion
136687
def AgregarUbicacionTambo(self, latitud, longitud, domicilio,
                              cod_localidad, cod_provincia, codigo_postal,
                              nombre_partido_depto, **kwargs):
        ""
        ubic_tambo = {'latitud': latitud, 
                      'longitud': longitud,
                      'domicilio': domicilio,
                      'codLocalidad': cod_localidad,
                      'codProvincia': cod_provincia,
                      'nombrePartidoDepto': nombre_partido_depto,
                      'codigoPostal': codigo_postal}
        self.solicitud['tambo']['ubicacionTambo'] = ubic_tambo
        return True
1185972
def AgregarGasto(self, cod_gasto, descripcion=None, base_imponible=None,
                     alicuota=None, importe=None, alicuota_iva=None,
                     tipo_iva_nulo=None):
        ""
        # WSLSPv1.4.1: tipo_iva_nulo debe ser NG, NA, EX: Exento.
        if alicuota_iva == 0:
            alicuota_iva = None         # sólo acepta [10.5, 21.0]
        elif alicuota_iva:
            tipo_iva_nulo = None
        gasto = {'codGasto': cod_gasto, 'descripcion': descripcion, 
                 'baseImponible': base_imponible, 'alicuota': alicuota, 
                 'importe': importe, 'alicuotaIVA': alicuota_iva,
                 'tipoIVANulo': tipo_iva_nulo,
                }
        if 'ajusteFinanciero' in self.solicitud:
            self.solicitud['ajusteFinanciero']['gasto'].append(gasto)
        else:
            self.solicitud['gasto'].append(gasto)
        return True
592201
def AgregarCalidad(self, analisis_muestra=None, nro_boletin=None,
                             cod_grado=None, valor_grado=None, 
                             valor_contenido_proteico=None, valor_factor=None, 
                             **kwargs):
        ""
        self.certificacion['primaria']['calidad'] = dict(
                analisisMuestra=analisis_muestra,
                nroBoletin=nro_boletin,
                codGrado=cod_grado,                 # G1 G2 G3 F1 F2 F3
                valorGrado=valor_grado or None,                     # opcional
                valorContProteico=valor_contenido_proteico,
                valorFactor=valor_factor,
                detalleMuestraAnalisis=[],     # <!--1 or more repetitions:-->
                )
        return True
1343707
public function analyse()
    {
        $result = [];
        $w = $this->w = imagesx($this->oImg);
        $h = $this->h = imagesy($this->oImg);

        $this->od = new \SplFixedArray ($h * $w * 3);
        $this->aSample = new \SplFixedArray ($h * $w);
        for ($y = 0; $y < $h; $y++)
        {
            for ($x = 0; $x < $w; $x++)
            {
                $p = ($y) * $this->w * 3 + ($x) * 3;
                $aRgb = $this->getRgbColorAt($x, $y);
                $this->od [$p + 1] = $this->edgeDetect($x, $y, $w, $h);
                $this->od [$p] = $this->skinDetect($aRgb [0], $aRgb [1], $aRgb [2], $this->sample($x, $y));
                $this->od [$p + 2] = $this->saturationDetect($aRgb [0], $aRgb [1], $aRgb [2], $this->sample($x, $y));
            }
        }

        $scoreOutput = $this->downSample($this->options ['scoreDownSample']);
        $topScore = -INF;
        $topCrop = null;
        $crops = $this->generateCrops();

        foreach ($crops as &$crop)
        {
            $crop ['score'] = $this->score($scoreOutput, $crop);
            if ($crop ['score'] ['total'] > $topScore)
            {
                $topCrop = $crop;
                $topScore = $crop ['score'] ['total'];
            }
        }

        $result ['topCrop'] = $topCrop;

        if ($this->options ['debug'] && $topCrop)
        {
            $result ['crops'] = $crops;
            $result ['debugOutput'] = $scoreOutput;
            $result ['debugOptions'] = $this->options;
            $result ['debugTopCrop'] = array_merge([], $result ['topCrop']);
        }

        return $result;
    }
807940
def CrearAjusteCredito(self, 
               datos_adicionales=None,              # unificado, contrato, papel
               concepto_importe_iva_0=None,         # unificado, contrato, papel
               importe_ajustar_iva_0=None,          # unificado, contrato, papel
               concepto_importe_iva_105=None,       # unificado, contrato, papel
               importe_ajustar_iva_105=None,        # unificado, contrato, papel
               concepto_importe_iva_21=None,        # unificado, contrato, papel
               importe_ajustar_iva_21=None,         # unificado, contrato, papel
               diferencia_peso_neto=None,           # unificado
               diferencia_precio_operacion=None,    # unificado
               cod_grado=None,                      # unificado
               val_grado=None,                      # unificado  
               factor=None,                         # unificado
               diferencia_precio_flete_tn=None,     # unificado
               **kwargs
               ):
        ""

        self.ajuste['ajusteCredito'] = {
            'diferenciaPesoNeto': diferencia_peso_neto,
            'diferenciaPrecioOperacion': diferencia_precio_operacion,
            'codGrado': cod_grado,
            'valGrado': val_grado,
            'factor': factor,
            'diferenciaPrecioFleteTn': diferencia_precio_flete_tn,
            'datosAdicionales': datos_adicionales,
            'opcionales': None,
            'conceptoImporteIva0': concepto_importe_iva_0,
            'importeAjustarIva0': importe_ajustar_iva_0,
            'conceptoImporteIva105': concepto_importe_iva_105,
            'importeAjustarIva105': importe_ajustar_iva_105,
            'conceptoImporteIva21': concepto_importe_iva_21,
            'importeAjustarIva21': importe_ajustar_iva_21,
            'deducciones': [],
            'retenciones': [],
            'percepciones': [],
            'certificados': [],
            }
        # vinculación con AgregarOpcional:
        self.opcionales = self.ajuste['ajusteCredito']['opcionales']
        # vinculación con AgregarRetencion y AgregarDeduccion
        self.deducciones = self.ajuste['ajusteCredito']['deducciones']
        self.retenciones = self.ajuste['ajusteCredito']['retenciones']
        # para LSG:
        self.percepciones = self.ajuste['ajusteCredito']['percepciones']
        # para compatibilidad con AgregarCertificado (WSLPGv1.17)
        self.liquidacion = self.ajuste['ajusteCredito']
        return True
1173550
def AgregarTributo(self, codigo_tributo, descripcion, base_imponible, alicuota, importe):
        ""
        trib = dict(codigoTributo=codigo_tributo, descripcion=descripcion, baseImponible=base_imponible, alicuota=alicuota, importe=importe)
        self.solicitud['tributo'].append(trib)
        return True
868141
public function insertar()
    {
        // Preparamos variables a usar
        $bd = Aplicacion::instanciar()->obtenerBdRelacional();
        $parametros = [];
        $llavePrimaria = (array) $this->__llavePrimaria;

        // Hacemos recorrido de campos
        foreach ($this->__campos as $campo => $meta) {

            // Verificamos si el campo es llave
            $esLlave = in_array($campo, $llavePrimaria);

            // Validamos requerimiento del campo
            if (!empty($meta['requerido']) && $this->campoVacio($campo)) {
                if (!($esLlave && $this->__llavePrimariaAutonum)) {
                    throw new \RuntimeException("Falta el campo requerido '{$campo}'.");
                }
            }

            // Agregamos campo existente a los parametros de inserción
            if (isset($this->{$campo})) {
                $parametros[$campo . '|' . $meta['tipo']] = $this->{$campo};
            }
        }

        if ($bd->insertar($this->__nombreTabla, $parametros)->ejecutar()) {
            if ($this->__llavePrimariaAutonum && !is_array($this->__llavePrimaria)) {
                $this->{$this->__llavePrimaria} = $bd->ultimoIdInsertado();
            }

            return true;
        }

        return false;
    }
75837
def AgregarEmisor(self, tipo_cbte, pto_vta, nro_cbte, cod_caracter=None,
                      fecha_inicio_act=None, iibb=None, nro_ruca=None,
                      nro_renspa=None, cuit_autorizado=None, **kwargs):
        ""
        # cod_caracter y fecha_inicio_act no es requerido para ajustes
        d = {'tipoComprobante': tipo_cbte, 'puntoVenta': pto_vta,
             'nroComprobante': nro_cbte, 
             'codCaracter': cod_caracter,
             'fechaInicioActividades': fecha_inicio_act,
             'iibb': iibb,
             'nroRUCA': nro_ruca,
             'nroRenspa': nro_renspa,
             'cuitAutorizado': cuit_autorizado}
        self.solicitud['emisor'].update(d)
        return True
1113068
public function eliminar()
    {
        // Preparamos variables a usar
        $filtro = [];
        $llavePrimaria = (array) $this->__llavePrimaria;

        // Hacemos recorrido de llave primaria para rellenar el filtro de consulta
        foreach ($llavePrimaria as $campo) {
            if ($this->campoVacio($campo)) {
                throw new \RuntimeException("Falta rellenar el campo llave '{$campo}'.");
            }

            $filtro[$campo . '|' . $this->__campos[$campo]['tipo']] = $this->{$campo};
        }

        return Aplicacion::instanciar()->obtenerBdRelacional()
            ->eliminar($this->__nombreTabla)
            ->donde($filtro)
            ->ejecutar();
    }
781705
def Guardar(self, tipo_doc, nro_doc, denominacion, cat_iva, direccion, 
               email, imp_ganancias='NI', imp_iva='NI', monotributo='NI', 
               integrante_soc='N', empleador='N'):
        ""
        if self.Buscar(nro_doc, tipo_doc):
            sql = ("UPDATE padron SET denominacion=?, cat_iva=?, email=?, "
					"imp_ganancias=?, imp_iva=?, monotributo=?, "
					"integrante_soc=?, empleador=? "
                    "WHERE tipo_doc=? AND nro_doc=?")
            params = [denominacion, cat_iva, email, imp_ganancias, 
                      imp_iva, monotributo, integrante_soc, empleador,
                     tipo_doc, nro_doc]
        else:
            sql = ("INSERT INTO padron (tipo_doc, nro_doc, denominacion, "
                    "cat_iva, email, imp_ganancias, imp_iva, monotributo, "
                    "integrante_soc, empleador) "
                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
            params = [tipo_doc, nro_doc, denominacion, cat_iva, email,
                      imp_ganancias, imp_iva, monotributo, 
                      integrante_soc, empleador]
        self.cursor.execute(sql, params)
        # agregar el domicilio solo si no existe:
        if direccion:
            self.cursor.execute("SELECT * FROM domicilio WHERE direccion=? "
                                "AND tipo_doc=? AND nro_doc=?", 
                                [direccion, tipo_doc, nro_doc])
            if self.cursor.rowcount < 0:
                sql = ("INSERT INTO domicilio (nro_doc, tipo_doc, direccion)"
                        "VALUES (?, ?, ?)")
                self.cursor.execute(sql, [nro_doc, tipo_doc, direccion])
        self.db.commit()
        return True
1062581
def AgregarDeduccion(self, codigo_concepto=None, detalle_aclaratorio=None,
                               dias_almacenaje=None, precio_pkg_diario=None,
                               comision_gastos_adm=None, base_calculo=None,
                               alicuota=None, **kwargs):
        ""
        # limpiar campo según validación (comision_gastos_adm puede ser 0.00!)
        if codigo_concepto != "CO" and comision_gastos_adm is not None \
            and float(comision_gastos_adm) == 0:
            comision_gastos_adm = None
        # no enviar campos para prevenir errores AFIP 1705, 1707, 1708
        if base_calculo is not None:
            if codigo_concepto == "AL":
                base_calculo = None
            if codigo_concepto == "CO" and float(base_calculo) == 0:
                base_calculo = None         # no enviar, por retrocompatibilidad
        if codigo_concepto != "AL":
            dias_almacenaje = None
            precio_pkg_diario = None
        self.deducciones.append(dict(
                                    deduccion=dict(
                                        codigoConcepto=codigo_concepto,
                                        detalleAclaratorio=detalle_aclaratorio,
                                        diasAlmacenaje=dias_almacenaje,
                                        precioPKGdiario=precio_pkg_diario,
                                        comisionGastosAdm=comision_gastos_adm,
                                        baseCalculo=base_calculo,
                                        alicuotaIva=alicuota, 
                                    ))
                            )
        return True
243887
def AgregarConceptosBasicosMercadoInterno(self, kg_produccion_gb, precio_por_kg_produccion_gb, 
                                              kg_produccion_pr, precio_por_kg_produccion_pr,
                                              kg_crecimiento_gb, precio_por_kg_crecimiento_gb,
                                              kg_crecimiento_pr, precio_por_kg_crecimiento_pr,
                                               **kwargs):
        ""
        d = {'kgProduccionGB': kg_produccion_gb, 
             'precioPorKgProduccionGB': precio_por_kg_produccion_gb, 
             'kgProduccionPR': kg_produccion_pr, 
             'precioPorKgProduccionPR': precio_por_kg_produccion_pr, 
             'kgCrecimientoGB': kg_crecimiento_gb, 
             'precioPorKgCrecimientoGB': precio_por_kg_crecimiento_gb, 
             'kgCrecimientoPR':kg_crecimiento_pr, 
             'precioPorKgCrecimientoPR': precio_por_kg_crecimiento_pr}
        self.solicitud['conceptosBasicosMercadoInterno'] = d
        return True
1335987
public function getCodigoBarras()
    {
        if (!empty($this->campoCodigoBarras)) {
            return $this->campoCodigoBarras;
        }

        if (!$this->isValid($messages)) {
            throw new \Exception('Campos requeridos pelo banco, aparentam estar ausentes ' . $messages);
        }

        $codigo = Util::numberFormatGeral($this->getCodigoBanco(), 3)
            . $this->getMoeda()
            . Util::fatorVencimento($this->getDataVencimento())
            . Util::numberFormatGeral($this->getValor(), 10)
            . $this->getCampoLivre();

        $resto = Util::modulo11($codigo, 2, 9, 0);
        $dv = (in_array($resto, [0, 10, 11])) ? 1 : $resto;

        return $this->campoCodigoBarras = substr($codigo, 0, 4) . $dv . substr($codigo, 4);
    }
88688
public static function calcularParcelamento($capital, $taxa, $tempo, $semjuros) {
        $parcelamento = array();
        for ($i = 1; $i <= $tempo; $i++) {
            $m = $capital * pow((1 + $taxa / 100), $i);
            if ($i <= $semjuros) {
                $parcelamento[$i] = array(
                    'parcela' => self::formataValor(($capital / $i), '.', 2, ',', '.'),
                    'total' => self::formataValor($capital, '.', 2, ',', '.'),
                    'status' => 'sem juros'
                );
            } else {
                $parcelamento[$i] = array(
                    'parcela' => self::formataValor(($m / $i), '.', 2, ',', '.'),
                    'total' => self::formataValor($m, '.', 2, ',', '.'),
                    'status' => 'com juros'
                );
            }
        }

        return $parcelamento;
    }
1028957
def AgregarCompraAsociada(self, tipo_cbte, pto_vta, nro_cbte, cant_asoc, nro_item):
        ""
        d = {'tipoComprobante': tipo_cbte, 
             'puntoVenta': pto_vta,
             'nroComprobante': nro_cbte, 
             'nroItem': nro_item,
             'cantidadAsociada': cant_asoc}
        if 'itemDetalleLiquidacion' in self.solicitud:
            item_liq = self.solicitud['itemDetalleLiquidacion'][-1]
            item_liq['liquidacionCompraAsociada'].append(d)
        else:
            item_liq = self.solicitud['itemDetalleAjusteLiquidacion'][-1]
            item_liq['ajusteCompraAsociada'].append(d)
        return True