Establece condiciones para la consulta unidas por AND
14636
def where(self, field, value = None, operator = '='):
        
        if field is None:
            return self
        conjunction = None
        if value is None and isinstance(field, dict):
            for field, value in field.items():
                operator, value = value if isinstance(value, tuple) else ('=', value)
                self.where(field, value, operator)
        else:
            if self.where_criteria.size() > 0:
                    conjunction = 'AND'
            self.where_criteria.append(expressions.ConditionExpression(field, value, operator=operator, conjunction=conjunction))
        return self
930096
public function index() {
        $this->Prg->commonProcess();
        $conds = $this->IvaResponsabilidad->parseCriteria( $this->Prg->parsedParams() );
        $this->Paginator->settings['conditions'] = $conds;
        $this->IvaResponsabilidad->recursive = 0;
        $ivaResponsabilidades = $this->Paginator->paginate('IvaResponsabilidad');
        $this->set('ivaResponsabilidades',$ivaResponsabilidades);
    }
347442
def ConsultarCertificacionUltNroOrden(self, pto_emision=1):
        ""
        ret = self.client.cgConsultarUltimoNroOrden(
                    auth={
                        'token': self.Token, 'sign': self.Sign,
                        'cuit': self.Cuit, },
                    ptoEmision=pto_emision,
                    )
        ret = ret['liqUltNroOrdenReturn']
        self.__analizar_errores(ret)
        self.NroOrden = ret['nroOrden']
        return True
595786
def ConsultarUltNroOrden(self, pto_emision=1):
        ""
        ret = self.client.liquidacionUltimoNroOrdenConsultar(
                    auth={
                        'token': self.Token, 'sign': self.Sign,
                        'cuit': self.Cuit, },
                    ptoEmision=pto_emision,
                    )
        ret = ret['liqUltNroOrdenReturn']
        self.__analizar_errores(ret)
        self.NroOrden = ret['nroOrden']
        return True
68274
def AgregarAjusteMonetario(self, precio_unitario, precio_recupero=None, 
                               **kwargs):
        ""
        d = {'precioUnitario': precio_unitario, 
             'precioRecupero': precio_recupero,
            }
        item_liq = self.solicitud['itemDetalleAjusteLiquidacion'][-1]
        item_liq['ajusteMonetario'] = d
        return True
523257
def ProcesarPlantillaPDF(self, num_copias=1, lineas_max=24, qty_pos='izq', 
                                   clave=''):
        ""
        try:
            f = self.template
            liq = self.params_out
            # actualizo los campos según la clave (ajuste debitos / creditos)
            if clave and clave in liq:
                liq = liq.copy()
                liq.update(liq[clave])  # unificar con AnalizarAjusteCredito/Debito

            if HOMO:
                self.AgregarDatoPDF("homo", u"HOMOLOGACIÓN")

            copias = {1: 'Original', 2: 'Duplicado', 3: 'Triplicado', 
                      4: 'Cuadruplicado', 5: 'Quintuplicado'}
                        
            # convierto el formato de intercambio para representar los valores:        
            fmt_encabezado = dict([(v[0], v[1:]) for v in ENCABEZADO])
            fmt_deduccion = dict([(v[0], v[1:]) for v in DEDUCCION])
            fmt_retencion = dict([(v[0], v[1:]) for v in RETENCION])
            
            def formatear(campo, valor, formato):
                "Convertir el valor a una cadena correctamente s/ formato ($ % ...)"
                if campo in formato and v is not None:
                    fmt = formato[campo]
                    if fmt[1] == N:
                        if 'cuit' in campo:
                            c = str(valor)
                            if len(c) == 11:
                                valor = "%s-%s-%s" % (c[0:2], c[2:10], c[10:])
                            else:
                                valor = ""
                        elif 'peso' in campo:
                            valor = "%s Kg" % valor
                        elif valor is not None and valor != "":
                            valor = "%d" % int(valor)
                        else:
                            valor = ""
                    elif fmt[1] == I:
                        valor = ("%%0.%df" % fmt[2]) % valor
                        if 'alic' in campo or 'comision' in campo:
                            valor = valor + " %"
                        elif 'factor' in campo or 'cont' in campo or 'cant' in campo:
                            pass
                        else:
                            valor = "$ " + valor
                    elif 'fecha' in campo:
                        d = valor
                        if isinstance(d, (datetime.date, datetime.datetime)):
                            valor = d.strftime("%d/%m/%Y")
                        else:
                            valor = "%s/%s/%s" % (d[8:10], d[5:7], d[0:4])
                return valor

            def buscar_localidad_provincia(cod_prov, cod_localidad): 
                "obtener la descripción de la provincia/localidad (usar cache)"
                cod_prov = int(cod_prov)
                cod_localidad = str(cod_localidad)
                provincia = datos.PROVINCIAS[cod_prov]
                localidad = self.BuscarLocalidades(cod_prov, cod_localidad)
                return localidad, provincia                

            # divido los datos adicionales (debe haber renglones 1 al 9):
            if liq.get('datos_adicionales') and f.has_key('datos_adicionales1'):
                d = liq.get('datos_adicionales')
                for i, ds in enumerate(f.split_multicell(d, 'datos_adicionales1')):
                    liq['datos_adicionales%s' % (i + 1)] = ds
                
            for copia in range(1, num_copias+1):
                
                # completo campos y hojas
                f.add_page()                   
                f.set('copia', copias.get(copia, "Adicional %s" % copia))
                
                f.set('anulado', {'AC': '', '': 'SIN ESTADO',
                                  'AN': "ANULADO"}.get(liq['estado'], "ERROR"))

                try:
                    cod_tipo_ajuste = int(liq["cod_tipo_ajuste"] or '0')
                except: 
                    cod_tipo_ajuste = None
                f.set('tipo_ajuste', {3: u'Liquidación de Débito', 
                                      4: u'Liquidación de Crédito',
                                      }.get(cod_tipo_ajuste, ''))

                # limpio datos del corredor si no corresponden:
                if liq.get('actua_corredor', 'N') == 'N':
                    if liq.get('cuit_corredor', None) == 0:
                        del liq['cuit_corredor']
                    
                # establezco campos según tabla encabezado:
                for k,v in liq.items():
                    v = formatear(k, v, fmt_encabezado)
                    if isinstance(v, (basestring, int, long, float)):
                        f.set(k, v)
                    elif isinstance(v, decimal.Decimal):
                        f.set(k, str(v))
                    elif isinstance(v, datetime.datetime):
                        f.set(k, str(v))

                import wslpg_datos as datos
                
                campania = int(liq.get('campania_ppal') or 0)
                f.set("campania_ppal", datos.CAMPANIAS.get(campania, campania))
                f.set("tipo_operacion", datos.TIPOS_OP.get(int(liq.get('cod_tipo_operacion') or 0), ""))
                f.set("actividad", datos.ACTIVIDADES.get(int(liq.get('nro_act_comprador') or 0), ""))
                if 'cod_grano' in liq and liq['cod_grano']:
                    cod_grano = int(liq['cod_grano'])
                else:
                    cod_grano = int(self.datos.get('cod_grano') or 0)
                f.set("grano", datos.GRANOS.get(cod_grano, ""))
                cod_puerto = int(liq.get('cod_puerto', self.datos.get('cod_puerto')) or 0)
                if cod_puerto in datos.PUERTOS:
                    f.set("des_puerto_localidad", datos.PUERTOS[cod_puerto])

                cod_grado_ref = liq.get('cod_grado_ref', self.datos.get('cod_grado_ref')) or ""
                if cod_grado_ref in datos.GRADOS_REF:
                    f.set("des_grado_ref", datos.GRADOS_REF[cod_grado_ref])
                else:
                    f.set("des_grado_ref", cod_grado_ref)
                cod_grado_ent = liq.get('cod_grado_ent', self.datos.get('cod_grado_ent'))
                if 'val_grado_ent' in liq and int(liq.get('val_grado_ent') or 0):
                    val_grado_ent = liq['val_grado_ent']
                elif 'val_grado_ent' in self.datos:
                    val_grado_ent = self.datos.get('val_grado_ent')
                elif cod_grano in datos.GRADO_ENT_VALOR: 
                    valores = datos.GRADO_ENT_VALOR[cod_grano]
                    if cod_grado_ent in valores:
                        val_grado_ent = valores[cod_grado_ent]
                    else:
                        val_grado_ent = ""
                else:
                    val_grado_ent = ""
                f.set("valor_grado_ent", "%s %s" % (cod_grado_ent or "", val_grado_ent or ""))
                f.set("cont_proteico", liq.get('cont_proteico', self.datos.get('cont_proteico', "")))
                
                if liq.get('certificados'):
                    # uso la procedencia del certificado de depósito 
                    cert = liq['certificados'][0]
                    localidad, provincia = buscar_localidad_provincia(
                        cert['cod_prov_procedencia'],
                        cert['cod_localidad_procedencia'])
                elif liq.get('cod_prov_procedencia_sin_certificado'):
                    localidad, provincia = buscar_localidad_provincia(
                        liq['cod_prov_procedencia_sin_certificado'], 
                        liq['cod_localidad_procedencia_sin_certificado'])
                else:
                    localidad, provincia = "", ""
    
                f.set("procedencia", "%s - %s" % (localidad, provincia))
                
                # si no se especifíca, uso la procedencia para el lugar
                if not self.datos.get('lugar_y_fecha'):
                    localidad, provincia = buscar_localidad_provincia(
                        liq['cod_prov_procedencia'], 
                        liq['cod_localidad_procedencia'])
                    lugar = "%s - %s " % (localidad, provincia)
                    fecha = datetime.datetime.today().strftime("%d/%m/%Y")
                    f.set("lugar_y_fecha", "%s, %s" % (fecha, lugar))
                    if 'lugar_y_fecha' in self.datos:
                        del self.datos['lugar_y_fecha']

                if HOMO:
                    homo = "(pruebas)"
                else:
                    homo = ""
                
                if int(liq['cod_tipo_operacion'] or 0) == 1: 
                    f.set("comprador.L", "COMPRADOR:")
                    f.set("vendedor.L", "VENDEDOR:")
                    f.set("formulario", u"Form. Electrónico 1116 B %s" % homo)
                else:
                    f.set("comprador.L", "MANDATARIO/CONSIGNATARIO:")
                    f.set("vendedor.L", "MANDANTE/COMITENTE:")
                    f.set("formulario", u"Form. Electrónico 1116 C %s" % homo)
                
                if int(liq.get("coe_ajustado") or 0) or int(liq.get("nro_contrato") or 0):
                    f.set("formulario", u"Ajuste Unificado %s" % homo)

                certs = []
                for cert in liq.get('certificados', []):
                    certs.append(u"%s Nº %s" % (
                        datos.TIPO_CERT_DEP[int(cert['tipo_certificado_deposito'])],
                        cert['nro_certificado_deposito']))
                f.set("certificados_deposito", ', '.join(certs))

                for i, deduccion in enumerate(liq.get('deducciones', [])):
                    for k, v in deduccion.items():
                        v = formatear(k, v, fmt_deduccion)
                        f.set("deducciones_%s_%02d" % (k, i + 1), v)

                for i, retencion in enumerate(liq.get('retenciones', [])):
                    for k, v in retencion.items():
                        v = formatear(k, v, fmt_retencion)
                        f.set("retenciones_%s_%02d" % (k, i + 1), v)
                    if retencion['importe_certificado_retencion']:
                        d = retencion['fecha_certificado_retencion']
                        f.set('retenciones_cert_retencion_%02d' % (i + 1),
                            "%s $ %0.2f %s" % (
                                retencion['nro_certificado_retencion'] or '',
                                retencion['importe_certificado_retencion'],
                                "%s/%s/%s" % (d[8:10], d[5:7], d[2:4]), 
                            ))

                # cargo campos adicionales ([PDF] en .ini y AgregarDatoPDF)
                for k,v in self.datos.items():
                    f.set(k, v)
                
                # Ajustes:
                
                if clave:
                    f.set('subtipo_ajuste', {'ajuste_debito': u'AJUSTE DÉBITO',
                           'ajuste_credito': u'AJUSTE CRÉDITO'}[clave])
                
                if int(liq.get('coe_ajustado') or 0):
                    f.set("leyenda_coe_nro", "COE Ajustado:")
                    f.set("nro_contrato_o_coe_ajustado", liq['coe_ajustado'])
                    f.set("coe_relacionados.L", "")
                    f.set("coe_relacionados", "")
                elif liq.get('nro_contrato'):
                    f.set("leyenda_coe_nro", "Contrato Ajustado:")
                    f.set("nro_contrato_o_coe_ajustado", liq['nro_contrato'])
                    ##f.set("coe_relacionados", TODO)
                    
            return True
        except Exception, e:
            ex = utils.exception_info()
            try:
                f.set('anulado', "%(name)s:%(lineno)s" % ex)
            except:
                pass
            self.Excepcion = ex['msg']
            self.Traceback = ex['tb']
            if DEBUG:
                print self.Excepcion
                print self.Traceback
            return False
706766
def ConsultarCertificacion(self, pto_emision=None, nro_orden=None, 
                                     coe=None, pdf=None):
        ""
        if coe:
            ret = self.client.cgConsultarXCoe(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        pdf='S' if pdf else 'N',
                        )
        else:
            ret = self.client.cgConsultarXNroOrden(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        ptoEmision=pto_emision,
                        nroOrden=nro_orden,
                        )
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        if 'autorizacion' in ret:
            self.AnalizarAutorizarCertificadoResp(ret)
        # guardo el PDF si se indico archivo y vino en la respuesta:
        if pdf and 'pdf' in ret:
            open(pdf, "wb").write(ret['pdf'])
        return True
291256
def ConsultarBonificacionesPenalizaciones(self, sep="||"):
        ""
        ret = self.client.consultarBonificacionesPenalizaciones(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        self.XmlResponse = self.client.xml_response
        array = ret.get('tipo', [])
        if sep is None:
            # sin separador, devuelve un diccionario con clave cod_variadedad
            # y valor: {"descripcion": ds_variedad, "clases": lista_clases}
            # siendo lista_clases = [{'codigo': ..., 'descripcion': ...}]
            return dict([(it['codigo'], {'descripcion': it['descripcion'], 
                                         'subtipo': it['subtipo']}) 
                         for it in array])
        else:
            # con separador, devuelve una lista de strings:
            # || cod.variedad || desc.variedad || desc.clase || cod.clase ||
            ret = []
            for it in array:
                for subtipo in it['subtipo']:
                    ret.append(
                        ("%s %%s %s %%s %s %%s %s %%s %s %%s %s %%s %s" % 
                            (sep, sep, sep, sep, sep, sep, sep)) %
                        (it['codigo'], it['descripcion'], 
                         subtipo['descripcion'], subtipo['codigo'],
                         subtipo['valor'], subtipo['signo']) 
                        )
            return ret
891254
def ConsultarTipoDeduccion(self, sep="||"):
        ""
        ret = self.client.tipoDeduccionConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoDeduccionReturn']
        self.__analizar_errores(ret)
        array = ret.get('tiposDeduccion', [])
        return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
502009
def ConsultarAjuste(self, pto_emision=None, nro_orden=None, nro_contrato=None,
                              coe=None, pdf=None):
        ""
        if nro_contrato:
            ret = self.client.ajustePorContratoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        nroContrato=nro_contrato,
                        )
            ret = ret['ajusteContratoReturn']
        elif coe is None or pdf is None:
            ret = self.client.ajusteXNroOrdenConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        ptoEmision=pto_emision,
                        nroOrden=nro_orden,
                        pdf='S' if pdf else 'N',
                        )
            ret = ret['ajusteXNroOrdenConsReturn']
        else:
            ret = self.client.ajusteXCoeConsultar(
                       auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        pdf='S' if pdf else 'N',
                        )
            ret = ret['ajusteConsReturn']

        self.__analizar_errores(ret)
        if 'ajusteUnificado' in ret:
            aut = ret['ajusteUnificado']
            self.AnalizarAjuste(aut)
        # guardo el PDF si se indico archivo y vino en la respuesta:
        if pdf and 'pdf' in ret:
            open(pdf, "wb").write(ret['pdf'])
        return True
205336
def AgregarAjusteFisico(self, cantidad, cantidad_cabezas=None, 
                            cantidad_kg_vivo=None, **kwargs):
        ""
        d = {'cantidad': cantidad,
             'cantidadCabezas': cantidad_cabezas, 
             'cantidadKgVivo': cantidad_kg_vivo, 
            }
        item_liq = self.solicitud['itemDetalleAjusteLiquidacion'][-1]
        item_liq['ajusteFisico'] = d
        return True
320183
def AnularCertificacion(self, coe):
        ""
        ret = self.client.cgSolicitarAnulacion(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        )
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        self.Estado = ret.get('estadoCertificado', "")
        return self.COE
578023
def ConsultarCTGActivosPorPatente(self, patente="ZZZ999"):
        ""
        ret = self.client.consultarCTGActivosPorPatente(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        patente=patente,
                            ))['response']
        self.__analizar_errores(ret)
        datos = ret.get('arrayConsultarCTGActivosPorPatenteResponse')
        if datos:
            self.DatosCTG = datos
            self.LeerDatosCTG(pop=False)
            return True
        else:
            self.DatosCTG = []
        return False
953459
def Consultar(self, nro_doc):
        ""
        n = 0
        while n <= 4:
            n += 1                          # reintentar 3 veces
            try:
                if not self.client:
                    if DEBUG:
                        warnings.warn("reconectando intento [%d]..." % n)
                    self.Conectar()
                self.response = self.client("sr-padron", "v2", "persona", str(nro_doc))
            except Exception as e:
                self.client = None
                ex = exception_info()
                self.Traceback = ex.get("tb", "")
                try:
                    self.Excepcion = norm(ex.get("msg", "").replace("\n", ""))
                except:
                    self.Excepcion = "<no disponible>"
                if DEBUG:
                    warnings.warn("Error %s [%d]" % (self.Excepcion, n))
            else:
                break
        else:
            return False
        result = json.loads(self.response)
        if result['success']:
            data = result['data']
            # extraigo datos generales del contribuyente:
            self.cuit = data["idPersona"]
            self.tipo_persona = data["tipoPersona"]
            self.tipo_doc = TIPO_CLAVE.get(data["tipoClave"])
            self.dni = data.get("numeroDocumento")
            self.estado = data.get("estadoClave")
            self.denominacion = data.get("nombre")
            # analizo el domicilio
            domicilio = data.get("domicilioFiscal")
            if domicilio:
                self.direccion = domicilio.get("direccion", "")
                self.localidad = domicilio.get("localidad", "")  # no usado en CABA
                self.provincia = PROVINCIAS.get(domicilio.get("idProvincia"), "")
                self.cod_postal = domicilio.get("codPostal")
            else:
                self.direccion = self.localidad = self.provincia = ""
                self.cod_postal = ""
            # retrocompatibilidad:
            self.domicilios = ["%s - %s (%s) - %s" % (
                                    self.direccion, self.localidad, 
                                    self.cod_postal, self.provincia,) ]
            # analizo impuestos:
            self.impuestos = data.get("impuestos", [])
            self.actividades = data.get("actividades", [])
            if 32 in self.impuestos:
                self.imp_iva = "EX"
            elif 33 in self.impuestos:
                self.imp_iva = "NI"
            elif 34 in self.impuestos:
                self.imp_iva = "NA"
            else:
                self.imp_iva = "S" if 30 in self.impuestos else "N"
            mt = data.get("categoriasMonotributo", {})
            self.monotributo = "S" if mt else "N"
            self.actividad_monotributo = "" # TODO: mt[0].get("idCategoria")
            self.integrante_soc = ""
            self.empleador = "S" if 301 in self.impuestos else "N"
            self.cat_iva = ""
            self.data = data
        else:
            error = result['error']
            self.Excepcion = error['mensaje']
        return True
881686
def ConsultarDepositosAcopio(self, sep="||"):
        ""
        ret = self.client.consultarDepositosAcopio(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('acopio', [])
        if sep is None:
            return array
        else:
            return [("%s %%s %s %%s %s %%s %s %%s %s" % (sep, sep, sep, sep, sep)) %
                    (it['codigo'], it['direccion'], it['localidad'], it['codigoPostal']) 
                    for it in array]
486697
def AnularLiquidacion(self, coe):
        ""
        ret = self.client.liquidacionAnular(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        coe=coe,
                        )
        ret = ret['anulacionReturn']
        self.__analizar_errores(ret)
        self.Resultado = ret['resultado']
        return self.COE
718864
def build_request_consulta_transacao_completa numero_transacao
      # Montar os parâmetros para consulta
      params = {
        consulta_transacao_w_s: {
          codigo_estabelecimento: SuperpayApi.estabelecimento,
          numero_transacao: numero_transacao,
        }
      }
      # Adiciona as configurações de login
      params.merge! SuperpayApi.login
    end