Consulta un ajuste de liquidación por No de orden o numero de contrato
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
363568
def AgregarCondicionVenta(self, codigo, descripcion=None, **kwargs):
        ""
        cond = {'codigo': codigo, 'descripcion': descripcion}
        self.solicitud['liquidacion']['condicionVenta'].append(cond)
        return True
316092
def ConfirmarDefinitivo(self, numero_carta_de_porte, numero_ctg, 
                            establecimiento=None, codigo_cosecha=None, peso_neto_carga=None, 
                            **kwargs):
        ""
        ret = self.client.confirmarDefinitivo(request=dict(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuitRepresentado': self.Cuit, },
                        datosConfirmarDefinitivo=dict(
                            cartaPorte=numero_carta_de_porte, 
                            ctg=numero_ctg,
                            establecimiento=establecimiento,
                            codigoCosecha=codigo_cosecha,
                            pesoNeto=peso_neto_carga,
                            )))['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.get('codigoOperacion', ""))
            self.Observaciones = ""
        return self.CodigoTransaccion
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
1310831
def Buscar(self, nro_doc, tipo_doc=80):
        ""
        # cuit: codigo único de identificación tributaria del contribuyente
        #       (sin guiones)
        self.cursor.execute("SELECT * FROM padron WHERE "
                            " tipo_doc=? AND nro_doc=?", [tipo_doc, nro_doc])
        row = self.cursor.fetchone()
        for key in [k for k, l, t, d in FORMATO]:
            if row:
                val = row[key]
                if not isinstance(val, basestring):
                    val = str(row[key])
                setattr(self, key, val)
            else:
                setattr(self, key, '')
        if self.tipo_doc == 80:
            self.cuit = self.nro_doc
        elif self.tipo_doc == 96:
            self.dni = self.nro_doc
        # determinar categoría de IVA (tentativa)
        try:
            cat_iva = int(self.cat_iva)
        except ValueError:
            cat_iva = None
        if cat_iva:
            pass
        elif self.imp_iva in ('AC', 'S'):
            self.cat_iva = 1  # RI
        elif self.imp_iva == 'EX':
            self.cat_iva = 4  # EX
        elif self.monotributo:
            self.cat_iva = 6  # MT
        else:
            self.cat_iva = 5  # CF
        return True if row else False
1031222
def AnalizarLiquidacion(self, aut, liq=None, ajuste=False):
        ""
        # proceso los datos básicos de la liquidación (devuelto por consultar):
        if liq:
            self.params_out = dict(
                        pto_emision=liq.get('ptoEmision'),
                        nro_orden=liq.get('nroOrden'),
                        cuit_comprador=liq.get('cuitComprador'),
                        nro_act_comprador=liq.get('nroActComprador'),
                        nro_ing_bruto_comprador=liq.get('nroIngBrutoComprador'),
                        cod_tipo_operacion=liq.get('codTipoOperacion'),
                        es_liquidacion_propia=liq.get('esLiquidacionPropia'),
                        es_canje=liq.get('esCanje'),
                        cod_puerto=liq.get('codPuerto'),
                        des_puerto_localidad=liq.get('desPuertoLocalidad'),
                        cod_grano=liq.get('codGrano'),
                        cuit_vendedor=liq.get('cuitVendedor'),
                        nro_ing_bruto_vendedor=liq.get('nroIngBrutoVendedor'),
                        actua_corredor=liq.get('actuaCorredor'),
                        liquida_corredor=liq.get('liquidaCorredor'),
                        cuit_corredor=liq.get('cuitCorredor'),
                        comision_corredor=liq.get('comisionCorredor'),
                        nro_ing_bruto_corredor=liq.get('nroIngBrutoCorredor'),
                        fecha_precio_operacion=liq.get('fechaPrecioOperacion'),
                        precio_ref_tn=liq.get('precioRefTn'),
                        cod_grado_ref=liq.get('codGradoRef'),
                        cod_grado_ent=liq.get('codGradoEnt'),
                        factor_ent=liq.get('factorEnt'),
                        precio_flete_tn=liq.get('precioFleteTn'),
                        cont_proteico=liq.get('contProteico'),
                        alic_iva_operacion=liq.get('alicIvaOperacion'),
                        campania_ppal=liq.get('campaniaPPal'),
                        cod_localidad_procedencia=liq.get('codLocalidadProcedencia'),
                        cod_prov_procedencia=liq.get('codProvProcedencia'),
                        datos_adicionales=liq.get('datosAdicionales'),
                        peso_neto_sin_certificado=liq.get('pesoNetoSinCertificado'),
                        cod_localidad_procedencia_sin_certificado=liq.get('codLocalidadProcedenciaSinCertificado'),
                        cod_prov_procedencia_sin_certificado=liq.get('codProvProcedenciaSinCertificado'),
                        certificados=[],
                    )
            if ajuste:
                self.params_out.update(
                        # ajustes:
                        diferencia_peso_neto=liq.get('diferenciaPesoNeto'),
                        diferencia_precio_operacion=liq.get('diferenciaPrecioOperacion'),
                        cod_grado=liq.get('codGrado'),
                        val_grado=liq.get('valGrado'),
                        factor=liq.get('factor'),
                        diferencia_precio_flete_tn=liq.get('diferenciaPrecioFleteTn'),
                        concepto_importe_iva_0=liq.get('conceptoImporteIva0'),
                        importe_ajustar_iva_0=liq.get('importeAjustarIva0'),
                        concepto_importe_iva_105=liq.get('conceptoImporteIva105'),
                        importe_ajustar_iva_105=liq.get('importeAjustarIva105'),
                        concepto_importe_iva_21=liq.get('conceptoImporteIva21'),
                        importe_ajustar_iva_21=liq.get('importeAjustarIva21'),
                    )
                # analizar detalle de importes ajustados discriminados por alicuota
                # (por compatibildiad y consistencia se usan los mismos campos)
                for it in liq.get("importes", liq.get("importe")):
                    # en ajustes LSG no se agrupan los importes en un subtipo...
                    if 'importeReturn' in it:
                        it = it['importeReturn'][0]     # TODO: revisar SOAP
                    tasa = "iva_%s" % str(it['alicuota']).replace(".", "").strip()
                    self.params_out["concepto_importe_%s" % tasa] = it['concepto']
                    self.params_out["importe_ajustar_%s" % tasa] = it['importe']
                    self.params_out["iva_calculado_%s" % tasa] = it['ivaCalculado']
            if 'certificados' in liq:
                for c in liq['certificados']:
                    cert = c['certificado']
                    self.params_out['certificados'].append(dict(
                        tipo_certificado_deposito=cert['tipoCertificadoDeposito'],
                        nro_certificado_deposito=cert['nroCertificadoDeposito'],
                        peso_neto=cert['pesoNeto'],
                        cod_localidad_procedencia=cert['codLocalidadProcedencia'],
                        cod_prov_procedencia=cert['codProvProcedencia'],
                        campania=cert['campania'],
                        fecha_cierre=cert['fechaCierre'],
                    ))

        self.params_out['errores'] = self.errores
            
        # proceso la respuesta de autorizar, ajustar (y consultar):
        if aut:
            self.TotalDeduccion = aut.get('totalDeduccion')
            self.TotalRetencion = aut.get('totalRetencion')
            self.TotalRetencionAfip = aut.get('totalRetencionAfip')
            self.TotalOtrasRetenciones = aut.get('totalOtrasRetenciones')
            self.TotalNetoAPagar = aut.get('totalNetoAPagar')
            self.TotalIvaRg4310_18 = aut.get('totalIvaRg4310_18')
            self.TotalPagoSegunCondicion = aut.get('totalPagoSegunCondicion')
            self.COE = str(aut.get('coe', ''))
            self.COEAjustado = aut.get('coeAjustado')
            self.Estado = aut.get('estado', '')
            self.NroContrato = aut.get('numeroContrato', '')

            # actualizo parámetros de salida:
            self.params_out['coe'] = self.COE
            self.params_out['coe_ajustado'] = self.COEAjustado
            self.params_out['estado'] = self.Estado
            self.params_out['total_deduccion'] = self.TotalDeduccion
            self.params_out['total_retencion'] = self.TotalRetencion
            self.params_out['total_retencion_afip'] = self.TotalRetencionAfip
            self.params_out['total_otras_retenciones'] = self.TotalOtrasRetenciones
            self.params_out['total_neto_a_pagar'] = self.TotalNetoAPagar
            self.params_out['total_iva_rg_4310_18'] = self.TotalIvaRg4310_18
            self.params_out['total_pago_segun_condicion'] = self.TotalPagoSegunCondicion

            # datos adicionales:
            self.NroOrden = self.params_out['nro_orden'] = aut.get('nroOrden')
            self.params_out['cod_tipo_ajuste'] = aut.get('codTipoAjuste')
            fecha = aut.get('fechaLiquidacion')
            if fecha:
                fecha = str(fecha)
            self.params_out['fecha_liquidacion'] = fecha
            self.params_out['importe_iva'] = aut.get('importeIva')
            self.params_out['nro_op_comercial'] = aut.get('nroOpComercial')
            self.params_out['operacion_con_iva'] = aut.get('operacionConIva')
            self.params_out['precio_operacion'] = aut.get('precioOperacion')
            self.params_out['total_peso_neto'] = aut.get('totalPesoNeto')
            self.params_out['subtotal'] = aut.get('subTotal')
            # LSG (especificos):
            self.params_out['total_deducciones'] = aut.get('totalDeducciones')
            if 'todalPercepciones' in aut:
                # error de tipeo en el WSDL de AFIP...
                self.params_out['total_percepciones'] = aut.get('todalPercepciones')
            else:
                self.params_out['total_percepciones'] = aut.get('totalPercepciones')
            # sub estructuras:
            self.params_out['retenciones'] = []
            self.params_out['deducciones'] = []
            self.params_out['percepciones'] = []
            for retret in aut.get("retenciones", []):
                retret = retret['retencionReturn']
                self.params_out['retenciones'].append({
                    'importe_retencion': retret['importeRetencion'],
                    'alicuota': retret['retencion'].get('alicuota'),
                    'base_calculo': retret['retencion'].get('baseCalculo'),
                    'codigo_concepto': retret['retencion'].get('codigoConcepto'),
                    'detalle_aclaratorio': (retret['retencion'].get('detalleAclaratorio') or "").replace("\n", ""),
                    'importe_certificado_retencion': retret['retencion'].get('importeCertificadoRetencion'),
                    'nro_certificado_retencion': retret['retencion'].get('nroCertificadoRetencion'),
                    'fecha_certificado_retencion': retret['retencion'].get('fechaCertificadoRetencion'),
                    })
            for dedret in aut.get("deducciones", []):
                dedret = dedret['deduccionReturn']
                self.params_out['deducciones'].append({
                    'importe_deduccion': dedret['importeDeduccion'],
                    'importe_iva': dedret.get('importeIva'),
                     'alicuota': dedret['deduccion'].get('alicuotaIva'),
                     'base_calculo': dedret['deduccion'].get('baseCalculo'),
                     'codigo_concepto': dedret['deduccion'].get('codigoConcepto'),
                     'detalle_aclaratorio': dedret['deduccion'].get('detalleAclaratorio', "").replace("\n", ""),
                     'dias_almacenaje': dedret['deduccion'].get('diasAlmacenaje'),
                     'precio_pkg_diario': dedret['deduccion'].get('precioPKGdiario'),
                     'comision_gastos_adm': dedret['deduccion'].get('comisionGastosAdm'),
                    })
            for perret in aut.get("percepciones", []):
                perret = perret.get('percepcionReturn', perret)
                self.params_out['percepciones'].append({
                     'importe_final': perret['percepcion']['importeFinal'],
                     'alicuota': perret['percepcion'].get('alicuota'),
                     'base_calculo': perret['percepcion'].get('baseCalculo'),
                     'descripcion': perret['percepcion'].get('descripcion', "").replace("\n", ""),
                    })
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
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
1296021
def AutorizarLiquidacionSecundaria(self):
        ""

        # extraer y adaptar los campos para liq. sec.
        if self.deducciones:
            self.liquidacion['deduccion'] = []
            for it in self.deducciones:
                ded = it['deduccion']                  # no se agrupa
                self.liquidacion['deduccion'].append({
                    'detalleAclaratoria': ded['detalleAclaratorio'],
                    'baseCalculo': ded['baseCalculo'], 
                    'alicuotaIVA': ded['alicuotaIva']})
        if self.percepciones:
            self.liquidacion['percepcion'] = []
            for it in self.percepciones:
                per = it['percepcion']                  # no se agrupa
                self.liquidacion['percepcion'].append(per)
        if self.opcionales:
            self.liquidacion['opcionales'] = self.opcionales    # agrupado ok
        
        # llamo al webservice:
        ret = self.client.lsgAutorizar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        liqSecundariaBase=self.liquidacion,
                        facturaPapel=self.factura_papel,
                        )

        # analizo la respusta
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        self.AnalizarLiquidacion(ret.get('autorizacion'), self.liquidacion)
        return True
665256
def ConsultarTiposEstado(self, sep="||"):
        ""
        ret = self.client.consultarTiposEstado(
                            authRequest={
                                'token': self.Token, 'sign': self.Sign,
                                'cuitRepresentada': self.Cuit, },
                                )['consultarTiposEstadoReturn']
        self.__analizar_errores(ret)
        array = ret.get('arrayTiposEstado', [])
        lista = [it['codigoDescripcionString'] for it in array]
        return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista]
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
472336
public function getCodigoNome()
    {
        $codigo = $this->getCodigo();

        if (\Cnab\Banco::BRADESCO == $this->_codigo_banco) {
            if (2 == $codigo) {
                return 'Entrada Confirmada';
            } elseif (3 == $codigo) {
                return 'Entrada Rejeitada';
            } elseif (6 == $codigo) {
                return 'Liquidação normal';
            } elseif (9 == $codigo) {
                return 'Baixado Automat. via Arquivo';
            } elseif (10 == $codigo) {
                return 'Baixado conforme instruções da Agência';
            } elseif (11 == $codigo) {
                return 'Em Ser - Arquivo de Títulos pendentes';
            } elseif (12 == $codigo) {
                return 'Abatimento Concedido';
            } elseif (13 == $codigo) {
                return 'Abatimento Cancelado';
            } elseif (14 == $codigo) {
                return 'Vencimento Alterado';
            } elseif (15 == $codigo) {
                return 'Liquidação em Cartório';
            } elseif (16 == $codigo) {
                return 'Título Pago em Cheque – Vinculado';
            } elseif (17 == $codigo) {
                return 'Liquidação após baixa ou Título não registrado';
            } elseif (18 == $codigo) {
                return 'Acerto de Depositária (sem motivo)';
            } elseif (19 == $codigo) {
                return 'Confirmação Receb. Inst. de Protesto';
            } elseif (20 == $codigo) {
                return 'Confirmação Recebimento Instrução Sustação de Protesto';
            } elseif (21 == $codigo) {
                return 'Acerto do Controle do Participante';
            } elseif (22 == $codigo) {
                return 'Título Com Pagamento Cancelado';
            } elseif (23 == $codigo) {
                return 'Entrada do Título em Cartório';
            } elseif (24 == $codigo) {
                return 'Entrada rejeitada por CEP Irregular';
            } elseif (27 == $codigo) {
                return 'Baixa Rejeitada';
            } elseif (28 == $codigo) {
                return 'Débito de tarifas/custas';
            } elseif (30 == $codigo) {
                return 'Alteração de Outros Dados Rejeitados';
            } elseif (32 == $codigo) {
                return 'Instrução Rejeitada';
            } elseif (33 == $codigo) {
                return 'Confirmação Pedido Alteração Outros Dados';
            } elseif (34 == $codigo) {
                return 'Retirado de Cartório e Manutenção Carteira';
            } elseif (35 == $codigo) {
                return 'Desagendamento do débito automático';
            } elseif (40 == $codigo) {
                return 'Estorno de pagamento';
            } elseif (55 == $codigo) {
                return 'Sustado judicial';
            } elseif (68 == $codigo) {
                return 'Acerto dos dados do rateio de Crédito';
            } elseif (69 == $codigo) {
                return 'Cancelamento dos dados do rateio';
            }
        } elseif (\Cnab\Banco::CEF == $this->_codigo_banco) {
            if (1 == $codigo) {
                return 'Entrada Confirmada';
            } elseif (2 == $codigo) {
                return 'Baixa Confirmada';
            } elseif (3 == $codigo) {
                return 'Abatimento Concedido';
            } elseif (4 == $codigo) {
                return 'Abatimento Cancelado';
            } elseif (5 == $codigo) {
                return 'Vencimento Alterado';
            } elseif (6 == $codigo) {
                return 'Uso da Empresa Alterado';
            } elseif (7 == $codigo) {
                return 'Prazo de Protesto Alterado';
            } elseif (8 == $codigo) {
                return 'Prazo de Devolução Alterado';
            } elseif (9 == $codigo) {
                return 'Alteração Confirmada';
            } elseif (10 == $codigo) {
                return 'Alteração com Reemissão de Bloqueto Confirmada';
            } elseif (11 == $codigo) {
                return 'Alteração da Opção de Protesto para Devolução';
            } elseif (12 == $codigo) {
                return 'Alteração da Opção de Devolução para protesto';
            } elseif (20 == $codigo) {
                return 'Em Ser';
            } elseif (21 == $codigo) {
                return 'Liquidação';
            } elseif (22 == $codigo) {
                return 'Liquidação em Cartório';
            } elseif (23 == $codigo) {
                return 'Baixa por Devolução';
            } elseif (24 == $codigo) {
                return 'Baixa por Franco Pagamento';
            } elseif (25 == $codigo) {
                return 'Baixa por Protesto';
            } elseif (26 == $codigo) {
                return 'Título enviado para Cartório';
            } elseif (27 == $codigo) {
                return 'Sustação de Protesto';
            } elseif (28 == $codigo) {
                return 'Estorno de Protesto';
            } elseif (29 == $codigo) {
                return 'Estorno de Sustação de Protesto';
            } elseif (30 == $codigo) {
                return 'Alteração de Título';
            } elseif (31 == $codigo) {
                return 'Tarifa sobre Título Vencido';
            } elseif (32 == $codigo) {
                return 'Outras Tarifas de Alteração';
            } elseif (33 == $codigo) {
                return 'Estorno de Baixa/Liquidação';
            } elseif (34 == $codigo) {
                return 'Transferência de Carteira/Entrada';
            } elseif (35 == $codigo) {
                return 'Transferência de Carteira/Baixa';
            } elseif (99 == $codigo) {
                return 'Rejeição do Título – Cód. Rejeição informado nas POS 80 a 82';
            }
        } else {
            if ($codigo == 2) {
                return 'ENTRADA CONFIRMADA COM POSSIBILIDADE DE MENSAGEM (NOTA 20 – TABELA 10) ';
            } elseif ($codigo == 3) {
                return 'ENTRADA REJEITADA (NOTA 20 - TABELA 1)';
            } elseif ($codigo == 4) {
                return 'ALTERAÇÃO DE DADOS - NOVA ENTRADA OU ALTERAÇÃO/EXCLUSÃO DE DADOS ACATADA ';
            } elseif ($codigo == 5) {
                return 'ALTERAÇÃO DE DADOS – BAIXA';
            } elseif ($codigo == 6) {
                return 'LIQUIDAÇÃO NORMAL';
            } elseif ($codigo == 7) {
                return 'LIQUIDAÇÃO PARCIAL – COBRANÇA INTELIGENTE (B2B)';
            } elseif ($codigo == 8) {
                return 'LIQUIDAÇÃO EM CARTÓRIO ';
            } elseif ($codigo == 9) {
                return 'BAIXA SIMPLES';
            } elseif ($codigo == 10) {
                return 'BAIXA POR TER SIDO LIQUIDADO ';
            } elseif ($codigo == 11) {
                return 'EM SER (SÓ NO RETORNO MENSAL)';
            } elseif ($codigo == 12) {
                return 'ABATIMENTO CONCEDIDO ';
            } elseif ($codigo == 13) {
                return 'ABATIMENTO CANCELADO';
            } elseif ($codigo == 14) {
                return 'VENCIMENTO ALTERADO ';
            } elseif ($codigo == 15) {
                return 'BAIXAS REJEITADAS (NOTA 20 - TABELA 4)';
            } elseif ($codigo == 16) {
                return 'INSTRUÇÕES REJEITADAS (NOTA 20 - TABELA 3) ';
            } elseif ($codigo == 17) {
                return 'ALTERAÇÃO/EXCLUSÃO DE DADOS REJEITADOS (NOTA 20 - TABELA 2)';
            } elseif ($codigo == 18) {
                return 'COBRANÇA CONTRATUAL - INSTRUÇÕES/ALTERAÇÕES REJEITADAS/PENDENTES (NOTA 20 - TABELA 5) ';
            } elseif ($codigo == 19) {
                return 'CONFIRMA RECEBIMENTO DE INSTRUÇÃO DE PROTESTO';
            } elseif ($codigo == 20) {
                return 'CONFIRMA RECEBIMENTO DE INSTRUÇÃO DE SUSTAÇÃO DE PROTESTO /TARIFA';
            } elseif ($codigo == 21) {
                return 'CONFIRMA RECEBIMENTO DE INSTRUÇÃO DE NÃO PROTESTAR';
            } elseif ($codigo == 23) {
                return 'TÍTULO ENVIADO A CARTÓRIO/TARIFA';
            } elseif ($codigo == 24) {
                return 'INSTRUÇÃO DE PROTESTO REJEITADA / SUSTADA / PENDENTE (NOTA 20 - TABELA 7)';
            } elseif ($codigo == 25) {
                return 'ALEGAÇÕES DO SACADO (NOTA 20 - TABELA 6)';
            } elseif ($codigo == 26) {
                return 'TARIFA DE AVISO DE COBRANÇA';
            } elseif ($codigo == 27) {
                return 'TARIFA DE EXTRATO POSIÇÃO (B40X)';
            } elseif ($codigo == 28) {
                return 'TARIFA DE RELAÇÃO DAS LIQUIDAÇÕES';
            } elseif ($codigo == 29) {
                return 'TARIFA DE MANUTENÇÃO DE TÍTULOS VENCIDOS';
            } elseif ($codigo == 30) {
                return 'DÉBITO MENSAL DE TARIFAS (PARA ENTRADAS E BAIXAS)';
            } elseif ($codigo == 32) {
                return 'BAIXA POR TER SIDO PROTESTADO';
            } elseif ($codigo == 33) {
                return 'CUSTAS DE PROTESTO';
            } elseif ($codigo == 34) {
                return 'CUSTAS DE SUSTAÇÃO';
            } elseif ($codigo == 35) {
                return 'CUSTAS DE CARTÓRIO DISTRIBUIDOR';
            } elseif ($codigo == 36) {
                return 'CUSTAS DE EDITAL';
            } elseif ($codigo == 37) {
                return 'TARIFA DE EMISSÃO DE BOLETO/TARIFA DE ENVIO DE DUPLICATA';
            } elseif ($codigo == 38) {
                return 'TARIFA DE INSTRUÇÃO';
            } elseif ($codigo == 39) {
                return 'TARIFA DE OCORRÊNCIAS';
            } elseif ($codigo == 40) {
                return 'TARIFA MENSAL DE EMISSÃO DE BOLETO/TARIFA MENSAL DE ENVIO DE DUPLICATA';
            } elseif ($codigo == 41) {
                return 'DÉBITO MENSAL DE TARIFAS – EXTRATO DE POSIÇÃO (B4EP/B4OX)';
            } elseif ($codigo == 42) {
                return 'DÉBITO MENSAL DE TARIFAS – OUTRAS INSTRUÇÕES';
            } elseif ($codigo == 43) {
                return 'DÉBITO MENSAL DE TARIFAS – MANUTENÇÃO DE TÍTULOS VENCIDOS';
            } elseif ($codigo == 44) {
                return 'DÉBITO MENSAL DE TARIFAS – OUTRAS OCORRÊNCIAS';
            } elseif ($codigo == 45) {
                return 'DÉBITO MENSAL DE TARIFAS – PROTESTO';
            } elseif ($codigo == 46) {
                return 'DÉBITO MENSAL DE TARIFAS – SUSTAÇÃO DE PROTESTO';
            } elseif ($codigo == 47) {
                return 'BAIXA COM TRANSFERÊNCIA PARA DESCONTO';
            } elseif ($codigo == 48) {
                return 'CUSTAS DE SUSTAÇÃO JUDICIAL';
            } elseif ($codigo == 51) {
                return 'TARIFA MENSAL REF A ENTRADAS BANCOS CORRESPONDENTES NA CARTEIRA';
            } elseif ($codigo == 52) {
                return 'TARIFA MENSAL BAIXAS NA CARTEIRA';
            } elseif ($codigo == 53) {
                return 'TARIFA MENSAL BAIXAS EM BANCOS CORRESPONDENTES NA CARTEIRA';
            } elseif ($codigo == 54) {
                return 'TARIFA MENSAL DE LIQUIDAÇÕES NA CARTEIRA';
            } elseif ($codigo == 55) {
                return 'TARIFA MENSAL DE LIQUIDAÇÕES EM BANCOS CORRESPONDENTES NA CARTEIRA';
            } elseif ($codigo == 56) {
                return 'CUSTAS DE IRREGULARIDADE';
            } elseif ($codigo == 57) {
                return 'INSTRUÇÃO CANCELADA (NOTA 20 – TABELA 8)';
            } elseif ($codigo == 59) {
                return 'BAIXA POR CRÉDITO EM C/C ATRAVÉS DO SISPAG';
            } elseif ($codigo == 60) {
                return 'ENTRADA REJEITADA CARNÊ (NOTA 20 – TABELA 1)';
            } elseif ($codigo == 61) {
                return 'TARIFA EMISSÃO AVISO DE MOVIMENTAÇÃO DE TÍTULOS (2154)';
            } elseif ($codigo == 62) {
                return 'DÉBITO MENSAL DE TARIFA - AVISO DE MOVIMENTAÇÃO DE TÍTULOS (2154)';
            } elseif ($codigo == 63) {
                return 'TÍTULO SUSTADO JUDICIALMENTE';
            } elseif ($codigo == 64) {
                return 'ENTRADA CONFIRMADA COM RATEIO DE CRÉDITO';
            } elseif ($codigo == 69) {
                return 'CHEQUE DEVOLVIDO (NOTA 20 - TABELA 9)';
            } elseif ($codigo == 71) {
                return 'ENTRADA REGISTRADA, AGUARDANDO AVALIAÇÃO';
            } elseif ($codigo == 72) {
                return 'BAIXA POR CRÉDITO EM C/C ATRAVÉS DO SISPAG SEM TÍTULO CORRESPONDENTE';
            } elseif ($codigo == 73) {
                return 'CONFIRMAÇÃO DE ENTRADA NA COBRANÇA SIMPLES – ENTRADA NÃO ACEITA NA COBRANÇA CONTRATUAL';
            } elseif ($codigo == 76) {
                return 'CHEQUE COMPENSADO';
            } else {
                return 'Código Inexistente';
            }
        }
    }
1190273
def LeerContribuyente(self, pop=True):
        ""
        # por compatibilidad hacia atras, la primera vez no remueve de la lista
        # (llamado de ConsultarContribuyentes con pop=False)
        if self.contribuyentes:
            contrib = self.contribuyentes[0]
            if pop:
                del self.contribuyentes[0]
        else:
            contrib = {}
        self.CuitContribuyente = contrib.get('CuitContribuytente', "")
        self.AlicuotaPercepcion = contrib.get('AlicuotaPercepcion', "")
        self.AlicuotaRetencion = contrib.get('AlicuotaRetencion', "")
        self.GrupoPercepcion = contrib.get('GrupoPercepcion', "")
        self.GrupoRetencion = contrib.get('GrupoRetencion', "")
        self.errores = contrib.get('Errores', [])
        return len(contrib) > 0
1022128
protected function gerarNossoNumero()
    {
        $convenio = $this->getConvenio();
        $numero_boleto = $this->getNumero();
        switch (strlen($convenio)) {
        case 4:
            $numero = Util::numberFormatGeral($convenio, 4) . Util::numberFormatGeral($numero_boleto, 7);
            break;
        case 6:
            if (in_array($this->getCarteira(), ['16', '18']) && $this->getVariacaoCarteira() == 17) {
                $numero = Util::numberFormatGeral($numero_boleto, 17);
            } else {
                $numero = Util::numberFormatGeral($convenio, 6) . Util::numberFormatGeral($numero_boleto, 5);
            }
            break;
        case 7:
            $numero = Util::numberFormatGeral($convenio, 7) . Util::numberFormatGeral($numero_boleto, 10);
            break;
        default:
            throw new \Exception('O código do convênio precisa ter 4, 6 ou 7 dígitos!');
        }
        return $numero;
    }
1248280
def ConsultarMotivos(self, sep="||"):
        ""
        ret = self.client.consultarMotivos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('motivo', [])
        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]
1266983
def GenerarAjusteFisico(self):
        ""
        
        # renombrar la clave principal de la estructura
        if 'liquidacion' in self.solicitud:
            liq = self.solicitud.pop('liquidacion')
            self.solicitud = liq
        
        # llamar al webservice:
        ret = self.client.generarAjusteFisico(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        solicitud=self.solicitud,
                        )
        # analizar el resultado:
        ret = ret['respuesta']
        self.__analizar_errores(ret)
        liqs = ret.get('liquidacion', [])
        liq = liqs[0] if liqs else None
        self.AnalizarLiquidacion(liq)
        return True
781274
def AgregarAjuste(self, cai, tipo_cbte, pto_vta, nro_cbte, cae_a_ajustar):
        ""
        ajuste = self.solicitud['liquidacion']['ajuste'] = {}
        if cae_a_ajustar:
            ajuste['caeAAjustar'] = cae_a_ajustar
        if cai:
            cbte = dict(cai=cai, caeAAjustar=cae_a_ajustar, 
                        tipoComprobante=tipo_cbte, puntoVenta=pto_vta, 
                        nroComprobante=nro_cbte)
            ajuste['formularioPapel'] = cbte
        return True