Beispiel #1
0
def leer_archivo(nombre_archivo):
    archivo = open(nombre_archivo, "r")
    items = []
    ext = os.path.splitext(nombre_archivo)[1]
    if ext == '.csv':
        csv_reader = csv.reader(open(ENTRADA), dialect='excel', delimiter=";")
        for row in csv_reader:
            items.append(row)
        cols = [str(it).strip() for it in items[0]]
        # armar diccionario por cada linea
        items = [dict([(cols[i],str(v).strip()) for i,v in enumerate(item)]) for item in items[1:]]
        return cols, items
    elif ext == '.json':
        items = json.load(archivo)
    elif ext == '.dbf':
        dic = {}
        formatos = [('Encabezado', ENCABEZADO, dic), ]
        leer_dbf(formatos, conf_dbf)
        items = [dic]
    elif ext == '.txt':
        dic = {}
        for linea in archivo:
            if str(linea[0])=='0':
                dic.update(leer(linea, ENCABEZADO))
            else:
                print "Tipo de registro incorrecto:", linea[0]
        items.append(dic)
    else:
        raise RuntimeError("Extension de archivo desconocida: %s" % ext)
    archivo.close()
    cols = [k[0] for k in ENCABEZADO]
    return cols, items
Beispiel #2
0
def leer_archivo(nombre_archivo):
    archivo = open(nombre_archivo, "r")
    if '--json' in sys.argv:
        dic = json.load(archivo)
    elif '--dbf' in sys.argv:
        dic = {}
        formatos = [
            ('Encabezado', ENCABEZADO, dic),
        ]
        leer_dbf(formatos, conf_dbf)
    else:
        dic = {}
        for linea in archivo:
            if str(linea[0]) == '0':
                d = leer(linea, ENCABEZADO)
                dic.update(d)
            else:
                print "Tipo de registro incorrecto:", linea[0]
    archivo.close()

    if not 'cod_autorizacion' in dic:
        raise RuntimeError(
            "Archivo de entrada invalido, revise campos y lineas en blanco")

    return dic
Beispiel #3
0
def leer_archivo(nombre_archivo):
    archivo = open(nombre_archivo, "r")
    if '--json' in sys.argv:
        dic = json.load(archivo)
    elif '--dbf' in sys.argv:
        dic = {}
        formatos = [('Encabezado', ENCABEZADO, dic), 
                    ]
        leer_dbf(formatos, conf_dbf)
    else:
        dic = {}
        for linea in archivo:
            if str(linea[0])=='0':
                d = leer(linea, ENCABEZADO)
                dic.update(d)
            else:
                print "Tipo de registro incorrecto:", linea[0]
    archivo.close()
                
    if not 'cod_autorizacion' in dic:
        raise RuntimeError("Archivo de entrada invalido, revise campos y lineas en blanco")

    return dic
Beispiel #4
0
def main():
    "Función principal de pruebas (obtener CAE)"
    import os, time, sys
    global WSDL, LOCATION

    DEBUG = '--debug' in sys.argv

    ws = TrazaVet()
    
    ws.Username = '******'
    ws.Password = '******'
    
    if '--prod' in sys.argv and not H**O:
        WSDL = "https://servicios.pami.org.ar/trazavet.WebService?wsdl"
        print "Usando WSDL:", WSDL
        sys.argv.pop(sys.argv.index("--prod"))

    if '--proxy' in sys.argv and not H**O:
        proxy = sys.argv.pop(sys.argv.index("--proxy") + 1)
        print "Usando proxy:", proxy
        sys.argv.pop(sys.argv.index("--proxy"))
    else:
        proxy = None

    # Inicializo las variables y estructuras para el archivo de intercambio:
    transaccion_dto = []
    transacciones = []
    errores = []
    formatos = [('TransaccionDTO', TRANSACCION_DTO, transaccion_dto), 
                ('Transacciones', TRANSACCIONES, transacciones),
                ('Errores', ERRORES, errores),
               ]

    if '--formato' in sys.argv:
        print "Formato:"
        for msg, formato, lista in formatos:
            comienzo = 1
            print "=== %s ===" % msg
            print "|| %-25s || %-12s || %-5s || %-4s || %-10s ||" % (  
                "Nombre", "Tipo", "Long.", "Pos(txt)", "Campo(dbf)")
            claves = []
            for fmt in formato:
                clave, longitud, tipo = fmt[0:3]
                clave_dbf = dar_nombre_campo_dbf(clave, claves)
                claves.append(clave_dbf)
                print "|| %-25s || %-12s || %5d ||   %4d   || %-10s ||" % (
                    clave, tipo, longitud, comienzo, clave_dbf)
                comienzo += longitud
        sys.exit(0)
        
    if '--cargar' in sys.argv:
        if '--dbf' in sys.argv:
            leer_dbf(formatos[:1], {})        
        elif '--json' in sys.argv:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".json", "r")
                d = json.load(archivo)
                formato[2].extend(d)
                archivo.close()
        else:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".txt", "r")
                for linea in archivo:
                    d = leer(linea, formato[1])
                    formato[2].append(d)
                archivo.close()
        
    ws.Conectar("", WSDL, proxy)
    
    if ws.Excepcion:
        print ws.Excepcion
        print ws.Traceback
        sys.exit(-1)
    
    # Datos de pruebas:
    
    if '--test' in sys.argv:
        transaccion_dto.append(dict(
            gln_origen="9876543210982", gln_destino="3692581473693", 
            f_operacion=datetime.datetime.now().strftime("%d/%m/%Y"),
            f_elaboracion=datetime.datetime.now().strftime("%d/%m/%Y"),
            f_vto=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"),
            id_evento=11,
            cod_producto="88900000000001",
            n_cantidad=1,
            n_serie=int(time.time()*10), 
            n_lote=datetime.datetime.now().strftime("%Y"),
            n_cai="123456789012345",
            n_cae="",
            id_motivo_destruccion=0,
            n_manifiesto="",
            en_transporte="N",
            n_remito="1234",
            motivo_devolucion="",
            observaciones="prueba",
            n_vale_compra="",
            apellidoNombres="Juan Peres",
            direccion="Saraza", numero="1234", 
            localidad="Hurlingham", provincia="Buenos Aires",
            n_postal="1688",
            cuit="20267565393",
            codigo_transaccion=None,
        ))

    # Opciones principales:
    
    if '--confirma' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML("trazamed_confirma.xml")  # cargo respuesta
            ok = ws.SendConfirmaTransacc(usuario="pruebasws", password="******",
                                   p_ids_transac="1", f_operacion="31-12-2013")
            if not ok:
                raise RuntimeError(ws.Excepcion)
        ws.SendConfirmaTransacc(*sys.argv[sys.argv.index("--confirma")+1:])
    elif '--alerta' in sys.argv:
        ws.SendAlertaTransacc(*sys.argv[sys.argv.index("--alerta")+1:])
    elif '--cancela' in sys.argv:
        ws.SendCancelaTransac(*sys.argv[sys.argv.index("--cancela")+1:])
    elif '--consulta' in sys.argv:
        ws.GetTransacciones(
                            *sys.argv[sys.argv.index("--consulta")+1:]
                            )
        print "CantPaginas", ws.CantPaginas
        print "HayError", ws.HayError
        #print "TransaccionSenasa", ws.TransaccionSenasa
        # parametros comunes de salida (columnas de la tabla):
        claves = [k for k, v, l in TRANSACCIONES]
        # extiendo la lista de resultado para el archivo de intercambio:
        transacciones.extend(ws.TransaccionSenasa)
        # encabezado de la tabla:
        print "||", "||".join(["%s" % clave for clave in claves]), "||"
        # recorro los datos devueltos (TransaccionSenasa):
        while ws.LeerTransaccion():     
            for clave in claves:
                print "||", ws.GetParametro(clave),         # imprimo cada fila
            print "||"
    else:
        argv = [argv for argv in sys.argv if not argv.startswith("--")]
        if not transaccion_dto:
            if len(argv)>10:
                ws.SaveTransaccion(*argv[1:])
            else:
                print "ERROR: no se indicaron todos los parámetros requeridos"
        elif transaccion_dto:
            try:
                usuario, password = argv[-2:]
            except:
                print "ADVERTENCIA: no se indico parámetros usuario y passoword"
                usuario, password = "******", "Clave2013"
            for i, dto in enumerate(transaccion_dto):
                print "Procesando registro", i
                del dto['codigo_transaccion']
                ws.SaveTransaccion(usuario, password, **dto)
                dto['codigo_transaccion'] = ws.CodigoTransaccion
                errores.extend(ws.errores)
                print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                    ws.Resultado,
                    ws.CodigoTransaccion,
                    '|'.join(ws.Errores or []),
                    )
        else:
            print "ERROR: no se especificaron productos a informar"
            
    if not transaccion_dto:
        print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                ws.Resultado,
                ws.CodigoTransaccion,
                '|'.join(ws.Errores or []),
                )

    if ws.Excepcion:
        print ws.Traceback

    if '--grabar' in sys.argv:
        if '--dbf' in sys.argv:
            guardar_dbf(formatos, True, {})        
        elif '--json' in sys.argv:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".json", "w")
                json.dump(formato[2], archivo, sort_keys=True, indent=4)
                archivo.close()
        else:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".txt", "w")
                for it in formato[2]:
                    archivo.write(escribir(it, formato[1]))
            archivo.close()
Beispiel #5
0
def autorizar(ws, entrada, salida, informar_caea=False):
    encabezados = []
    if '/dbf' in sys.argv:
        tributos = []
        ivas = []
        cbtasocs = []
        encabezados = []
        opcionales = []
        compradores = []
        if DEBUG: print "Leyendo DBF..."

        formatos = [('Encabezado', ENCABEZADO, encabezados), 
                    ('Tributo', TRIBUTO, tributos), 
                    ('Iva', IVA, ivas), 
                    ('Comprobante Asociado', CMP_ASOC, cbtasocs),
                    ('Datos Opcionales', OPCIONAL, opcionales),
                    ('Compradores', COMPRADOR, compradores),
                    ]
        dic = leer_dbf(formatos, conf_dbf)
        
        # rearmar estructura asociando id (comparando, si se útiliza)
        for encabezado in encabezados:
            for tributo in tributos:
                if tributo.get("id") == encabezado.get("id"):
                    encabezado.setdefault("tributos", []).append(tributo)
            for iva in ivas:
                if iva.get("id") == encabezado.get("id"):
                    encabezado.setdefault("ivas", []).append(iva)
            for cbtasoc in cbtasocs:
                if cbtasoc.get("id") == encabezado.get("id"):
                    encabezado.setdefault("cbtasocs", []).append(cbtasoc)
            for opcional in opcionales:
                if opcional.get("id") == encabezado.get("id"):
                    encabezado.setdefault("opcionales", []).append(opcional)
            for comprador in compradores:
                if comprador.get("id") == encabezado.get("id"):
                    encabezado.setdefault("compradores", []).append(comprador)
            if encabezado.get("id") is None and len(encabezados) > 1:
                # compatibilidad hacia atrás, descartar si hay más de 1 factura
                warnings.warn("Para múltiples registros debe usar campo id!")
                break
    elif '/json' in sys.argv:
        # ya viene estructurado
        import json
        encabezados = json.load(entrada)
    else:
        # la estructura está implícita en el órden de los registros (líneas)
        for linea in entrada:
            if str(linea[0])=='0':
                encabezado = leer(linea, ENCABEZADO)
                encabezados.append(encabezado)
                if DEBUG: print len(encabezados), "Leida factura %(cbt_desde)s" % encabezado 
            elif str(linea[0])=='1':
                tributo = leer(linea, TRIBUTO)
                encabezado.setdefault("tributos", []).append(tributo)
            elif str(linea[0])=='2':
                iva = leer(linea, IVA)
                encabezado.setdefault("ivas", []).append(iva)
            elif str(linea[0])=='3':
                cbtasoc = leer(linea, CMP_ASOC)
                encabezado.setdefault("cbtasocs", []).append(cbtasoc)
            elif str(linea[0])=='6':
                opcional = leer(linea, OPCIONAL)
                encabezado.setdefault("opcionales", []).append(opcional)
            elif str(linea[0])=='7':
                comprador = leer(linea, COMPRADOR)
                encabezado.setdefault("compradores", []).append(comprador)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if not encabezados:
        raise RuntimeError("No se pudieron leer los registros de la entrada")

    # ajusto datos para pruebas en depuración (nro de cbte. / fecha)
    if '--testing' in sys.argv and DEBUG:
        encabezado['punto_vta'] = 9998
        cbte_nro = int(ws.CompUltimoAutorizado(encabezado['tipo_cbte'], 
                                               encabezado['punto_vta'])) + 1
        encabezado['cbt_desde'] = cbte_nro
        encabezado['cbt_hasta'] = cbte_nro
        encabezado['fecha_cbte'] = datetime.datetime.now().strftime("%Y%m%d")

    # recorrer los registros para obtener CAE (dicts tendrá los procesados)
    dicts = []
    for encabezado in encabezados:
        if informar_caea:
            if '/testing' in sys.argv:
                encabezado['cae'] = '21073372218437'
            encabezado['caea'] = encabezado['cae']
        # extraer sub-registros:
        ivas = encabezado.get('ivas', encabezado.get('iva', []))
        tributos = encabezado.get('tributos', [])
        cbtasocs = encabezado.get('cbtasocs', [])
        opcionales = encabezado.get('opcionales', [])
        compradores = encabezado.get('compradores', [])

        ws.CrearFactura(**encabezado)
        for tributo in tributos:
            ws.AgregarTributo(**tributo)
        for iva in ivas:
            ws.AgregarIva(**iva)
        for cbtasoc in cbtasocs:
            ws.AgregarCmpAsoc(**cbtasoc)
        for opcional in opcionales:
            ws.AgregarOpcional(**opcional)
        for comprador in compradores:
            ws.AgregarComprador(**comprador)

        if DEBUG:
            print '\n'.join(["%s='%s'" % (k,str(v)) for k,v in ws.factura.items()])
        if not DEBUG or raw_input("Facturar (S/n)?")=="S":
            if not informar_caea:
                cae = ws.CAESolicitar()
                dic = ws.factura
            else:
                cae = ws.CAEARegInformativo()
                dic = ws.factura
            print "Procesando %s %04d %08d %08d %s %s $ %0.2f IVA: $ %0.2f" % (
                TIPO_CBTE.get(dic['tipo_cbte'], dic['tipo_cbte']), 
                dic['punto_vta'], dic['cbt_desde'], dic['cbt_hasta'], 
                TIPO_DOC.get(dic['tipo_doc'], dic['tipo_doc']), dic['nro_doc'], 
                float(dic['imp_total']), 
                float(dic['imp_iva'] if dic['imp_iva'] is not None else 'NaN')) 
            dic.update(encabezado)         # preservar la estructura leida
            dic.update({
                'cae': cae and str(cae) or '',
                'fch_venc_cae': ws.Vencimiento and str(ws.Vencimiento) or '',
                'resultado': ws.Resultado,
                'motivos_obs': ws.Obs,
                'err_code': str(ws.ErrCode),
                'err_msg': ws.ErrMsg,
                'reproceso': ws.Reproceso,
                'emision_tipo': ws.EmisionTipo,
                })
            dicts.append(dic)
            print "NRO:", dic['cbt_desde'], "Resultado:", dic['resultado'], "%s:" % ws.EmisionTipo,dic['cae'],"Obs:",dic['motivos_obs'].encode("ascii", "ignore"), "Err:", dic['err_msg'].encode("ascii", "ignore"), "Reproceso:", dic['reproceso']
    if dicts:
        escribir_facturas(dicts, salida)
Beispiel #6
0
def main():
    "Función principal de pruebas (obtener CAE)"
    import os, time, sys
    global WSDL, LOCATION

    DEBUG = '--debug' in sys.argv

    ws = TrazaFito()
    
    ws.Username = '******'
    ws.Password = '******'
    
    if '--prod' in sys.argv and not H**O:
        WSDL = "https://servicios.pami.org.ar/trazaagr.WebService?wsdl"
        print "Usando WSDL:", WSDL
        sys.argv.pop(sys.argv.index("--prod"))

    # Inicializo las variables y estructuras para el archivo de intercambio:
    transaccion_dto = []
    transacciones = []
    errores = []
    formatos = [('TransaccionDTO', TRANSACCION_DTO, transaccion_dto), 
                ('Transacciones', TRANSACCIONES, transacciones),
                ('Errores', ERRORES, errores),
               ]

    if '--formato' in sys.argv:
        print "Formato:"
        for msg, formato, lista in formatos:
            comienzo = 1
            print "=== %s ===" % msg
            print "|| %-25s || %-12s || %-5s || %-4s || %-10s ||" % (  
                "Nombre", "Tipo", "Long.", "Pos(txt)", "Campo(dbf)")
            claves = []
            for fmt in formato:
                clave, longitud, tipo = fmt[0:3]
                clave_dbf = dar_nombre_campo_dbf(clave, claves)
                claves.append(clave_dbf)
                print "|| %-25s || %-12s || %5d ||   %4d   || %-10s ||" % (
                    clave, tipo, longitud, comienzo, clave_dbf)
                comienzo += longitud
        sys.exit(0)
        
    if '--cargar' in sys.argv:
        if '--dbf' in sys.argv:
            leer_dbf(formatos[:1], {})        
        elif '--json' in sys.argv:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".json", "r")
                d = json.load(archivo)
                formato[2].extend(d)
                archivo.close()
        else:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".txt", "r")
                for linea in archivo:
                    d = leer(linea, formato[1])
                    formato[2].append(d)
                archivo.close()
        
    ws.Conectar("", WSDL)
    
    if ws.Excepcion:
        print ws.Excepcion
        print ws.Traceback
        sys.exit(-1)
    
    # Datos de pruebas:
    
    if '--test' in sys.argv:
        transaccion_dto.append(dict(
            gln_origen="9876543210982", gln_destino="3692581473693", 
            f_operacion=datetime.datetime.now().strftime("%d/%m/%Y"),
            f_elaboracion=datetime.datetime.now().strftime("%d/%m/%Y"),
            f_vto=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"),
            id_evento=11,
            cod_producto="88900000000001",
            n_cantidad=1,
            n_serie=int(time.time()*10), 
            n_lote=datetime.datetime.now().strftime("%Y"),
            n_cai="123456789012345",
            n_cae="",
            id_motivo_destruccion=0,
            n_manifiesto="",
            en_transporte="N",
            n_remito="1234",
            motivo_devolucion="",
            observaciones="prueba",
            n_vale_compra="",
            apellidoNombres="Juan Peres",
            direccion="Saraza", numero="1234", 
            localidad="Hurlingham", provincia="Buenos Aires",
            n_postal="1688",
            cuit="20267565393",
            codigo_transaccion=None,
        ))

    # Opciones principales:
    
    if '--confirma' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML("trazamed_confirma.xml")  # cargo respuesta
            ok = ws.SendConfirmaTransacc(usuario="pruebasws", password="******",
                                   p_ids_transac="1", f_operacion="31-12-2013")
            if not ok:
                raise RuntimeError(ws.Excepcion)
        ws.SendConfirmaTransacc(*sys.argv[sys.argv.index("--confirma")+1:])
    elif '--alerta' in sys.argv:
        ws.SendAlertaTransacc(*sys.argv[sys.argv.index("--alerta")+1:])
    elif '--cancela' in sys.argv:
        ws.SendCancelaTransac(*sys.argv[sys.argv.index("--cancela")+1:])
    elif '--consulta' in sys.argv:
        ws.GetTransacciones(
                            *sys.argv[sys.argv.index("--consulta")+1:]
                            )
        print "CantPaginas", ws.CantPaginas
        print "HayError", ws.HayError
        #print "TransaccionSenasa", ws.TransaccionSenasa
        # parametros comunes de salida (columnas de la tabla):
        claves = [k for k, v, l in TRANSACCIONES]
        # extiendo la lista de resultado para el archivo de intercambio:
        transacciones.extend(ws.TransaccionSenasa)
        # encabezado de la tabla:
        print "||", "||".join(["%s" % clave for clave in claves]), "||"
        # recorro los datos devueltos (TransaccionSenasa):
        while ws.LeerTransaccion():     
            for clave in claves:
                print "||", ws.GetParametro(clave),         # imprimo cada fila
            print "||"
    else:
        argv = [argv for argv in sys.argv if not argv.startswith("--")]
        if not transaccion_dto:
            if len(argv)>10:
                ws.SaveTransaccion(*argv[1:])
            else:
                print "ERROR: no se indicaron todos los parámetros requeridos"
        elif transaccion_dto:
            try:
                usuario, password = argv[-2:]
            except:
                print "ADVERTENCIA: no se indico parámetros usuario y passoword"
                usuario, password = "******", "Clave2013"
            for i, dto in enumerate(transaccion_dto):
                print "Procesando registro", i
                del dto['codigo_transaccion']
                ws.SaveTransaccion(usuario, password, **dto)
                dto['codigo_transaccion'] = ws.CodigoTransaccion
                errores.extend(ws.errores)
                print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                    ws.Resultado,
                    ws.CodigoTransaccion,
                    '|'.join(ws.Errores or []),
                    )
        else:
            print "ERROR: no se especificaron productos a informar"
            
    if not transaccion_dto:
        print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                ws.Resultado,
                ws.CodigoTransaccion,
                '|'.join(ws.Errores or []),
                )

    if ws.Excepcion:
        print ws.Traceback

    if '--grabar' in sys.argv:
        if '--dbf' in sys.argv:
            guardar_dbf(formatos, True, {})        
        elif '--json' in sys.argv:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".json", "w")
                json.dump(formato[2], archivo, sort_keys=True, indent=4)
                archivo.close()
        else:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".txt", "w")
                for it in formato[2]:
                    archivo.write(escribir(it, formato[1]))
            archivo.close()
Beispiel #7
0
def main():
    "Función principal de pruebas (obtener CAE)"
    import os, time, sys
    global WSDL, LOCATION

    DEBUG = '--debug' in sys.argv

    ws = TrazaProdMed()

    ws.Username = '******'
    ws.Password = '******'

    if '--prod' in sys.argv and not H**O:
        WSDL = WSDL_PROD
        print "Usando WSDL:", WSDL
        sys.argv.pop(sys.argv.index("--prod"))

    # Inicializo las variables y estructuras para el archivo de intercambio:
    transacciones = []
    errores = []
    formatos = []

    if '--formato' in sys.argv:
        print "Formato:"
        for msg, formato, lista in formatos:
            comienzo = 1
            print "=== %s ===" % msg
            print "|| %-25s || %-12s || %-5s || %-4s || %-10s ||" % (
                "Nombre", "Tipo", "Long.", "Pos(txt)", "Campo(dbf)")
            claves = []
            for fmt in formato:
                clave, longitud, tipo = fmt[0:3]
                clave_dbf = dar_nombre_campo_dbf(clave, claves)
                claves.append(clave_dbf)
                print "|| %-25s || %-12s || %5d ||   %4d   || %-10s ||" % (
                    clave, tipo, longitud, comienzo, clave_dbf)
                comienzo += longitud
        sys.exit(0)

    if '--cargar' in sys.argv:
        if '--dbf' in sys.argv:
            leer_dbf(formatos[:1], {})
        elif '--json' in sys.argv:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".json", "r")
                d = json.load(archivo)
                formato[2].extend(d)
                archivo.close()
        else:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".txt", "r")
                for linea in archivo:
                    d = leer(linea, formato[1])
                    formato[2].append(d)
                archivo.close()

    ws.Conectar("", WSDL)

    if ws.Excepcion:
        print ws.Excepcion
        print ws.Traceback
        sys.exit(-1)

    # Datos de pruebas:

    if '--test' in sys.argv:
        ws.CrearTransaccion(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"),
            gln_origen="7791234567801",
            gln_destino="7791234567801",
            n_remito="R0001-12341234",
            n_factura="A0001-12341234",
            vencimiento=(datetime.datetime.now() +
                         datetime.timedelta(30)).strftime("%d/%m/%Y"),
            gtin="07791234567810",
            lote=datetime.datetime.now().strftime("%Y"),  # R4556567
            numero_serial=int(time.time() * 10),  # A23434
            id_evento=1,
            cuit_medico="30711622507",
            id_obra_social=465667,
            apellido="Reingart",
            nombres="Mariano",
            tipo_documento="96",
            n_documento="28510785",
            sexo="M",
            calle="San Martin",
            numero="5656",
            piso="",
            depto="1",
            localidad="Berazategui",
            provincia="Buenos Aires",
            n_postal="1700",
            fecha_nacimiento="20/12/1972",
            telefono="5555-5555",
            nro_afiliado="9999999999999",
            cod_diagnostico="B30",
            cod_hiv="NOAP31121970",
            id_motivo_devolucion=1,
            otro_motivo_devolucion="producto fallado",
        )

    # Opciones principales:

    if '--cancela' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML(
                "tests/xml/trazaprodmed_cancela_err.xml")  # cargo respuesta
        ws.SendCancelacTransacc(*sys.argv[sys.argv.index("--cancela") + 1:])
    elif '--cancela_parcial' in sys.argv:
        ws.SendCancelacTransaccParcial(
            *sys.argv[sys.argv.index("--cancela_parcial") + 1:])
    elif '--consulta' in sys.argv:
        ws.GetTransaccionesWS(*sys.argv[sys.argv.index("--consulta") + 1:])
        print "CantPaginas", ws.CantPaginas
        print "HayError", ws.HayError
        #print "TransaccionPlainWS", ws.TransaccionPlainWS
        # parametros comunes de salida (columnas de la tabla):
        TRANSACCIONES = ws.Transacciones[0].keys() if ws.Transacciones else []
        claves = [k for k in TRANSACCIONES]
        # extiendo la lista de resultado para el archivo de intercambio:
        transacciones.extend(ws.Transacciones)
        # encabezado de la tabla:
        print "||", "||".join(["%s" % clave for clave in claves]), "||"
        # recorro los datos devueltos (TransaccionPlainWS):
        while ws.LeerTransaccion():
            for clave in claves:
                print "||", ws.GetParametro(clave),  # imprimo cada fila
            print "||"
    elif '--catalogo' in sys.argv:
        ret = ws.GetCatalogoElectronicoByGTIN(
            *sys.argv[sys.argv.index("--catalogo") + 1:])
        for catalogo in ws.params_out.values():
            print catalogo  # imprimo cada fila
    else:
        argv = [argv for argv in sys.argv if not argv.startswith("--")]
        if not transacciones:
            if len(argv) > 16:
                ws.CrearTransaccion(*argv[3:])
            else:
                print "ERROR: no se indicaron todos los parámetros requeridos"
        if ws.Transacciones:
            try:
                usuario, password = argv[1:3]
            except:
                print "ADVERTENCIA: no se indico parámetros usuario y passoword"
                usuario = password = "******"
            ws.InformarProducto(usuario, password)
            for i, tx in enumerate(transacciones):
                print "Procesando registro", i
                tx['codigo_transaccion'] = ws.CodigoTransaccion
                errores.extend(ws.errores)
            print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                ws.Resultado,
                ws.CodigoTransaccion,
                '|'.join(ws.Errores or []),
            )
        else:
            print "ERROR: no se especificaron productos a informar"

    if ws.Excepcion:
        print ws.Traceback

    if '--grabar' in sys.argv:
        if '--dbf' in sys.argv:
            guardar_dbf(formatos, True, {})
        elif '--json' in sys.argv:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".json", "w")
                json.dump(formato[2], archivo, sort_keys=True, indent=4)
                archivo.close()
        else:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".txt", "w")
                for it in formato[2]:
                    archivo.write(escribir(it, formato[1]))
            archivo.close()
Beispiel #8
0
def autorizar(ws, entrada, salida):
    # recupero el último número de transacción
    ##id = wsbfe.ultnro(client, token, sign, cuit)

    detalles = []
    encabezado = {}
    if '/dbf' in sys.argv:
        encabezados = []
        formatos = [('Encabezado', ENCABEZADO, encabezados),
                    ('Detalles', DETALLE, detalles)]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezados[0]
    else:
        for linea in entrada:
            if str(linea[0]) == '0':
                encabezado = leer(linea, ENCABEZADO)
            elif str(linea[0]) == '1':
                detalle = leer(linea, DETALLE)
                detalles.append(detalle)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if isinstance(encabezado['id'],
                  basestring) and not encabezado['id'].strip():
        # TODO: habria que leer y/o grabar el id en el archivo
        ##id += 1 # incremento el nº de transacción
        # Por el momento, el id se calcula con el tipo, pv y nº de comprobant
        i = long(encabezado['cbte_nro'])
        i += (int(encabezado['cbte_nro']) * 10**4 +
              int(encabezado['punto_vta'])) * 10**8
        encabezado['id'] = i

    if not encabezado['zona'].strip():
        encabezado['zona'] = 0

    if 'testing' in sys.argv:
        ult_cbte = ws.GetLastCMP(punto_vta, tipo_cbte)
        encabezado['cbte_nro'] = ult_cbte + 1
        ult_id = ws.GetLastID()
        encabezado['id'] = ult_id + 1

    ##encabezado['imp_moneda_ctz'] = 1.00
    ws.CrearFactura(**encabezado)
    for detalle in detalles:
        ws.AgregarItem(**detalle)

    if DEBUG:
        print '\n'.join(["%s='%s'" % (k, v) for k, v in ws.factura.items()])
        print 'id:', encabezado['id']
    if not DEBUG or raw_input("Facturar?") == "S":
        cae = ws.Authorize(encabezado['id'])
        dic = ws.factura
        dic.update({
            'id': encabezado['id'],
            'fecha_cbte': ws.FechaCbte,
            'imp_total': ws.ImpTotal or 0,
            'imp_neto': ws.ImpNeto or 0,
            'impto_liq': ws.ImptoLiq or 0,
            'cae': str(ws.CAE),
            'obs': str(ws.Obs),
            'reproceso': str(ws.Reproceso),
            'fch_venc_cae': ws.Vencimiento,
            'err_msg': ws.ErrMsg,
        })
        escribir_factura(dic, salida)
        print "ID:", dic['id'], "CAE:", dic['cae'], "Obs:", dic[
            'obs'], "Reproceso:", dic['reproceso']
Beispiel #9
0
def autorizar(ws, entrada, salida, informar_caea=False):
    tributos = []
    ivas = []
    cbtasocs = []
    encabezado = []
    detalles = []
    if '/dbf' in sys.argv:
        formatos = [('Encabezado', ENCABEZADO, encabezado),
                    ('Tributo', TRIBUTO, tributos), ('Iva', IVA, ivas),
                    ('Comprobante Asociado', CMP_ASOC, cbtasocs),
                    ('Detalles', DETALLE, detalles)]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezado[0]
    else:
        for linea in entrada:
            if str(linea[0]) == TIPOS_REG[0]:
                encabezado = leer(linea, ENCABEZADO, expandir_fechas=True)
                if 'cbte_nro' in encabezado:
                    print "*" * 80
                    print "cbte_nro", encabezado['cbte_nro']
                    encabezado['cbt_desde'] = encabezado['cbte_nro']
                    encabezado['cbt_hasta'] = encabezado['cbte_nro']
                    del encabezado['cbte_nro']
            elif str(linea[0]) == TIPOS_REG[1]:
                tributo = leer(linea, TRIBUTO)
                tributos.append(tributo)
            elif str(linea[0]) == TIPOS_REG[2]:
                iva = leer(linea, IVA)
                ivas.append(iva)
            elif str(linea[0]) == TIPOS_REG[3]:
                cbtasoc = leer(linea, CMP_ASOC)
                if 'cbte_punto_vta' in cbteasoc:
                    cbtasoc['tipo'] = cbtasoc['cbte_tipo']
                    cbtasoc['pto_vta'] = cbtasoc['cbte_punto_vta']
                    cbtasoc['nro'] = cbtasoc['cbte_nro']
                cbtasocs.append(cbtasoc)
            elif str(linea[0]) == TIPOS_REG[4]:
                detalle = leer(linea, DETALLE)
                detalles.append(detalle)
                if 'imp_subtotal' not in detalle:
                    detalle['imp_subtotal'] = detalle['importe']
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if informar_caea:
        if '/testing' in sys.argv:
            encabezado['cae'] = '21353598240916'
            encabezado['fch_venc_cae'] = '2011-09-15'
        encabezado['caea'] = encabezado['cae']

    if 'imp_subtotal' not in encabezado:
        encabezado['imp_subtotal'] = encabezado['imp_neto'] + encabezado[
            'imp_tot_conc']

    ws.CrearFactura(**encabezado)
    for detalle in detalles:
        ws.AgregarItem(**detalle)
    for tributo in tributos:
        ws.AgregarTributo(**tributo)
    for iva in ivas:
        ws.AgregarIva(**iva)
    for cbtasoc in cbtasocs:
        ws.AgregarCmpAsoc(**cbtasoc)

    if DEBUG:
        print '\n'.join(
            ["%s='%s'" % (k, str(v)) for k, v in ws.factura.items()])
    if not DEBUG or raw_input("Facturar?") == "S":
        if not informar_caea:
            cae = ws.AutorizarComprobante()
            dic = ws.factura
        else:
            cae = ws.InformarComprobanteCAEA()
            dic = ws.factura
        dic.update({
            'cae': cae,
            'fch_venc_cae': ws.Vencimiento,
            'resultado': ws.Resultado,
            'motivos_obs': ws.Obs,
            'err_code': ws.ErrCode,
            'err_msg': ws.ErrMsg,
            'reproceso': ws.Reproceso,
            'emision_tipo': ws.EmisionTipo,
        })
        escribir_factura(dic, salida)
        print "NRO:", dic['cbt_desde'], "Resultado:", dic[
            'resultado'], "%s:" % ws.EmisionTipo, dic['cae'], "Obs:", dic[
                'motivos_obs'].encode(
                    "ascii", "ignore"), "Err:", dic['err_msg'].encode(
                        "ascii", "ignore"), "Reproceso:", dic['reproceso']
Beispiel #10
0
def autorizar(ws, entrada, salida, informar_caea=False):
    tributos = []
    ivas = []
    cbtasocs = []
    encabezado = []
    opcionales = []
    if '/dbf' in sys.argv:
        if DEBUG: print "Leyendo DBF..."

        formatos = [
            ('Encabezado', ENCABEZADO, encabezado),
            ('Tributo', TRIBUTO, tributos),
            ('Iva', IVA, ivas),
            ('Comprobante Asociado', CMP_ASOC, cbtasocs),
            ('Datos Opcionales', OPCIONAL, opcionales),
        ]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezado[0]
    elif '/json' in sys.argv:
        import json
        encabezado = json.load(entrada)[0]
        ivas = encabezado.get('ivas', encabezado.get('iva', []))
        tributos = encabezado.get('tributos', [])
        cbtasocs = encabezado.get('cbtasocs', [])
        opcionales = encabezado.get('opcionales', [])
    else:
        for linea in entrada:
            if str(linea[0]) == '0':
                encabezado = leer(linea, ENCABEZADO)
            elif str(linea[0]) == '1':
                tributo = leer(linea, TRIBUTO)
                tributos.append(tributo)
            elif str(linea[0]) == '2':
                iva = leer(linea, IVA)
                ivas.append(iva)
            elif str(linea[0]) == '3':
                cbtasoc = leer(linea, CMP_ASOC)
                cbtasocs.append(cbtasoc)
            elif str(linea[0]) == '6':
                opcional = leer(linea, OPCIONAL)
                opcionales.append(opcional)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if informar_caea:
        if '/testing' in sys.argv:
            encabezado['cae'] = '21073372218437'
        encabezado['caea'] = encabezado['cae']

    if not encabezado:
        raise RuntimeError("No se pudieron leer los registros de la entrada")

    # ajusto datos para pruebas en depuración (nro de cbte. / fecha)
    if '--testing' in sys.argv and DEBUG:
        encabezado['punto_vta'] = 9998
        cbte_nro = int(
            ws.CompUltimoAutorizado(encabezado['tipo_cbte'],
                                    encabezado['punto_vta'])) + 1
        encabezado['cbt_desde'] = cbte_nro
        encabezado['cbt_hasta'] = cbte_nro
        encabezado['fecha_cbte'] = datetime.datetime.now().strftime("%Y%m%d")

    ws.CrearFactura(**encabezado)
    for tributo in tributos:
        ws.AgregarTributo(**tributo)
    for iva in ivas:
        ws.AgregarIva(**iva)
    for cbtasoc in cbtasocs:
        ws.AgregarCmpAsoc(**cbtasoc)
    for opcional in opcionales:
        ws.AgregarOpcional(**opcional)

    if DEBUG:
        print '\n'.join(
            ["%s='%s'" % (k, str(v)) for k, v in ws.factura.items()])
    if not DEBUG or raw_input("Facturar (S/n)?") == "S":
        if not informar_caea:
            cae = ws.CAESolicitar()
            dic = ws.factura
        else:
            cae = ws.CAEARegInformativo()
            dic = ws.factura
        print "Procesando %s %04d %08d %08d %s %s $ %0.2f IVA: $ %0.2f" % (
            TIPO_CBTE.get(dic['tipo_cbte'], dic['tipo_cbte']),
            dic['punto_vta'], dic['cbt_desde'], dic['cbt_hasta'],
            TIPO_DOC.get(dic['tipo_doc'], dic['tipo_doc']), dic['nro_doc'],
            float(dic['imp_total']),
            float(dic['imp_iva'] if dic['imp_iva'] is not None else 'NaN'))
        dic.update(encabezado)  # preservar la estructura leida
        dic.update({
            'cae': cae and str(cae) or '',
            'fch_venc_cae': ws.Vencimiento and str(ws.Vencimiento) or '',
            'resultado': ws.Resultado,
            'motivos_obs': ws.Obs,
            'err_code': str(ws.ErrCode),
            'err_msg': ws.ErrMsg,
            'reproceso': ws.Reproceso,
            'emision_tipo': ws.EmisionTipo,
        })
        escribir_factura(dic, salida)
        print "NRO:", dic['cbt_desde'], "Resultado:", dic[
            'resultado'], "%s:" % ws.EmisionTipo, dic['cae'], "Obs:", dic[
                'motivos_obs'].encode(
                    "ascii", "ignore"), "Err:", dic['err_msg'].encode(
                        "ascii", "ignore"), "Reproceso:", dic['reproceso']
Beispiel #11
0
def autorizar(ws, entrada, salida):
    # recupero el último número de transacción
    ##id = wsfex.ultnro(client, token, sign, cuit)

    detalles = []
    permisos = []
    cbtasocs = []
    encabezado = []
    if '/dbf' in sys.argv:
        formatos = [('Encabezado', ENCABEZADO, encabezado), ('Permisos', PERMISO, permisos), ('Comprobante Asociado', CMP_ASOC, cbtasocs), ('Detalles', DETALLE, detalles)]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezado[0]
    else:
        encabezado = {}
        for linea in entrada:
            if str(linea[0])==TIPOS_REG[0]:
                encabezado = leer(linea, ENCABEZADO)
                if 'nro_doc' in encabezado:
                    encabezado['cuit_pais_cliente'] = encabezado['nro_doc']
            elif str(linea[0])==TIPOS_REG[1]:
                detalle = leer(linea, DETALLE)
                detalles.append(detalle)
            elif str(linea[0])==TIPOS_REG[2]:
                permiso = leer(linea, PERMISO)
                permisos.append(permiso)
            elif str(linea[0])==TIPOS_REG[3]:
                cbtasoc = leer(linea, CMP_ASOC)
                cbtasocs.append(cbtasoc)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if not encabezado['id']:
        # TODO: habria que leer y/o grabar el id en el archivo
        ##id += 1 # incremento el nº de transacción 
        # Por el momento, el id se calcula con el tipo, pv y nº de comprobant
        i = long(encabezado['cbte_nro'])
        i += (int(encabezado['cbte_nro'])*10**4 + int(encabezado['punto_vta']))*10**8
        encabezado['id'] = ws.GetLastID() + 1
    
    if '/testing' in sys.argv:
        encabezado['id'] = long(ws.GetLastID()) + 1
        encabezado['cbte_nro'] = int(ws.GetLastCMP(encabezado['tipo_cbte'], encabezado['punto_vta'])) + 1
        encabezado['fecha_cbte'] = datetime.datetime.now().strftime("%Y%m%d")

    ws.CrearFactura(**encabezado)
    for detalle in detalles:
        ws.AgregarItem(**detalle)
    for permiso in permisos:
        ws.AgregarPermiso(**permiso)
    for cbtasoc in cbtasocs:
        ws.AgregarCmpAsoc(**cbtasoc)

    if DEBUG:
        #print f.to_dict()
        print '\n'.join(["%s='%s'" % (k,str(v)) for k,v in encabezado.items()])
        for detalle in detalles:
            print ', '.join(["%s='%s'" % (k,str(v)) for k,v in detalle.items()])
            print "DIF:", detalle['qty'] * detalle['precio'] - detalle['importe']
            
        print 'id:', encabezado['id']
    if not DEBUG or not sys.stdout.isatty() or raw_input("Facturar?")=="S":
        ws.LanzarExcepcion = False
        cae = ws.Authorize(id=encabezado['id'])
        dic = ws.factura
        dic.update({
            'cae': cae and str(cae) or '',
            'fch_venc_cae': ws.FchVencCAE and str(ws.FchVencCAE) or '',
            'resultado': ws.Resultado or '',
            'motivos_obs': ws.Obs or '',
            'err_code': str(ws.ErrCode),
            'err_msg': ws.ErrMsg or '',
            'reproceso': ws.Reproceso or '',
            })
        escribir_factura(dic, salida)
        print "ID:", encabezado['id'], "NRO:", dic['cbte_nro'], "Resultado:", dic['resultado'],
        print "CAE:", dic['cae'], "Obs:", dic['motivos_obs'].encode("ascii", "ignore"),
        print "Err:", dic['err_msg'].encode("ascii", "ignore"), "Reproceso:", dic['reproceso']
        if ws.Excepcion:
            print "Excepcion:", ws.Excepcion.encode("ascii", "ignore")
            print "Traceback:", ws.Traceback.encode("ascii", "ignore")
Beispiel #12
0
def autorizar(ws, entrada, salida, informar_caea=False):
    tributos = []
    ivas = []
    cbtasocs = []
    encabezado = []
    opcionales = []
    if '/dbf' in sys.argv:
        if DEBUG: print "Leyendo DBF..."

        formatos = [('Encabezado', ENCABEZADO, encabezado), 
                    ('Tributo', TRIBUTO, tributos), 
                    ('Iva', IVA, ivas), 
                    ('Comprobante Asociado', CMP_ASOC, cbtasocs),
                    ('Datos Opcionales', OPCIONAL, opcionales),
                    ]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezado[0]
    elif '/json' in sys.argv:
        import json
        encabezado = json.load(entrada)[0]
        ivas = encabezado.get('ivas', [])
        tributos = encabezado.get('tributos', [])
        cbtasocs = encabezado.get('cbtasocs', [])
        opcionales = encabezado.get('opcionales', [])
    else:
        for linea in entrada:
            if str(linea[0])=='0':
                encabezado = leer(linea, ENCABEZADO)
            elif str(linea[0])=='1':
                tributo = leer(linea, TRIBUTO)
                tributos.append(tributo)
            elif str(linea[0])=='2':
                iva = leer(linea, IVA)
                ivas.append(iva)
            elif str(linea[0])=='3':
                cbtasoc = leer(linea, CMP_ASOC)
                cbtasocs.append(cbtasoc)
            elif str(linea[0])=='6':
                opcional = leer(linea, OPCIONAL)
                opcionales.append(opcional)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if informar_caea:
        if '/testing' in sys.argv:
            encabezado['cae'] = '21073372218437'
        encabezado['caea'] = encabezado['cae']

    if not encabezado:
        raise RuntimeError("No se pudieron leer los registros de la entrada")

    ws.CrearFactura(**encabezado)
    for tributo in tributos:
        ws.AgregarTributo(**tributo)
    for iva in ivas:
        ws.AgregarIva(**iva)
    for cbtasoc in cbtasocs:
        ws.AgregarCmpAsoc(**cbtasoc)
    for opcional in opcionales:
        ws.AgregarOpcional(**opcional)

    if DEBUG:
        print '\n'.join(["%s='%s'" % (k,str(v)) for k,v in ws.factura.items()])
    if not DEBUG or raw_input("Facturar?")=="S":
        if not informar_caea:
            cae = ws.CAESolicitar()
            dic = ws.factura
        else:
            cae = ws.CAEARegInformativo()
            dic = ws.factura
        print "Procesando %s %04d %08d %08d %s %s $ %0.2f IVA: $ %0.2f" % (
            TIPO_CBTE.get(dic['tipo_cbte'], dic['tipo_cbte']), 
            dic['punto_vta'], dic['cbt_desde'], dic['cbt_hasta'], 
            TIPO_DOC.get(dic['tipo_doc'], dic['tipo_doc']), dic['nro_doc'], 
            float(dic['imp_total']), float(dic['imp_iva'])) 
        dic.update(encabezado)         # preservar la estructura leida
        dic.update({
            'cae': cae and str(cae) or '',
            'fch_venc_cae': ws.Vencimiento and str(ws.Vencimiento) or '',
            'resultado': ws.Resultado,
            'motivos_obs': ws.Obs,
            'err_code': str(ws.ErrCode),
            'err_msg': ws.ErrMsg,
            'reproceso': ws.Reproceso,
            'emision_tipo': ws.EmisionTipo,
            })
        escribir_factura(dic, salida)
        print "NRO:", dic['cbt_desde'], "Resultado:", dic['resultado'], "%s:" % ws.EmisionTipo,dic['cae'],"Obs:",dic['motivos_obs'].encode("ascii", "ignore"), "Err:", dic['err_msg'].encode("ascii", "ignore"), "Reproceso:", dic['reproceso']
Beispiel #13
0
def main():
    "Función principal de pruebas (obtener CAE)"
    import os, time, sys
    global WSDL, LOCATION

    DEBUG = '--debug' in sys.argv

    ws = TrazaMed()
    
    ws.Username = '******'
    ws.Password = '******'
    
    if '--prod' in sys.argv and not H**O:
        WSDL = "https://trazabilidad.pami.org.ar:9050/trazamed.WebService"
        print "Usando WSDL:", WSDL
        sys.argv.pop(sys.argv.index("--prod"))

    # Inicializo las variables y estructuras para el archivo de intercambio:
    medicamentos = []
    transacciones = []
    errores = []
    formatos = [('Medicamentos', MEDICAMENTOS, medicamentos), 
                ('Transacciones', TRANSACCIONES, transacciones),
                ('Errores', ERRORES, errores),
               ]

    if '--formato' in sys.argv:
        print "Formato:"
        for msg, formato, lista in formatos:
            comienzo = 1
            print "=== %s ===" % msg
            print "|| %-25s || %-12s || %-5s || %-4s || %-10s ||" % (  
                "Nombre", "Tipo", "Long.", "Pos(txt)", "Campo(dbf)")
            claves = []
            for fmt in formato:
                clave, longitud, tipo = fmt[0:3]
                clave_dbf = dar_nombre_campo_dbf(clave, claves)
                claves.append(clave_dbf)
                print "|| %-25s || %-12s || %5d ||   %4d   || %-10s ||" % (
                    clave, tipo, longitud, comienzo, clave_dbf)
                comienzo += longitud
        sys.exit(0)
        
    if '--cargar' in sys.argv:
        if '--dbf' in sys.argv:
            leer_dbf(formatos[:1], {})        
        elif '--json' in sys.argv:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".json", "r")
                d = json.load(archivo)
                formato[2].extend(d)
                archivo.close()
        else:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".txt", "r")
                for linea in archivo:
                    d = leer(linea, formato[1])
                    formato[2].append(d)
                archivo.close()
        
    ws.Conectar("", WSDL)
    
    if ws.Excepcion:
        print ws.Excepcion
        print ws.Traceback
        sys.exit(-1)
    
    # Datos de pruebas:
    
    if '--test' in sys.argv:
        medicamentos.append(dict(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"), 
            gln_origen="9999999999918", gln_destino="glnws", 
            n_remito="R000100001234", n_factura="A000100001234", 
            vencimiento=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"), 
            gtin="GTIN1", lote=datetime.datetime.now().strftime("%Y"),
            numero_serial=int(time.time()*10), 
            id_obra_social=None, id_evento=134,
            cuit_origen="20267565393", cuit_destino="20267565393", 
            apellido="Reingart", nombres="Mariano",
            tipo_documento="96", n_documento="26756539", sexo="M",
            direccion="Saraza", numero="1234", piso="", depto="", 
            localidad="Hurlingham", provincia="Buenos Aires",
            n_postal="1688", fecha_nacimiento="01/01/2000", 
            telefono="5555-5555", 
            nro_asociado="9999999999999",
            cantidad=None, 
            desde_numero_serial=None, hasta_numero_serial=None, 
            codigo_transaccion=None, 
        ))            
    if '--testfraccion' in sys.argv:
        medicamentos.append(dict(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"), 
            gln_origen="9999999999918", gln_destino="glnws", 
            n_remito="1234", n_factura="1234", 
            vencimiento=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"), 
            gtin="GTIN1", lote=datetime.datetime.now().strftime("%Y"),
            numero_serial=int(time.time()*10), 
            id_obra_social=None, id_evento=134,
            cuit_origen="20267565393", cuit_destino="20267565393", 
            apellido="Reingart", nombres="Mariano",
            tipo_documento="96", n_documento="26756539", sexo="M",
            direccion="Saraza", numero="1234", piso="", depto="", 
            localidad="Hurlingham", provincia="Buenos Aires",
            n_postal="1688", fecha_nacimiento="01/01/2000", 
            telefono="5555-5555",
            nro_asociado="9999999999999",
            cantidad=5,
            desde_numero_serial=None, hasta_numero_serial=None, 
            codigo_transaccion=None,
        ))
    if '--testdh' in sys.argv:
        medicamentos.append(dict(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"), 
            gln_origen="9999999999918", gln_destino="glnws", 
            n_remito="1234", n_factura="1234", 
            vencimiento=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"), 
            gtin="GTIN1", lote=datetime.datetime.now().strftime("%Y"),
            desde_numero_serial=int(time.time()*10)-1, 
            hasta_numero_serial=int(time.time()*10)+1, 
            id_obra_social=None, id_evento=134,
            nro_asociado="1234",
            cantidad=None, numero_serial=None,
            codigo_transaccion=None,
        ))

    # Opciones principales:
    
    if '--cancela' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML("trazamed_cancela_err.xml")  # cargo respuesta
        ws.SendCancelacTransacc(*sys.argv[sys.argv.index("--cancela")+1:])
    elif '--cancela_parcial' in sys.argv:
        ws.SendCancelacTransaccParcial(*sys.argv[sys.argv.index("--cancela_parcial")+1:])
    elif '--confirma' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML("trazamed_confirma.xml")  # cargo respuesta
            ok = ws.SendConfirmaTransacc(usuario="pruebasws", password="******",
                                   p_ids_transac="1", f_operacion="31-12-2013")
            if not ok:
                raise RuntimeError(ws.Excepcion)
        ws.SendConfirmaTransacc(*sys.argv[sys.argv.index("--confirma")+1:])
    elif '--alerta' in sys.argv:
        ws.SendAlertaTransacc(*sys.argv[sys.argv.index("--alerta")+1:])
    elif '--consulta' in sys.argv:
        if '--alertados' in sys.argv:
            ws.GetEnviosPropiosAlertados(
                                *sys.argv[sys.argv.index("--alertados")+1:]
                                )
        elif '--movimientos' in sys.argv:
            ws.GetTransaccionesWS(
                                *sys.argv[sys.argv.index("--movimientos")+1:]
                                )
        else:
            ws.GetTransaccionesNoConfirmadas(
                                *sys.argv[sys.argv.index("--consulta")+1:]
                                #usuario="pruebasws", password="******", 
                                #p_id_transaccion_global="1234", 
                                #id_agente_informador="1", 
                                #id_agente_origen="1", 
                                #id_agente_destino="1", 
                                #id_medicamento="1", 
                                #id_evento="1", 
                                #fecha_desde_op="01/01/2015", 
                                #fecha_hasta_op="31/12/2013", 
                                #fecha_desde_t="01/01/2013", 
                                #fecha_hasta_t="31/12/2013", 
                                #fecha_desde_v="01/04/2013", 
                                #fecha_hasta_v="30/04/2013", 
                                #n_factura=5, n_remito=6,
                                #estado=1,
                                #lote=88745,
                                #numero_serial=894124788,
                                )
        print "CantPaginas", ws.CantPaginas
        print "HayError", ws.HayError
        #print "TransaccionPlainWS", ws.TransaccionPlainWS
        # parametros comunes de salida (columnas de la tabla):
        claves = [k for k, v, l in TRANSACCIONES]
        # extiendo la lista de resultado para el archivo de intercambio:
        transacciones.extend(ws.TransaccionPlainWS)
        # encabezado de la tabla:
        print "||", "||".join(["%s" % clave for clave in claves]), "||"
        # recorro los datos devueltos (TransaccionPlainWS):
        while ws.LeerTransaccion():     
            for clave in claves:
                print "||", ws.GetParametro(clave),         # imprimo cada fila
            print "||"
    elif '--catalogo' in sys.argv:
        ret = ws.GetCatalogoElectronicoByGTIN(
                                *sys.argv[sys.argv.index("--catalogo")+1:]
                                )
        for catalogo in ws.params_out.values():
            print catalogo        # imprimo cada fila
    elif '--stock' in sys.argv:
        ret = ws.GetConsultaStock(
                            *sys.argv[sys.argv.index("--stock")+1:]
                            )
        print "\n".join([str(s) for s in ws.params_out.values()])
    else:
        argv = [argv for argv in sys.argv if not argv.startswith("--")]
        if not medicamentos:
            if len(argv)>16:
                if '--dh' in sys.argv:
                    ws.SendMedicamentosDHSerie(*argv[1:])
                elif '--fraccion' in sys.argv:
                    ws.SendMedicamentosFraccion(*argv[1:])
                else:
                    ws.SendMedicamentos(*argv[1:])
            else:
                print "ERROR: no se indicaron todos los parámetros requeridos"
        elif medicamentos:
            try:
                usuario, password = argv[1:3]
            except:
                print "ADVERTENCIA: no se indico parámetros usuario y passoword"
                usuario = password = "******"
            for i, med in enumerate(medicamentos):
                print "Procesando registro", i
                del med['codigo_transaccion']
                if med.get("cantidad"):
                    del med["desde_numero_serial"]
                    del med["hasta_numero_serial"]
                    ws.SendMedicamentosFraccion(usuario, password, **med)
                elif med.get("desde_numero_serial"):
                    del med["cantidad"]
                    del med["numero_serial"]
                    ws.SendMedicamentosDHSerie(usuario, password, **med)
                else:
                    del med["cantidad"]
                    del med["desde_numero_serial"]
                    del med["hasta_numero_serial"]
                    ws.SendMedicamentos(usuario, password, **med)
                med['codigo_transaccion'] = ws.CodigoTransaccion
                errores.extend(ws.errores)
                print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                    ws.Resultado,
                    ws.CodigoTransaccion,
                    '|'.join(ws.Errores or []),
                    )
        else:
            print "ERROR: no se especificaron medicamentos a informar"
            
    if not medicamentos:
        print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                ws.Resultado,
                ws.CodigoTransaccion,
                '|'.join(ws.Errores or []),
                )

    if ws.Excepcion:
        print ws.Traceback

    if '--grabar' in sys.argv:
        if '--dbf' in sys.argv:
            guardar_dbf(formatos, True, {})        
        elif '--json' in sys.argv:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".json", "w")
                json.dump(formato[2], archivo, sort_keys=True, indent=4)
                archivo.close()
        else:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".txt", "w")
                for it in formato[2]:
                    archivo.write(escribir(it, formato[1]))
            archivo.close()
Beispiel #14
0
def autorizar(ws, entrada, salida):
    # recupero el último número de transacción
    ##id = wsfex.ultnro(client, token, sign, cuit)

    detalles = []
    permisos = []
    cbtasocs = []
    encabezado = []
    if '/dbf' in sys.argv:
        formatos = [('Encabezado', ENCABEZADO, encabezado), ('Permisos', PERMISO, permisos), ('Comprobante Asociado', CMP_ASOC, cbtasocs), ('Detalles', DETALLE, detalles)]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezado[0]
    else:
        encabezado = {}
        for linea in entrada:
            if str(linea[0])==TIPOS_REG[0]:
                encabezado = leer(linea, ENCABEZADO)
                if 'nro_doc' in encabezado:
                    encabezado['cuit_pais_cliente'] = encabezado['nro_doc']
            elif str(linea[0])==TIPOS_REG[1]:
                detalle = leer(linea, DETALLE)
                detalles.append(detalle)
            elif str(linea[0])==TIPOS_REG[2]:
                permiso = leer(linea, PERMISO)
                permisos.append(permiso)
            elif str(linea[0])==TIPOS_REG[3]:
                cbtasoc = leer(linea, CMP_ASOC)
                cbtasocs.append(cbtasoc)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if not encabezado['id']:
        # TODO: habria que leer y/o grabar el id en el archivo
        ##id += 1 # incremento el nº de transacción 
        # Por el momento, el id se calcula con el tipo, pv y nº de comprobant
        i = long(encabezado['cbte_nro'])
        i += (int(encabezado['cbte_nro'])*10**4 + int(encabezado['punto_vta']))*10**8
        encabezado['id'] = ws.GetLastID() + 1
    
    if '/testing' in sys.argv:
        encabezado['id'] = long(ws.GetLastID()) + 1
        encabezado['cbte_nro'] = int(ws.GetLastCMP(encabezado['tipo_cbte'], encabezado['punto_vta'])) + 1
        encabezado['fecha_cbte'] = datetime.datetime.now().strftime("%Y%m%d")

    ws.CrearFactura(**encabezado)
    for detalle in detalles:
        ws.AgregarItem(**detalle)
    for permiso in permisos:
        ws.AgregarPermiso(**permiso)
    for cbtasoc in cbtasocs:
        ws.AgregarCmpAsoc(**cbtasoc)

    if DEBUG:
        #print f.to_dict()
        print '\n'.join(["%s='%s'" % (k,str(v)) for k,v in encabezado.items()])
        for detalle in detalles:
            print ', '.join(["%s='%s'" % (k,str(v)) for k,v in detalle.items()])
            print "DIF:", detalle['qty'] * detalle['precio'] - detalle['importe']
            
        print 'id:', encabezado['id']
    if not DEBUG or not sys.stdout.isatty() or raw_input("Facturar?")=="S":
        ws.LanzarExcepcion = False
        cae = ws.Authorize(id=encabezado['id'])
        dic = ws.factura
        dic.update({
            'cae': cae and str(cae) or '',
            'fch_venc_cae': ws.FchVencCAE and str(ws.FchVencCAE) or '',
            'resultado': ws.Resultado or '',
            'motivos_obs': ws.Obs or '',
            'err_code': str(ws.ErrCode),
            'err_msg': ws.ErrMsg or '',
            'reproceso': ws.Reproceso or '',
            })
        escribir_factura(dic, salida)
        print "ID:", encabezado['id'], "NRO:", dic['cbte_nro'], "Resultado:", dic['resultado'],
        print "CAE:", dic['cae'], "Obs:", dic['motivos_obs'].encode("ascii", "ignore"),
        print "Err:", dic['err_msg'].encode("ascii", "ignore"), "Reproceso:", dic['reproceso']
        if ws.Excepcion:
            print "Excepcion:", ws.Excepcion.encode("ascii", "ignore")
            print "Traceback:", ws.Traceback.encode("ascii", "ignore")
Beispiel #15
0
def autorizar(ws, entrada, salida, informar_caea=False):
    tributos = []
    ivas = []
    cbtasocs = []
    encabezado = []
    detalles = []
    formas_pago = []
    if '/dbf' in sys.argv:
        formatos = [('Encabezado', ENCABEZADO, encabezado), 
                    ('Tributo', TRIBUTO, tributos), 
                    ('Iva', IVA, ivas), 
                    ('Comprobante Asociado', CMP_ASOC, cbtasocs), 
                    ('Detalles', DETALLE, detalles)]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezado[0]
    elif '/json' in sys.argv:
        encabezado = json.load(entrada)
        for lista, clave in ((detalles, "detalles"), (ivas, "iva"),
                             (tributos, "tributos"), (cbtasocs, "cbtes_asoc"),
                             (formas_pago, "formas_pago")):
            if clave in encabezado:
                lista.extend(encabezado.pop(clave))
    else:
        for linea in entrada:
            if str(linea[0])==TIPOS_REG[0]:
                encabezado = leer(linea, ENCABEZADO, expandir_fechas=True)
            elif str(linea[0])==TIPOS_REG[1]:
                tributo = leer(linea, TRIBUTO)
                tributos.append(tributo)
            elif str(linea[0])==TIPOS_REG[2]:
                iva = leer(linea, IVA)
                ivas.append(iva)
            elif str(linea[0])==TIPOS_REG[3]:
                cbtasoc = leer(linea, CMP_ASOC)
                cbtasocs.append(cbtasoc)
            elif str(linea[0])==TIPOS_REG[4]:
                detalle = leer(linea, DETALLE)
                detalles.append(detalle)
            elif str(linea[0])==TIPOS_REG[5]:
                fp = leer(linea, FORMA_PAGO)
                formas_pago.append(fp)
                for campo in fp.keys():
                    if not fp[campo]:
                        fp[campo] = None
            else:
                print "Tipo de registro incorrecto:", linea[0]
       
    if informar_caea:
        if '/testing' in sys.argv:
            encabezado['cae'] = '21353598240916'
            encabezado['fch_venc_cae'] = '2011-09-15'
        encabezado['caea'] = encabezado['cae']

    if 'imp_subtotal' not in encabezado:
        encabezado['imp_subtotal'] = encabezado['imp_neto'] + encabezado['imp_tot_conc']

    ws.CrearFactura(**encabezado)
    for detalle in detalles:
        if 'imp_subtotal' not in detalle:
            detalle['imp_subtotal'] = detalle['importe']
        ws.AgregarItem(**detalle)
    for tributo in tributos:
        if 'alic' not in tributo:
            tributo['alic'] = None
        ws.AgregarTributo(**tributo)
    for iva in ivas:
        if 'base_imp' not in iva:
            iva['base_imp'] = None
        ws.AgregarIva(**iva)
    for cbtasoc in cbtasocs:
        if 'cbte_punto_vta' in cbtasoc:
            cbtasoc['tipo'] = cbtasoc.pop('cbte_tipo')
            cbtasoc['pto_vta'] = cbtasoc.pop('cbte_punto_vta')
            cbtasoc['nro'] = cbtasoc.pop('cbte_nro')
        ws.AgregarCmpAsoc(**cbtasoc)
    for fp in formas_pago:
        ws.AgregarFormaPago(**fp)

    if DEBUG:
        print '\n'.join(["%s='%s'" % (k,str(v)) for k,v in ws.factura.items()])
    if not DEBUG or raw_input("Facturar?")=="S":
        if not informar_caea:
            cae = ws.AutorizarComprobante()
            dic = ws.factura
        else:
            cae = ws.InformarComprobanteCAEA()
            dic = ws.factura
        dic.update({
            'cae':cae,
            'fch_venc_cae': ws.Vencimiento,
            'resultado': ws.Resultado,
            'motivos_obs': ws.Obs,
            'err_code': ws.ErrCode,
            'err_msg': ws.ErrMsg,
            'reproceso': ws.Reproceso,
            'emision_tipo': ws.EmisionTipo,
            })
        escribir_factura(dic, salida)
        print "NRO:", dic['cbte_nro'], "Resultado:", dic['resultado'], "%s:" % ws.EmisionTipo,dic['cae'],"Obs:",dic['motivos_obs'].encode("ascii", "ignore"), "Err:", dic['err_msg'].encode("ascii", "ignore"), "Reproceso:", dic['reproceso']
Beispiel #16
0
def main():
    "Función principal de pruebas (obtener CAE)"
    import os, time, sys
    global WSDL, LOCATION

    DEBUG = '--debug' in sys.argv

    ws = TrazaMed()
    
    ws.Username = '******'
    ws.Password = '******'
    
    if '--prod' in sys.argv and not H**O:
        WSDL = "https://trazabilidad.pami.org.ar:9050/trazamed.WebService"
        print "Usando WSDL:", WSDL
        sys.argv.pop(sys.argv.index("--prod"))

    # Inicializo las variables y estructuras para el archivo de intercambio:
    medicamentos = []
    transacciones = []
    errores = []
    formatos = [('Medicamentos', MEDICAMENTOS, medicamentos), 
                ('Transacciones', TRANSACCIONES, transacciones),
                ('Errores', ERRORES, errores),
               ]

    if '--formato' in sys.argv:
        print "Formato:"
        for msg, formato, lista in formatos:
            comienzo = 1
            print "=== %s ===" % msg
            print "|| %-25s || %-12s || %-5s || %-4s || %-10s ||" % (  
                "Nombre", "Tipo", "Long.", "Pos(txt)", "Campo(dbf)")
            claves = []
            for fmt in formato:
                clave, longitud, tipo = fmt[0:3]
                clave_dbf = dar_nombre_campo_dbf(clave, claves)
                claves.append(clave_dbf)
                print "|| %-25s || %-12s || %5d ||   %4d   || %-10s ||" % (
                    clave, tipo, longitud, comienzo, clave_dbf)
                comienzo += longitud
        sys.exit(0)
        
    if '--cargar' in sys.argv:
        if '--dbf' in sys.argv:
            leer_dbf(formatos[:1], {})        
        elif '--json' in sys.argv:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".json", "r")
                d = json.load(archivo)
                formato[2].extend(d)
                archivo.close()
        else:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".txt", "r")
                for linea in archivo:
                    d = leer(linea, formato[1])
                    formato[2].append(d)
                archivo.close()
        
    ws.Conectar("", WSDL)
    
    if ws.Excepcion:
        print ws.Excepcion
        print ws.Traceback
        sys.exit(-1)
    
    # Datos de pruebas:
    
    if '--test' in sys.argv:
        medicamentos.append(dict(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"), 
            gln_origen="9999999999918", gln_destino="glnws", 
            n_remito="R000100001234", n_factura="A000100001234", 
            vencimiento=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"), 
            gtin="GTIN1", lote=datetime.datetime.now().strftime("%Y"),
            numero_serial=int(time.time()*10), 
            id_obra_social=None, id_evento=134,
            cuit_origen="20267565393", cuit_destino="20267565393", 
            apellido="Reingart", nombres="Mariano",
            tipo_documento="96", n_documento="26756539", sexo="M",
            direccion="Saraza", numero="1234", piso="", depto="", 
            localidad="Hurlingham", provincia="Buenos Aires",
            n_postal="1688", fecha_nacimiento="01/01/2000", 
            telefono="5555-5555", 
            nro_asociado="9999999999999",
            cantidad=None, 
            desde_numero_serial=None, hasta_numero_serial=None, 
            codigo_transaccion=None, 
        ))            
    if '--testfraccion' in sys.argv:
        medicamentos.append(dict(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"), 
            gln_origen="9999999999918", gln_destino="glnws", 
            n_remito="1234", n_factura="1234", 
            vencimiento=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"), 
            gtin="GTIN1", lote=datetime.datetime.now().strftime("%Y"),
            numero_serial=int(time.time()*10), 
            id_obra_social=None, id_evento=134,
            cuit_origen="20267565393", cuit_destino="20267565393", 
            apellido="Reingart", nombres="Mariano",
            tipo_documento="96", n_documento="26756539", sexo="M",
            direccion="Saraza", numero="1234", piso="", depto="", 
            localidad="Hurlingham", provincia="Buenos Aires",
            n_postal="1688", fecha_nacimiento="01/01/2000", 
            telefono="5555-5555",
            nro_asociado="9999999999999",
            cantidad=5,
            desde_numero_serial=None, hasta_numero_serial=None, 
            codigo_transaccion=None,
        ))
    if '--testdh' in sys.argv:
        medicamentos.append(dict(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"), 
            gln_origen="9999999999918", gln_destino="glnws", 
            n_remito="1234", n_factura="1234", 
            vencimiento=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"), 
            gtin="GTIN1", lote=datetime.datetime.now().strftime("%Y"),
            desde_numero_serial=int(time.time()*10)-1, 
            hasta_numero_serial=int(time.time()*10)+1, 
            id_obra_social=None, id_evento=134,
            nro_asociado="1234",
            cantidad=None, numero_serial=None,
            codigo_transaccion=None,
        ))

    # Opciones principales:
    
    if '--cancela' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML("trazamed_cancela_err.xml")  # cargo respuesta
        ws.SendCancelacTransacc(*sys.argv[sys.argv.index("--cancela")+1:])
    elif '--cancela_parcial' in sys.argv:
        ws.SendCancelacTransaccParcial(*sys.argv[sys.argv.index("--cancela_parcial")+1:])
    elif '--confirma' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML("trazamed_confirma.xml")  # cargo respuesta
            ok = ws.SendConfirmaTransacc(usuario="pruebasws", password="******",
                                   p_ids_transac="1", f_operacion="31-12-2013")
            if not ok:
                raise RuntimeError(ws.Excepcion)
        ws.SendConfirmaTransacc(*sys.argv[sys.argv.index("--confirma")+1:])
    elif '--alerta' in sys.argv:
        ws.SendAlertaTransacc(*sys.argv[sys.argv.index("--alerta")+1:])
    elif '--consulta' in sys.argv:
        if '--alertados' in sys.argv:
            ws.GetEnviosPropiosAlertados(
                                *sys.argv[sys.argv.index("--alertados")+1:]
                                )
        elif '--movimientos' in sys.argv:
            ws.GetTransaccionesWS(
                                *sys.argv[sys.argv.index("--movimientos")+1:]
                                )
        else:
            ws.GetTransaccionesNoConfirmadas(
                                *sys.argv[sys.argv.index("--consulta")+1:]
                                #usuario="pruebasws", password="******", 
                                #p_id_transaccion_global="1234", 
                                #id_agente_informador="1", 
                                #id_agente_origen="1", 
                                #id_agente_destino="1", 
                                #id_medicamento="1", 
                                #id_evento="1", 
                                #fecha_desde_op="01/01/2015", 
                                #fecha_hasta_op="31/12/2013", 
                                #fecha_desde_t="01/01/2013", 
                                #fecha_hasta_t="31/12/2013", 
                                #fecha_desde_v="01/04/2013", 
                                #fecha_hasta_v="30/04/2013", 
                                #n_factura=5, n_remito=6,
                                #estado=1,
                                #lote=88745,
                                #numero_serial=894124788,
                                )
        print "CantPaginas", ws.CantPaginas
        print "HayError", ws.HayError
        #print "TransaccionPlainWS", ws.TransaccionPlainWS
        # parametros comunes de salida (columnas de la tabla):
        claves = [k for k, v, l in TRANSACCIONES]
        # extiendo la lista de resultado para el archivo de intercambio:
        transacciones.extend(ws.TransaccionPlainWS)
        # encabezado de la tabla:
        print "||", "||".join(["%s" % clave for clave in claves]), "||"
        # recorro los datos devueltos (TransaccionPlainWS):
        while ws.LeerTransaccion():     
            for clave in claves:
                print "||", ws.GetParametro(clave),         # imprimo cada fila
            print "||"
    elif '--catalogo' in sys.argv:
        ret = ws.GetCatalogoElectronicoByGTIN(
                                *sys.argv[sys.argv.index("--catalogo")+1:]
                                )
        for catalogo in ret:
            print ret        # imprimo cada fila
    else:
        argv = [argv for argv in sys.argv if not argv.startswith("--")]
        if not medicamentos:
            if len(argv)>16:
                if '--dh' in sys.argv:
                    ws.SendMedicamentosDHSerie(*argv[1:])
                elif '--fraccion' in sys.argv:
                    ws.SendMedicamentosFraccion(*argv[1:])
                else:
                    ws.SendMedicamentos(*argv[1:])
            else:
                print "ERROR: no se indicaron todos los parámetros requeridos"
        elif medicamentos:
            try:
                usuario, password = argv[1:3]
            except:
                print "ADVERTENCIA: no se indico parámetros usuario y passoword"
                usuario = password = "******"
            for i, med in enumerate(medicamentos):
                print "Procesando registro", i
                del med['codigo_transaccion']
                if med.get("cantidad"):
                    del med["desde_numero_serial"]
                    del med["hasta_numero_serial"]
                    ws.SendMedicamentosFraccion(usuario, password, **med)
                elif med.get("desde_numero_serial"):
                    del med["cantidad"]
                    del med["numero_serial"]
                    ws.SendMedicamentosDHSerie(usuario, password, **med)
                else:
                    del med["cantidad"]
                    del med["desde_numero_serial"]
                    del med["hasta_numero_serial"]
                    ws.SendMedicamentos(usuario, password, **med)
                med['codigo_transaccion'] = ws.CodigoTransaccion
                errores.extend(ws.errores)
                print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                    ws.Resultado,
                    ws.CodigoTransaccion,
                    '|'.join(ws.Errores or []),
                    )
        else:
            print "ERROR: no se especificaron medicamentos a informar"
            
    if not medicamentos:
        print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                ws.Resultado,
                ws.CodigoTransaccion,
                '|'.join(ws.Errores or []),
                )

    if ws.Excepcion:
        print ws.Traceback

    if '--grabar' in sys.argv:
        if '--dbf' in sys.argv:
            guardar_dbf(formatos, True, {})        
        elif '--json' in sys.argv:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".json", "w")
                json.dump(formato[2], archivo, sort_keys=True, indent=4)
                archivo.close()
        else:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".txt", "w")
                for it in formato[2]:
                    archivo.write(escribir(it, formato[1]))
            archivo.close()
Beispiel #17
0
def main():
    "Función principal de pruebas (obtener CAE)"
    import os, time, sys
    global WSDL, LOCATION

    DEBUG = '--debug' in sys.argv

    ws = TrazaProdMed()
    
    ws.Username = '******'
    ws.Password = '******'
    
    if '--prod' in sys.argv and not H**O:
        WSDL = WSDL_PROD
        print "Usando WSDL:", WSDL
        sys.argv.pop(sys.argv.index("--prod"))

    # Inicializo las variables y estructuras para el archivo de intercambio:
    transacciones = []
    errores = []
    formatos = []

    if '--formato' in sys.argv:
        print "Formato:"
        for msg, formato, lista in formatos:
            comienzo = 1
            print "=== %s ===" % msg
            print "|| %-25s || %-12s || %-5s || %-4s || %-10s ||" % (  
                "Nombre", "Tipo", "Long.", "Pos(txt)", "Campo(dbf)")
            claves = []
            for fmt in formato:
                clave, longitud, tipo = fmt[0:3]
                clave_dbf = dar_nombre_campo_dbf(clave, claves)
                claves.append(clave_dbf)
                print "|| %-25s || %-12s || %5d ||   %4d   || %-10s ||" % (
                    clave, tipo, longitud, comienzo, clave_dbf)
                comienzo += longitud
        sys.exit(0)
        
    if '--cargar' in sys.argv:
        if '--dbf' in sys.argv:
            leer_dbf(formatos[:1], {})        
        elif '--json' in sys.argv:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".json", "r")
                d = json.load(archivo)
                formato[2].extend(d)
                archivo.close()
        else:
            for formato in formatos[:1]:
                archivo = open(formato[0].lower() + ".txt", "r")
                for linea in archivo:
                    d = leer(linea, formato[1])
                    formato[2].append(d)
                archivo.close()
        
    ws.Conectar("", WSDL)
    
    if ws.Excepcion:
        print ws.Excepcion
        print ws.Traceback
        sys.exit(-1)
    
    # Datos de pruebas:

    if '--test' in sys.argv:
        ws.CrearTransaccion(
            f_evento=datetime.datetime.now().strftime("%d/%m/%Y"),
            h_evento=datetime.datetime.now().strftime("%H:%M"), 
            gln_origen="7791234567801", gln_destino="7791234567801", 
            n_remito="R0001-12341234", n_factura="A0001-12341234", 
            vencimiento=(datetime.datetime.now()+datetime.timedelta(30)).strftime("%d/%m/%Y"), 
            gtin="07791234567810", lote=datetime.datetime.now().strftime("%Y"), # R4556567
            numero_serial=int(time.time()*10), # A23434
            id_evento=1, 
            cuit_medico="30711622507", id_obra_social=465667,
            apellido="Reingart", nombres="Mariano",
            tipo_documento="96", n_documento="28510785", sexo="M",
            calle="San Martin", numero="5656", piso="", depto="1", 
            localidad="Berazategui", provincia="Buenos Aires",
            n_postal="1700", fecha_nacimiento="20/12/1972", 
            telefono="5555-5555", 
            nro_afiliado="9999999999999",
            cod_diagnostico="B30",
            cod_hiv="NOAP31121970",
            id_motivo_devolucion=1,
            otro_motivo_devolucion="producto fallado",
        )           

    # Opciones principales:
    
    if '--cancela' in sys.argv:
        if '--loadxml' in sys.argv:
            ws.LoadTestXML("tests/xml/trazaprodmed_cancela_err.xml")  # cargo respuesta
        ws.SendCancelacTransacc(*sys.argv[sys.argv.index("--cancela")+1:])
    elif '--cancela_parcial' in sys.argv:
        ws.SendCancelacTransaccParcial(*sys.argv[sys.argv.index("--cancela_parcial")+1:])
    elif '--consulta' in sys.argv:
        ws.GetTransaccionesWS(
                            *sys.argv[sys.argv.index("--consulta")+1:]
                            )
        print "CantPaginas", ws.CantPaginas
        print "HayError", ws.HayError
        #print "TransaccionPlainWS", ws.TransaccionPlainWS
        # parametros comunes de salida (columnas de la tabla):
        TRANSACCIONES = ws.Transacciones[0].keys() if ws.Transacciones else []
        claves = [k for k in TRANSACCIONES]
        # extiendo la lista de resultado para el archivo de intercambio:
        transacciones.extend(ws.Transacciones)
        # encabezado de la tabla:
        print "||", "||".join(["%s" % clave for clave in claves]), "||"
        # recorro los datos devueltos (TransaccionPlainWS):
        while ws.LeerTransaccion():     
            for clave in claves:
                print "||", ws.GetParametro(clave),         # imprimo cada fila
            print "||"
    elif '--catalogo' in sys.argv:
        ret = ws.GetCatalogoElectronicoByGTIN(
                                *sys.argv[sys.argv.index("--catalogo")+1:]
                                )
        for catalogo in ws.params_out.values():
            print catalogo        # imprimo cada fila
    else:
        argv = [argv for argv in sys.argv if not argv.startswith("--")]
        if not transacciones:
            if len(argv)>16:
                ws.CrearTransaccion(*argv[3:])
            else:
                print "ERROR: no se indicaron todos los parámetros requeridos"
        if ws.Transacciones:
            try:
                usuario, password = argv[1:3]
            except:
                print "ADVERTENCIA: no se indico parámetros usuario y passoword"
                usuario = password = "******"
            ws.InformarProducto(usuario, password)
            for i, tx in enumerate(transacciones):
                print "Procesando registro", i
                tx['codigo_transaccion'] = ws.CodigoTransaccion
                errores.extend(ws.errores)
            print "|Resultado %5s|CodigoTransaccion %10s|Errores|%s|" % (
                ws.Resultado,
                ws.CodigoTransaccion,
                '|'.join(ws.Errores or []),
                )
        else:
            print "ERROR: no se especificaron productos a informar"

    if ws.Excepcion:
        print ws.Traceback

    if '--grabar' in sys.argv:
        if '--dbf' in sys.argv:
            guardar_dbf(formatos, True, {})        
        elif '--json' in sys.argv:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".json", "w")
                json.dump(formato[2], archivo, sort_keys=True, indent=4)
                archivo.close()
        else:
            for formato in formatos:
                archivo = open(formato[0].lower() + ".txt", "w")
                for it in formato[2]:
                    archivo.write(escribir(it, formato[1]))
            archivo.close()
Beispiel #18
0
def autorizar(ws, entrada, salida, informar_caea=False):
    tributos = []
    ivas = []
    cbtasocs = []
    encabezado = []
    if '/dbf' in sys.argv:
        if DEBUG: print "Leyendo DBF..."

        formatos = [('Encabezado', ENCABEZADO, encabezado), ('Tributo', TRIBUTO, tributos), ('Iva', IVA, ivas), ('Comprobante Asociado', CMP_ASOC, cbtasocs)]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezado[0]
    elif '/json' in sys.argv:
        import json
        encabezado = json.load(entrada)[0]
        ivas = encabezado.get('ivas', [])
        tributos = encabezado.get('tributos', [])
        cbtasocs = encabezado.get('cbtasocs', [])
    else:
        for linea in entrada:
            if str(linea[0])=='0':
                encabezado = leer(linea, ENCABEZADO)
            elif str(linea[0])=='1':
                tributo = leer(linea, TRIBUTO)
                tributos.append(tributo)
            elif str(linea[0])=='2':
                iva = leer(linea, IVA)
                ivas.append(iva)
            elif str(linea[0])=='3':
                cbtasoc = leer(linea, CMP_ASOC)
                cbtasocs.append(cbtasoc)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if informar_caea:
        if '/testing' in sys.argv:
            encabezado['cae'] = '21073372218437'
        encabezado['caea'] = encabezado['cae']

    ws.CrearFactura(**encabezado)
    for tributo in tributos:
        ws.AgregarTributo(**tributo)
    for iva in ivas:
        ws.AgregarIva(**iva)
    for cbtasoc in cbtasocs:
        ws.AgregarCmpAsoc(**cbtasoc)

    if DEBUG:
        print '\n'.join(["%s='%s'" % (k,str(v)) for k,v in ws.factura.items()])
    if not DEBUG or raw_input("Facturar?")=="S":
        if not informar_caea:
            cae = ws.CAESolicitar()
            dic = ws.factura
        else:
            cae = ws.CAEARegInformativo()
            dic = ws.factura
        dic.update(encabezado)         # preservar la estructura leida
        dic.update({
            'cae': cae and str(cae) or '',
            'fch_venc_cae': ws.Vencimiento and str(ws.Vencimiento) or '',
            'resultado': ws.Resultado,
            'motivos_obs': ws.Obs,
            'err_code': str(ws.ErrCode),
            'err_msg': ws.ErrMsg,
            'reproceso': ws.Reproceso,
            'emision_tipo': ws.EmisionTipo,
            })
        escribir_factura(dic, salida)
        print "NRO:", dic['cbt_desde'], "Resultado:", dic['resultado'], "%s:" % ws.EmisionTipo,dic['cae'],"Obs:",dic['motivos_obs'].encode("ascii", "ignore"), "Err:", dic['err_msg'].encode("ascii", "ignore"), "Reproceso:", dic['reproceso']
Beispiel #19
0
def autorizar(ws, entrada, salida, informar_caea=False):
    encabezados = []
    if '/dbf' in sys.argv:
        tributos = []
        ivas = []
        cbtasocs = []
        encabezados = []
        opcionales = []
        if DEBUG: print "Leyendo DBF..."

        formatos = [('Encabezado', ENCABEZADO, encabezados), 
                    ('Tributo', TRIBUTO, tributos), 
                    ('Iva', IVA, ivas), 
                    ('Comprobante Asociado', CMP_ASOC, cbtasocs),
                    ('Datos Opcionales', OPCIONAL, opcionales),
                    ]
        dic = leer_dbf(formatos, conf_dbf)
        
        # rearmar estructura asociando id (comparando, si se útiliza)
        for encabezado in encabezados:
            for tributo in tributos:
                if tributo.get("id") == encabezado.get("id"):
                    encabezado.setdefault("tributos", []).append(tributo)
            for iva in ivas:
                if iva.get("id") == encabezado.get("id"):
                    encabezado.setdefault("ivas", []).append(iva)
            for cbtasoc in cbtasocs:
                if cbtasoc.get("id") == encabezado.get("id"):
                    encabezado.setdefault("cbtasocs", []).append(cbtasoc)
            for opcional in opcionales:
                if opcional.get("id") == encabezado.get("id"):
                    encabezado.setdefault("opcionales", []).append(opcional)
            if encabezado.get("id") is None and len(encabezados) > 1:
                # compatibilidad hacia atrás, descartar si hay más de 1 factura
                warnings.warn("Para múltiples registros debe usar campo id!")
                break
    elif '/json' in sys.argv:
        # ya viene estructurado
        import json
        encabezados = json.load(entrada)
    else:
        # la estructura está implícita en el órden de los registros (líneas)
        for linea in entrada:
            if str(linea[0])=='0':
                encabezado = leer(linea, ENCABEZADO)
                encabezados.append(encabezado)
                if DEBUG: print len(encabezados), "Leida factura %(cbt_desde)s" % encabezado 
            elif str(linea[0])=='1':
                tributo = leer(linea, TRIBUTO)
                encabezado.setdefault("tributos", []).append(tributo)
            elif str(linea[0])=='2':
                iva = leer(linea, IVA)
                encabezado.setdefault("ivas", []).append(iva)
            elif str(linea[0])=='3':
                cbtasoc = leer(linea, CMP_ASOC)
                encabezado.setdefault("cbtasocs", []).append(cbtasoc)
            elif str(linea[0])=='6':
                opcional = leer(linea, OPCIONAL)
                encabezado.setdefault("opcionales", []).append(opcional)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if informar_caea:
        if '/testing' in sys.argv:
            encabezado['cae'] = '21073372218437'
        encabezado['caea'] = encabezado['cae']

    if not encabezados:
        raise RuntimeError("No se pudieron leer los registros de la entrada")

    # ajusto datos para pruebas en depuración (nro de cbte. / fecha)
    if '--testing' in sys.argv and DEBUG:
        encabezado['punto_vta'] = 9998
        cbte_nro = int(ws.CompUltimoAutorizado(encabezado['tipo_cbte'], 
                                               encabezado['punto_vta'])) + 1
        encabezado['cbt_desde'] = cbte_nro
        encabezado['cbt_hasta'] = cbte_nro
        encabezado['fecha_cbte'] = datetime.datetime.now().strftime("%Y%m%d")

    # recorrer los registros para obtener CAE (dicts tendrá los procesados)
    dicts = []
    for encabezado in encabezados:
        # extraer sub-registros:
        ivas = encabezado.get('ivas', encabezado.get('iva', []))
        tributos = encabezado.get('tributos', [])
        cbtasocs = encabezado.get('cbtasocs', [])
        opcionales = encabezado.get('opcionales', [])

        ws.CrearFactura(**encabezado)
        for tributo in tributos:
            ws.AgregarTributo(**tributo)
        for iva in ivas:
            ws.AgregarIva(**iva)
        for cbtasoc in cbtasocs:
            ws.AgregarCmpAsoc(**cbtasoc)
        for opcional in opcionales:
            ws.AgregarOpcional(**opcional)

        if DEBUG:
            print '\n'.join(["%s='%s'" % (k,str(v)) for k,v in ws.factura.items()])
        if not DEBUG or raw_input("Facturar (S/n)?")=="S":
            if not informar_caea:
                cae = ws.CAESolicitar()
                dic = ws.factura
            else:
                cae = ws.CAEARegInformativo()
                dic = ws.factura
            print "Procesando %s %04d %08d %08d %s %s $ %0.2f IVA: $ %0.2f" % (
                TIPO_CBTE.get(dic['tipo_cbte'], dic['tipo_cbte']), 
                dic['punto_vta'], dic['cbt_desde'], dic['cbt_hasta'], 
                TIPO_DOC.get(dic['tipo_doc'], dic['tipo_doc']), dic['nro_doc'], 
                float(dic['imp_total']), 
                float(dic['imp_iva'] if dic['imp_iva'] is not None else 'NaN')) 
            dic.update(encabezado)         # preservar la estructura leida
            dic.update({
                'cae': cae and str(cae) or '',
                'fch_venc_cae': ws.Vencimiento and str(ws.Vencimiento) or '',
                'resultado': ws.Resultado,
                'motivos_obs': ws.Obs,
                'err_code': str(ws.ErrCode),
                'err_msg': ws.ErrMsg,
                'reproceso': ws.Reproceso,
                'emision_tipo': ws.EmisionTipo,
                })
            dicts.append(dic)
            print "NRO:", dic['cbt_desde'], "Resultado:", dic['resultado'], "%s:" % ws.EmisionTipo,dic['cae'],"Obs:",dic['motivos_obs'].encode("ascii", "ignore"), "Err:", dic['err_msg'].encode("ascii", "ignore"), "Reproceso:", dic['reproceso']
    if dicts:
        escribir_facturas(dicts, salida)
Beispiel #20
0
def autorizar(ws, entrada, salida):
    # recupero el último número de transacción
    ##id = wsbfe.ultnro(client, token, sign, cuit)

   
    detalles = []
    encabezado = {}
    if '/dbf' in sys.argv:
        encabezados = []
        formatos = [('Encabezado', ENCABEZADO, encabezados), ('Detalles', DETALLE, detalles)]
        dic = leer_dbf(formatos, conf_dbf)
        encabezado = encabezados[0]
    else:
        for linea in entrada:
            if str(linea[0])=='0':
                encabezado = leer(linea, ENCABEZADO)
            elif str(linea[0])=='1':
                detalle = leer(linea, DETALLE)
                detalles.append(detalle)
            else:
                print "Tipo de registro incorrecto:", linea[0]

    if isinstance(encabezado['id'], basestring) and not encabezado['id'].strip():
        # TODO: habria que leer y/o grabar el id en el archivo
        ##id += 1 # incremento el nº de transacción 
        # Por el momento, el id se calcula con el tipo, pv y nº de comprobant
        i = long(encabezado['cbte_nro'])
        i += (int(encabezado['cbte_nro'])*10**4 + int(encabezado['punto_vta']))*10**8
        encabezado['id'] = i

    if not encabezado['zona'].strip():
        encabezado['zona'] = 0

    if 'testing' in sys.argv:
        ult_cbte = ws.GetLastCMP(punto_vta, tipo_cbte)
        encabezado['cbte_nro'] = ult_cbte + 1
        ult_id = ws.GetLastID()
        encabezado['id'] = ult_id + 1    
   
    ##encabezado['imp_moneda_ctz'] = 1.00
    ws.CrearFactura(**encabezado)
    for detalle in detalles:
        ws.AgregarItem(**detalle)
            
    if DEBUG:
        print '\n'.join(["%s='%s'" % (k,v) for k,v in ws.factura.items()])
        print 'id:', encabezado['id']
    if not DEBUG or raw_input("Facturar?")=="S":
        cae = ws.Authorize(encabezado['id'])
        dic = ws.factura
        dic.update({'id':  encabezado['id'],
                    'fecha_cbte': ws.FechaCbte, 
                    'imp_total': ws.ImpTotal or 0,
                    'imp_neto': ws.ImpNeto or 0, 
                    'impto_liq': ws.ImptoLiq or 0, 
                    'cae': str(ws.CAE), 
                    'obs': str(ws.Obs), 'reproceso': str(ws.Reproceso),
                    'fch_venc_cae': ws.Vencimiento,  
                    'err_msg': ws.ErrMsg,
                   })
        escribir_factura(dic, salida)
        print "ID:", dic['id'], "CAE:",dic['cae'],"Obs:",dic['obs'],"Reproceso:",dic['reproceso']