def pagina_princiapl():
if request.method == 'GET':
msgResult = ONT['getLotes_' + str(get_count())]
gr = Graph()
gr.add((msgResult, RDF.type, ONT.GetLotes))
AgentLog = get_agent_info(agn.AgentLogistico, DirectoryAgent,
AgentTransportista, get_count())
gr2 = infoagent_search_message(AgentLog.address, AgentLog.uri, gr,
msgResult)
index = 0
subject_pos = {}
lista = []
for s, p, o in gr2:
if s not in subject_pos:
subject_pos[s] = index
lista.append({})
index += 1
if s in subject_pos:
subject_dict = lista[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ONT.id_lote:
subject_dict['id_lote'] = o
lista[subject_pos[s]] = subject_dict
return render_template('transportista.html', lotes=lista)
else:
if request.form['submit'] == 'Enviado!':
msgResult = ONT['cobro_' + str(get_count())]
id_lot = request.form['id_lote']
gr = Graph()
body_lote = ONT['id_Lote_' + id_lot]
gr.add((msgResult, RDF.type, ONT.ProductoEnviado))
gr.add(
(body_lote, ONT.id_lote, Literal(id_lot,
datatype=XSD.integer)))
AgentLog = get_agent_info(agn.AgentCobrador, DirectoryAgent,
AgentTransportista, get_count())
gr2 = infoagent_search_message(AgentLog.address, AgentLog.uri, gr,
msgResult)
return "producto enviado xd"
def browserDevolucion():
global compras
if request.method == 'GET':
logger.info('Se muestran todas las Compras')
count, counts = getAllCompras()
return render_template('devolucion.html', compras=compras, count=count, tam=counts)
else:
logger.info('Peticon de devolucion')
devoluciones = []
for item in request.form.getlist("checkbox"):
devoluciones.append(compras[int(item)][0])
g = Graph()
content = ECSDI['Devolver_producto_' + str(get_count())]
g.add((content, RDF.type, ECSDI.Devolver_producto))
for compra in devoluciones:
g.add((compra, RDF.type, ECSDI.Compra))
logger.info('AQUI SI')
agenteDevoluciones = get_agent_info(agn.AgenteDevoluciones, AgenteDirectorio, AgenteExternoAsistentePersonal, get_count())
logger.info('AQUI NO')
gm = send_message(
build_message(g, perf=ACL.request, sender=AgenteExternoAsistentePersonal.uri, receiver=agenteDevoluciones.uri,
msgcnt=get_count(),
content=content), agenteDevoluciones.address)
subject = gm.value(predicate=RDF.type, object=ECSDI.Info_transporte)
transportista = gm.value(subject=subject, predicate=ECSDI.Nombre_transportista)
logger.info(transportista)
return render_template('finalDevolucion.html', transportista=transportista)
def alta():
if request.method == 'GET':
return render_template('alta_producto.html')
else:
if request.form['submit'] == 'Dar de alta':
id = str(random.randint(1, 1000000000))
nombre = request.form['nombre']
marca = request.form['marca']
precio = request.form['precio']
peso = request.form['peso']
proc = 'externo'
producto = ONT['Producto_externo_' + id]
msgResult = ONT['Registrar_' + str(get_count())]
gr = Graph()
gr.add((msgResult, RDF.type, ONT.Registrar))
gr.add((producto, RDF.type, ONT.Producto_externo))
gr.add((producto, ONT.nombre, Literal(nombre, datatype=XSD.string)))
gr.add((producto, ONT.marca, Literal(marca, datatype=XSD.string)))
gr.add((producto, ONT.precio, Literal(precio, datatype=XSD.float)))
gr.add((producto, ONT.peso, Literal(peso, datatype=XSD.float)))
gr.add((producto, ONT.id, Literal(id, datatype=XSD.integer)))
gr.add((producto, ONT.proc, Literal(proc, datatype=XSD.string)))
gr.add((msgResult, ONT.Producto_externo, producto))
AgentLog = get_agent_info(agn.AgentLogistico, DirectoryAgent, AgentTiendaExterna, get_count())
infoagent_search_message(AgentLog.address, AgentLog.uri, gr, msgResult)
prod = {'pnombre': request.form['nombre'], 'pmarca': request.form['marca'],
'pprecio': request.form['precio'], 'ppeso': request.form['peso']}
return render_template('alta_producto.html', producto=prod)
def buscar_actividades(type): # type = ludica/festiva/cultural
# Creamos el contenido
content = ECSDI['peticion_de_actividades' + str(get_count())]
# Creamos los objetos necesarios para las tripletas del grafo
tipo = ECSDI['tipoActividad' + str(get_count())]
# Creamos el grafo con las tripletas
grafo = Graph()
grafo.add((tipo, RDF.type, ECSDI.ciudadOrigen))
grafo.add((content, RDF.type, ECSDI.peticion_de_actividades))
# Preguntamos por el agente que necesitamos
agente_actividades = get_agent_info(
agn.AgenteObtenedorDeOfertasDeActividades, DirectoryAgent,
AgenteProcesador, get_count())
# Enviamos el mensaje
gr = send_message(
build_message(grafo,
perf=ACL.request,
sender=AgenteProcesador.uri,
receiver=agente_actividades.uri,
msgcnt=get_count(),
content=content), agente_actividades.address)
# Retornamos el grafo respuesta del mensaje
return gr
def buscar_desplazamiento(ciudadNombre='Barcelona'):
# Creamos el contenido
content = ECSDI['peticion_de_desplazamiento' + str(get_count())]
# Creamos los objetos necesarios para las tripletas del grafo
ciudadOrigen = ECSDI['ciudadOrigen' + str(get_count())]
ciudadDestino = ECSDI['ciudadDestino' + str(get_count())]
# Creamos el grafo con las tripletas
grafo = Graph()
grafo.add((ciudadOrigen, RDF.type, ECSDI.ciudadOrigen))
grafo.add((ciudadDestino, RDF.type, ECSDI.ciudadOrigen))
grafo.add((content, RDF.type, ECSDI.peticion_de_desplazamiento))
# Preguntamos por el agente que necesitamos
agente_desplazamiento = get_agent_info(
agn.AgenteObtenedorDeOfertasDeDesplazamiento, DirectoryAgent,
AgenteProcesador, get_count())
# Enviamos el mensaje
gr = send_message(
build_message(grafo,
perf=ACL.request,
sender=AgenteProcesador.uri,
receiver=agente_desplazamiento.uri,
msgcnt=get_count(),
content=content), agente_desplazamiento.address)
# Retornamos el grafo respuesta del mensaje
return gr
def comunicacion():
logger.info("Peticion recibida")
global mss_cnt
global dsgraph
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = None
if msgdic is None:
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteDevoluciones.uri, msgcnt=get_count())
else:
if msgdic['performative'] != ACL.request:
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteDevoluciones.uri, msgcnt=get_count())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
if accion == ECSDI.Devolver_producto:
logger.info("Peticion de retorno")
if gm.value(subject=accion, predicate=RDF.type) == ECSDI.Devolucion_insatisfaccion and fuera_plazo(gm, content): # si se ha comprado hace mas de 15 dias, rechazado
gr = build_message(Graph(), ACL['refuse'], sender=AgenteDevoluciones.uri, msgcnt=get_count())
else:
comprasbd = open("../data/productos_pedidos.owl")
gcomp = Graph()
gcomp.parse(comprasbd, format='turtle')
compras = gm.subjects(predicate=RDF.type, object=ECSDI.Compra)
pesototal = 0.0
logger.info("fuera")
for compra in compras:
logger.info("dentro")
productos = gcomp.objects(subject=compra, predicate=ECSDI.Productos)
for prod in productos:
gcomp.remove((compra, ECSDI.Productos, prod))
peso = gcomp.value(subject=prod, predicate=ECSDI.Peso)
logger.info(peso)
pesototal += peso.toPython()
gcomp.remove((compra,RDF.type, ECSDI.Compra))
comprasbd.close()
gcomp.serialize(destination='../data/productos_pedidos.owl', format='turtle')
gr = Graph()
gr.add((content, RDF.type, ECSDI.Devolver_producto))
gr.add((content, ECSDI.Peso_lote, Literal(pesototal)))
centroLogistico = get_agent_info(agn.AgenteCentroLogistico, AgenteDirectorio, AgenteDevoluciones, get_count())
gr = send_message(build_message(gr, perf=ACL.request, sender=AgenteDevoluciones.uri, receiver=centroLogistico.uri, msgcnt=get_count(), content=content), centroLogistico.address)
else:
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteDevoluciones.uri, msgcnt=get_count())
logger.info('Respondemos a la peticion')
return gr.serialize(format='xml')
def anadir_producto(request):
logger.info("Analizando petición de añadir producto")
id_producto = uuid.uuid4() #generate a random id
vendedor = request.form["id_vendedor"]
nombre = request.form["nombre_producto"]
precio = int(int(request.form["precio_producto"]) * 100)
peso = int(request.form["peso"])
marca = request.form["marca"]
categoria = request.form["categoria"]
descripcion = request.form["descripcion_producto"]
unidades = request.form["unidades"]
tarjeta = request.form["tarjeta"]
sujeto = ECSDIAmazon["Anadir_producto" + str(get_message_count())]
grafo = Graph()
grafo.add((sujeto, RDF.type, ECSDIAmazon.Anadir_producto))
grafo.add((sujeto, ECSDIAmazon.Id_producto,
Literal(id_producto, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Vendedor, Literal(vendedor, datatype=XSD.string)))
grafo.add((sujeto, ECSDIAmazon.Nombre_producto,
Literal(nombre, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Precio_producto, Literal(precio,
datatype=XSD.int)))
grafo.add((sujeto, ECSDIAmazon.Descripcion_producto,
Literal(descripcion, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Categoria, Literal(categoria,
datatype=XSD.string)))
grafo.add((sujeto, ECSDIAmazon.Marca, Literal(marca, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Peso_producto, Literal(peso, datatype=XSD.int)))
grafo.add(
(sujeto, ECSDIAmazon.Tarjeta, Literal(tarjeta, datatype=XSD.string)))
grafo.add((sujeto, ECSDIAmazon.Unidades, Literal(unidades,
datatype=XSD.int)))
# logger.info("Cogiendo informacion del AgenteGestorDeProductos")
agente = get_agent_info(agn.AgenteGestorDeProductos, DirectoryAgent,
AgenteVendedorExterno, get_message_count())
logger.info(
"Enviando peticion de anadir producto al AgenteGestorDeProductos")
respuesta_msg = send_message(
build_message(grafo,
perf=ACL.request,
sender=AgenteVendedorExterno.uri,
receiver=agente.uri,
msgcnt=get_message_count(),
content=sujeto), agente.address)
return render_template('prod_anadido.html')
def contactarCobrador(gm):
index = 0
subject_pos = {}
lista = []
procedencia = ""
usuario = ""
targeta = ""
id = ""
precio = 0.0
for s, p, o in gm:
if s not in subject_pos:
subject_pos[s] = index
lista.append({})
index += 1
if s in subject_pos:
subject_dict = lista[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ONT.id:
id = subject_dict['id'] = o
elif p == ONT.proc:
subject_dict['proc'] = o
procedencia = subject_dict['proc']
elif p == ONT.precio:
precio = subject_dict['precio'] = o
elif p == ONT.targeta:
targeta = subject_dict['targeta'] = o
elif p == ONT.usuario:
usuario = subject_dict['usuario'] = o
lista[subject_pos[s]] = subject_dict
msgResult = ONT['cobro2_' + str(get_count())]
gr = Graph()
body_prod_dev = ONT['id_Dev_' + id]
gr.add((msgResult, RDF.type, ONT.ProductoDevuelto))
gr.add((body_prod_dev, RDF.type, ONT.Producto_devuelto))
gr.add((body_prod_dev, ONT.id, Literal(id, datatype=XSD.integer)))
gr.add((body_prod_dev, ONT.proc, Literal(procedencia,
datatype=XSD.string)))
gr.add((body_prod_dev, ONT.precio, Literal(precio, datatype=XSD.float)))
gr.add((body_prod_dev, ONT.targeta, Literal(targeta, datatype=XSD.string)))
gr.add((body_prod_dev, ONT.usuario, Literal(usuario, datatype=XSD.string)))
gr.add((msgResult, ONT.DevolverProducto, URIRef(body_prod_dev)))
AgentCobr = get_agent_info(agn.AgentCobrador, DirectoryAgent,
AgentDevoluciones, get_count())
gr2 = infoagent_search_message(AgentCobr.address, AgentCobr.uri, gr,
msgResult)
return gm
def cobroVenta(precio_quasi_total,precio_envio,tarjeta):
"""Se comunica con el agente financiero para que realice el cobro"""
agente_financiero = get_agent_info(agn.AgenteFinanciero, DirectoryAgent, AgenteGestorDeVentas, get_message_count())
logger.info("Enviando peticion de cobro al AgenteFinanciero")
# print("La informacion del agente financiero es:")
# print(agente_financiero.name)
# print(agente_financiero.address)
# print(agente_financiero.uri)
grafo_transaccion = Graph()
precio_total_final = precio_quasi_total + precio_envio
contenido = ECSDIAmazon["Transferencia_cobro"+ str(get_message_count())]
grafo_transaccion.add((contenido, RDF.type, ECSDIAmazon.Transferencia_cobrar))
grafo_transaccion.add((contenido, ECSDIAmazon.Tarjeta, Literal(tarjeta, datatype=XSD.string)))
grafo_transaccion.add((contenido, ECSDIAmazon.Precio_total, Literal(precio_total_final, datatype=XSD.int)))
# Cobro al usuario
respuesta_cobro = send_message(build_message(
grafo_transaccion, perf=ACL.request, sender=AgenteGestorDeVentas.uri, receiver=agente_financiero.uri, msgcnt=get_message_count(),
content=contenido), agente_financiero.address)
# print(respuesta_cobro.serialize(format="turtle" ).decode())
transferencia = respuesta_cobro.value(predicate=RDF.type, object=ECSDIAmazon.Transferencia)
# print("La transferencia es :", transferencia)
if "Exitosa" == str(respuesta_cobro.value(subject=transferencia, predicate=ECSDIAmazon.Estado)):
logger.info("Se ha cobrado la venta exitosamente")
# mensaje = "Se ha cobrado a su cuenta"
else:
logger.info("No se ha podido cobrar la venta exitosamente")
# mensaje = "Ohoh no se ha podido cobrar a el precio de la venta "
# Pago a vendedor externo
# respuesta_pago = send_message(build_message(
# grafo_transaccion, perf=ACL.request, sender=AgenteGestorDeVentas.uri, receiver=agente_financiero.uri, msgcnt=get_message_count(),
# content=contenido), agente_financiero.address)
#
# Datos relevantes a(suponemos que solo hay un agente usuario) del cobro al vendedor externo(solo un vendedor externo)
logger.info("Se genera el informe con la información de cobro")
grafo_transaccion = Graph()
contenido = ECSDIAmazon["Informar"+ str(get_message_count())]
grafo_transaccion.add((contenido, RDF.type, ECSDIAmazon.Informar))
grafo_transaccion.add((contenido, ECSDIAmazon.Tarjeta, Literal(tarjeta, datatype=XSD.string)))
grafo_transaccion.add((contenido, ECSDIAmazon.Precio_total, Literal(precio_total_final, datatype=XSD.float)))
# grafo_transaccion.add((contenido, ECSDIAmazon.Mensaje, Literal(mensaje, datatype=XSD.string)))
return grafo_transaccion
def browser_cerca():
"""
Permite la comunicacion con el agente
"""
logger.info("Enviando peticion de busqueda")
# Content of the message
contentResult = ECSDI['peticion_de_plan' + str(get_count())]
# Graph creation
gr = Graph()
gr.add((contentResult, RDF.type, ECSDI.peticion_de_plan))
# Obtenemos los datos del formulario, ciudad a visitar y fechas disponibles
originCity = request.form.get('originCity')
destinationCity = request.form.get('destinationCity')
initDate = request.form.get('initDate')
finDate = request.form.get('finDate')
logger.info(originCity)
if originCity:
city = ECSDI['ciudad' + str(get_count())]
gr.add((city, RDF.type, ECSDI.ciudad))
gr.add((city, ECSDI.nombre, Literal(originCity, datatype=XSD.string)))
# Add restriccio to content
gr.add((contentResult, ECSDI.tiene_como_destino, URIRef(city)))
# imprimimos el grafo
logger.info(gr)
planificador = get_agent_info(agn.PlannerAgent, DirectoryAgent,
AdministrativeAgent, get_count())
gresp = send_message(
build_message(gr,
perf=ACL.request,
sender=AdministrativeAgent.uri,
receiver=planificador.uri,
msgcnt=get_count(),
content=contentResult), planificador.address)
return 1
def buscar_alojamiento(ciudadNombre='Barcelona'):
# Creamos el contenido
content = ECSDI['peticion_de_alojamiento' + str(get_count())]
# Creamos los objetos necesarios para las tripletas del grafo
ciudad = ECSDI['ciudad' + str(get_count())]
localizacion = ECSDI['localizacion' + str(get_count())]
# Creamos el grafo con las tripletas
grafo = Graph()
grafo.add((ciudad, RDF.type, ECSDI.ciudad))
grafo.add((localizacion, RDF.type, ECSDI.localizacion))
grafo.add((ciudad, ECSDI.nombre, Literal(ciudadNombre)))
grafo.add((localizacion, ECSDI.pertenece_a, URIRef(ciudad)))
grafo.add((content, RDF.type, ECSDI.peticion_de_alojamiento))
grafo.add((content, ECSDI.tiene_como_restriccion_de_localizacion,
URIRef(localizacion)))
# Preguntamos por el agente que necesitamos
agente_alojamiento = get_agent_info(
agn.AgenteObtenedorDeOfertasDeAlojamiento, DirectoryAgent,
AgenteProcesador, get_count())
# Enviamos el mensaje
gr = send_message(
build_message(grafo,
perf=ACL.request,
sender=AgenteProcesador.uri,
receiver=agente_alojamiento.uri,
msgcnt=get_count(),
content=content), agente_alojamiento.address)
# Retornamos el grafo respuesta del mensaje
return gr
def buscar():
if request.method == 'GET':
msgResult = ONT['BusquedaRecom' + str(get_count())]
gr3 = Graph()
gr3.add((msgResult, RDF.type, ONT.BusquedaRecom))
grAgentRecom = get_agent_info(agn.AgentRecomendador, DirectoryAgent,
AgentClient, get_count())
gr4 = infoagent_search_message(grAgentRecom.address, grAgentRecom.uri,
gr3, msgResult)
index = 0
recomendaciones1 = []
del recomendaciones[:]
subject_pos = {}
for s, p, o in gr4:
if s not in subject_pos:
subject_pos[s] = index
recomendaciones1.append({})
index += 1
if s in subject_pos:
subject_dict = recomendaciones1[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ONT.marca:
subject_dict['marca'] = o
elif p == ONT.precio:
subject_dict['precio'] = o
elif p == ONT.nombre:
subject_dict['nombre'] = o
elif p == ONT.nvotes:
subject_dict['nvotes'] = o
elif p == ONT.valoracion:
subject_dict['valoracion'] = o
recomendaciones1[subject_pos[s]] = subject_dict
for i in range(0, len(recomendaciones1)):
if float(recomendaciones1[i]['valoracion']) > 3.4:
recomendaciones.append(recomendaciones1[i])
return render_template('buscar.html', recomendaciones=recomendaciones)
else:
if request.form['submit'] == 'Buscar':
logger.info("Petición de búsqueda enviada")
msgResult = ONT['Busqueda' + str(get_count())]
gr = Graph()
gr.add((msgResult, RDF.type, ONT.Busqueda))
nombre = request.form['nombre']
marca = request.form['marca']
precio_max = request.form['precio_max']
if nombre:
body_nombre = ONT['restriccion_de_nombre' + str(get_count())]
gr.add((body_nombre, RDF.type, ONT.restriccion_de_nombre))
gr.add((body_nombre, ONT.nombre,
Literal(nombre, datatype=XSD.string)))
gr.add((msgResult, ONT.Restringe, URIRef(body_nombre)))
if marca:
body_marca = ONT['restriccion_de_marca' + str(get_count())]
gr.add((body_marca, RDF.type, ONT.restriccion_de_marca))
gr.add(
(body_marca, ONT.marca, Literal(marca,
datatype=XSD.string)))
gr.add((msgResult, ONT.Restringe, URIRef(body_marca)))
if precio_max:
body_precio = ONT['restriccion_de_precio' + str(get_count())]
gr.add((body_precio, RDF.type, ONT.restriccion_de_precio))
gr.add((body_precio, ONT.precio_max,
Literal(precio_max, datatype=XSD.float)))
gr.add((msgResult, ONT.Restringe, URIRef(body_precio)))
grAgentBuscador = get_agent_info(agn.AgentBuscador, DirectoryAgent,
AgentClient, get_count())
gr2 = infoagent_search_message(grAgentBuscador.address,
grAgentBuscador.uri, gr, msgResult)
index = 0
subject_pos = {}
lista = []
for s, p, o in gr2:
if s not in subject_pos:
subject_pos[s] = index
lista.append({})
index += 1
if s in subject_pos:
subject_dict = lista[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ONT.marca:
subject_dict['marca'] = o
elif p == ONT.precio:
subject_dict['precio'] = o
elif p == ONT.nombre:
subject_dict['nombre'] = o
elif p == ONT.id:
subject_dict['id'] = o
elif p == ONT.proc:
subject_dict['proc'] = o
elif p == ONT.peso:
subject_dict['peso'] = o
lista[subject_pos[s]] = subject_dict
total = calcula_precio_carrito()
return render_template('buscar.html',
productos=lista,
productos_carrito=carrito_compra,
total=total,
recomendaciones=recomendaciones)
elif request.form['submit'] == 'Al carrito!':
item = {}
item["id"] = request.form["id"]
item["proc"] = request.form["proc"]
item["marca"] = request.form["marca"]
item["precio"] = request.form["precio"]
item["nombre"] = request.form["nombre"]
item["peso"] = request.form["peso"]
carrito_compra.append(item)
total = calcula_precio_carrito()
return render_template('buscar.html',
productos_carrito=carrito_compra,
total=total,
recomendaciones=recomendaciones)
elif request.form['submit'] == 'Eliminar':
idd = request.form["id"]
ii = -1
for i in range(0, len(carrito_compra)):
if carrito_compra[i]["id"] == idd:
ii = i
del carrito_compra[ii]
total = calcula_precio_carrito()
return render_template('buscar.html',
productos_carrito=carrito_compra,
total=total,
recomendaciones=recomendaciones)
elif request.form['submit'] == 'Comprar':
total = calcula_precio_carrito()
return render_template('datos_cliente.html',
productos_carrito=carrito_compra,
total=total)
elif request.form['submit'] == 'Confirmar compra':
direccion = str(request.form["direccion"])
nombre = str(request.form["nombre"])
targeta = str(request.form["targeta"])
if nombre == "" or targeta == "" or direccion == "":
total = calcula_precio_carrito()
error = "Faltan campos por llenar. Por favor, no dejes ningun campo en blanco"
return render_template('datos_cliente.html',
productos_carrito=carrito_compra,
total=total,
error=error)
datos = {}
prioridad = int(request.form["prioridad"])
if prioridad == 1:
datos["envio"] = 0
datos["llegada"] = "7 y 10 dias laborables"
elif prioridad == 2:
datos["envio"] = 4.95
datos["llegada"] = "3 y 6 dias laborables"
elif prioridad == 3:
datos["envio"] = 15
datos["llegada"] = "1 y 2 dias laborables"
total = calcula_precio_carrito()
datos["precio"] = round(total / 1.21, 2)
datos["iva"] = round(total - total / 1.21, 2)
datos["total"] = total + datos["envio"]
datos["nombre"] = nombre
datos["targeta"] = targeta
datos["direccion"] = direccion
precio_externo = calcula_precio_externo()
id_compra = str(random.randint(1, 1000000000))
gr2 = Graph()
compra = ONT['Compra_' + id_compra]
msgResult2 = ONT['Comprar_' + str(get_count())]
gr2.add((msgResult2, RDF.type, ONT.Comprar))
gr2.add((compra, RDF.type, ONT.Compra))
gr2.add(
(compra, ONT.id_compra, Literal(id_compra,
datatype=XSD.integer)))
gr2.add(
(compra, ONT.precio, Literal(datos["total"],
datatype=XSD.float)))
gr2.add((compra, ONT.precio_externo,
Literal(precio_externo, datatype=XSD.float)))
gr2.add((compra, ONT.nombre, Literal(nombre, datatype=XSD.string)))
gr2.add((compra, ONT.targeta, Literal(targeta,
datatype=XSD.string)))
gr2.add(
(compra, ONT.direccion, Literal(direccion,
datatype=XSD.string)))
gr2.add(
(compra, ONT.prioridad, Literal(prioridad,
datatype=XSD.integer)))
gr2.add(
(compra, ONT.peso, Literal(getPesoTotal(),
datatype=XSD.float)))
gr2.add((compra, ONT.enviado, Literal('false',
datatype=XSD.boolean)))
gr2.add((compra, ONT.id_lote, Literal(0, datatype=XSD.integer)))
gr2.add((compra, ONT.total,
Literal(len(carrito_compra), datatype=XSD.integer)))
AgentVen = get_agent_info(agn.AgentVendedor, DirectoryAgent,
AgentClient, get_count())
infoagent_search_message(AgentVen.address, AgentVen.uri, gr2,
msgResult2)
for producto in carrito_compra:
gr = Graph()
id_producto = str(random.randint(1, 1000000000))
producto_a_comprar = ONT['Producto_Comprado_' + id_producto]
msgResult = ONT['Comprar_Producto_' + str(get_count())]
gr.add((msgResult, RDF.type, ONT.Comprar_producto))
gr.add((producto_a_comprar, RDF.type, ONT.Producto_comprado))
gr.add((producto_a_comprar, ONT.nombre,
Literal(producto['nombre'], datatype=XSD.string)))
gr.add((producto_a_comprar, ONT.marca,
Literal(producto['marca'], datatype=XSD.string)))
gr.add((producto_a_comprar, ONT.proc,
Literal(producto['proc'], datatype=XSD.string)))
gr.add((producto_a_comprar, ONT.precio,
Literal(producto['precio'], datatype=XSD.float)))
gr.add((producto_a_comprar, ONT.id,
Literal(producto['id'], datatype=XSD.integer)))
gr.add((producto_a_comprar, ONT.targeta,
Literal(targeta, datatype=XSD.string)))
gr.add((producto_a_comprar, ONT.usuario,
Literal(nombre, datatype=XSD.string)))
gr.add((producto_a_comprar, ONT.te_feedback,
Literal("", datatype=XSD.string)))
gr.add((msgResult, ONT.Compra, producto_a_comprar))
infoagent_search_message(AgentVen.address, AgentVen.uri, gr,
msgResult)
return render_template('factura.html',
productos_carrito=carrito_compra,
datos=datos)
elif request.form['submit'] == 'Realizar otra compra':
del carrito_compra[:]
return render_template('buscar.html',
recomendaciones=recomendaciones)
def comunicacion():
"""
Entrypoint de comunicacion
"""
logger.info('Peticion de plan recibida')
global dsGraph
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = None
respfinal = Graph()
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgentePlanificador.uri,
msgcnt=get_count())
else:
# Obtenemos la performativa
if msgdic['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_count())
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia
# de registro
content = msgdic['content']
# Averiguamos el tipo de la accion
accion = gm.value(subject=content, predicate=RDF.type)
# Accion de busqueda
if accion == ECSDI.Peticion_Transporte:
transporte = get_agent_info(agn.AgenteTransporte,
DirectoryAgent, AgentePlanificador,
get_count())
contentmsg = ECSDI['Peticion_Transporte_' + str(get_count())]
gr = Graph()
gr.add((contentmsg, RDF.type, ECSDI.Peticion_Transporte))
grmsg = send_message(
build_message(gr,
perf=ACL.request,
sender=AgentePlanificador.uri,
receiver=transporte.uri,
msgcnt=get_count(),
content=contentmsg), transporte.address)
for (s, p, o) in grmsg:
if s == ECSDI['vuelo_1']:
respfinal.add((s, p, o))
alojamiento = get_agent_info(agn.AgenteAlojamiento,
DirectoryAgent,
AgentePlanificador, get_count())
contentmsg2 = ECSDI['Peticion_Alojamiento_' + str(get_count())]
gr2 = Graph()
gr2.add((contentmsg2, RDF.type, ECSDI.Peticion_Alojamiento))
grmsg2 = send_message(
build_message(gr2,
perf=ACL.request,
sender=AgentePlanificador.uri,
receiver=alojamiento.uri,
msgcnt=get_count(),
content=contentmsg2), alojamiento.address)
for (s, p, o) in grmsg2:
if s == ECSDI['Alojamiento_2']:
respfinal.add((s, p, o))
actividades = get_agent_info(agn.AgenteActividades,
DirectoryAgent,
AgentePlanificador, get_count())
contentmsg3 = ECSDI['Peticion_Actividades_' + str(get_count())]
gr3 = Graph()
gr3.add((contentmsg3, RDF.type, ECSDI.Peticion_Actividades))
grmsg3 = send_message(
build_message(gr3,
perf=ACL.request,
sender=AgentePlanificador.uri,
receiver=actividades.uri,
msgcnt=get_count(),
content=contentmsg3), actividades.address)
for (s, p, o) in grmsg3:
if s == ECSDI['Museos_3']:
respfinal.add((s, p, o))
for (s, p, o) in grmsg3:
if s == ECSDI['Restaurantes_1']:
respfinal.add((s, p, o))
return respfinal.serialize(format='xml'), 200
def feedback_devolver():
if request.method == 'GET':
msgResult = ONT['Busqueda' + str(get_count())]
gr = Graph()
gr.add((msgResult, RDF.type, ONT.Busqueda))
body_nombre = ONT['productos_usuario' + str(get_count())]
gr.add((body_nombre, RDF.type, ONT.productos_usuario))
gr.add((body_nombre, ONT.nombre,
Literal(nombre_usuario, datatype=XSD.string)))
gr.add((msgResult, ONT.Restringe, URIRef(body_nombre)))
grAgentVendedor = get_agent_info(agn.AgentVendedor, DirectoryAgent,
AgentClient, get_count())
gr2 = infoagent_search_message(grAgentVendedor.address,
grAgentVendedor.uri, gr, msgResult)
index = 0
subject_pos = {}
for s, p, o in gr2:
if s not in subject_pos:
subject_pos[s] = index
productos_comprados.append({})
index += 1
if s in subject_pos:
subject_dict = productos_comprados[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ONT.marca:
subject_dict['marca'] = o
elif p == ONT.precio:
subject_dict['precio'] = o
elif p == ONT.nombre:
subject_dict['nombre'] = o
elif p == ONT.proc:
subject_dict['proc'] = o
elif p == ONT.id:
subject_dict['id'] = o
elif p == ONT.targeta:
subject_dict['targeta'] = o
elif p == ONT.te_feedback:
subject_dict['te_feedback'] = o
productos_comprados[subject_pos[s]] = subject_dict
return render_template('feedback_devolver.html',
productos=productos_comprados)
else:
if request.form['submit'] == 'Devolver producto':
msgResult = ONT['cobro_' + str(get_count())]
idd = id = request.form['id']
proc = request.form['proc']
precio = request.form['precio']
targeta = request.form['targeta']
usuario = nombre_usuario
gr = Graph()
body_prod_dev = ONT['id_Dev_' + id]
gr.add((msgResult, RDF.type, ONT.ProductoDevuelto))
gr.add((body_prod_dev, ONT.id, Literal(id, datatype=XSD.integer)))
gr.add((body_prod_dev, ONT.proc, Literal(proc,
datatype=XSD.string)))
gr.add(
(body_prod_dev, ONT.precio, Literal(precio,
datatype=XSD.float)))
gr.add((body_prod_dev, ONT.targeta,
Literal(targeta, datatype=XSD.string)))
gr.add((body_prod_dev, ONT.usuario,
Literal(usuario, datatype=XSD.string)))
AgentDev = get_agent_info(agn.AgentDevoluciones, DirectoryAgent,
AgentClient, get_count())
gr2 = infoagent_search_message(AgentDev.address, AgentDev.uri, gr,
msgResult)
ii = -1
for i in range(0, len(productos_comprados)):
if int(productos_comprados[i]["id"]) == int(idd):
ii = i
del productos_comprados[ii]
return render_template('feedback_devolver.html',
productos=productos_comprados)
elif request.form['submit'] == 'Escribir feedback':
idd = int(request.form["id"])
ii = -1
for i in range(0, len(productos_comprados)):
if int(productos_comprados[i]['id']) == idd:
ii = i
productos_comprados[ii]['te_feedback'] = "si"
id = str(random.randint(1, 1000000000))
valoracion = request.form['valoracion']
marca = request.form['marca']
precio = request.form['precio']
nombre = request.form['nombre']
proc = 'externo'
producto = ONT['Producto_valorado_' + id]
msgResult = ONT['Registrar_prod_Valorado_' + str(get_count())]
gr = Graph()
gr.add((msgResult, RDF.type, ONT.Registrar_Valoracion))
gr.add((producto, RDF.type, ONT.Producto_valorado))
gr.add((producto, ONT.nombre, Literal(nombre,
datatype=XSD.string)))
gr.add((producto, ONT.marca, Literal(marca, datatype=XSD.string)))
gr.add((producto, ONT.precio, Literal(precio, datatype=XSD.float)))
gr.add((producto, ONT.id, Literal(idd, datatype=XSD.integer)))
gr.add((producto, ONT.valoracion,
Literal(valoracion, datatype=XSD.integer)))
gr.add((msgResult, ONT.Producto_valorado, producto))
AgentFeed = get_agent_info(agn.AgentFeedback, DirectoryAgent,
AgentClient, get_count())
infoagent_search_message(AgentFeed.address, AgentFeed.uri, gr,
msgResult)
return render_template('feedback_devolver.html',
productos=productos_comprados)
def enviarVenta(contenido,grafo):
'''Se encarga de enviar asignar el encargo de envio al centro logistico mas cercano al codigo postal'''
# logger.info("Obteniendo el centro logistico mas cercano al lugar de envio mediante el codigo postal")
#Obtener el agente mas cercano
# centrologistico = get_Neareast_Logistic_Center_info(agn.AgenteCentroLogistico, DirectoryAgent, AgenteGestorDeVentas, get_message_count(),int(codepostal))
centrologistico = get_agent_info(agn.AgenteCL, DirectoryAgent, AgenteGestorDeVentas, get_message_count())
###ERROR: No esta reemplazando el Iniciar_venta por el Encargo_envio correctamente
###Solucionado
#Reusamos el contenido del grafo antiguo para que se convierta en uno de tipo Encargo_envio
# logger.info("Haciendo generando encargo envio")
grafo.remove((contenido, RDF.type, ECSDIAmazon.Iniciar_venta))
sujeto = ECSDIAmazon['Encargo_envio' + str(get_message_count())]
grafo.add((sujeto, RDF.type, ECSDIAmazon.Encargo_envio))
for a, b, c in grafo:
if a == contenido:
grafo.remove((a, b, c))
grafo.add((sujeto, b, c))
#####
# print(grafo.serialize(format="turtle").decode())
logger.info("Informando de encargo de envio a centro logistico")
msg_respuesta = send_message(build_message(
grafo, perf=ACL.request, sender=AgenteGestorDeVentas.uri,receiver=centrologistico.uri,msgcnt=get_message_count(), content=sujeto)
, centrologistico.address)
logger.info("El encargo de envio, ya ha sido enviado por el centro logistico")
respuesta_centro_logistico = msg_respuesta.value(predicate=RDF.type, object=ECSDIAmazon.Respuesta)
# print(msg_respuesta.serialize(format="turtle").decode())
# print("El nombre de la respuesta es:", respuesta_centro_logistico)
# print(msg_respuesta.value(subject=respuesta_centro_logistico, predicate=ECSDIAmazon.Mensaje))
if "Enviado" == str(msg_respuesta.value(subject=respuesta_centro_logistico, predicate=ECSDIAmazon.Mensaje)) :
fecha_final = str(msg_respuesta.value(subject=respuesta_centro_logistico, predicate=ECSDIAmazon.Fecha_final))
transportista_asignado = str(msg_respuesta.value(subject=respuesta_centro_logistico, predicate=ECSDIAmazon.Transportista_asignado))
precio_envio = float(msg_respuesta.value(subject=respuesta_centro_logistico, predicate=ECSDIAmazon.Precio_envio))
precio_quasi_total = grafo.value(subject=sujeto, predicate=ECSDIAmazon.Precio_total)
tarjeta = str(grafo.value(subject=sujeto, predicate=ECSDIAmazon.Tarjeta))
logger.info("Se prodece al cobro")
grafinfo = cobroVenta(precio_quasi_total, precio_envio, tarjeta)
informar=grafinfo.value(predicate=RDF.type, object=ECSDIAmazon.Informar)
#Esta parte esta comentada por que ya esta en el grafoinforme
# grafinfo.add((informar, ECSDIAmazon.Tarjeta, Literal(tarjeta, datatype=XSD.string)))
# grafinfo.add((informar, ECSDIAmazon.Precio_total, Literal(preciototal, datatype=XSD.float)))
# grafinfo.add((informar, ECSDIAmazon.message, Literal(message, datatype=XSD.string)))
grafinfo.add((informar, ECSDIAmazon.Precio_envio, Literal(precio_envio, datatype=XSD.float)))
grafinfo.add((informar, ECSDIAmazon.Precio_venta, Literal(precio_quasi_total, datatype=XSD.float)))
logger.info("Se complementa el informe con la información de envio")
grafinfo.add((informar, ECSDIAmazon.Fecha_final, Literal(fecha_final, datatype=XSD.string)))
grafinfo.add((informar, ECSDIAmazon.Transportista_asignado, Literal(transportista_asignado, datatype=XSD.string)))
idventa = grafo.value(subject=sujeto, predicate=ECSDIAmazon.Id_venta)
grafinfo.add((informar, ECSDIAmazon.Id_venta, Literal(idventa, datatype=XSD.int)))
logger.info("Se informa al usuario que la venta con id"+str(idventa)+ "ha sido enviada y cobrada")
# print(grafinfo.serialize(format = "turtle").decode())
agente_usuario = get_agent_info(agn.AgenteUsuario, DirectoryAgent, AgenteGestorDeVentas, get_message_count())
msg_respuesta_user = send_message(build_message(
grafinfo, perf=ACL.request, sender=AgenteGestorDeVentas.uri,receiver=agente_usuario.uri,msgcnt=get_message_count(), content=informar)
, agente_usuario.address)
respuesta_user= msg_respuesta_user.value(predicate=RDF.type, object=ECSDIAmazon.Respuesta)
if "OK" == str(msg_respuesta_user.value(subject=respuesta_user, predicate=ECSDIAmazon.Mensaje)):
logger.info("Finalizado proceso de la venta " + str(idventa) +",la creación, el envio y el cobro de esta han sido exitosos")
else:
logger.info("No se esperaba esta respuesta del usuario al enviarle el informe")
else:
logger.info("No se esperaba esta respuesta del centro logistico")
def browser_registrarProducto():
"""
Permite la comunicacion con el agente via un navegador
via un formulario
"""
if request.method == 'GET':
return render_template('añadirProducto.html')
else:
nombre = request.form['nombre']
marca = request.form['marca']
modelo = request.form['modelo']
precio = request.form['precio']
peso = request.form['peso']
content = ECSDI['Integrar_producto_' + str(get_count())]
logger.info("----0----")
gr = Graph()
gr.bind('pont', ECSDI)
gr.add((content, RDF.type, ECSDI.Integrar_producto))
logger.info("----1----")
sProdructo = RESOURCES['Producto_' +
str(random.randint(1, sys.float_info.max))]
logger.info("----2----")
gr.add((sProdructo, RDF.type, ECSDI.Producto))
gr.add((sProdructo, PROPS.nombre, Literal(nombre, datatype=XSD.string)))
gr.add((sProdructo, PROPS.marca, Literal(marca, datatype=XSD.string)))
gr.add((sProdructo, PROPS.modelo, Literal(modelo, datatype=XSD.string)))
gr.add((sProdructo, PROPS.precio, Literal(precio, datatype=XSD.float)))
gr.add((sProdructo, PROPS.peso, Literal(peso, datatype=XSD.float)))
logger.info("----3----")
#gr.add((content, ECSDI.producto, sProdructo))
logger.info("----4----")
agente = get_agent_info(agn.AgenteNegociadorTiendasExternas,
AgenteDirectorio, AgenteExternoTiendaExterna,
get_count())
logger.info("----5----")
gr = send_message(
build_message(gr,
perf=ACL.request,
sender=AgenteExternoTiendaExterna.uri,
receiver=agente.uri,
content=content,
msgcnt=get_count()), agente.address)
logger.info("----6----")
res = {
'marca': request.form['marca'],
'nombre': request.form['nombre'],
'modelo': request.form['modelo'],
'precio': request.form['precio'],
'peso': request.form['peso']
}
return render_template('rootTiendaExterna.html', res=res)
def crear_lote():
if request.method == 'GET':
msgResult = ONT['getProductos_' + str(get_count())]
gr = Graph()
gr.add((msgResult, RDF.type, ONT.GetProductos))
AgentLog = get_agent_info(agn.AgentLogistico, DirectoryAgent,
AgentCentroLogistico, get_count())
gr2 = infoagent_search_message(AgentLog.address, AgentLog.uri, gr,
msgResult)
index = 0
subject_pos = {}
for s, p, o in gr2:
if s not in subject_pos:
subject_pos[s] = index
compras_sin_asignar.append({})
index += 1
if s in subject_pos:
subject_dict = compras_sin_asignar[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ONT.direccion:
subject_dict['direccion'] = o
elif p == ONT.id_lote:
subject_dict['id_lote'] = o
elif p == ONT.id_compra:
subject_dict['id_compra'] = o
elif p == ONT.peso:
subject_dict['peso'] = o
elif p == ONT.total:
subject_dict['total'] = o
elif p == ONT.prioridad:
subject_dict['prioridad'] = o
compras_sin_asignar[subject_pos[s]] = subject_dict
global id_lote
id_lote = str(random.randint(1, 1000000000))
return render_template('crear_lote.html',
productos=compras_sin_asignar)
else:
if request.form['submit'] == 'Al lote!':
idd = int(request.form["id_compra"])
ii = -1
for i in range(0, len(compras_sin_asignar)):
if int(compras_sin_asignar[i]["id_compra"]) == idd:
ii = i
compras_sin_asignar[ii]["id_lote"] = id_lote
compras_asignadas.append(compras_sin_asignar[ii])
del compras_sin_asignar[ii]
if len(compras_sin_asignar) == 0:
return render_template('crear_lote.html',
productos_lote=compras_asignadas)
return render_template('crear_lote.html',
productos=compras_sin_asignar,
productos_lote=compras_asignadas)
if request.form['submit'] == 'Enviar Lote':
for compra in compras_asignadas:
compra_asignada = ONT['Compra_Asignada_' + compra['id_compra']]
msgResult = ONT['Asignar_compra_' + str(get_count())]
gr = Graph()
gr.add((msgResult, RDF.type, ONT.Asignar_compra))
gr.add((compra_asignada, RDF.type, ONT.Compra))
gr.add((compra_asignada, ONT.id_lote,
Literal(id_lote, datatype=XSD.string)))
gr.add((compra_asignada, ONT.id_compra,
Literal(compra['id_compra'], datatype=XSD.string)))
gr.add((msgResult, ONT.Compra_asignada, compra_asignada))
AgentLog = get_agent_info(agn.AgentLogistico, DirectoryAgent,
AgentCentroLogistico, get_count())
infoagent_search_message(AgentLog.address, AgentLog.uri, gr,
msgResult)
del compras_sin_asignar[:]
del compras_asignadas[:]
return redirect(url_for('crear_lote'))
def browser_cerca():
"""
Permite la comunicacion con el agente via un navegador
via un formulario
"""
if request.method == 'GET':
return render_template('busqueda.html', plan=None)
elif request.method == 'POST':
# Peticio de cerca
if request.form['submit'] == 'Generar Plan de Viaje':
logger.info("Enviando peticion de busqueda")
# Content of the message
contentResult = ECSDI['Peticion_Traansporte' + str(get_count())]
# Graph creation
gr = Graph()
gr.add((contentResult, RDF.type, ECSDI.Peticion_Transporte))
ciudad_origen = request.form['ciudad_origen']
ciudad_destino = request.form['ciudad_destino']
fecha_ida = request.form['fecha_ida']
fecha_vuelta = request.form['fecha_vuelta']
presupuesto = request.form['presupuesto']
subject = ECSDI["Restricciones"]
gr.add((subject + "_origen", ECSDI.aeropuerto_ini,
Literal(ciudad_origen, datatype=XSD.string)))
gr.add((subject + "_destino", ECSDI.aeropuerto_fi,
Literal(ciudad_destino, datatype=XSD.string)))
gr.add((subject + "_ida", ECSDI.Fecha_Partida,
Literal(fecha_ida, datatype=XSD.string)))
gr.add((subject + "_vuelta", ECSDI.Fecha_Llegada,
Literal(fecha_vuelta, datatype=XSD.string)))
gr.add((subject + "_precio", ECSDI.Precio,
Literal(presupuesto, datatype=XSD.string)))
gr.add((contentResult, ECSDI.Restinge, URIRef(subject)))
planificador = get_agent_info(agn.AgentePlanificador,
DirectoryAgent, AgentePersonal,
get_count())
gr2 = send_message(
build_message(gr,
perf=ACL.request,
sender=AgentePersonal.uri,
receiver=planificador.uri,
msgcnt=get_count(),
content=contentResult), planificador.address)
index = 0
subject_pos = {}
flights_list = []
for s, p, o in gr2:
if s not in subject_pos:
subject_pos[s] = index
flights_list.append({})
index += 1
if s in subject_pos:
subject_dict = flights_list[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ECSDI.aeropuerto_ini:
subject_dict['ciudad_origen'] = o
elif p == ECSDI.aeropuerto_fi:
subject_dict['ciudad_destino'] = o
elif p == ECSDI.Fecha_Partida:
subject_dict['fecha_ida'] = o
elif p == ECSDI.Precio:
subject_dict['presupuesto'] = o
elif p == ECSDI.Fecha_Llegada:
subject_dict['fecha_vuelta'] = o
elif p == ECSDI.nombre:
subject_dict['nombre_hotel'] = o
elif p == ECSDI.direccion:
subject_dict['direccion_hotel'] = o
elif p == ECSDI.telefono:
subject_dict['telefono_hotel'] = o
flights_list[subject_pos[s]] = subject_dict
return render_template('busqueda.html', plan=flights_list)
def browserBuscador():
"""
Comunicacion con el agente mediante un formulario en un navegador
"""
global listaProductos
if request.method == 'GET':
return render_template('buscador.html', productos=None)
elif request.method == 'POST':
#peticion de busqueda
if request.form['submit'] == 'buscar':
logger.info("Enviar peticion de busqueda")
content = ECSDI['BuscarProductos_' + str(get_count())]
gr = Graph()
gr.add((content, RDF.type, ECSDI.Buscar))
modelo = request.form['modelo']
if modelo:
# Subject modelo
sModelo = ECSDI['RestriccioModelo' + str(get_count())]
gr.add((sModelo, RDF.type, ECSDI.Restriccion_Modelo))
gr.add((sModelo, ECSDI.Modelo, Literal(modelo, datatype=XSD.string)))
# Add restriccio to content
gr.add((content, ECSDI.Restringe, URIRef(sModelo)))
marca = request.form['marca']
if marca:
smarca = ECSDI['RestriccionMarca_' + str(get_count())]
gr.add((smarca, RDF.type, ECSDI.Restriccion_Marca))
gr.add((smarca, ECSDI.Marca, Literal(marca, datatype=XSD.string)))
gr.add((content, ECSDI.Restringe, URIRef(smarca)))
min_price = request.form['min_price']
max_price = request.form['max_price']
if min_price or max_price:
sPrecio = ECSDI['RestriccionPrecio_' + str(get_count())]
gr.add((sPrecio, RDF.type, ECSDI.Restriccion_Precio))
if min_price:
gr.add((sPrecio, ECSDI.Precio_min, Literal(min_price)))
if max_price:
gr.add((sPrecio, ECSDI.Precio_max, Literal(max_price)))
gr.add((content, ECSDI.Restringe, URIRef(sPrecio)))
buscador = get_agent_info(agn.AgenteBuscador, AgenteDirectorio, AgenteExternoAsistentePersonal, get_count())
logger.info("He recibido la uri del buscador")
gr2 = send_message(
build_message(
gr, perf=ACL.request, sender=AgenteExternoAsistentePersonal.uri, receiver=buscador.uri, msgcnt=get_count(), content=content), buscador.address)
logger.info("Todo feten con la llamada al buscador")
index = 0
# posicion del sujeto
sPos = {}
listaProductos = []
for s, p, o in gr2:
if s not in sPos:
sPos[s] = index
listaProductos.append({})
index += 1
if s in sPos:
sDict = listaProductos[sPos[s]]
if p == RDF.type:
sDict['url'] = s
elif p == ECSDI.Marca:
sDict['marca'] = o
elif p == ECSDI.Modelo:
sDict['modelo'] = o
elif p == ECSDI.Precio:
sDict['precio'] = o
elif p == ECSDI.Nombre:
sDict['nombre'] = o
elif p == ECSDI.Peso:
sDict['peso'] = o
listaProductos[sPos[s]] = sDict
logger.info(listaProductos)
return render_template('buscador.html', products=listaProductos)
elif request.form['submit'] == 'comprar':
productosPedidos = []
for producto in request.form.getlist("checkbox"):
productoMarcado = []
productosMap = listaProductos[int(producto)]
productoMarcado.append(productosMap['marca'])
productoMarcado.append(productosMap['modelo'])
productoMarcado.append(productosMap['nombre'])
productoMarcado.append(productosMap['precio'])
productoMarcado.append(productosMap['url'])
productoMarcado.append(productosMap['peso'])
productosPedidos.append(productoMarcado)
logger.info("Creando la peticion de compra")
# Content of the message
content = ECSDI['PeticionCompra_' + str(get_count())]
# Graph creation
gr = Graph()
gr.add((content, RDF.type, ECSDI.Peticion_compra))
tienda = get_agent_info(agn.AgenteCompras, AgenteDirectorio, AgenteExternoAsistentePersonal, get_count())
# Creacion del sobre (Compra) ------------------------------------------------------------------------------
subject_sobre = ECSDI['Compra_' + str(random.randint(1, sys.float_info.max))]
gr.add((subject_sobre, RDF.type, ECSDI.Compra))
total_price = 0.0
total_peso = 0.0
for item in productosPedidos:
total_price += float(item[3])
total_peso += float(item[5])
# Creacion del producto --------------------------------------------------------------------------------
subject_producto = item[4]
gr.add((subject_producto, RDF.type, ECSDI.Producto))
gr.add((subject_producto, ECSDI.Marca, Literal(item[0], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Modelo, Literal(item[1], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Nombre, Literal(item[2], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Precio, Literal(item[3], datatype=XSD.float)))
gr.add((subject_producto, ECSDI.Peso, Literal(item[5], datatype=XSD.float)))
gr.add((subject_sobre, ECSDI.Productos, URIRef(subject_producto)))
gr.add((subject_sobre, ECSDI.Precio_total, Literal(total_price, datatype=XSD.float)))
gr.add((content, ECSDI.Sobre, URIRef(subject_sobre)))
logger.info('Llego aqui1')
send_message(build_message(gr, perf=ACL.request, sender=AgenteExternoAsistentePersonal.uri, receiver=tienda.uri,
msgcnt=get_count(), content=content), tienda.address)
logger.info('Llego aqui2')
# Graph creation
gr = Graph()
gr.add((content, RDF.type, ECSDI.Pedido))
# Asignar prioridad a la peticion (asignamos el contador de mensaje)
gr.add((content, ECSDI.Prioridad, Literal(request.form["prioridad"], datatype=XSD.string)))
gr.add((content, ECSDI.Precio_total, Literal(total_price, datatype=XSD.float)))
gr.add((content, ECSDI.Peso, Literal(total_peso, datatype=XSD.float)))
logger.info('Llego aqui')
respuesta = send_message(
build_message(
gr, perf=ACL.request, sender=AgenteExternoAsistentePersonal.uri, receiver=tienda.uri, msgcnt=get_count(), content=content), tienda.address)
subject = respuesta.value(predicate=RDF.type, object=ECSDI.Info_transporte)
precio_transporte = respuesta.value(subject=subject, predicate=ECSDI.Precio)
nombre_transportista = respuesta.value(subject=subject, predicate=ECSDI.Nombre_transportista)
fecha_llegada = respuesta.value(subject=subject, predicate=ECSDI.Fecha_entrega)
logger.info(precio_transporte)
logger.info(nombre_transportista)
logger.info('Aqui no llego ni de coña')
if precio_transporte is not None:
precio_transporte = precio_transporte.toPython()
precio_transporte = round(precio_transporte, 2)
return render_template('finalCompra.html', products= productosPedidos,fecha_llegada=fecha_llegada, precio_total= total_price,precio_transporte=precio_transporte, nombre_transportista= nombre_transportista)
def comunicacion():
"""
Entrypoint de comunicacion
"""
global dsGraph
logger.info('Peticion de informacion recibida')
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = None
logger.info('HE LLEGAO AQUI COMPRAS')
if msgdic is None:
logger.info('NO ENTIENDO')
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteCompras.uri, msgcnt=get_count())
else:
content = msgdic['content']
if msgdic['performative'] == ACL.request:
content = msgdic['content']
# Averiguamos el tipo de la accion
accion = gm.value(subject=content, predicate=RDF.type)
logger.info("He rebut la peticio de request")
logger.info(accion)
if accion == ECSDI.Peticion_compra:
gm.remove((content, None, None))
for item in gm.subjects(RDF.type, ACL.FipaAclMessage):
gm.remove((item, None, None))
ontologyFile = open('../data/productos_pedidos.owl')
gr = Graph()
gr.parse(ontologyFile, format='turtle')
gr += gm
# Guardem el graf
gr.serialize(destination='../data/productos_pedidos.owl', format='turtle')
elif accion == ECSDI.Pedido:
logger.info("He rebut la peticio de compra")
centrologistico = get_agent_info(agn.AgenteCentroLogistico, AgenteDirectorio, AgenteCompras, get_count())
logger.info('HE LLEGAO AQUI COMPRAS')
gr = send_message(
build_message(gm, perf=ACL.request, sender=AgenteCompras.uri, receiver=centrologistico.uri,
msgcnt=get_count(),
content=content), centrologistico.address)
elif msgdic['performative'] == ACL.inform:
Agente = get_agent_info(agn.AgenteExternoAsistentePersonal, AgenteDirectorio, AgenteCompras, get_count())
# Averiguamos el tipo de la accion
nom = gm.value(subject=content, predicate=ECSDI.Nombre)
precio = gm.value(subject=content, predicate=ECSDI.Precio)
data_arribada = gm.value(subject=content, predicate=ECSDI.Fecha_Final)
gr = build_message(enviar_info_transporte(nom, precio, data_arribada),
ACL['request'],
sender=AgenteCompras.uri,
receiver=Agente,
msgcnt=get_count())
logger.info('Respondemos a la peticion')
return gr.serialize(format='xml'), 200
def communication():
"""
Communication Entrypoint
"""
logger.info('Peticion de informacion recibida')
global dsGraph
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = Graph
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteObtenedorActividades.uri, msgcnt=get_count())
else:
# Obtenemos la performativa
if msgdic['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_count())
else:
content = msgdic['content']
# Averiguamos el tipo de la accion
accion = gm.value(subject=content, predicate=RDF.type)
if accion == "peticion de actividades":
'''localizacion = gm.value(subject=content, predicate=ECSDI.tiene_como_restriccion_de_localizacion)
ciudad = gm.value(subject=localizacion, predicate=ECSDI.pertenece_a)
nombreCiudad = gm.value(subject=ciudad, predicate=ECSDI.nombre)'''
logger.info("Mensaje peticion de actividades")
agente_ext_actividades = get_agent_info(agn.AgenciaDeTransportes, DirectoryAgent,
AgenteObtenedorActividades, get_count())
# Enviamos el mensaje
gr = send_message(
build_message(gr, perf=ACL.request, sender=AgenteObtenedorActividades.uri,
receiver=agente_ext_actividades.uri,
msgcnt=get_count(),
content=content), agente_ext_actividades.address)
gr = build_message(gr,
ACL['inform-'],
sender=AgenteObtenedorActividades.uri,
msgcnt=mss_cnt,
receiver=msgdic['sender'])
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_count())
serialize = gr.serialize(format='xml')
return serialize, 200
def iniciar_venta(request):
global lista_de_productos
logger.info("Analizando la peticion de compra")
mi_compra = []
#coge los indices marcados
for p in request.form.getlist("product_checkbox"):
mi_compra.append(lista_de_productos[int(p)])
#cogo info de la compra
tarjeta = str(request.form['tarjeta'])
direccion = str(request.form['direccion'])
ciudad = str(request.form['ciudad'])
codigo_postal = int(request.form['codigo_postal'])
prioridad = int(request.form['prioridad']) #va entre 1 y 10, de mayor a menor prioridad
#preparo el grafo para comunicarme con el AgenteGestorDeVenta
#accion: Iniciar_venta
contenido = ECSDIAmazon["Iniciar_venta" + str(get_message_count())]
grafo_venta = Graph()
grafo_venta.add((contenido, RDF.type, ECSDIAmazon.Iniciar_venta))
grafo_venta.add((contenido, ECSDIAmazon.Tarjeta, Literal(tarjeta, datatype=XSD.int)))
grafo_venta.add((contenido, ECSDIAmazon.Prioridad, Literal(prioridad, datatype=XSD.int)))
direccion_cliente = ECSDIAmazon["Direccion"+ str(get_message_count())]
grafo_venta.add((direccion_cliente, RDF.type, ECSDIAmazon.Direccion))
grafo_venta.add((direccion_cliente, ECSDIAmazon.Direccion, Literal(direccion, datatype=XSD.string)))
grafo_venta.add((direccion_cliente, ECSDIAmazon.Ciudad, Literal(ciudad, datatype=XSD.string)))
grafo_venta.add((direccion_cliente, ECSDIAmazon.Codigo_postal, Literal(codigo_postal, datatype=XSD.int)))
venta = ECSDIAmazon["Venta"+str(get_message_count())]
grafo_venta.add((venta, RDF.type, ECSDIAmazon.Venta))
grafo_venta.add((venta, ECSDIAmazon.Destino, URIRef(direccion_cliente)))
logger.info("Mi lista de productos")
logger.info("Mi compra")
if not mi_compra:
return render_template('buscar.html', productos=lista_de_productos, b=True,only_search=False,buy_empty=True)
for producto in mi_compra:
s = producto["id_producto"]
url = ECSDIAmazon
sujeto = url.term(producto["id_producto"])
grafo_venta.add((sujeto, RDF.type, ECSDIAmazon.Producto))
grafo_venta.add((sujeto, ECSDIAmazon.Id_producto, Literal(producto['id_producto'], datatype=XSD.string)))
grafo_venta.add((sujeto, ECSDIAmazon.Nombre_producto, Literal(producto['nombre_producto'], datatype=XSD.string)))
grafo_venta.add((sujeto, ECSDIAmazon.Precio_producto, Literal(producto['precio_producto'], datatype=XSD.float)))
grafo_venta.add((sujeto, ECSDIAmazon.Descripcion_producto, Literal(producto['descripcion_producto'], datatype=XSD.string)))
grafo_venta.add((sujeto, ECSDIAmazon.Categoria, Literal(producto['categoria'], datatype=XSD.string)))
grafo_venta.add((sujeto, ECSDIAmazon.Marca, Literal(producto['marca'], datatype=XSD.string)))
grafo_venta.add((sujeto, ECSDIAmazon.Peso_producto, Literal(producto['peso'], datatype=XSD.int)))
grafo_venta.add((venta, ECSDIAmazon.Contiene, URIRef(sujeto)))
grafo_venta.add((contenido, ECSDIAmazon.De, URIRef(venta)))
agente = get_agent_info(agn.AgenteGestorDeVentas, DirectoryAgent, AgenteUsuario, get_message_count())
logger.info("Enviando peticion de iniciar venta al AgenteGestorDeVentas")
respuesta_msg = send_message(build_message(
grafo_venta, perf=ACL.request, sender=AgenteUsuario.uri, receiver=agente.uri, msgcnt=get_message_count(),
content=contenido), agente.address)
logger.info("Respuesta recibida")
#obtenemos valores factura, productos y tarjeta asocida a dicha factura de la compra para mostrar al usuario
venta_factura = respuesta_msg.value(predicate=RDF.type, object=ECSDIAmazon.Factura)
venta_tarjeta = str(respuesta_msg.value(subject=venta_factura, predicate=ECSDIAmazon.Tarjeta))
venta_fecha_aproximada = respuesta_msg.value(subject=venta_factura, predicate=ECSDIAmazon.Fecha_aproximada)
venta_precio_total = float(respuesta_msg.value(subject=venta_factura, predicate=ECSDIAmazon.Precio_total))
venta_id=str(respuesta_msg.value(subject=venta_factura, predicate=ECSDIAmazon.Id_venta))
venta_productos = respuesta_msg.subjects(object=ECSDIAmazon.Producto)
productos_factura = []
for prod in venta_productos:
product = dict(
nombre_producto=str(respuesta_msg.value(subject=prod, predicate=ECSDIAmazon.Nombre_producto)),
precio_producto=float(respuesta_msg.value(subject=prod, predicate=ECSDIAmazon.Precio_producto)),
)
productos_factura.append(product)
productos_factura = sorted(productos_factura, key=lambda p_list: p_list["precio_producto"])
logger.info("Mostramos la factura recibida")
#render de factura
return render_template('factura.html', productos=productos_factura,id_compra=venta_id, tarjeta=venta_tarjeta, precio_total=venta_precio_total,fecha_aproximada = venta_fecha_aproximada)
def peticion_buscar(request):
global lista_de_productos
logger.info("Preparando la peticion de busqueda")
#accion: Buscar_productos
contenido = ECSDIAmazon["Buscar_productos"+str(get_message_count())]
grafo = Graph()
grafo.add((contenido, RDF.type, ECSDIAmazon.Buscar_productos))
nombre_producto = request.form["nombre"]
#agregamos el nombre del producto
if nombre_producto:
nombre_sujeto = ECSDIAmazon["Restriccion_nombre" + str(get_message_count)]
grafo.add((nombre_sujeto, RDF.type, ECSDIAmazon.Restriccion_nombre))
grafo.add((nombre_sujeto, ECSDIAmazon.Nombre, Literal(nombre_producto, datatype=XSD.string)))
grafo.add((contenido, ECSDIAmazon.Restringe, URIRef(nombre_sujeto)))
precio_min = request.form['precio_min']
precio_max = request.form['precio_max']
# agregamos el rango de precios
## Recordar: El precio se recibe en euros pero se ha de cambiar a centimos de euro
if precio_min != "" or precio_max != "":
precio_sujeto = ECSDIAmazon['Restriccion_precio' + str(get_message_count())]
grafo.add((precio_sujeto, RDF.type, ECSDIAmazon.Restriccion_precio))
if precio_min != "":
if precio_min == "0":
precio_min = 0
else:
precio_min = int((float(request.form['precio_min'])*100)//1)
grafo.add((precio_sujeto, ECSDIAmazon.Precio_minimo, Literal(precio_min)))
if precio_max != "":
if precio_max == "0":
precio_max = 0
else:
precio_max = int((float(request.form['precio_max'])*100)//1)
grafo.add((precio_sujeto, ECSDIAmazon.Precio_maximo, Literal(precio_max)))
grafo.add((contenido, ECSDIAmazon.Restringe, URIRef(precio_sujeto)))
#pedimos informacion del agente GestorDeProductos
logger.info("Cogiendo informacion del AgenteGestorDeProductos")
agente = get_agent_info(agn.AgenteGestorDeProductos, DirectoryAgent, AgenteUsuario, get_message_count())
logger.info("Enviando peticion de busqueda al AgenteGestorDeProductos")
respuesta_msg = send_message(build_message(
grafo, perf=ACL.request, sender=AgenteUsuario.uri, receiver=agente.uri, msgcnt=get_message_count(),
content=contenido), agente.address)
lista_de_productos = []
for item in respuesta_msg.subjects(RDF.type, ECSDIAmazon.Producto):
product = dict(
id_producto=str(respuesta_msg.value(subject=item, predicate=ECSDIAmazon.Id_producto)),
nombre_producto=str(respuesta_msg.value(subject=item, predicate=ECSDIAmazon.Nombre_producto)),
precio_producto=int(respuesta_msg.value(subject=item, predicate=ECSDIAmazon.Precio_producto))/100,
descripcion_producto=str(respuesta_msg.value(subject=item, predicate=ECSDIAmazon.Descripcion_producto)),
categoria=str(respuesta_msg.value(subject=item, predicate=ECSDIAmazon.Categoria)),
marca=str(respuesta_msg.value(subject=item, predicate=ECSDIAmazon.Marca)),
peso=str(respuesta_msg.value(subject=item, predicate=ECSDIAmazon.Peso_producto))
)
lista_de_productos.append(product)
lista_de_productos = sorted(lista_de_productos, key=lambda p_list: p_list["precio_producto"])
logger.info("Mostramos resultado de la busqueda")
return render_template('buscar.html', productos=lista_de_productos, b=True,only_search=True)
