Agrega la información referente a las percepciones de la liquidación
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
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
423034
def AgregarItemDetalle(self, cuit_cliente, cod_categoria, tipo_liquidacion,
                           cantidad, precio_unitario, alicuota_iva, cod_raza,
                           cantidad_cabezas=None, nro_tropa=None, 
                           cod_corte=None, cantidad_kg_vivo=None,
                           precio_recupero=None, detalle_raza=None,
                           nro_item=None,
                           **kwargs):
        ""
        d = {'cuitCliente': cuit_cliente,
             'codCategoria': cod_categoria,
             'tipoLiquidacion': tipo_liquidacion, 
             'cantidad': cantidad,
             'precioUnitario': precio_unitario, 
             'alicuotaIVA': alicuota_iva, 
             'cantidadCabezas': cantidad_cabezas, 
             'raza': {'codRaza': cod_raza, 'detalle': detalle_raza}, 
             'nroTropa': nro_tropa, 
             'codCorte': cod_corte, 
             'cantidadKgVivo': cantidad_kg_vivo, 
             'precioRecupero': precio_recupero,
             'liquidacionCompraAsociada': [],
             'nroItem': nro_item,
            }
        self.solicitud['itemDetalleLiquidacion'].append(d)
        return True
77075
def ConsultarTiposComprobante(self, sep="||"):
        ""
        ret = self.client.consultarTiposComprobante(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('tipoComprobante', [])
        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]
579618
def AgregarContingencias(self, tipo=None, observacion=None, **kwargs):
        ""
        contingencia = dict(tipoContingencia=tipo, observacion=observacion)
        self.remito['arrayContingencias'].append(dict(contingencia=contingencia))
        return True
1204883
def AgregarCTG(self, nro_ctg=None, nro_carta_porte=None,
                         porcentaje_secado_humedad=None, importe_secado=None,
                         peso_neto_merma_secado=None, tarifa_secado=None,
                         importe_zarandeo=None, peso_neto_merma_zarandeo=None,
                         tarifa_zarandeo=None, 
                         peso_neto_confirmado_definitivo=None,
                         **kwargs):
        ""
        
        ctg = dict(
                nroCTG=nro_ctg,
                nroCartaDePorte=nro_carta_porte,
                pesoNetoConfirmadoDefinitivo=peso_neto_confirmado_definitivo,
                porcentajeSecadoHumedad=porcentaje_secado_humedad,
                importeSecado=importe_secado,
                pesoNetoMermaSecado=peso_neto_merma_secado,
                tarifaSecado=tarifa_secado,
                importeZarandeo=importe_zarandeo,
                pesoNetoMermaZarandeo=peso_neto_merma_zarandeo,
                tarifaZarandeo=tarifa_zarandeo,
            )
        self.certificacion['primaria']['ctg'].append(ctg)
        return True
989016
def AgregarDatosAutorizacion(self, nro_remito=None, cod_autorizacion=None, fecha_emision=None, fecha_vencimiento=None, **kwargs):
        ""
        self.remito['datosEmision'] = dict(nroRemito=nro_remito, codAutorizacion=cod_autorizacion,
                                                fechaEmision=fecha_emision, fechaVencimiento=fecha_vencimiento,
                                               )
        return True
688273
def AjustarLiquidacionSecundaria(self):
        ""
        
        # limpiar estructuras no utilizadas (si no hay deducciones / retenciones)
        for k in ('ajusteDebito', 'ajusteCredito'):
            if k not in self.ajuste:
                # ignorar si no se agrego estructura ajuste credito / debito
                continue
            elif not any(self.ajuste[k].values()):
                # eliminar estructura vacia credito / debito
                del self.ajuste[k]
            else:
                # ajustar cambios de nombre entre LSG y LPG
                for tasa in ("0", "105", "21"):
                    tasa_lsg = "10" if tasa == "105" else tasa 
                    self.ajuste[k]['importeAjustar%s' % tasa_lsg] = self.ajuste[k]['importeAjustarIva%s' % tasa]
                    self.ajuste[k]['conceptoIva%s' % tasa_lsg] = self.ajuste[k]['conceptoImporteIva%s' % tasa]
                # no enviar tag percepciones vacio (no agrupar en subtipo)
                if self.ajuste[k]['percepciones']:
                    self.ajuste[k]['percepcion'] = [ 
                        per["percepcion"] for per 
                        in self.ajuste[k]['percepciones']]
                del self.ajuste[k]['percepciones']
                    
                

        base = self.ajuste['ajusteBase']
        base['coe'] = base['coeAjustado']
        base['codProvincia'] = base['codProv']

        # llamar al webservice:
        
        if base['nroContrato'] is not None and long(base['nroContrato']):
            metodo = self.client.lsgAjustarXContrato
        else:
            metodo = self.client.lsgAjustarXCoe
        
        ret = metodo(
                    auth={
                        'token': self.Token, 'sign': self.Sign,
                        'cuit': self.Cuit, },
                    ajusteCredito=self.ajuste.get('ajusteCredito'),
                    ajusteDebito=self.ajuste.get('ajusteDebito'),
                    **base
                    )
        # analizar el resultado:
        ret = ret['oReturn']
        self.__analizar_errores(ret)
        if ret:
            self.AnalizarAjuste(ret)
        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
47456
def ConsultarTipoActividadRepresentado(self, sep="||"):
        ""
        try:
            ret = self.client.tipoActividadRepresentadoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
            self.__analizar_errores(ret)
            array = ret.get('tiposActividad', [])
            self.Excepcion = self.Traceback = ""
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
        except Exception:
            ex = utils.exception_info()
            self.Excepcion = ex['msg']
            self.Traceback = ex['tb']
            if sep:
                return ["ERROR"]
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]
284556
def AnalizarLiquidacion(self, liq):
        ""
        # proceso los datos básicos de la liquidación (devuelto por consultar):
        if liq:
            cab = liq['encabezado']
            self.CAE = str(cab['cae'])
            self.FechaComprobante = str(cab['fechaComprobante'])
            self.NroComprobante = cab['nroComprobante']
            tot = liq['resumenTotales']
            self.AlicuotaIVA = tot['alicuotaIVA']
            self.TotalNeto = tot['totalNetoLiquidacion']
            self.ImporteIVA = tot['importeIVA']
            self.TotalBonificacionesCalidad = tot['totalBonificacionesCalidad']
            self.TotalPenalizacionesCalidad = tot['totalPenalizacionesCalidad']
            self.TotalBonificacionesComerciales = tot['totalBonificacionesComerciales']
            self.TotalDebitosComerciales = tot['totalDebitosComerciales']
            self.TotalOtrosImpuestos = tot['totalOtrosImpuestos']
            self.Total = tot['totalLiquidacion']

            # parámetros de salida:
            self.params_out = dict(
                tipo_cbte=liq['encabezado']['tipoComprobante'],
                pto_vta=liq['encabezado']['puntoVenta'],
                nro_cbte=liq['encabezado']['nroComprobante'],
                fecha=str(liq['encabezado']['fechaComprobante']),
                cae=str(liq['encabezado']['cae']),
                domicilio_comprador=liq['encabezado']['domicilioComprador'],
                tambero=dict(
                    cuit=liq['tambero']['cuit'],
                    iibb=liq['tambero']['iibb'],
                    razon_social=liq['tambero']['razonSocial'],
                    situacion_iva=liq['tambero']['situacionIVA'],
                    domicilio_fiscal=liq['tambero']['domicilioFiscal'],
                    provincia=liq['tambero']['provincia'],
                    cod_postal=liq['tambero']['codPostal'],
                    ),
                resumen_kg_remitidos=liq['resumenKgRemitidos'],
                alicuota_iva=liq['resumenTotales']['alicuotaIVA'],
                importe_iva=liq['resumenTotales']['importeIVA'],
                total_neto=liq['resumenTotales']['totalNetoLiquidacion'],
                total_bonificaciones_calidad=liq['resumenTotales']['totalBonificacionesCalidad'],
                total_penalizaciones_calidad=liq['resumenTotales']['totalPenalizacionesCalidad'],
                total_bonificaciones_comerciales=liq['resumenTotales']['totalBonificacionesComerciales'],
                total_debitos_comerciales=liq['resumenTotales']['totalDebitosComerciales'],
                total_otros_impuestos=liq['resumenTotales']['totalOtrosImpuestos'],
                total=liq['resumenTotales']['totalLiquidacion'],
                bonificacion_penalizacion=[],
                remitos=[],
                otro_impuesto=[],               
                pdf=liq.get('pdf'),
                )
            for ret in liq.get('bonificacionPenalizacion', []):
                self.params_out['bonificacion_penalizacion'].append(dict(
                    retencion_codigo=ret['codigo'],
                    retencion_importe=ret['importe'],
                    ))
            for trib in liq.get('otroImpuesto',[]):
                self.params_out['otro_impuesto'].append(dict(
                    tributo_descripcion=trib.get('descripcion', ""),
                    tributo_base_imponible=trib['baseImponible'],
                    tributo_alicuota=trib['alicuota'],
                    tributo_codigo=trib['codigo'],
                    tributo_importe=trib['importe'],
                    ))
            if DEBUG:
                import pprint
                pprint.pprint(self.params_out)
        self.params_out['errores'] = self.errores
903142
def ConsultarLiquidacionesPorContrato(self, nro_contrato=None, 
                                                cuit_comprador=None, 
                                                cuit_vendedor=None,
                                                cuit_corredor=None,
                                                cod_grano=None,
                                                **kwargs):
        ""
        ret = self.client.liquidacionPorContratoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        nroContrato=nro_contrato,
                        cuitComprador=cuit_comprador,
                        cuitVendedor=cuit_vendedor,
                        cuitCorredor=cuit_corredor,
                        codGrano=cod_grano,
                        )
        ret = ret['liqPorContratoCons']
        self.__analizar_errores(ret)
        if 'coeRelacionados' in ret:
            # analizo la respuesta = [{'coe': "...."}]
            self.DatosLiquidacion = sorted(ret['coeRelacionados'])  
            # establezco el primer COE
            self.LeerDatosLiquidacion()
        return True
142529
def AjustarLiquidacion(self):
        ""
        # limpio los elementos que no correspondan por estar vacios:
        for item_liq in self.solicitud['itemDetalleAjusteLiquidacion']:
            campo = 'ajusteCompraAsociada'
            if campo in item_liq and not item_liq[campo]:
                del item_liq[campo]
        for campo in self.solicitud.get('ajusteFinanciero', {}).copy():
            if not self.solicitud['ajusteFinanciero'][campo]:
                del self.solicitud['ajusteFinanciero'][campo]
        # llamo al webservice:
        ret = self.client.generarAjuste(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                        solicitud=self.solicitud,
                        )
        # analizo la respusta
        ret = ret['respuesta']
        self.__analizar_errores(ret)
        self.AnalizarLiquidacion(ret)
        return True
935681
def AgregarComprobanteAAjustar(self, tipo_cbte, pto_vta, nro_cbte):
        ""
        cbte = dict(tipoComprobante=tipo_cbte, puntoVenta=pto_vta, nroComprobante=nro_cbte)
        self.solicitud['liquidacion']["comprobanteAAjustar"].append(cbte)
        return True
645334
def ConsultarRazas(self, sep="||"):
        ""
        ret = self.client.consultarRazas(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('raza', []) + ret.get('razaPorcina', [])
        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]
739149
def ConsultarPuntosVentas(self, sep="||"):
        ""
        ret = self.client.consultarPuntosVenta(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('puntoVenta', [])
        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]