diff --git a/wscpe.py b/wscpe.py index 5af2849a9..171cf9fe3 100644 --- a/wscpe.py +++ b/wscpe.py @@ -14,13 +14,24 @@ para transporte ferroviario y automotor RG 5017/2021 """ +from __future__ import print_function +from __future__ import absolute_import +from __future__ import unicode_literals + +from future import standard_library +from future.utils import string_types + +standard_library.install_aliases() +from builtins import str +from builtins import input + __author__ = "Mariano Reingart " __copyright__ = "Copyright (C) 2021- Mariano Reingart" __license__ = "LGPL 3.0" -__version__ = "1.00a" +__version__ = "1.01b" LICENCIA = """ -wscpe.py: Interfaz para generar Carta de Porte Electrónica AFIP v1.0.0 +wscpe.py: Interfaz para generar Carta de Porte Electrónica AFIP v1.4.0 Resolución General 5017/2021 Copyright (C) 2021 Mariano Reingart reingart@gmail.com http://www.sistemasagiles.com.ar/trac/wiki/CartadePorte @@ -39,68 +50,149 @@ --debug: modo depuración (detalla y confirma las operaciones) --prueba: genera y autoriza una rec de prueba (no usar en producción!) - --xml: almacena los requerimientos y respuestas XML (depuración) --dummy: consulta estado de servidores - --generar: generar un cpe - --emitir: emite un cpe - --anular: anula un cpe - --autorizar: autoriza un cpe - - --ult: consulta ultimo nro cpe emitido - --consultar: consulta un cpe generado - - --tipos_comprobante: tabla de parametros para tipo de comprobante - --tipos_contingencia: tipo de contingencia que puede reportar - --tipos_categoria_emisor: tipos de categorías de emisor - --tipos_categoria_receptor: tipos de categorías de receptor - --tipos_estados: estados posibles en los que puede estar un cpe granosero - --grupos_granos' grupos de los distintos tipos de cortes de granos - --tipos_granos': tipos de corte de granos - --codigos_domicilio: codigos de depositos habilitados para el cuit - Ver wscpe.ini para parámetros de configuración (URL, certificados, etc.)" """ -import os, sys, time, base64, datetime -from utils import date +import base64 +import datetime +import os +import sys +import time import traceback + from pysimplesoap.client import SoapFault -import utils # importo funciones compartidas: -from utils import json, BaseWS, inicializar_y_capturar_excepciones, get_install_dir, json_serializer - +from .utils import ( + date, + leer, + escribir, + leer_dbf, + guardar_dbf, + N, + A, + I, + json, + BaseWS, + inicializar_y_capturar_excepciones, + get_install_dir, + json_serializer, +) + + +# constantes de estado cpe. +ESTADO_CPE = { + "AC": "Activa", + "AN": "Anulada", + "BR": "Borrador", + "CF": "Activa con confirmacion de arribo", + "CN": "confirmada", + "CO": "Activa con contingencia", + "DE": "Desactivada", + "RE": "Rechazada", + "PA": "Pendiente de Aceptacion por el Productor", + "AP": "Anulacion por el Productor", + "DD": "Descargado en destino", +} # constantes de configuración (producción/homologación): +WSDL = [ + "https://serviciosjava.afip.gob.ar/cpe-ws/services/wscpe?wsdl", + "https://fwshomo.afip.gov.ar/wscpe/services/soap?wsdl", +] -WSDL = ["https://serviciosjava.afip.gob.ar/cpe-ws/services/wscpe?wsdl", - "https://fwshomo.afip.gov.ar/wscpe/services/soap?wsdl"] - -DEBUG = False +# Seteado para ambiente de homologacion/debug. +DEBUG = True XML = False CONFIG_FILE = "wscpe.ini" HOMO = True -ENCABEZADO = [] class WSCPE(BaseWS): - "Interfaz para el WebService de Carta de Porte Electrónica (Version 1)" - _public_methods_ = ['Conectar', 'Dummy', 'SetTicketAcceso', 'DebugLog', - 'GenerarCPE', 'EmitirCPE', 'AutorizarCPE', 'AnularCPE', 'ConsultarCPE', - 'InformarContingencia', 'ModificarViaje', 'RegistrarRecepcion', 'ConsultarUltimoCPEEmitido', - 'CrearCPE', 'AgregarViaje', 'AgregarVehiculo', 'AgregarMercaderia', 'AgregarReceptor', - 'AgregarDatosAutorizacion', 'AgregarContingencia', - 'ConsultarTiposMercaderia', 'ConsultarTiposEmbalaje', 'ConsultarTiposUnidades', 'ConsultarTiposComprobante', - 'ConsultarTiposComprobante', 'ConsultarTiposContingencia', 'ConsultarCodigosDomicilio', 'ConsultarPaises', - 'SetParametros', 'SetParametro', 'GetParametro', 'AnalizarXml', 'ObtenerTagXml', 'LoadTestXML', - ] - _public_attrs_ = ['XmlRequest', 'XmlResponse', 'Version', 'Traceback', 'Excepcion', 'LanzarExcepciones', - 'Token', 'Sign', 'Cuit', 'AppServerStatus', 'DbServerStatus', 'AuthServerStatus', - 'CodCPE', 'TipoComprobante', 'PuntoEmision', - 'NroCPE', 'CodAutorizacion', 'FechaVencimiento', 'FechaEmision', 'Estado', 'Resultado', 'QR', - 'ErrCode', 'ErrMsg', 'Errores', 'ErroresFormato', 'Observaciones', 'Obs', 'Evento', 'Eventos', - ] + "Interfaz para el WebService de Carta Porte Electrónica" + _public_methods_ = [ + "Conectar", + "Dummy", + "SetTicketAcceso", + "DebugLog", + "CrearCPE", + "AgregarCabecera", + "AgregarOrigen", + "AgregarRetiroProductor", + "AgregarIntervinientes", + "AgregarDatosCarga", + "AgregarDestino", + "AgregarTransporte", + "AgregarContingencia", + "DescargadoDestinoCPE", + "NuevoDestinoDestinatarioCPEFerroviaria", + "AutorizarCPEAutomotor", + "ConsultarLocalidadesPorProvincia", + "ConfirmarArriboCPE", + "AnularCPE", + "ConsultaCPEFerroviariaPorNroOperativo", + "InformarContingencia", + "ConsultarCPEFerroviaria", + "ConfirmacionDefinitivaCPEFerroviaria", + "CerrarContingenciaCPE", + "ConsultarUltNroOrden", + "ConsultarCPEAutomotor", + "ConsultarCPEPorDestino", + "ConsultarCPEPendientesDeResolucion", + "NuevoDestinoDestinatarioCPEAutomotor", + "RegresoOrigenCPEFerroviaria", + "RegresoOrigenCPEAutomotor", + "ConsultarLocalidadesProductor", + "RechazoCPE", + "ConfirmacionDefinitivaCPEAutomotor", + "ConsultarProvincias", + "DesvioCPEFerroviaria", + "ConsultarTiposGrano", + "AutorizarCPEFerroviaria", + "DesvioCPEAutomotor", + "EditarCPEAutomotor", + "EditarCPEFerroviaria", + "ConsultarPlantas", + "SetParametros", + "SetParametro", + "GetParametro", + "AnalizarXml", + "ObtenerTagXml", + "LoadTestXML", + ] + _public_attrs_ = [ + "XmlRequest", + "XmlResponse", + "Version", + "Traceback", + "Excepcion", + "LanzarExcepciones", + "Token", + "Sign", + "Cuit", + "AppServerStatus", + "DbServerStatus", + "AuthServerStatus", + "NroCTG", + "NroOrden", + "FechaInicioEstado", + "FechaEmision", + "FechaVencimiento", + "Estado", + "Resultado", + "PDF", + "ErrCode", + "ErrMsg", + "Errores", + "ErroresFormato", + "Observaciones", + "Obs", + "Evento", + "Eventos", + ] + _reg_progid_ = "WSCPE" _reg_clsid_ = "{37F6A7B5-344E-45C5-9198-0CF7B206F409}" @@ -108,7 +200,7 @@ class WSCPE(BaseWS): HOMO = HOMO WSDL = WSDL[HOMO] LanzarExcepciones = False - Version = "%s %s" % (__version__, HOMO and 'Homologación' or '') + Version = "%s %s" % (__version__, HOMO and "Homologación" or "") def Conectar(self, *args, **kwargs): ret = BaseWS.Conectar(self, *args, **kwargs) @@ -116,709 +208,1391 @@ def Conectar(self, *args, **kwargs): def inicializar(self): self.AppServerStatus = self.DbServerStatus = self.AuthServerStatus = None - self.CodCPE = self.TipoComprobante = self.PuntoEmision = None - self.NroCPE = self.CodAutorizacion = self.FechaVencimiento = self.FechaEmision = None - self.Estado = self.Resultado = self.QR = None + self.NroCTG = self.NroOrden = None + self.FechaInicioEstado = self.FechaVencimiento = self.FechaEmision = None + self.Estado = self.Resultado = self.PDF = None self.Errores = [] - self.ErroresFormato = [] - self.Observaciones = [] - self.Eventos = [] self.Evento = self.ErrCode = self.ErrMsg = self.Obs = "" + if not hasattr(self, "cpe"): + self.cpe = {} + if not hasattr(self, "_actualizar"): + self._actualizar = True def __analizar_errores(self, ret): "Comprueba y extrae errores si existen en la respuesta XML" - self.Errores = [err['codigoDescripcion'] for err in ret.get('arrayErrores', [])] - self.ErroresFormato = [err['codigoDescripcionString'] for err in ret.get('arrayErroresFormato', [])] - errores = self.Errores + self.ErroresFormato - self.ErrCode = ' '.join(["%(codigo)s" % err for err in errores]) - self.ErrMsg = '\n'.join(["%(codigo)s: %(descripcion)s" % err for err in errores]) + errores = self.Errores = [err["error"] for err in ret.get("errores", [])] + if errores: + errores = errores[0] + self.ErrCode = " ".join(["%(codigo)s" % err for err in errores]) + self.ErrMsg = "\n".join(["%(codigo)s - %(descripcion)s" % err for err in errores]) def __analizar_observaciones(self, ret): "Comprueba y extrae observaciones si existen en la respuesta XML" - self.Observaciones = [obs["codigoDescripcion"] for obs in ret.get('arrayObservaciones', [])] - self.Obs = '\n'.join(["%(codigo)s: %(descripcion)s" % obs for obs in self.Observaciones]) + self.Observaciones = [obs["codigoDescripcion"] for obs in ret.get("arrayObservaciones", [])] + self.Obs = "\n".join(["%(codigo)s: %(descripcion)s" % obs for obs in self.Observaciones]) def __analizar_evento(self, ret): "Comprueba y extrae el wvento informativo si existen en la respuesta XML" - evt = ret.get('evento') + evt = ret.get("evento") if evt: self.Eventos = [evt] self.Evento = "%(codigo)s: %(descripcion)s" % evt - @inicializar_y_capturar_excepciones - def CrearCPE(self, tipo_cp, sucursal, - tipo_titular_mercaderia, - cuit_solicitante=None, cuit_autorizado_retirar=None, - cuit_productor_contrato=None, numero_maquila=None, - cod_cpe=None, estado=None, es_entrega_mostrador=None, - **kwargs): - "Inicializa internamente los datos de un cpe para autorizar" - self.cpe = {'puntoEmision': punto_emision, 'tipoTitularMercaderia': tipo_titular_mercaderia, - 'cuitTitularMercaderia': cuit_titular_mercaderia, - 'cuitAutorizadoRetirar': cuit_autorizado_retirar, - 'cuitProductorContrato': cuit_productor_contrato, - 'numeroMaquila': numero_maquila, - 'codCPE': cod_cpe, - 'esEntregaMostrador': es_entrega_mostrador, - 'arrayMercaderias': [], 'arrayContingencias': [], - } + def CrearCPE(self): + """Cambia la estructura de datos en AgregarCabecera para crear una CPE.""" + self._actualizar = False return True @inicializar_y_capturar_excepciones - def AgregarReceptor(self, cuit_pais_receptor, - cuit_receptor=None, cod_dom_receptor=None, - cuit_despachante=None, codigo_aduana=None, - denominacion_receptor=None, domicilio_receptor=None, **kwargs): - "Agrega la información referente al viaje del cpe electrónico granosero" - receptor = {'cuitPaisReceptor': cuit_pais_receptor} - if cuit_receptor: - receptor['receptorNacional'] = {'codDomReceptor': cod_dom_receptor, - 'cuitReceptor':cuit_receptor} + def AgregarCabecera( + self, + tipo_cpe=None, + cuit_solicitante=None, + sucursal=None, + nro_orden=None, + planta=None, + carta_porte=None, + nro_ctg=None, + observaciones=None, + **kwargs + ): + """Inicializa internamente los datos de cabecera para una cpe.""" + # cabecera para modificaciones, rechazos o anulaciones. + if self._actualizar: + cabecera = { + "cuitSolicitante": cuit_solicitante, + "nroCTG": nro_ctg, + "cartaPorte": { + "tipoCPE": tipo_cpe, + "sucursal": sucursal, + "nroOrden": nro_orden, + }, + } + if not sucursal: + del cabecera["cartaPorte"] + self.cpe = cabecera else: - receptor['receptorExtranjero'] = { - 'codigoAduana': codigo_aduana, - 'cuitDespachante': cuit_despachante, - 'denominacionReceptor': denominacion_receptor, - 'domicilioReceptor': domicilio_receptor} - self.cpe['receptor'] = receptor + cabecera = { + "tipoCP": tipo_cpe, + "cuitSolicitante": cuit_solicitante, + "sucursal": sucursal, + "nroOrden": nro_orden, + "planta": planta, + } + # creo el diccionario para agregar datos cpe + self.cpe = { + "cabecera": cabecera, + "observaciones": observaciones, + } + return True @inicializar_y_capturar_excepciones - def AgregarViaje(self, fecha_inicio_viaje, distancia_km, cod_pais_transportista, ducto=None, **kwargs): - "Agrega la información referente al viaje del cpe electrónico granosero" - self.cpe.update({ - 'viaje': { - 'fechaInicioViaje': fecha_inicio_viaje , - 'kmDistancia': distancia_km, - 'tramo': [{ - }] - }}) - - if ducto: - transporte = self.cpe['viaje']['tramo'][0]['ducto'] = ducto + def AgregarOrigen( + self, + cod_provincia_operador=None, + cod_localidad_operador=None, + planta=None, + cod_provincia_productor=None, + cod_localidad_productor=None, + **kwargs + ): + """Inicializa internamente los datos de origen para una cpe.""" + operador = { + "codProvincia": cod_provincia_operador, + "codLocalidad": cod_localidad_operador, + "planta": planta, + } + productor = { + "codProvincia": cod_provincia_productor, + "codLocalidad": cod_localidad_productor, + } + origen = {} + if planta: + origen["operador"] = operador + if cod_localidad_productor: + origen["productor"] = productor + self.cpe["origen"] = origen + return True + + @inicializar_y_capturar_excepciones + def AgregarRetiroProductor( + self, + corresponde_retiro_productor=None, + es_solicitante_campo=None, + certificado_coe=None, + cuit_remitente_comercial_productor=None, + **kwargs + ): + """Inicializa internamente los datos de retiro de productor para una cpe.""" + retiro_productor = { + "certificadoCOE": certificado_coe, + "cuitRemitenteComercialProductor": cuit_remitente_comercial_productor, + } + self.cpe["correspondeRetiroProductor"] = corresponde_retiro_productor + self.cpe["esSolicitanteCampo"] = es_solicitante_campo + if certificado_coe: + self.cpe["retiroProductor"] = retiro_productor + return True + + @inicializar_y_capturar_excepciones + def AgregarIntervinientes( + self, + cuit_remitente_comercial_venta_primaria=None, + cuit_remitente_comercial_venta_secundaria=None, + cuit_remitente_comercial_venta_secundaria2=None, + cuit_mercado_a_termino=None, + cuit_corredor_venta_primaria=None, + cuit_corredor_venta_secundaria=None, + cuit_representante_entregador=None, + cuit_representante_recibidor=None, + **kwargs + ): + """Inicializa internamente los datos de los intervinientes para una cpe.""" + intervinientes = { + "cuitRemitenteComercialVentaPrimaria": cuit_remitente_comercial_venta_primaria, + "cuitRemitenteComercialVentaSecundaria": cuit_remitente_comercial_venta_secundaria, + "cuitRemitenteComercialVentaSecundaria2": cuit_remitente_comercial_venta_secundaria2, + "cuitMercadoATermino": cuit_mercado_a_termino, + "cuitCorredorVentaPrimaria": cuit_corredor_venta_primaria, + "cuitCorredorVentaSecundaria": cuit_corredor_venta_secundaria, + "cuitRepresentanteEntregador": cuit_representante_entregador, + "cuitRepresentanteRecibidor": cuit_representante_recibidor, + } + self.cpe["intervinientes"] = intervinientes + return True + + @inicializar_y_capturar_excepciones + def AgregarDatosCarga(self, cod_grano=None, cosecha=None, peso_bruto=None, peso_tara=None, **kwargs): + """Inicializa internamente los datos de carga para una cpe.""" + datos_carga = { + "codGrano": cod_grano, + "cosecha": cosecha, + "pesoBruto": peso_bruto, + "pesoTara": peso_tara, + } + if not datos_carga["cosecha"]: + self.cpe["pesoBrutoDescarga"] = peso_bruto + self.cpe["pesoTaraDescarga"] = peso_tara else: - self.cpe['viaje']['tramo'][0]['automotor'] = { - 'codPaisTransportista': cod_pais_transportista, - } + self.cpe["datosCarga"] = datos_carga return True @inicializar_y_capturar_excepciones - def AgregarVehiculo(self, dominio_vehiculo, dominio_acoplado=None, - cuit_transportista=None, cuit_conductor=None, - apellido_conductor=None, cedula_conductor=None, denom_transportista=None, - id_impositivo=None, nombre_conductor=None, - **kwargs): - "Agrega la información referente al vehiculo usado en el viaje del cpe electrónico granosero" - transporte = self.cpe['viaje']['tramo'][0]['automotor'] - vehiculo = { - 'dominioVehiculo': dominio_vehiculo, - 'dominioAcoplado': dominio_acoplado, - } - transporte.update(vehiculo) - - if cuit_transportista: - transporte['transporteNacional'] = { - 'cuitTransportista': cuit_transportista, - 'cuitConductor': cuit_conductor, + def AgregarDestino( + self, + cuit_destino=None, + es_destino_campo=None, + cod_provincia=None, + cod_localidad=None, + planta=None, + cuit_destinatario=None, + **kwargs + ): + """Inicializa internamente los datos de destino para una cpe.""" + destino = { + "cuit": cuit_destino, + "esDestinoCampo": es_destino_campo, + "codProvincia": cod_provincia, + "codLocalidad": cod_localidad, + "planta": planta, + } + cuit_destinatario = {"cuit": cuit_destinatario} + # maneja distintos campos para diferentes metodos + if destino["cuit"]: + self.cpe["destino"] = destino + if cuit_destinatario["cuit"]: + self.cpe["destinatario"] = cuit_destinatario + return True + + @inicializar_y_capturar_excepciones + def AgregarTransporte( + self, + cuit_transportista=None, + cuit_transportista_tramo2=None, + nro_vagon=None, + nro_precinto=None, + nro_operativo=None, + dominio=None, # 1 or more repetitions + fecha_hora_partida=None, + km_recorrer=None, + codigo_turno=None, + cuit_chofer=None, + tarifa=None, + cuit_pagador_flete=None, + mercaderia_fumigada=None, + cuit_intermediario_flete=None, + codigo_ramal=None, + descripcion_ramal=None, + **kwargs + ): + """Inicializa internamente los datos de transporte para una cpe.""" + if codigo_ramal: # cpe ferroviaria + transporte = { + "cuitTransportista": cuit_transportista, + "cuitTransportistaTramo2": cuit_transportista_tramo2, + "nroVagon": nro_vagon, + "nroPrecinto": nro_precinto, + "nroOperativo": nro_operativo, + "fechaHoraPartidaTren": fecha_hora_partida, + "kmRecorrer": km_recorrer, + "cuitPagadorFlete": cuit_pagador_flete, + "mercaderiaFumigada": mercaderia_fumigada, } + ramal = {"codigo": codigo_ramal, "descripcion": descripcion_ramal} + # ajuste para confirmacion_definitiva_cpe_ferroviaria + # ajuste para desviocpeferroviaria + if cuit_transportista or km_recorrer: + transporte["ramal"] = ramal + else: + transporte["ramalDescarga"] = ramal else: - transporte['transporteExtranjero'] = { - 'apellidoConductor': apellido_conductor, - 'cedulaConductor': cedula_conductor, - 'denomTransportista': denom_transportista, - 'idImpositivo': id_impositivo, - 'nombreConductor': nombre_conductor, + transporte = { + "cuitTransportista": cuit_transportista, + "dominio": dominio, + "fechaHoraPartida": fecha_hora_partida, + "kmRecorrer": km_recorrer, # obligatorio en todos los metodos que lo solicitan + "codigoTurno": codigo_turno, + "cuitChofer": cuit_chofer, + "tarifa": tarifa, + "cuitPagadorFlete": cuit_pagador_flete, + "cuitIntermediarioFlete": cuit_intermediario_flete, + "mercaderiaFumigada": mercaderia_fumigada, } + # ajuste para confirmacion_definitiva_cpe_ferroviaria + if transporte["kmRecorrer"]: + self.cpe["transporte"] = transporte + else: + self.cpe.update(transporte) + return True + def AgregarContingencia( + self, + concepto=None, + descripcion=None, # solo necesario si la opcion es F "otros" + ): + """Inicialliza datos para contingencias en cpe.""" + self.cpe["contingencia"] = {"concepto": concepto, "descripcion": descripcion} return True + def AgregarCerrarContingencia( + self, + concepto=None, + cuit_transportista=None, + nro_operativo=None, + concepto_desactivacion=None, + descripcion=None, + **kwrags + ): + """Inicializa datos para el cierre, la reactivacion, extension de una contingencias en cpe. + + A: Reactivación para descarga en destino. + B: Extensión cierre contingencia. + C: Desactivar definitivamente la CP. + """ + if concepto == "A": + motivo = { + "concepto": concepto, # A, B, C + "reactivacionDestino": { + "cuitTransportista": cuit_transportista, + "nroOperativo": nro_operativo, + } + } + else: + motivo = { + "concepto": concepto, # A, B, C - distintos para la desactivacion + "motivoDesactivacionCP": {"concepto": concepto_desactivacion, "descripcion": descripcion} + } + self.cpe.update(motivo) + @inicializar_y_capturar_excepciones - def AgregarMercaderia(self, orden, cod_tipo_prod, cod_tipo_emb, cantidad_emb, cod_tipo_unidad, cant_unidad, - anio_safra, **kwargs): - "Agrega la información referente a la mercadería del cpe electrónico granosero" - mercaderia = dict(orden=orden, - tipoProducto=cod_tipo_prod, - tipoEmbalaje=cod_tipo_emb, - unidadMedida=cod_tipo_unidad, - cantidad=cant_unidad, - anioZafra=anio_safra, - ) - self.cpe['arrayMercaderias'].append(dict(mercaderia=mercaderia)) + def AutorizarCPEFerroviaria(self, archivo="cpe_ferroviaria.pdf"): + """Informar los datos necesarios para la generación de una nueva carta porte.""" + response = self.client.autorizarCPEFerroviaria( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) return True @inicializar_y_capturar_excepciones - def AgregarDatosAutorizacion(self, nro_cpe=None, cod_autorizacion=None, fecha_emision=None, fecha_vencimiento=None, **kwargs): - "Agrega la información referente a los datos de autorización del cpe electrónico granosero" - self.cpe['datosEmision'] = dict(nroCPE=nro_cpe, codAutorizacion=cod_autorizacion, - fechaEmision=fecha_emision, fechaVencimiento=fecha_vencimiento, - ) + def AutorizarCPEAutomotor(self, archivo="cpe.pdf"): + """Informar los datos necesarios para la generación de una nueva carta porte.""" + response = self.client.autorizarCPEAutomotor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) return True @inicializar_y_capturar_excepciones - def AgregarContingencias(self, tipo=None, observacion=None, **kwargs): - "Agrega la información referente a los opcionales de la liq. seq." - contingencia = dict(tipoContingencia=tipo, observacion=observacion) - self.cpe['arrayContingencias'].append(dict(contingencia=contingencia)) + def AnalizarCPE(self, ret, archivo="cpe.pdf"): + "Extrae los resultados de autorización de una carta porte automotor." + cab = ret.get("cabecera") + self.NroCTG = cab.get("nroCTG") + self.FechaEmision = cab.get("fechaEmision") + self.Estado = cab.get("estado") + self.FechaInicioEstado = cab.get("fechaInicioEstado") + self.FechaVencimiento = cab.get("fechaVencimiento") + self.PDF = ret.get("pdf") # base64 + cpe_bytes = self.PDF + if isinstance(cpe_bytes, string_types): + cpe_bytes = cpe_bytes.encode("utf-8") + with open(archivo, "wb") as fh: + fh.write(cpe_bytes) + + @inicializar_y_capturar_excepciones + def AnularCPE(self, archivo="cpe.pdf"): + """Informar los datos necesarios para la generación de una nueva carta porte.""" + response = self.client.anularCPE( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) return True @inicializar_y_capturar_excepciones - def GenerarCPE(self, id_req, archivo="qr.png"): - "Informar los datos necesarios para la generación de un cpe nuevo" - if not self.cpe['arrayContingencias']: - del self.cpe['arrayContingencias'] - response = self.client.generarCPE( - authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit}, - idReqCliente=id_req, cpe=self.cpe) - ret = response.get("generarCPEReturn") + def RechazoCPE(self, archivo="cpe.pdf"): + """Informar el rechazo de una carta de porte existente.""" + response = self.client.rechazoCPE( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") if ret: self.__analizar_errores(ret) - self.__analizar_observaciones(ret) - self.__analizar_evento(ret) + if "cabecera" in ret: self.AnalizarCPE(ret, archivo) - return bool(self.CodCPE) + return True - def AnalizarCPE(self, ret, archivo=None): - "Extrae el resultado del cpe, si existen en la respuesta XML" + @inicializar_y_capturar_excepciones + def InformarContingencia(self, archivo="cpe.pdf"): + """informa de contingencia de una CPE existente.""" + response = self.client.informarContingencia( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") if ret: - datos_aut = ret.get('cpeDatosAutorizacion') - if datos_aut: - self.CodCPE = datos_aut.get("codigoCPE") - self.TipoComprobante = datos_aut.get("idTipoComprobante") - self.NroCPE = datos_aut.get('nroComprobante') - self.CodAutorizacion = datos_aut.get('codigoAutorizacion') - self.FechaEmision = datos_aut.get('fechaEmision') - self.FechaVencimiento = datos_aut.get('fechaVencimiento') - self.Estado = ret.get('estado') - self.Resultado = ret.get('resultado') - self.QR = ret.get('qr') or "" - if archivo: - f = open(archivo, "wb") - f.write(self.QR) - f.close() - - @inicializar_y_capturar_excepciones - def EmitirCPE(self, archivo="qr.png"): - "Emitir CPEs que se encuentren en estado Pendiente de Emitir." - response = self.client.emitirCPE( - authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit}, - emitirCPE=dict( - codigoCPE=self.cpe['codCPE'], - ) - ) - ret = response.get("emitirCPEReturn") + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def ConfirmarArriboCPE(self, archivo="cpe.pdf"): + "Informar la confirmación de arribo." + response = self.client.confirmarArriboCPE( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") if ret: self.__analizar_errores(ret) - self.__analizar_observaciones(ret) - self.__analizar_evento(ret) + if "cabecera" in ret: self.AnalizarCPE(ret, archivo) - return bool(self.CodCPE) + return True @inicializar_y_capturar_excepciones - def AutorizarCPE(self, archivo="qr.png"): - "Autorizar o denegar un cpe (cuando corresponde autorizacion) por parte del titular/depositario" - response = self.client.autorizarCPEAutomotor( - auth={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit}, - solicitud={ - 'cabecera': {'tipoCP': 1, 'cuitSolicitante': 20267565393, 'sucursal': 1, 'nroOrden': 1}, - 'origen': {'operador': {'planta': 1, 'codProvincia': 12, 'codLocalidad': 5544}}, - 'correspondeRetiroProductor': True, - 'esSolicitanteCampo': "N", - 'retiroProductor': {'certificadoCOE': 330100025869, 'cuitRemitenteComercialProductor': 20111111112}, - 'intervinientes': {'cuitMercadoATermino': 20222222223, 'cuitCorredorVentaPrimaria': 20222222223, 'cuitCorredorVentaSecundaria': 20222222223, 'cuitRemitenteComercialVentaSecundaria': 20222222223, 'cuitIntermediario': 20222222223, 'cuitRemitenteComercialVentaPrimaria': 20222222223, 'cuitRepresentanteEntregador': 20222222223}, - 'datosCarga': {'pesoTara': 1000, 'codGrano': 31, 'pesoBruto': 1000, 'cosecha': 910}, - 'destino': {'planta': 1, 'codProvincia': 12, 'esDestinoCampo': "M", 'codLocalidad': 3058, 'cuit': 20111111112}, - 'destinatario': {'cuit': 30000000006}, - 'transporte': {'fechaHoraPartida': datetime.datetime.now(), 'codigoTurno': "00", 'cuitTransportista': 20333333334, 'dominio': "ZZZ000", 'kmRecorrer': 500}, - 'productor': {'codLocalidad': 3059}, - } + def DescargadoDestinoCPE(self, archivo="cpe.pdf"): + "indicar por el solicitante de la Carta de Porte que la mercadería ha sido enviada." + response = self.client.descargadoDestinoCPE( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, ) ret = response.get("respuesta") - # 'cabecera': {'fechaEmision': datetime.datetime, 'sucursal': int, 'planta': int, 'tipoCartaPorte': int, 'nroCPE': long, 'nroOrden': long, 'fechaInicioEstado': datetime.datetime, 'estado': unicode, 'fechaVencimiento': datetime.datetime}, - # 'origen': {'planta': int, 'codProvincia': int, 'domicilio': unicode, 'codLocalidad': int}, - # 'correspondeRetiroProductor': bool, - # 'retiroProductor': { - # 'certificadoCOE': long, - # 'cuitRemitenteComercialProductor': long}, - # 'intervinientes': {'cuitMercadoATermino': long, 'cuitCorredorVentaPrimaria': long, 'cuitCorredorVentaSecundaria': long, 'cuitRemitenteComercialVentaSecundaria': long, 'cuitIntermediario': long, 'cuitRemitenteComercialVentaPrimaria': long, 'cuitRepresentanteEntregador': long}, - # 'datosCarga': { - # 'pesoTara': int, 'codGrano': int, 'pesoBruto': int, 'cosecha': int}, - # 'destino': {'planta': int, 'codProvincia': int, 'codLocalidad': int, 'cuit': long}, - # 'destinatario': {'cuit': long}, - # 'transporte': [{'fechaHoraPartida': datetime.datetime, 'codigoTurno': int, 'cuitTransportista': long, 'dominio': unicode, 'kmRecorrer': int}], - # 'errores': [{'error': [{'descripcion': unicode, 'codigo': unicode}]}], - # 'pdf': b64decode, - # 'metadata': {'servidor': unicode, 'fechaHora': datetime.datetime}} if ret: self.__analizar_errores(ret) - self.__analizar_observaciones(ret) - self.__analizar_evento(ret) + if "cabecera" in ret: self.AnalizarCPE(ret, archivo) - return bool(self.CodCPE) + return True @inicializar_y_capturar_excepciones - def AnularCPE(self): - "Anular un cpe generado que aún no haya sido emitido" - response = self.client.anularCPE( - authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit}, - codCPE=self.cpe['codCPE']) - ret = response.get("anularCPEReturn") + def EditarCPEFerroviaria( + self, + nro_ctg=None, + cuit_corredor_venta_primaria=None, + cuit_corredor_venta_secundaria=None, + cuit_remitente_comercial_venta_primaria=None, + cuit_remitente_comercial_venta_secundaria=None, + cuit_remitente_comercial_venta_secundaria2=None, + cuit_transportista=None, + peso_bruto=None, + cod_grano=None, + archivo="cpe.pdf", + **kwargs + ): + """Modificar datos de una CP Ferroviaria en estado Activo.""" + self.cpe.update({ + "nroCTG": nro_ctg, + "cuitCorredorVentaPrimaria": cuit_corredor_venta_primaria, + "cuitCorredorVentaSecundaria": cuit_corredor_venta_secundaria, + "cuitRemitenteComercialVentaPrimaria": cuit_remitente_comercial_venta_primaria, + "cuitRemitenteComercialVentaSecundaria": cuit_remitente_comercial_venta_secundaria, + "cuitRemitenteComercialVentaSecundaria2": cuit_remitente_comercial_venta_secundaria2, + "cuitTransportista": cuit_transportista, + "pesoBruto": peso_bruto, + "codGrano": cod_grano, + }) + response = self.client.editarCPEFerroviaria( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def ConsultarCPEFerroviaria( + self, tipo_cpe=None, cuit_solicitante=None, sucursal=None, nro_orden=None, nro_ctg=None, archivo="cpe.pdf" + ): + """Busca una CPE existente según parámetros de búsqueda y retorna información de la misma.""" + if not nro_ctg: + solicitud = { + "cartaPorte": { + "tipoCPE": tipo_cpe, + "sucursal": sucursal, + "nroOrden": nro_orden, + }, + } + else: + solicitud = { + "nroCTG": nro_ctg, + } + solicitud["cuitSolicitante"] = cuit_solicitante + response = self.client.consultarCPEFerroviaria( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=solicitud, + ) + ret = response.get("respuesta") if ret: self.__analizar_errores(ret) - self.__analizar_observaciones(ret) - self.__analizar_evento(ret) - self.AnalizarCPE(ret) - return bool(self.CodCPE) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True @inicializar_y_capturar_excepciones - def InformarContingencia(self, archivo="qr.png"): - "Reportar una contingencia que impide el envío de la mercadería y realiza la anulación del cpe" - mercaderias = [] - for it in self.cpe['arrayMercaderias']: - mercaderia = it['mercaderia'] - mercaderias.append({"mercaderia": [mercaderia]}) + def ConsultaCPEFerroviariaPorNroOperativo(self, nro_operativo=1111111111): + """Información resumida de cartas de porte asociadas a un mismo número de operativo.""" + response = self.client.consultaCPEFerroviariaPorNroOperativo( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud={"nroOperativo": nro_operativo}, + ) + ret = response.get("respuesta") + # respuesta distinta devuelve un array de resultados 'resumenCartaPorte' + if ret: + self.__analizar_errores(ret) + if 'resumenCartaPorte' in ret: + cps = [ + '\n'.join('{}: {}'.format(campo, valor) for campo, valor in carta_porte.items()) + for carta_porte in ret['resumenCartaPorte'] + ] + return '\n==========\n'.join(cps) - response = self.client.informarContingencia( - authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit}, - informarContingencia={ - 'codigoCPE': self.cpe["codCPE"], - 'tipoContingencia': self.cpe['arrayContingencias'][0]["contingencia"]["tipoContingencia"], - 'observaciones': self.cpe['arrayContingencias'][0]["contingencia"]["observacion"], - 'arrayMercaderiaPerdida': mercaderias, - }) - ret = response.get("informarContingenciaReturn") + @inicializar_y_capturar_excepciones + def ConfirmacionDefinitivaCPEFerroviaria(self, archivo="cpe.pdf"): + """Informar la confirmación definitiva de una carta de porte existente.""" + response = self.client.confirmacionDefinitivaCPEFerroviaria( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") if ret: self.__analizar_errores(ret) - self.__analizar_observaciones(ret) - self.__analizar_evento(ret) + if "cabecera" in ret: self.AnalizarCPE(ret, archivo) - return ret["resultado"] - - @inicializar_y_capturar_excepciones - def ConsultarUltimoCPEEmitido(self, tipo_comprobante=995, punto_emision=1): - "Obtener el último número de cpe que se emitió por tipo de comprobante y punto de emisión" - response = self.client.consultarUltimoCPEEmitido( - authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit}, - tipoComprobante=tipo_comprobante, - puntoEmision=punto_emision) - ret = response.get("consultarUltimoCPEReturn", {}) - id_req = ret.get("idReq", 0) - rec = ret.get("cpe", {}) + return True + + @inicializar_y_capturar_excepciones + def CerrarContingenciaCPE(self, archivo="cpe.pdf"): + """Informar del cierre de una contingencia asociado a una carta de porte ferroviaria.""" + response = self.client.cerrarContingenciaCPE( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def NuevoDestinoDestinatarioCPEFerroviaria(self, archivo="cpe.pdf"): + """Informar el regreso a origen de una carta de porte existente.""" + response = self.client.nuevoDestinoDestinatarioCPEFerroviaria( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def RegresoOrigenCPEFerroviaria(self, archivo="cpe.pdf"): + """Informar el regreso a origen de una carta de porte existente.""" + response = self.client.regresoOrigenCPEFerroviaria( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def DesvioCPEFerroviaria(self, archivo="cpe.pdf"): + """Informar el desvío de una carta de porte existente.""" + response = self.client.desvioCPEFerroviaria( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def EditarCPEAutomotor( + self, + nro_ctg=None, + cuit_corredor_venta_primaria=None, + cuit_corredor_venta_secundaria=None, + cuit_remitente_comercial_venta_primaria=None, + cuit_remitente_comercial_venta_secundaria=None, + cuit_remitente_comercial_venta_secundaria2=None, + cuit_chofer=None, + cuit_transportista=None, + peso_bruto=None, + cod_grano=None, + dominio=None, + archivo="cpe.pdf", + **kwargs + ): + """Modificar datos de una CP Automotor en estado Activo.""" + self.cpe.update({ + "nroCTG": nro_ctg, + "cuitCorredorVentaPrimaria": cuit_corredor_venta_primaria, + "cuitCorredorVentaSecundaria": cuit_corredor_venta_secundaria, + "cuitRemitenteComercialVentaPrimaria": cuit_remitente_comercial_venta_primaria, + "cuitRemitenteComercialVentaSecundaria": cuit_remitente_comercial_venta_secundaria, + "cuitRemitenteComercialVentaSecundaria2": cuit_remitente_comercial_venta_secundaria2, + "cuitChofer": cuit_chofer, + "cuitTransportista": cuit_transportista, + "pesoBruto": peso_bruto, + "codGrano": cod_grano, + "dominio": dominio, + }) + response = self.client.editarCPEAutomotor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def ConsultarCPEAutomotor( + self, tipo_cpe=None, cuit_solicitante=None, sucursal=None, nro_orden=None, nro_ctg=None, archivo="cpe.pdf" + ): + """Busca una CPE existente según parámetros de búsqueda y retorna información de la misma.""" + if not nro_ctg: + solicitud = { + "cartaPorte": { + "tipoCPE": tipo_cpe, + "sucursal": sucursal, + "nroOrden": nro_orden, + }, + } + else: + solicitud = { + "nroCTG": nro_ctg, + } + solicitud["cuitSolicitante"] = cuit_solicitante + response = self.client.consultarCPEAutomotor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=solicitud, + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def ConfirmacionDefinitivaCPEAutomotor(self, archivo="cpe.pdf"): + """Informar la confirmación definitiva de una carta de porte existente.""" + response = self.client.confirmacionDefinitivaCPEAutomotor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") + if ret: + self.__analizar_errores(ret) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def NuevoDestinoDestinatarioCPEAutomotor(self, archivo="cpe.pdf"): + """Informar el nuevo destino o destinatario de una carta deporte existente.""" + response = self.client.nuevoDestinoDestinatarioCPEAutomotor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - self.__analizar_observaciones(ret) - self.__analizar_evento(ret) - self.AnalizarCPE(rec) - return id_req - - @inicializar_y_capturar_excepciones - def ConsultarCPE(self, cod_cpe=None, id_req=None, - tipo_comprobante=None, punto_emision=None, nro_comprobante=None): - "Obtener los datos de un cpe generado" - ##print(self.client.help("consultarCPE")) - response = self.client.consultarCPE( - authRequest={'token': self.Token, 'sign': self.Sign, 'cuitRepresentada': self.Cuit}, - codCPE=cod_cpe, - cuitEmisor=self.Cuit, - idReq=id_req, - tipoComprobante=tipo_comprobante, - puntoEmision=punto_emision, - nroComprobante=nro_comprobante) - ret = response.get("consultarCPEReturn", {}) - id_req = ret.get("idReq", 0) - self.cpe = rec = ret.get("cpe", {}) + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def RegresoOrigenCPEAutomotor(self, archivo="cpe.pdf"): + """Informar el regreso a origen de una carta de porte existente.""" + response = self.client.regresoOrigenCPEAutomotor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - self.__analizar_observaciones(ret) - self.__analizar_evento(ret) - self.AnalizarCPE(rec) - return id_req + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True @inicializar_y_capturar_excepciones - def Dummy(self): - "Obtener el estado de los servidores de la AFIP" - results = self.client.dummy()['dummyReturn'] - self.AppServerStatus = str(results['appserver']) - self.DbServerStatus = str(results['dbserver']) - self.AuthServerStatus = str(results['authserver']) - - @inicializar_y_capturar_excepciones - def ConsultarTiposComprobante(self, sep="||"): - "Obtener el código y descripción para tipo de comprobante" - ret = self.client.consultarTiposComprobante( - authRequest={ - 'token': self.Token, 'sign': self.Sign, - 'cuitRepresentada': self.Cuit, }, - )['consultarTiposComprobanteReturn'] + def DesvioCPEAutomotor(self, archivo="cpe.pdf"): + """Informar el desvío de una carta de porte existente.""" + response = self.client.desvioCPEAutomotor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=self.cpe, + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - array = ret.get('arrayTiposComprobante', []) - lista = [it['codigoDescripcion'] for it in array] - return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista] - - @inicializar_y_capturar_excepciones - def ConsultarPaises(self, sep="||"): - "Obtener el código y descripción para los paises" - ret = self.client.consultarPaises( - authRequest={ - 'token': self.Token, 'sign': self.Sign, - 'cuitRepresentada': self.Cuit, }, - )['consultarCodigosPaisReturn'] + if "cabecera" in ret: + self.AnalizarCPE(ret, archivo) + return True + + @inicializar_y_capturar_excepciones + def ConsultarCPEPorDestino( + self, + planta=None, + fecha_partida_desde=None, + fecha_partida_hasta=None, + tipo_cpe=None, + sep="||" + ): + """Consulta de CPE en calidad de destino para una planta y rango de fechas específicos.""" + solicitud = { + "planta": planta, + "fechaPartidaDesde": fecha_partida_desde, + "fechaPartidaHasta": fecha_partida_hasta, + "tipoCartaPorte": tipo_cpe, + } + response = self.client.consultarCPEPorDestino( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=solicitud + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - array = ret.get('arrayPaises', []) - lista = [it['pais'] for it in array] - return [(u"%s {codigo} %s {cuit} %s {nombre} %s {tipoSujeto} %s" % (sep, sep, sep, sep, sep)).format(**it) if sep else it for it in lista] - - @inicializar_y_capturar_excepciones - def ConsultarTiposContingencia(self, sep="||"): - "Obtener el código y descripción para cada tipo de contingencia que puede reportar" - ret = self.client.consultarTiposContingencia( - authRequest={ - 'token': self.Token, 'sign': self.Sign, - 'cuitRepresentada': self.Cuit, }, - )['codigoDescripcionReturn'] + if "cartaPorte" in ret: + # agrego titulos para respuesta + array = [ + { + "nroCTG": "Nro CTG", + "fechaPartida": "Fecha de Partida", + "estado": "Estado", + "fechaUltimaModificacion": "Ultima fecha de modificacion", + } + ] + array.extend(ret.get("cartaPorte", [])) + return [ + ("%s {nroCTG} %s {fechaPartida} %s {estado} %s {fechaUltimaModificacion} %s" % (sep, sep, sep, sep, sep)).format(**it) + if sep else it for it in array + ] + + @inicializar_y_capturar_excepciones + def ConsultarCPEPendientesDeResolucion(self, perfil=None, planta=None, sep="||"): + """consulta de CPE que se encuentran pendientes de resolución.""" + solicitud = { + "perfil": perfil, + "planta": planta, + } + response = self.client.consultarCPEPPendientesDeResolucion( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud=solicitud + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - array = ret.get('arrayCodigoDescripcion', []) - lista = [it['codigoDescripcion'] for it in array] - return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista] - - @inicializar_y_capturar_excepciones - def ConsultarTiposMercaderia(self, sep="||"): - "Obtener el código y descripción códigos y la descripción para cada tipo de mercadería" - ret = self.client.consultarTiposMercaderia( - authRequest={ - 'token': self.Token, 'sign': self.Sign, - 'cuitRepresentada': self.Cuit, }, - )['codigoDescripcionReturn'] + if "cartaPorte" in ret: + # agrego titulos para respuesta + array = [ + { + "nroCTG": "Nro CTG", + "fechaPartida": "Fecha de Partida", + "estado": "Estado", + "fechaUltimaModificacion": "Ultima fecha de modificacion", + } + ] + array.extend(ret.get("cartaPorte", [])) + return [ + ("%s {nroCTG} %s {fechaPartida} %s {estado} %s {fechaUltimaModificacion} %s" % (sep, sep, sep, sep, sep)).format(**it) + if sep else it for it in array + ] + + @inicializar_y_capturar_excepciones + def ConsultarUltNroOrden(self, sucursal=None, tipo_cpe=None): + """Obtiene el último número de orden de CPE autorizado según número de sucursal.""" + response = self.client.consultarUltNroOrden( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud={"sucursal": sucursal, "tipoCPE": tipo_cpe}, + ) + ret = response.get("respuesta") + self.__analizar_errores(ret) + if "nroOrden" in ret: + self.NroOrden = ret["nroOrden"] + return True + + @inicializar_y_capturar_excepciones + def ConsultarProvincias(self, sep="||"): + """Obtener los códigos numéricos de las provincias.""" + response = self.client.consultarProvincias( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - array = ret.get('arrayCodigoDescripcion', []) - lista = [it['codigoDescripcion'] for it in array] - return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista] - - @inicializar_y_capturar_excepciones - def ConsultarTiposEmbalaje(self, sep="||"): - "Obtener el código y descripción códigos y la descripción para cada tipo de embalaje" - ret = self.client.consultarTiposEmbalaje( - authRequest={ - 'token': self.Token, 'sign': self.Sign, - 'cuitRepresentada': self.Cuit, }, - )['codigoDescripcionReturn'] + array = ret.get("provincia", []) + return [("%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in array] + + @inicializar_y_capturar_excepciones + def ConsultarLocalidadesPorProvincia(self, cod_provincia=1, sep="||"): + """Obtener los códigos de las localidades por provincia.""" + response = self.client.consultarLocalidadesPorProvincia( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud={"codProvincia": cod_provincia}, + ) + ret = response.get("respuesta") + self.__analizar_errores(ret) + array = ret.get("localidad", []) + return [("%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in array] + + @inicializar_y_capturar_excepciones + def ConsultarTiposGrano(self, sep="||"): + """Obtener los códigos numéricos de los tipos de granos.""" + response = self.client.consultarTiposGrano( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - array = ret.get('arrayCodigoDescripcion', []) - lista = [it['codigoDescripcion'] for it in array] - return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista] - - @inicializar_y_capturar_excepciones - def ConsultarTiposUnidades(self, sep="||"): - "Obtener el código y descripción códigos y la descripción para cada tipo de unidades de venta" - ret = self.client.consultarUnidadesMedida( - authRequest={ - 'token': self.Token, 'sign': self.Sign, - 'cuitRepresentada': self.Cuit, }, - )['codigoDescripcionReturn'] + array = ret.get("grano", []) + return [("%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in array] + + @inicializar_y_capturar_excepciones + def ConsultarLocalidadesProductor(self, cuit_productor=None, sep="||"): + """Obtener de localidades del cuit asociado al productor.""" + response = self.client.consultarLocalidadesProductor( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud={"cuit": cuit_productor}, + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - array = ret.get('arrayCodigoDescripcion', []) - lista = [it['codigoDescripcion'] for it in array] - return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista] - - @inicializar_y_capturar_excepciones - def ConsultarCodigosDomicilio(self, cuit_titular=1, sep="||"): - "Obtener el código de depositos que tiene habilitados para operar el cuit informado" - ret = self.client.consultarCodigosDomicilio( - authRequest={ - 'token': self.Token, 'sign': self.Sign, - 'cuitRepresentada': self.Cuit, }, - cuitTitularDomicilio=cuit_titular, - )['consultarCodigosDomicilioReturn'] + array = ret.get("localidad", []) + return [("%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in array] + + @inicializar_y_capturar_excepciones + def ConsultarPlantas(self, cuit, sep="||"): + """Permite la consulta de plantas activas""" + response = self.client.consultarPlantas( + auth={ + "token": self.Token, + "sign": self.Sign, + "cuitRepresentada": self.Cuit, + }, + solicitud={"cuit": cuit}, + ) + ret = response.get("respuesta") self.__analizar_errores(ret) - array = ret.get('arrayDomicilios', []) - lista = [it['codigoDescripcion'] for it in array] - return [(u"%s {codigo} %s {descripcion} %s" % (sep, sep, sep)).format(**it) if sep else it for it in lista] + if "planta" in ret: + # agrego titulos para respuesta + array = [ + { + "nroPlanta": "Nro Planta", + "codProvincia": "Cod Provincia", + "codLocalidad": "Cod Localidad" + } + ] + array.extend(ret.get("planta", [])) + return [ + ("%s {nroPlanta} %s {codProvincia} %s {codLocalidad} %s" % (sep, sep, sep, sep)).format(**it) + if sep else it for it in array + ] + @inicializar_y_capturar_excepciones + def Dummy(self): + """Obtener el estado de los servidores de la AFIP.""" + results = self.client.dummy()["respuesta"] + self.AppServerStatus = str(results["appserver"]) + self.DbServerStatus = str(results["dbserver"]) + self.AuthServerStatus = str(results["authserver"]) -# busco el directorio de instalación (global para que no cambie si usan otra dll) -if not hasattr(sys, "frozen"): - basepath = __file__ -elif sys.frozen=='dll': - import win32api - basepath = win32api.GetModuleFileName(sys.frozendllhandle) -else: - basepath = sys.executable INSTALL_DIR = WSCPE.InstallDir = get_install_dir() - -if __name__ == '__main__': - if '--ayuda' in sys.argv: - print LICENCIA - print AYUDA +if __name__ == "__main__": + # obteniendo el TA + from .wsaa import WSAA + + wsaa_url = "" + wscpe_url = WSDL[HOMO] + + CERT = os.getenv("CERT", "reingart.crt") + PRIVATEKEY = os.getenv("PKEY", "reingart.key") + CUIT = os.getenv("CUIT", "20267565393") + + wsaa = WSAA() + ta = wsaa.Autenticar("wscpe", CERT, PRIVATEKEY, wsaa_url, debug=DEBUG) + if not ta: + sys.exit("Imposible autenticar con WSAA: %s" % wsaa.Excepcion) + + # cliente soap del web service + wscpe = WSCPE() + wscpe.Conectar(wsdl=wscpe_url) + wscpe.SetTicketAcceso(ta) + wscpe.Cuit = CUIT + ok = None + + if "--dummy" in sys.argv: + ret = wscpe.Dummy() + print("AppServerStatus", wscpe.AppServerStatus) + print("DbServerStatus", wscpe.DbServerStatus) + print("AuthServerStatus", wscpe.AuthServerStatus) sys.exit(0) - if "--register" in sys.argv or "--unregister" in sys.argv: - import win32com.server.register - win32com.server.register.UseCommandLine(WSCPE) - sys.exit(0) + if "--autorizar_cpe_automotor" in sys.argv: + ok = wscpe.ConsultarUltNroOrden(sucursal=221, tipo_cpe=74) + nro_orden = wscpe.NroOrden + 1 + ok = wscpe.CrearCPE() + ok = wscpe.AgregarCabecera( + tipo_cpe=74, + cuit_solicitante=CUIT, + sucursal=221, + nro_orden=nro_orden, + observaciones="Notas del transporte" + ) + ok = wscpe.AgregarOrigen( + # planta=1, + # cod_provincia_operador=12, + # cod_localidad_operador=7717, + cod_provincia_productor=1, + cod_localidad_productor=14310 + ) + ok = wscpe.AgregarDestino( + planta=1938, + cod_provincia=12, + es_destino_campo=True, + cod_localidad=14310, + cuit_destino=CUIT, + cuit_destinatario=CUIT, + ) + ok = wscpe.AgregarRetiroProductor( + # certificado_coe=330100025869, + # cuit_remitente_comercial_productor=20111111112, + corresponde_retiro_productor=False, # chequear dice booleano + es_solicitante_campo=True, # chequear dice booleano + ) + ok = wscpe.AgregarIntervinientes( + # cuit_mercado_a_termino=20222222223, + # cuit_corredor_venta_primaria=20200000006, + # cuit_corredor_venta_secundaria=20222222223, + # cuit_remitente_comercial_venta_secundaria=20222222223, + cuit_remitente_comercial_venta_secundaria2=20400000000, + cuit_remitente_comercial_venta_primaria=27000000014, + # cuit_representante_entregador=20222222223, + # cuit_representante_recibidor=20222222223 + ) + ok = wscpe.AgregarDatosCarga( + peso_tara=10, + cod_grano=23, + peso_bruto=110, + cosecha=2021, + ) + ok = wscpe.AgregarTransporte( + cuit_transportista=20120372913, + fecha_hora_partida=datetime.datetime.now() + datetime.timedelta(days=1), + # codigo_turno="00", + dominio=["AA001SC", "BB111CC"], # 1 or more repetitions + km_recorrer=500, + cuit_chofer=20333333334, + # tarifa=100.10, + # cuit_pagador_flete=20333333334, + # cuit_intermediario_flete=20333333334, + mercaderia_fumigada=True, + ) + wscpe.LanzarExcepciones = False + ok = wscpe.AutorizarCPEAutomotor() + if wscpe.NroCTG: + print("Numero de ctg:", wscpe.NroCTG) + print("Fecha de emision:", wscpe.FechaEmision) + print("Estado:", wscpe.Estado, "-", ESTADO_CPE[wscpe.Estado]) + print("Fecha de inicio de estado:", wscpe.FechaInicioEstado) + print("Fecha de vencimiento:", wscpe.FechaVencimiento) + + with open("wscpe.xml", "w") as x: + import xml.dom.minidom + + dom = xml.dom.minidom.parseString(wscpe.XmlRequest) + x.write(dom.toprettyxml()) + + if "--autorizar_cpe_ferroviaria" in sys.argv: + ok = wscpe.CrearCPE() + ok = wscpe.AgregarCabecera( + sucursal=1, + nro_orden=1, + planta=1, + observaciones="Notas del transporte" + ) + ok = wscpe.AgregarDestino( + cuit_destinatario=30000000006, + cuit_destino=20111111112, + es_destino_campo=True, + planta=1, + cod_provincia=12, + cod_localidad=3058, + ) + ok = wscpe.AgregarRetiroProductor( + # certificado_coe=330100025869, + # cuit_remitente_comercial_productor=20111111112, + corresponde_retiro_productor=False, + ) + # ok = wscpe.AgregarIntervinientes( + # cuit_mercado_a_termino=20222222223, + # cuit_corredor_venta_primaria=20222222223, + # cuit_corredor_venta_secundaria=20222222223, + # cuit_remitente_comercial_venta_secundaria=20222222223, + # cuit_remitente_comercial_venta_secundaria2=20222222223, + # cuit_remitente_comercial_venta_primaria=20222222223, + # cuit_representante_entregador=20222222223, + # cuit_representante_recibidor=20222222223, # nuevo + # ) + ok = wscpe.AgregarDatosCarga( + peso_tara=1000, + cod_grano=31, + peso_bruto=1000, + cosecha=910, + ) + ok = wscpe.AgregarTransporte( + # cuit_pagador_flete=20333333335, + cuit_transportista=20333333334, + # cuit_transportista_tramo2=20222222223, + nro_vagon=55555555, + nro_precinto=1, + nro_operativo=1111111111, + fecha_hora_partida=datetime.datetime.now(), + km_recorrer=500, + codigo_ramal=99, + descripcion_ramal="XXXXX", + mercaderia_fumigada=True, + ) + wscpe.AutorizarCPEFerroviaria() + if wscpe.NroCTG: + print(wscpe.NroCTG) + print(wscpe.FechaEmision) + print(wscpe.Estado) + print(wscpe.FechaInicioEstado) + print(wscpe.FechaVencimiento) + + with open("wscpe.xml", "w") as x: + import xml.dom.minidom + + dom = xml.dom.minidom.parseString(wscpe.XmlRequest) + x.write(dom.toprettyxml()) + + if "--ult" in sys.argv: + wscpe.ConsultarUltNroOrden(sucursal=221, tipo_cpe=74) + if wscpe.NroOrden: + print("Nro Orden: ", wscpe.NroOrden) + + if "--anular_cpe" in sys.argv: + wscpe.AgregarCabecera(tipo_cpe=74, sucursal=1, nro_orden=1) + wscpe.AnularCPE() + + if "--rechazo_cpe" in sys.argv: + wscpe.AgregarCabecera(cuit_solicitante=CUIT, tipo_cpe=74, sucursal=1, nro_orden=1) + wscpe.RechazoCPE() + + if "--confirmar_arribo_cpe" in sys.argv: + wscpe.AgregarCabecera(cuit_solicitante=CUIT, tipo_cpe=74, sucursal=1, nro_orden=1) + wscpe.ConfirmarArriboCPE() + + if "--informar_contingencia" in sys.argv: + wscpe.AgregarCabecera(cuit_solicitante=CUIT, tipo_cpe=74, sucursal=1, nro_orden=1) + wscpe.AgregarContingencia(concepto="F", descripcion="XXXXX") + wscpe.InformarContingencia() + + if "--descargado_destino_cpe" in sys.argv: + wscpe.AgregarCabecera( + cuit_solicitante=CUIT, + tipo_cpe=74, + sucursal=1, + nro_orden=1, + ) + wscpe.DescargadoDestinoCPE() + + if "--editar_cpe_ferroviaria" in sys.argv: + wscpe.AgregarDestino( + cuit_destinatario=30000000006, + cuit_destino=20111111112, + es_destino_campo=True, + cod_provincia=1, + cod_localidad=10216, + planta=1, + ) + wscpe.EditarCPEFerroviaria( + nro_ctg=10100000542, + cuit_corredor_venta_primaria=20222222223, + cuit_corredor_venta_secundaria=20222222223, + cuit_remitente_comercial_venta_primaria=20222222223, + cuit_remitente_comercial_venta_secundaria=20222222223, + cuit_remitente_comercial_venta_secundaria2=20111111113, + cuit_transportista=20120372913, + peso_bruto=1000, + cod_grano=31, + ) - from ConfigParser import SafeConfigParser - - try: - - if "--version" in sys.argv: - print "Versión: ", __version__ - - for arg in sys.argv[1:]: - if arg.startswith("--"): - break - print "Usando configuración:", arg - CONFIG_FILE = arg - - config = SafeConfigParser() - config.read(CONFIG_FILE) - CERT = config.get('WSAA','CERT') - PRIVATEKEY = config.get('WSAA','PRIVATEKEY') - CUIT = config.get('WSCPE','CUIT') - ENTRADA = config.get('WSCPE','ENTRADA') - SALIDA = config.get('WSCPE','SALIDA') - - if config.has_option('WSAA','URL') and not HOMO: - wsaa_url = config.get('WSAA','URL') - else: - wsaa_url = None - if config.has_option('WSCPE','URL') and not HOMO: - wscpe_url = config.get('WSCPE','URL') - else: - wscpe_url = WSDL[HOMO] + if "--consultar_cpe_ferroviaria" in sys.argv: + wscpe.ConsultarCPEFerroviaria(tipo_cpe=75, sucursal=1, nro_orden=1, cuit_solicitante=CUIT) - if config.has_section('DBF'): - conf_dbf = dict(config.items('DBF')) - if DEBUG: print "conf_dbf", conf_dbf - else: - conf_dbf = {} - - DEBUG = '--debug' in sys.argv - XML = '--xml' in sys.argv - - if DEBUG: - print "Usando Configuración:" - print "wsaa_url:", wsaa_url - print "wscpe_url:", wscpe_url - - # obteniendo el TA - from wsaa import WSAA - wsaa = WSAA() - ta = wsaa.Autenticar("wscpe", CERT, PRIVATEKEY, wsaa_url, debug=DEBUG) - ##if not ta: - ## sys.exit("Imposible autenticar con WSAA: %s" % wsaa.Excepcion) - - # cliente soap del web service - wscpe = WSCPE() - wscpe.Conectar(wsdl=wscpe_url) - print(wscpe.client.help("autorizarCPEAutomotor")) - wscpe.SetTicketAcceso(ta) - wscpe.Cuit = CUIT - ok = None - - if '--dummy' in sys.argv: - ret = wscpe.Dummy() - print "AppServerStatus", wscpe.AppServerStatus - print "DbServerStatus", wscpe.DbServerStatus - print "AuthServerStatus", wscpe.AuthServerStatus - sys.exit(0) - - if '--ult' in sys.argv: - try: - pto_emision = int(sys.argv[sys.argv.index("--ult") + 1]) - except IndexError, ValueError: - pto_emision = 1 - try: - tipo_cbte = int(sys.argv[sys.argv.index("--ult") + 1]) - except IndexError, ValueError: - tipo_comprobante = 995 - rec = {} - print "Consultando ultimo cpe pto_emision=%s tipo_comprobante=%s" % (pto_emision, tipo_comprobante) - ok = wscpe.ConsultarUltimoCPEEmitido(tipo_comprobante, pto_emision) - if wscpe.Excepcion: - print >> sys.stderr, "EXCEPCION:", wscpe.Excepcion - if DEBUG: print >> sys.stderr, wscpe.Traceback - print "Ultimo Nro de CPE", wscpe.NroCPE - print "Errores:", wscpe.Errores - - if '--consultar' in sys.argv: - rec = {} - try: - cod_cpe = sys.argv[sys.argv.index("--consultar") + 1] - print "Consultando cpe cod_cpe=%s" % (cod_cpe, ) - ok = wscpe.ConsultarCPE(cod_cpe=cod_cpe) - except IndexError, ValueError: - pto_emision = raw_input("Punto de emision [1]:") or 1 - tipo_cbte = raw_input("Tipo de comprobante [995]:") or 995 - nro_comprobante = raw_input("Nro de comprobante:") or 1 - ok = wscpe.ConsultarCPE(tipo_comprobante=tipo_cbte, - punto_emision=pto_emision, - nro_comprobante=nro_comprobante) - if wscpe.Excepcion: - print >> sys.stderr, "EXCEPCION:", wscpe.Excepcion - if DEBUG: print >> sys.stderr, wscpe.Traceback - print "Ultimo Nro de CPE", wscpe.NroCPE - print "Errores:", wscpe.Errores - if DEBUG: - import pprint - pprint.pprint(wscpe.cpe) - - ##wscpe.client.help("generarCPE") - if '--prueba' in sys.argv: - rec = dict( - tipo_comprobante=997, punto_emision=1, - tipo_titular_mercaderia=1, - cuit_titular_mercaderia='20222222223', - cuit_autorizado_retirar='20111111112', - cuit_productor_contrato=None, - numero_maquila=9999, - cod_cpe=1234 if '--informar-contingencia' in sys.argv else None, - estado=None, - id_req=int(time.time()), - es_entrega_mostrador='S', - ) - if "--autorizar" in sys.argv: - rec["estado"] = 'A' # 'A': Autorizar, 'D': Denegar - rec['receptor'] = dict( - cuit_pais_receptor='50000000016', - cuit_receptor='20111111112', cod_dom_receptor=1, - cuit_despachante=None, codigo_aduana=None, - denominacion_receptor=None, domicilio_receptor=None) - rec['viaje'] = dict(fecha_inicio_viaje='2020-04-01', distancia_km=999, cod_pais_transportista=200, ducto="S") - rec['viaje']['vehiculo'] = dict( - dominio_vehiculo='AAA000', dominio_acoplado='ZZZ000', - cuit_transportista='20333333334', cuit_conductor='20333333334', - apellido_conductor=None, cedula_conductor=None, denom_transportista=None, - id_impositivo=None, nombre_conductor=None) - rec['mercaderias'] = [dict(orden=1, cod_tipo_prod=1, cod_tipo_emb=1, cantidad_emb=1, cod_tipo_unidad=1, cant_unidad=1, - anio_safra=2019 )] - rec['datos_autorizacion'] = None # dict(nro_cpe=None, cod_autorizacion=None, fecha_emision=None, fecha_vencimiento=None) - rec['contingencias'] = [dict(tipo=1, observacion="anulacion")] - with open(ENTRADA, "w") as archivo: - json.dump(rec, archivo, sort_keys=True, indent=4) - - if '--cargar' in sys.argv: - with open(ENTRADA, "r") as archivo: - rec = json.load(archivo) - wscpe.CrearCPE(**rec) - if 'receptor' in rec: - wscpe.AgregarReceptor(**rec['receptor']) - if 'viaje' in rec: - wscpe.AgregarViaje(**rec['viaje']) - if not rec["viaje"].get("ducto"): - wscpe.AgregarVehiculo(**rec['viaje']['vehiculo']) - for mercaderia in rec.get('mercaderias', []): - wscpe.AgregarMercaderia(**mercaderia) - datos_aut = rec.get('datos_autorizacion') - if datos_aut: - wscpe.AgregarDatosAutorizacion(**datos_aut) - for contingencia in rec.get('contingencias', []): - wscpe.AgregarContingencias(**contingencia) - - if '--generar' in sys.argv: - if '--testing' in sys.argv: - wscpe.LoadTestXML("tests/xml/wscpe.xml") # cargo respuesta - - ok = wscpe.GenerarCPE(id_req=rec['id_req'], archivo="qr.jpg") - - if '--emitir' in sys.argv: - ok = wscpe.EmitirCPE() - - if '--autorizar' in sys.argv: - ok = wscpe.AutorizarCPE() - - if '--anular' in sys.argv: - ok = wscpe.AnularCPE() - - if '--informar-contingencia' in sys.argv: - ok = wscpe.InformarContingencia() - - if ok is not None: - print "Resultado: ", wscpe.Resultado - print "Cod CPE: ", wscpe.CodCPE - if wscpe.CodAutorizacion: - print "Numero CPE: ", wscpe.NroCPE - print "Cod Autorizacion: ", wscpe.CodAutorizacion - print "Fecha Emision", wscpe.FechaEmision - print "Fecha Vencimiento", wscpe.FechaVencimiento - print "Estado: ", wscpe.Estado - print "Observaciones: ", wscpe.Observaciones - print "Errores:", wscpe.Errores - print "Errores Formato:", wscpe.ErroresFormato - print "Evento:", wscpe.Evento - rec['cod_cpe'] = wscpe.CodCPE - rec['resultado'] = wscpe.Resultado - rec['observaciones'] = wscpe.Observaciones - rec['fecha_emision'] = wscpe.FechaEmision - rec['fecha_vencimiento'] = wscpe.FechaVencimiento - rec['errores'] = wscpe.Errores - rec['errores_formato'] = wscpe.ErroresFormato - rec['evento'] = wscpe.Evento - - if '--grabar' in sys.argv: - with open(SALIDA, "w") as archivo: - json.dump(rec, archivo, sort_keys=True, indent=4, default=json_serializer) - - # Recuperar parámetros: - - if '--tipos_comprobante' in sys.argv: - ret = wscpe.ConsultarTiposComprobante() - print "\n".join(ret) - - if '--tipos_contingencia' in sys.argv: - ret = wscpe.ConsultarTiposContingencia() - print "\n".join(ret) - - if '--tipos_mercaderia' in sys.argv: - ret = wscpe.ConsultarTiposMercaderia() - print "\n".join(ret) - - if '--tipos_embalaje' in sys.argv: - ret = wscpe.ConsultarTiposEmbalaje() - print "\n".join(ret) - - if '--tipos_unidades' in sys.argv: - ret = wscpe.ConsultarTiposUnidades() - print "\n".join(ret) - - if '--tipos_categoria_emisor' in sys.argv: - ret = wscpe.ConsultarTiposCategoriaEmisor() - print "\n".join(ret) - - if '--tipos_categoria_receptor' in sys.argv: - ret = wscpe.ConsultarTiposCategoriaReceptor() - print "\n".join(ret) - - if '--tipos_estados' in sys.argv: - ret = wscpe.ConsultarTiposEstado() - print "\n".join(ret) - - if '--paises' in sys.argv: - ret = wscpe.ConsultarPaises() - print "\n".join(ret) - - if '--grupos_granos' in sys.argv: - ret = wscpe.ConsultarGruposAzucar() - print "\n".join(ret) - - if '--tipos_granos' in sys.argv: - for grupo_granos in wscpe.ConsultarGruposAzucar(sep=None): - ret = wscpe.ConsultarTiposAzucar(grupo_granos['codigo']) - print "\n".join(ret) - - if '--codigos_domicilio' in sys.argv: - cuit = raw_input("Cuit Titular Domicilio: ") - ret = wscpe.ConsultarCodigosDomicilio(cuit) - print "\n".join(utils.norm(ret)) - - if wscpe.Errores or wscpe.ErroresFormato: - print "Errores:", wscpe.Errores, wscpe.ErroresFormato - - print "hecho." - - except SoapFault,e: - print "Falla SOAP:", e.faultcode, e.faultstring.encode("ascii","ignore") - sys.exit(3) - except Exception, e: - ex = utils.exception_info() - print ex - if DEBUG: - raise - sys.exit(5) + if "--consulta_cpe_ferroviaria_por_nro_operativo" in sys.argv: + wscpe.ConsultaCPEFerroviariaPorNroOperativo(nro_operativo=1111111111) + + if "--confirmacion_definitiva_cpe_ferroviaria" in sys.argv: + wscpe.AgregarCabecera( + cuit_solicitante=CUIT, tipo_cpe=75, sucursal=1, nro_orden=1 + ) + # wscpe.AgregarDestino( + # cuit_destinatario=30000000006, + # ) + # wscpe.AgregarIntervinientes( + # cuit_corredor_venta_primaria=20222222223, + # cuit_corredor_venta_secundaria=20222222223, + # cuit_remitente_comercial_venta_primaria=20222222223, + # cuit_remitente_comercial_venta_secundaria=20222222223, + # cuit_remitente_comercial_venta_secundaria2=20222222223, + # cuit_representante_recibidor=20222222223, # nuevo + # ) + wscpe.AgregarDatosCarga(peso_bruto=1000, peso_tara=10000) + wscpe.AgregarTransporte( + codigo_ramal=99, + descripcion_ramal="XXXXX", + ) + wscpe.ConfirmacionDefinitivaCPEFerroviaria() + + if "--cerrar_contingencia" in sys.argv: + wscpe.AgregarCabecera( + tipo_cpe=75, + sucursal=1, + nro_orden=1, + ) + wscpe.AgregarCerrarContingencia( + concepto="A", + # cuit_transportista=20333333334, + # nro_operativo=1111111111, + # concepto_desactivacion="A", + # descripcion="bloqueo" + ) + wscpe.CerrarContingenciaCPE() + + if "--nuevo_destino_destinatario_cpe_ferroviaria" in sys.argv: + wscpe.AgregarCabecera( + tipo_cpe=75, + sucursal=1, + nro_orden=1, + ) + wscpe.AgregarDestino( + # cuit_destinatario=30000000006, + cuit_destino=20111111112, + cod_provincia=1, + cod_localidad=10216, + planta=1, + ) + wscpe.AgregarTransporte( + codigo_ramal=99, + descripcion_ramal="Ok", + fecha_hora_partida=datetime.datetime.now()+datetime.timedelta(days=1), + km_recorrer=333, + ) + wscpe.NuevoDestinoDestinatarioCPEFerroviaria() + + if "--regreso_origen_cpe_ferroviaria" in sys.argv: + wscpe.AgregarCabecera( + cuit_solicitante=CUIT, + tipo_cpe=75, + sucursal=1, + nro_orden=1, + ) + wscpe.AgregarTransporte( + codigo_ramal=99, + descripcion_ramal="Ok", + fecha_hora_partida=datetime.datetime.now(), + km_recorrer=333, + ) + wscpe.RegresoOrigenCPEFerroviaria() + + if "--desvio_cpe_ferroviaria" in sys.argv: + wscpe.AgregarCabecera( + cuit_solicitante=CUIT, + tipo_cpe=75, + sucursal=1, + nro_orden=1, + ) + wscpe.AgregarDestino( + cuit_destino=20111111112, + cod_provincia=1, + cod_localidad=10216, + planta=1, + # es_destino_campo=True, + ) + wscpe.AgregarTransporte( + codigo_ramal=99, + descripcion_ramal="Ok", + fecha_hora_partida=datetime.datetime.now() + datetime.timedelta(days=1), + km_recorrer=333, + ) + wscpe.DesvioCPEFerroviaria() + + if "--editar_cpe_automotor" in sys.argv: + wscpe.AgregarDestino( + cuit_destinatario=30000000006, + cuit_destino=20111111112, + es_destino_campo=True, + cod_provincia=1, + cod_localidad=10216, + planta=1, + ) + wscpe.EditarCPEAutomotor( + nro_ctg=10100000542, + cuit_corredor_venta_primaria=20222222223, + cuit_corredor_venta_secundaria=20222222223, + cuit_remitente_comercial_venta_primaria=20222222223, + cuit_remitente_comercial_venta_secundaria=20222222223, + cuit_remitente_comercial_venta_secundaria2=20222222223, + cuit_chofer=20333333334, + cuit_transportista=20120372913, + peso_bruto=1000, + cod_grano=31, + dominio=["AA001ST"], + ) + + if "--consultar_cpe_automotor" in sys.argv: + wscpe.ConsultarCPEAutomotor(tipo_cpe=74, sucursal=1, nro_orden=1, cuit_solicitante=CUIT) + + if "--confirmacion_definitiva_cpe_automotor" in sys.argv: + wscpe.AgregarCabecera(cuit_solicitante=CUIT, tipo_cpe=74, sucursal=1, nro_orden=1) + # wscpe.AgregarIntervinientes(cuit_representante_recibidor=20222222223) + wscpe.AgregarDatosCarga(peso_bruto=1000, peso_tara=10000) + wscpe.ConfirmacionDefinitivaCPEAutomotor() + + if "--nuevo_destino_destinatario_cpe_automotor" in sys.argv: + wscpe.AgregarCabecera(tipo_cpe=74, sucursal=1, nro_orden=1) + wscpe.AgregarDestino( + cuit_destino=20111111112, cod_provincia=1, cod_localidad=10216, planta=1, es_destino_campo=True, cuit_destinatario=30000000006 + ) + wscpe.AgregarTransporte(fecha_hora_partida=datetime.datetime.now(), km_recorrer=333, codigo_turno="00") + wscpe.NuevoDestinoDestinatarioCPEAutomotor() + + if "--regreso_origen_cpe_automotor" in sys.argv: + wscpe.AgregarCabecera(tipo_cpe=74, sucursal=1, nro_orden=1) + wscpe.AgregarTransporte(fecha_hora_partida=datetime.datetime.now(), km_recorrer=333, codigo_turno="00") + wscpe.RegresoOrigenCPEAutomotor() + + if "--desvio_cpe_automotor" in sys.argv: + wscpe.AgregarCabecera(cuit_solicitante=CUIT, tipo_cpe=74, sucursal=1, nro_orden=1) + wscpe.AgregarDestino( + cuit_destino=20111111112, cod_provincia=1, cod_localidad=10216, planta=1, es_destino_campo=True # newton + ) + wscpe.AgregarTransporte(fecha_hora_partida=datetime.datetime.now(), km_recorrer=333, codigo_turno="00") + wscpe.DesvioCPEAutomotor() + + if "--consultar_cpe_por_destino" in sys.argv: + today = datetime.datetime.now().date() + ret = wscpe.ConsultarCPEPorDestino( + planta=1938, + fecha_partida_desde=today - datetime.timedelta(days=3), # solo hasta 3 dias antes + fecha_partida_hasta=today, + tipo_cpe=74 # opcional + ) + if ret: + print("\n".join(ret)) + + if "--consultar_cpe_pendientes_de_resolucion" in sys.argv: + ret = wscpe.ConsultarCPEPendientesDeResolucion( + perfil="S", # S: Solicitante, D: Destino + # planta=1938, + ) + if ret: + print("\n".join(ret)) + + if "--provincias" in sys.argv: + ret = wscpe.ConsultarProvincias() + print("\n".join(ret)) + + if "--localidades_por_provincias" in sys.argv: + ret = wscpe.ConsultarLocalidadesPorProvincia() + print("\n".join(ret)) + + if "--tipos_grano" in sys.argv: + ret = wscpe.ConsultarTiposGrano() + print("\n".join(ret)) + + if "--localidades_productor" in sys.argv: + ret = wscpe.ConsultarLocalidadesProductor(cuit_productor=CUIT) + print("\n".join(ret)) + + if "--plantas" in sys.argv: + ret = wscpe.ConsultarPlantas(cuit=CUIT) + if ret: + print("\n".join(ret)) + + if "--debug" in sys.argv: + with open("xml_response.xml", "wb") as bh: + bh.write(wscpe.XmlResponse) + with open("xml_request.xml", "wb") as bh: + bh.write(wscpe.XmlRequest) + + if wscpe.Errores: + print("Error:", wscpe.ErrMsg)