def comunicacion():
"""
Communication Entrypoint
"""
global dsGraph
logger.info('Aviso a Tienda Externa de Compra Realizada')
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = None
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteExternoTiendaExterna.uri,
msgcnt=get_count())
else:
# El AgenteNegociadorTiendasExternas nos informa de que ha habido una compra de uno de nuestros productos
if msgdic['performative'] != ACL.inform:
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteExternoTiendaExterna.uri,
msgcnt=get_count())
else:
procesarCompra()
def comunicacion():
message = request.args['content'] #cogo el contenido enviado
grafo = Graph()
grafo.parse(data=message)
message_properties = get_message_properties(grafo)
resultado_comunicacion = None
if message_properties is None:
# Respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(), ACL['not-understood'],
sender=AgenteCL.uri, msgcnt=get_message_count())
else:
# Obtenemos la performativa
if message_properties['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(), ACL['not-understood'],
sender=AgenteCL.uri, msgcnt=get_message_count())
else:
#Extraemos el contenido que ha de ser una accion de la ontologia
contenido = message_properties['content']
accion = grafo.value(subject=contenido, predicate=RDF.type)
logger.info("La accion es: " + accion)
# Si la acción es de tipo iniciar_venta empezamos
if accion == ECSDIAmazon.Encargo_envio:
resultado_comunicacion = gestionarEncargo(contenido, grafo)
serialize = resultado_comunicacion.serialize(format='xml')
return serialize, 200
def directory_search(self, DirectoryAgent, type):
global mss_cnt
logging.info('Buscamos en el servicio de registro')
gmess = Graph()
gmess.bind('foaf', FOAF)
gmess.bind('dso', DSO)
reg_obj = agn[self.name + '-search']
gmess.add((reg_obj, RDF.type, DSO.Search))
gmess.add((reg_obj, DSO.AgentType, type))
msg = build_message(gmess, perf=ACL.request,
sender=self.uri,
receiver=DirectoryAgent.uri,
content=reg_obj,
msgcnt=mss_cnt)
gr = send_message(msg, DirectoryAgent.address)
mss_cnt += 1
logging.info('Recibimos informacion del agente')
content = get_message_properties(gr)['content']
address = gr.value(subject=content, predicate=DSO.Address)
uri = gr.value(subject=content, predicate=DSO.Uri)
name = gr.value(subject=content, predicate=DSO.Name)
return Agent(name, uri, address, None)
def communication():
message = request.args['content'] #cogo el contenido enviado
grafo = Graph()
grafo.parse(data=message)
# logger.info('--Envian una comunicacion')
message_properties = get_message_properties(grafo)
resultado_comunicacion = None
if message_properties is None:
# Respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(), ACL['not-understood'],
sender=AgenteGestorDeVentas.uri, msgcnt=get_message_count())
else:
# Obtenemos la performativa
if message_properties['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(), ACL['not-understood'],
sender=AgenteGestorDeVentas.uri, msgcnt=get_message_count())
else:
#Extraemos el contenido que ha de ser una accion de la ontologia
contenido = message_properties['content']
accion = grafo.value(subject=contenido, predicate=RDF.type)
logger.info("La accion es: " + accion)
# Si la acción es de tipo iniciar_venta empezamos
if accion == ECSDIAmazon.Iniciar_venta:
for item in grafo.subjects(RDF.type, ACL.FipaAclMessage):
grafo.remove((item, None, None))
resultado_comunicacion = vender_productos(contenido, grafo)
logger.info('Antes de serializar la respuesta')
serialize = resultado_comunicacion.serialize(format='xml')
return serialize, 200
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 comunicacion():
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'Empezar_Envio_Compra':
return empezar_envio_compra(req, content)
def comunicacion():
"""
Entrypoint de comunicacion del agente
Simplementet retorna un objeto fijo que representa una
respuesta a una busqueda de hotel
Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer
el agente (buscar con ciertas restricciones, reservar)
Las acciones se mandan siempre con un Request
Prodriamos resolver las busquedas usando una performativa de Query-ref
"""
global dsgraph
global mss_cnt
#Extraemos el mensaje y creamos un grafo con el
message= request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=InfoAgent.uri, msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=InfoAgent.uri, msgcnt=mss_cnt)
else:
#Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate= RDF.type)
# Aqui realizariamos lo que pide la accion
paq = paquet["vacances"]
actTypes = gm.value(subject= paq, predicate= paquet.act_types)
destination = gm.value(subject= paq, predicate= paquet.desti)
ga = buscar_activitats(destination, actTypes)
# Por ahora simplemente retornamos un Inform-done
gr = build_message(ga,
ACL['inform-done'],
sender=InfoAgent.uri,
msgcnt=mss_cnt,
receiver=msgdic['sender'],)
mss_cnt += 1
return gr.serialize(format='xml')
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=AgenteBuscador.uri, msgcnt=get_count())
else:
if msgdic['performative'] != ACL.request:
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=get_count())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
if accion == ECSDI.Buscar:
restricciones = gm.objects(content, ECSDI.Restringe)
restricciones_dict = {}
for restriccion in restricciones:
if gm.value(subject=restriccion, predicate=RDF.type) == ECSDI.Restriccion_Marca:
marca = gm.value(subject=restriccion, predicate=ECSDI.Marca)
logger.info("Marca: "+marca)
restricciones_dict['marca'] = marca
elif gm.value(subject=restriccion, predicate=RDF.type) == ECSDI.Restriccion_Modelo:
modelo = gm.value(subject=restriccion, predicate=ECSDI.Modelo)
logger.info('Modelo: ' + modelo)
restricciones_dict['modelo'] = modelo
elif gm.value(subject=restriccion, predicate=RDF.type) == ECSDI.Restriccion_Precio:
precio_max = gm.value(subject=restriccion, predicate=ECSDI.Precio_max)
precio_min = gm.value(subject=restriccion, predicate=ECSDI.Precio_min)
if precio_min:
logger.info('Precio minimo: ' + precio_min)
restricciones_dict['precio_min'] = precio_min
logger.info(restricciones_dict['precio_min'])
if precio_max:
logger.info('Precio maximo: ' + precio_max)
restricciones_dict['precio_max'] = precio_max
gr = buscarProductos(**restricciones_dict)
gr = build_message(gr, perf=ACL['inform-done'], sender=AgenteBuscador.uri, msgcnt=get_count(), receiver=msgdic['sender'])
else:
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=get_count())
logger.info('Respondemos a la peticion')
return gr.serialize(format='xml')
def comunicacion():
"""
Entrypoint de comunicacion del agente
Simplemente retorna un objeto fijo que representa una
respuesta a una busqueda de hotel
Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer
el agente (buscar con ciertas restricciones, reservar)
Las acciones se mandan siempre con un Request
Prodriamos resolver las busquedas usando una performativa de Query-ref
"""
global dsgraph
global mss_cnt
logger.info('Peticion de informacion recibida')
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgentDevoluciones.uri,
msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgentDevoluciones.uri,
msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
if accion == ONT.ProductoDevuelto:
gr = contactarCobrador(gm)
mss_cnt += 1
logger.info('Respondemos a la peticion')
return gr.serialize(format='xml')
def comm():
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'EnvioTiendaExterna':
return notificarEnvio(req, content)
elif accion == 'NotificarCobro':
return notificarCobro(req, content)
def realizarPedido():
global gcarrito
dicreq = request.form
nombre = request.form.get("nombre")
email = request.form.get("email")
ciudad = request.form.get("ciudad")
tarjeta = request.form.get("tarjeta")
direccion = request.form.get("direccion")
urgencia = request.form.get("urgencia")
print("urgencia " + urgencia)
gc = cargar_grafo_turtle(AgentUtil.Agents.path_clientes)
gc.add((ECSDI['Cliente' + email], ECSDI.nombre, Literal(nombre)))
gc.add((ECSDI['Cliente' + email], ECSDI.email, Literal(email)))
gc.add((ECSDI['Cliente' + email], ECSDI.localizacion, Literal(ciudad)))
gc.add((ECSDI['Cliente' + email], ECSDI.tarjeta, Literal(tarjeta)))
gc.add((ECSDI['Cliente' + email], ECSDI.direccion, Literal(direccion)))
guardar_grafo_turtle(gc, AgentUtil.Agents.path_clientes)
gm = Graph()
gm.bind('ecsdi', ECSDI)
content = ECSDI['ordenCompra']
gm.add((content, ECSDI.email, Literal(email)))
gm.add((content, ECSDI.urgencia, Literal(urgencia)))
gm += gcarrito
msg = build_message(gm, perf=ACL.request,
sender=AgentUtil.Agents.AgenteUsuario.uri,
receiver=AgentUtil.Agents.AgenteDistribuidorBultos.uri,
content=content)
# graf amb tots els productes relacionats amb el criteri de busqueda
gr = send_message(msg, AgentUtil.Agents.AgenteDistribuidorBultos.address)
msgdic = get_message_properties(gr)
perf = msgdic['performative']
if (perf == ACL.agree):
mensaje = "Su pedido ha sido recibido correctamente!"
else:
mensaje = "Ha habido un error al enviar el pedido!"
# gcarrito = cargarCarrito()
# Realizar pedido contactar con agente distribuidor bultos
gcarrito = Graph()
# guardarCarrito(gcarrito)
return render_template('mensajePedidoEnviado.html', mensaje=mensaje)
def comunicacion():
"""
Entrypoint de comunicacion
"""
global dsgraph
global mss_cnt
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
mss_cnt += 1
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteVendedorExterno.uri,
msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteVendedorExterno.uri,
msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
# Aqui realizariamos lo que pide la accion
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteVendedorExterno.uri,
msgcnt=mss_cnt)
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteVendedorExterno.uri,
msgcnt=mss_cnt)
return gr.serialize(format='xml')
def comunicacion():
"""
Entrypoint de comunicacion
"""
global dsgraph
global mss_cnt
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
# Aqui realizariamos lo que pide la accion
if accion == AM2.Realiza_envio:
logger.info('Realizando el envio')
products = Graph()
for s in gm.subjects(RDF.type,AM2["Producto"]):
products += gm.triples((s,None,None))
# for s,p,o in products:
# print("Procesando productos: %s | %s | %s"%(s,p,o))
negociaEnvio()
time.sleep(10) #Hacemos que tarde un tiempo en procesar antes de confirmar el envio
gr = confirmaEnvio(msgdic)
else:
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt)
else:
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlmacen.uri, msgcnt=mss_cnt)
mss_cnt += 1
logger.info('Confirmamos que se ha relizado el envio')
return gr.serialize(format='xml')
def comunicacion():
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'Negociar':
return negociar(req, content)
elif accion == 'Contraoferta':
return contraoferta(req, content)
elif accion == 'Transportar':
return transportar(req, content)
def comunicacion():
"""
Entrypoint de comunicacion
"""
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'Devolver':
return devolver(req, content)
elif accion == 'Buscar_Productos_Usuario':
return buscar_productos_usuario(req, content)
def devolverCompras(request):
global mss_cnt
global username
# for id in request.form.getlist('comprasToReturn'):
# print("Ids: %s"%id)
gmess = Graph()
# Creamos el sujeto -> contenido del mensaje
sj_contenido = agn[AgenteCliente.name + '-Peticion_devolucion-' +
str(mss_cnt)]
# le damos un tipo
gmess.add((sj_contenido, RDF.type, AM2.Peticion_devolucion))
gmess.add((sj_contenido, AM2.username, Literal(username)))
compras = Graph()
compraProductos = open('../datos/compras')
compras.parse(compraProductos, format='turtle')
# misCompras = Graph()
# for compra in compras.subjects(AM2.username,Literal(username)):
# misCompras += compras.triples((compra,None,None))
for id in request.form.getlist('comprasToReturn'):
# print("Ids: %s"%id)
sj_nombre = AM2[id] #creamos una instancia con nombre Modelo1..2.
gmess.add((sj_nombre, RDF.type,
AM2['Compra'])) # indicamos que es de tipo Modelo
gmess += compras.triples((AM2[id], None, None))
# gmess.add((sj_contenido, AM2.Compras, URIRef(sj_nombre)))
agenteDevolucion = directory_search_agent(DSO.AgenteDevoluciones,
AgenteCliente, DirectoryAgent,
mss_cnt)[0]
msg = build_message(gmess,
perf=ACL.request,
sender=AgenteCliente.uri,
receiver=agenteDevolucion.uri,
content=sj_contenido,
msgcnt=mss_cnt)
# print("devolverCompras BUILD")
gr = send_message(msg, agenteDevolucion.address)
# print("devolverCompras SENT")
mss_cnt += 1
msgdic = get_message_properties(gr)
content = msgdic['content']
resultadoDevolucion = gr.value(subject=content,
predicate=AM2.resultadoDevolucion)
return resultadoDevolucion
def comunicacion():
"""
Entrypoint de comunicacion
"""
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'Buscar_Productos':
return buscar_productos(req, content)
elif accion == 'Comprar':
return comprar(req, content)
elif accion == 'Informar_Envio_Iniciado':
return informar_envio_iniciado(req, content)
def comunicacion():
"""
Entrypoint de comunicacion
"""
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'Pedir_Feedback':
return pedir_feedback(req, content)
elif accion == 'Enviar_Feedback':
return enviar_feedback(req, content)
elif accion == 'Recibir_Recomendaciones':
return recomendaciones(req, content)
def comunicacion():
global dsgraph
global mss_cnt
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'CobrarP':
return cobrarP(req, content)
elif accion == 'Pagar':
return pagar(req, content)
elif accion == 'PagarTiendaExterna':
return pagarTiendaExterna(req, content)
def comunicacion():
"""
Entrypoint de comunicacion
"""
global dsGraph
logger.info('Peticion de nuevo producto externo recivida')
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = None
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteNegociadorTiendasExternas.uri,
msgcnt=get_count())
else:
# Llega una metodologia
if msgdic['performative'] == ACL.inform:
content = msgdic['content']
metodologiaDePago = gm.value(subject=content,
predicate=ECSDI.Metodologia_de_pago)
tiendaExterna = msgdic['sender']
gr = añadirMetodologiaDePago(tiendaExterna, metodologiaDePago)
# Una tienda externa quiere añadir un producto a nuestra tienda
elif msgdic['performative'] == ACL.request:
tiendaOrigen = msgdic['sender']
anadirProductosTiendaExterna(gm, tiendaOrigen)
gr = build_message(Graph(),
perf=ACL['inform'],
sender=AgenteNegociadorTiendasExternas.uri,
msgcnt=get_count(),
receiver=tiendaOrigen)
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 = None
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=PlannerAgent.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)
if accion == ECSDI.peticion_de_plan:
logger.info("Estoy en else")
logger.info(accion)
logger.info('Respondemos a la peticion')
serialize = gr.serialize(format='xml')
return serialize, 200
def comunicacion():
"""
Entrypoint de comunicacion
"""
global mss_cnt
logging.info("ARRIBA?")
req = Graph()
req.parse(data=request.args['content'])
message_properties = get_message_properties(req)
content = message_properties['content']
accion = str(req.value(subject=content, predicate=RDF.type))
logging.info('Accion: ' + accion)
if accion == 'Enviar_Peticion':
return recibir_peticion(req, content)
elif accion == 'EnviarProdTiendaExterna':
return notificar_envio_tienda_externa(req, content)
elif accion == 'NotificarCobro':
return notificar_cobro(req, content)
def comunicacion():
"""
Entrypoint de comunicacion del agente
"""
global dsgraph
global mss_cnt
#Extraemos el mensaje y creamos un grafo con el
message= request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'],AgentSistemanfoAgent.uri, msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'],AgentSistemanfoAgent.uri, msgcnt=mss_cnt)
else:
#Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate= RDF.type)
# Aqui realizariamos lo que pide la accion
gp = crear_paquet(gm)
# Por ahora simplemente retornamos un Inform-done
gr = build_message(gp,
ACL['inform-done'],
sender=AgentSistema.uri,
msgcnt=mss_cnt,
receiver=msgdic['sender'],)
mss_cnt += 1
return gr.serialize(format='xml')
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
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlojamiento.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_Alojamiento:
gr = findHoteles()
logger.info('Api usada')
serialize = gr.serialize(format='xml')
logger.info("bye bye")
return serialize, 200
def comunicacion():
global ultimo_informe_recibido
message = request.args['content'] #cogo el contenido enviado
grafo = Graph()
logger.info('--Envian una comunicacion')
grafo.parse(data=message)
logger.info('--Envian una comunicacion')
message_properties = get_message_properties(grafo)
resultado_comunicacion = None
if message_properties is None:
#respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(), ACL['not-understood'],
sender=AgenteUsuario.uri, msgcnt=get_message_count())
else:
#obtenemos la performativa
if message_properties['performative'] != ACL.request:
#Si no es un request, respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(), ACL['not-understood'],
sender=AgenteUsuario.uri, msgcnt=get_message_count())
else:
#Extraemos el contenido que ha de ser una accion de la ontologia
contenido = message_properties['content']
accion = grafo.value(subject=contenido, predicate=RDF.type)
logger.info("La accion es: " + accion)
#si la acción es de tipo tranferencia empezamos
if accion == ECSDIAmazon.Informar:
logger.info("Ya apunto de finalizar")
# thread = Thread(target=enviarVenta, args=(contenido,grafo))
# thread.start()
ultimo_informe_recibido = grafo
graf = Graph()
mensaje = ECSDIAmazon["Respuesta"+ str(get_message_count())]
graf.add((mensaje,RDF.type, ECSDIAmazon.Respuesta))
graf.add((mensaje,ECSDIAmazon.Mensaje,Literal("OK",datatype=XSD.string)))
resultado_comunicacion = graf
logger.info("Antes de serializar la respuesta")
serialize = resultado_comunicacion.serialize(format="xml")
return serialize, 200
def communication():
message = request.args['content'] #cogo el contenido enviado
grafo = Graph()
logger.info('--Envian una comunicacion')
grafo.parse(data=message)
logger.info('--Envian una comunicacion')
message_properties = get_message_properties(grafo)
resultado_comunicacion = None
if message_properties is None:
# Respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(
Graph(),
ACL['not-understood'],
sender=AgenteGestorDeProductos.uri,
msgcnt=get_message_count())
else:
# Obtenemos la performativa
if message_properties['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_message_count())
else:
# Extraemos el contenido que ha de ser una accion de la ontologia definida en Protege
contenido = message_properties['content']
accion = grafo.value(subject=contenido, predicate=RDF.type)
logger.info("La accion es: " + accion)
# Si la acción es de tipo busqueda empezamos
if accion == ECSDIAmazon.Buscar_productos:
resultado_comunicacion = buscar_productos(contenido, grafo)
elif accion == ECSDIAmazon.Anadir_producto:
resultado_comunicacion = anadir_producto(grafo)
logger.info('Antes de serializar la respuesta')
serialize = resultado_comunicacion
return serialize, 200
def hoteles():
"""
calls to /browsequotes/v1.0/{country}/{currency}/{locale}/{originPlace}/{destinationPlace}/{outboundPartialDate}/{inboundPartialDate}
:return:
"""
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=AgenteObtenedorAlojamiento.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_alojamiento":
outbounddate = request.args["fechaSalida"]
inbounddate = request.args["fechaVuelta"]
respuesta = arrayalojamientos[random.randint(0, len(arrayalojamientos)-1)]
return respuesta
return 0 #lol
def communication():
message = request.args['content'] #cogo el contenido enviado
grafo = Graph()
grafo.parse(data=message)
message_properties = get_message_properties(grafo)
resultado_comunicacion = None
if message_properties is None:
#respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(),
ACL['not-understood'],
sender=AgenteFinanciero.uri,
msgcnt=get_message_count())
else:
#obtenemos la performativa
if message_properties['performative'] != ACL.request:
#Si no es un request, respondemos que no hemos entendido el mensaje
resultado_comunicacion = build_message(Graph(),
ACL['not-understood'],
sender=AgenteFinanciero.uri,
msgcnt=get_message_count())
else:
#Extraemos el contenido que ha de ser una accion de la ontologia
contenido = message_properties['content']
accion = grafo.value(subject=contenido, predicate=RDF.type)
#si la acción es de tipo tranferencia empezamos
if accion == ECSDIAmazon.Transferencia_cobrar:
resultado_comunicacion = realizar_transferencia(
contenido, grafo, True)
elif accion == ECSDIAmazon.Tranferencia_pago:
resultado_comunicacion = realizar_transferencia(
contenido, grafo, False)
serialize = resultado_comunicacion.serialize(format="xml")
return serialize, 200
def comunicacion():
"""
Entrypoint de comunicacion del agente
Simplementet retorna un objeto fijo que representa una
respuesta a una busqueda de hotel
Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer
el agente (buscar con ciertas restricciones, reservar)
Las acciones se mandan siempre con un Request
Prodriamos resolver las busquedas usando una performativa de Query-ref
"""
global dsgraph
global mss_cnt
# Variables globales con los parametros de busqueda de actividades
# Realmente creo que podrian ser locales...
global location
global activity
global radius
global tipo
#logger.info('Peticion de informacion recibida')
print 'INFO AgentBuscador=> Peticion de informacion recibida\n'
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
print "INFO AgentBuscador => Mensaje extraído\n"
# VERBOSE
print message
print '\n\n'
# Grafo en el que volcamos el contenido de la request
gm = Graph()
gm.parse(data=message)
# Damos por supuesto que el sujeto es una peticion de actividad
# En general habra que comprobar de que tipo es la peticion y hacer casos,
# aunque creo que podemos poner todas las peticiones en un mosmo grafo
# con diferentes sujetos (peticiones)
# Propiedades del mensaje
msgdic = get_message_properties(gm)
# VERBOSE
#print msgdic
#print '\n\n'
# Creo la lista de tipos con UN SOLO tipo
# Habra que generalizar esto para mas de un tipo (o no)
# Si lo hacemos, el planificador me tendra que pasar una list como parametro
# VERBOSE
#print "Lista append:"
#print lista
hotel = myns_pet.hotel
busqueda = myns_pet.busqueda
originCit = gm.value(subject= busqueda, predicate= myns_par.originCity)
destinationCit = gm.value(subject= busqueda, predicate= myns_par.destinationCity)
originVuelo="PRG"
if str(originCit) == "Barcelona":
originVuelo="BCN"
elif str(originCit) == "Amsterdam":
originVuelo="AMS"
elif str(originCit) == "London":
originVuelo="LON"
elif str(originCit) == "Roma":
originVuelo="ROM"
elif str(originCit) == "Paris":
originVuelo="PAR"
destinationVuelo="BCN"
destinationCountry="Spain"
if str(destinationCit) == "Amsterdam":
destinationVuelo="AMS"
destinationCountry="Holland"
elif str(destinationCit) == "London":
destinationVuelo="LON"
destinationCountry="United Kingdom"
elif str(destinationCit) == "Roma":
destinationVuelo="ROM"
destinationCountry="Italy"
elif str(destinationCit) == "Praha":
destinationVuelo="PRG"
destinationCountry="Czech Republic"
elif str(destinationCit) == "Paris":
destinationVuelo="PAR"
destinationCountry="France"
# Buscamos actividades en el metodo de AgentActividades
print "INFO AgentBuscador => Looking for activities (in AgentActividades)..."
actividadesInt = gm.triples((None, myns_atr.tipo, None))
gactividades = Graph()
for s,p, o in actividadesInt:
print o
gactividades += buscar_actividades(destinationCity=destinationCit,
destinationCountry= destinationCountry, types= [o])
print "INFO AgentBuscador => Activities found"
#VERBOSE
#Imprimimos el grafo de resultados para ver que pinta tiene
#Realmente solo queremos devolverlo al planificador
# for s, p, o in gactividades:
# print 's: ' + s
# print 'p: ' + p
# print 'o: ' + o
# print '\n'
print "Buscamos hoteles"
departureDat=gm.value(subject= busqueda, predicate= myns_par.departureDate)
returnDat=gm.value(subject= busqueda, predicate= myns_par.returnDate)
propertyCategor=gm.value(subject= busqueda, predicate= myns_par.propertyCategory)
print "INFO AgentBuscador => Looking for hotels (in AgentHotel)..."
ghoteles = buscar_hoteles(destinationCity = destinationCit,
destinationCountry = destinationCountry,
arrivalDate = departureDat,
departureDate = returnDat,
propertyCategory = propertyCategor)
# Buscamos vuelos
print "INFO AgentBuscador => Looking for flights (in AgentFlightsGoogle)..."
maxPric=gm.value(subject= busqueda, predicate= myns_par.maxPrice)
gvuelos = Graph()
gvuelos = buscar_vuelos(origin=originVuelo,
destination=destinationVuelo,
departureDate= departureDat,
returnDate=returnDat,
maxPrice=maxPric)
# Juntamos los tres grafos en una respuesta
grespuesta = Graph()
grespuesta = gvuelos + ghoteles + gactividades
res_obj= agn['Buscador-responde']
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=mss_cnt)
print 'INFO AgentBuscador => El mensaje no era un FIPA ACL'
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
print "INFO AgentBuscador => No es una request FIPA ACL\n"
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteBuscador.uri, msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
# Aqui realizariamos lo que pide la accion
# Retornamos un Inform-done con el grafo del resultado de la busqueda (grespuesta)
gr = build_message(grespuesta,
ACL['inform-done'],
sender=AgenteBuscador.uri,
msgcnt=mss_cnt,
receiver=msgdic['sender'],
content=res_obj
)
mss_cnt += 1
print 'INFO AgentBuscador => Respondemos a la peticion de busqueda'
return gr.serialize(format='xml')
def comunicacion():
"""
Entrypoint de comunicacion
"""
global dsgraph
global mss_cnt
print 'Peticion de informacion recibida\n'
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
print "Mensaje extraído\n"
# VERBOSE
print message
print "\n\n"
gm = Graph()
gm.parse(data=message)
print 'Grafo creado con el mensaje'
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
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=mss_cnt)
print 'El mensaje no era un FIPA ACL'
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgentePlanificador.uri, msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
# if 'content' in msgdic:
# content = msgdic['content']
# accion = gm.value(subject=content, predicate=RDF.type)
# Apartir de aqui tenemos que obtener parametro desde dialog y luego comunicar con buscador
###########################################################
# Parsear los parametros de Dialog
print "Parsear los parametros de Dialog"
#############################################################
peticion = myns_pet["Dialogador-pide-paquete"]
parametros = gm.triples((peticion, None, None))
# VERBOSE
print "Parametros: "
print parametros
actv = myns_pet.actividad
###########################################################
# Comunicar con buscador
print "Los parametros recibidos"
#############################################################
# departureDate="2015-08-20"
# returnDate="2015-08-30"
# maxPrice=500
# originCity="Amsterdam"
# destinationCity="Barcelona"
# propertyCategory=1
originCity = gm.value(subject= peticion, predicate= myns_atr.originCity)
#gmess.add((actv, myns_atr.lugar, origin))
# VERBOSE
print "originCity: "
print originCity
departureDate = gm.value(subject= peticion, predicate= myns_atr.departureDate)
#gmess.add((actv, myns_atr.lugar, departureDate))
# VERBOSE
print "departureDate: "
print departureDate
returnDate = gm.value(subject= peticion, predicate= myns_atr.returnDate)
#gmess.add((actv, myns_atr.lugar, returnDate))
# VERBOSE
print "returnDate: "
print returnDate
maxPrice = float(gm.value(subject= peticion, predicate= myns_atr.maxPrice))
#gmess.add((actv, myns_atr.lugar, maxPrice))
# VERBOSE
print "maxPrice: "
print maxPrice
propertyCategory = gm.value(subject= peticion, predicate= myns_atr.propertyCategory)
#gmess.add((actv, myns_atr.lugar, numberOfStars))
# VERBOSE
print "propertyCategory: "
print propertyCategory
actividades = []
actividadesInt = gm.triples((None, myns_atr.tipo, None))
for s,p, o in actividadesInt:
actividades.append(o)
activity= gm.value(subject= peticion, predicate= myns_atr.activities)
print "activity: "
print activity
actividades.append(activity)
destinationCity=gm.value(subject= peticion, predicate= myns_atr.destinationCity)
print "destinationCity: "
print destinationCity
# Graph para buscador
gmess = Graph()
gmess.bind('myns_pet', myns_pet)
gmess.bind('myns_atr', myns_atr)
###########################################################
# Comunicar con buscador
# print "Los parametros hardcoreado"
#############################################################
# actividades= [types.TYPE_MOVIE_THEATER, types.TYPE_CASINO, types.TYPE_MUSEUM]
# departureDate="2015-08-20"
# returnDate="2015-08-30"
# maxPrice=500
# originCity="Amsterdam"
# destinationCity="Barcelona"
# propertyCategory=1
print departureDate
###########################################################
# Mejorar preferencia de busqueda
print "Mejorar preferencia de busqueda"
#############################################################
###########################################################
# Comunicar con buscador
print "Iniciar la comunicaion con buscador"
#############################################################
# Hago bind de las ontologias que voy a usar en el grafo
# Estas ontologias estan definidas arriba (abajo de los imports)
# Son las de peticiones y atributos (para los predicados de la tripleta)
# Sujeto de la tripleta: http://my.namespace.org/peticiones/actividad
# O sea, el mensaje sera una peticion de actividad
# El buscador tendra que ver que tipo de peticion es
###########################################################
# Comunicar con buscador
print "Añadir parametros de actividad"
#############################################################
# Paso los parametros de busqueda de actividad en el grafo
busqueda = myns_pet.busqueda
i = 0
for a in actividades:
i+= 1
actv = "actividad" + str(i)
gmess.add((busqueda, myns_par.actividad, myns_act.actv))
gmess.add((myns_act.actv, myns_atr.tipo, Literal(a)))
i+= 1
actv = "actividad" + str(i)
gmess.add((busqueda, myns_par.actividad, myns_act.actv))
gmess.add((myns_act.actv, myns_atr.tipo, Literal('restaurant')))
###########################################################
# Comunicar con buscador
print "Añadir parametros de vuelo"
#############################################################
gmess.add((busqueda, myns_par.departureDate, Literal(departureDate)))
gmess.add((busqueda, myns_par.returnDate, Literal(returnDate)))
gmess.add((busqueda, myns_par.maxPrice, Literal(maxPrice/3)))
###########################################################
# Comunicar con buscador
print "Añadir parametros de hotel"
#############################################################
hotel = myns_pet.hotel
gmess.add((busqueda, myns_par.originCity, Literal(originCity)))
gmess.add((busqueda, myns_par.destinationCity, Literal(destinationCity)))
gmess.add((busqueda, myns_par.propertyCategory, Literal(propertyCategory)))
# Uri asociada al mensaje sera: http://www.agentes.org#Planificador-pide-actividades
res_obj= agn['Planificador-pide-datos']
# Construyo el grafo y lo mando (ver los metodos send_message y build_message
# en ACLMessages para entender mejor los parametros)
print "INFO AgentePlanificador=> Sending request to AgenteBuscador\n"
gr = send_message(build_message(gmess,
perf=ACL.request,
sender=AgentePlanificador.uri,
receiver=AgenteBuscador.uri,
content=res_obj,
msgcnt=mss_cnt
),
AgenteBuscador.address)
print "Respuesta de busqueda recibida\n"
# for s, p, o in grep:
# print 's: ' + s
# print 'p: ' + p
# print 'o: ' + o.encode('utf-8')
# print '\n'
###########################################################
# Calcular paquete
print "Calcular paquete"
#############################################################
grep = Graph()
###########################################################
# Calcular paquete
print "Calcular Vuelos"
#############################################################
gvuelo = Graph()
for s,p,o in gr.triples((None, myns_atr.esUn, myns.viaje)):
gvuelo += gr.triples((s, None, None) )
gvueloid = gvuelo.query("""
PREFIX myns_atr: <http://my.namespace.org/atributos/>
SELECT DISTINCT ?a ?cuesta
WHERE{
?a myns_atr:cuesta ?cuesta .
FILTER(str(?cuesta) != "")
}
ORDER BY (?cuesta)
LIMIT 1
""")
Aid = []
cuestaVuelo = 0
for s, c in gvueloid:
print s
Aid.append(s)
cuestaVuelo = float(c[3:])
maxPrice -= cuestaVuelo
grep += gvuelo.triples((Aid[0], None, None))
idgo = gr.value(subject= Aid[0], predicate= myns_atr.ida)
idback = gr.value(subject= Aid[0], predicate= myns_atr.vuelta)
grep += gr.triples((idgo,None, None))
grep += gr.triples((idback, None, None))
###########################################################
# Calcular paquete
print "Calcular Hotel"
#############################################################
ghotel = Graph()
for s,p,o in gr.triples((None, myns_atr.esUn, myns.hotel)):
ghotel += gr.triples((s, None, None) )
ghotelid = ghotel.query("""
PREFIX myns_atr: <http://my.namespace.org/atributos/>
SELECT DISTINCT ?a ?cuesta
WHERE{
?a myns_atr:rating ?ratin .
?a myns_atr:cuesta ?cuesta .
FILTER(str(?ratin) != "" && str(?cuesta) != "")
}
ORDER BY DESC(?ratin) ?cuesta
LIMIT 1
""")
Aid = []
cuestaHotel = 0
for s, c in ghotelid:
Aid.append(s)
cuestaHotel = float(c)
maxPrice -= cuestaHotel
grep += ghotel.triples((Aid[0], None, None))
#Actividades
###########################################################
# Calcular paquete
print "Calcular Actividades"
#############################################################
gactividad = Graph()
for s,p,o in gr.triples((None, myns_atr.esUn, myns.actividad)):
gactividad += gr.triples((s, None, None) )
grestaurante = gactividad.query("""
PREFIX myns_atr: <http://my.namespace.org/atributos/>
SELECT DISTINCT ?a ?ratin ?tip
WHERE{
?a myns_atr:rating ?ratin .
?a myns_atr:tipo ?tip
FILTER(?tip = "restaurant")
}
ORDER BY DESC(?ratin)
""")
restaurant = []
for g, r, t in grestaurante:
restaurant.append(g)
gnight = gactividad.query("""
PREFIX myns_atr: <http://my.namespace.org/atributos/>
SELECT DISTINCT ?a ?ratin ?tip
WHERE{
?a myns_atr:rating ?ratin .
?a myns_atr:tipo ?tip
FILTER
(?tip = "night_club" ||
?tip = "bar" ||
?tip = "casino"
)
}
ORDER BY DESC(?ratin)
""")
night = []
for g, r, t in gnight:
night.append(g)
print len(night)
gday = gactividad.query("""
PREFIX myns_atr: <http://my.namespace.org/atributos/>
SELECT DISTINCT ?a ?ratin ?tip
WHERE{
?a myns_atr:rating ?ratin .
?a myns_atr:tipo ?tip
}
ORDER BY DESC(?ratin)
""")
daylist = []
for g, r, t in gday:
daylist.append(g)
###########################################################
# Escoger Actividades
print "Escoger Actividades"
#############################################################
day = datetime.strptime(departureDate, '%Y-%m-%d')
cday = 0
cnight = 0
cres = 0
rd = datetime.strptime(returnDate, '%Y-%m-%d')
while day <= rd:
# cada dia
grfdata = myns_data.day
if len(daylist) != 0:
# manana
grep.add((grfdata, myns_data.manana, daylist[cday%len(daylist)]))
grep += gactividad.triples((daylist[cday%len(daylist)], None, None))
cday += 1;
grep.add((grfdata, myns_data.tarde, daylist[cday%len(daylist)]))
grep += gactividad.triples((daylist[cday%len(daylist)], None, None))
cday += 1;
# comida
grep.add((grfdata, myns_data.comida, restaurant[cres%len(restaurant)]))
grep += gactividad.triples((restaurant[cres%len(restaurant)], None, None))
cres += 1;
# cena
grep.add((grfdata, myns_data.cena, restaurant[cres%len(restaurant)]))
grep += gactividad.triples((restaurant[cres%len(restaurant)], None, None))
cres += 1;
# noche
if len(night) != 0:
grep.add((grfdata, myns_data.noche, night[cnight%len(night)]))
grep += gactividad.triples((night[cnight%len(night)], None, None))
cnight += 1;
day = day + timedelta(days=1)
###########################################################
# Construir mensage de repuesta
print "Construir mensage de repuesta"
#############################################################
# for s, p, o in grep:
# print 's: ' + s
# print 'p: ' + p
# print 'o: ' + o.encode('utf-8')
# print '\n'
mss_cnt += 1
print 'Respondemos a la peticion\n'
###########################################################
# Construir mensage de repuesta
print "Retornar repuesta"
#############################################################
return grep.serialize(format='xml')
def comunicacion():
"""
Entrypoint de comunicacion
"""
global dsgraph
global mss_cnt
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
# Aqui realizariamos lo que pide la accion
if accion == AM2.Solicitud_envio:
logger.info("Petición de envio recibida")
productsInternos = Graph()
productsExternos = Graph()
# Productos recibidos
hayExterno = False
hayInterno = False
for s in gm.subjects(RDF.type, AM2["Producto"]):
tipoEnvio = gm.value(s, AM2.TipoEnvio)
if str(tipoEnvio) == 'Interno':
hayInterno = True
productsInternos += gm.triples((s, None, None))
else:
hayExterno = True
productsExternos += gm.triples((s, None, None))
if hayExterno and not hayInterno:
gr = confirmaEnvio(msgdic, productsExternos)
colaAvisarAgenteVendedorExterno(productsExternos)
else:
gmess = Graph()
sj_contenido = MSG[AgenteLogistico.name +
'-Realiza_envio-' + str(mss_cnt)]
gmess.add((sj_contenido, RDF.type, AM2.Realiza_envio))
gmess += productsInternos
agenteAlmacen = directory_search_agent(
DSO.AgenteAlmacen, AgenteLogistico, DirectoryAgent,
mss_cnt)[0]
grm = build_message(gmess,
perf=ACL.request,
sender=AgenteLogistico.uri,
receiver=agenteAlmacen.uri,
content=sj_contenido,
msgcnt=mss_cnt)
gr = send_message(grm, agenteAlmacen.address)
logger.info(
'Se ha informado al almacen que debe realizar envio'
)
if hayExterno:
gmess2 = Graph()
sj_contenido = MSG[
AgenteLogistico.name +
'-Confirmacion_envio_externo_interno-' +
str(mss_cnt)]
gmess2.add(
(sj_contenido, RDF.type,
AM2.Confirmacion_envio_externo_interno))
gr = build_message(gmess2,
ACL['inform-done'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt,
content=sj_contenido,
receiver=msgdic['sender'])
colaAvisarAgenteVendedorExterno(productsExternos)
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
mss_cnt += 1
logger.info('Respondemos a la solicitud de envio')
return gr.serialize(format='xml')
def register():
"""
Entry point del agente que recibe los mensajes de registro
La respuesta es enviada al retornar la funcion,
no hay necesidad de enviar el mensaje explicitamente
Asumimos una version simplificada del protocolo FIPA-request
en la que no enviamos el mesaje Agree cuando vamos a responder
:return:
"""
def process_register():
# Si la hay extraemos el nombre del agente (FOAF.Name), el URI del agente
# su direccion y su tipo
logger.info('Peticion de registro')
agn_add = gm.value(subject=content, predicate=DSO.Address)
agn_name = gm.value(subject=content, predicate=FOAF.Name)
agn_uri = gm.value(subject=content, predicate=DSO.Uri)
agn_type = gm.value(subject=content, predicate=DSO.AgentType)
# Añadimos la informacion en el grafo de registro vinculandola a la URI
# del agente y registrandola como tipo FOAF.Agent
dsgraph.add((agn_uri, RDF.type, FOAF.Agent))
dsgraph.add((agn_uri, FOAF.name, agn_name))
dsgraph.add((agn_uri, DSO.Address, agn_add))
dsgraph.add((agn_uri, DSO.AgentType, agn_type))
# Generamos un mensaje de respuesta
return build_message(Graph(),
ACL.confirm,
sender=DirectoryAgent.uri,
receiver=agn_uri,
msgcnt=mss_cnt)
def process_search():
# Asumimos que hay una accion de busqueda que puede tener
# diferentes parametros en funcion de si se busca un tipo de agente
# o un agente concreto por URI o nombre
# Podriamos resolver esto tambien con un query-ref y enviar un objeto de
# registro con variables y constantes
# Solo consideramos cuando Search indica el tipo de agente
# Buscamos una coincidencia exacta
# Retornamos el primero de la lista de posibilidades
logger.info('Peticion de busqueda')
agn_type = gm.value(subject=content, predicate=DSO.AgentType)
rsearch = dsgraph.triples((None, DSO.AgentType, agn_type))
if rsearch is not None:
agn_uri = rsearch.next()[0]
agn_add = dsgraph.value(subject=agn_uri, predicate=DSO.Address)
gr = Graph()
gr.bind('dso', DSO)
rsp_obj = agn['Directory-response']
gr.add((rsp_obj, DSO.Address, agn_add))
gr.add((rsp_obj, DSO.Uri, agn_uri))
return build_message(gr,
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt,
receiver=agn_uri,
content=rsp_obj)
else:
# Si no encontramos nada retornamos un inform sin contenido
return build_message(Graph(),
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
global dsgraph
global mss_cnt
# Extraemos el mensaje y creamos un grafo con él
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if not msgdic:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
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=mss_cnt)
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 registro
if accion == DSO.Register:
gr = process_register()
# Accion de busqueda
elif accion == DSO.Search:
gr = process_search()
# No habia ninguna accion en el mensaje
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
mss_cnt += 1
return gr.serialize(format='xml')
def comunicacion():
"""
Entrypoint de comunicacion
"""
global dsgraph
global mss_cnt
message = request.args['content']
print("requestargs")
print(request.args['content'])
gm = Graph()
gm.parse(data=message)
gr = None
gcopia = gm
msgdic = get_message_properties(gm)
if msgdic is None:
gr = build_message(
Graph(),
ACL['not-understood'],
sender=AgentUtil.Agents.AgenteDistribuidorBultos.uri,
msgcnt=mss_cnt)
else:
perf = msgdic['performative']
if perf == ACL.request:
if 'content' in msgdic:
content = msgdic['content']
email = gcopia.value(subject=content, predicate=ECSDI.email)
gcopia.remove((content, ECSDI.email, None))
urgencia = gcopia.value(subject=content,
predicate=ECSDI.urgencia)
gcopia.remove((content, ECSDI.urgencia, None))
print("busqueda: " + email)
for (su, pd, ob) in gcopia:
print("sujeto " + su)
print("predicado " + pd)
print("objeto " + ob)
codigoPedido = random.randint(0, 999999999999)
gclientes = cargar_grafo_turtle(AgentUtil.Agents.path_clientes)
# sujetoCliente = gclientes.subjects(predicate=ECSDI.email, object=email)
# print("----------------------------------")
# print(sujetoCliente)
# print(ECSDI.sujetoCliente)
# print(ECSDI[sujetoCliente])
# print(ECSDI['Cliente'+email])
# print("----------------------------------")
gpedidos = cargar_grafo_turtle(AgentUtil.Agents.path_pedidos)
gpedidos.add((ECSDI['Pedido' + str(codigoPedido)], RDF.type,
Literal('Pedido')))
gpedidos.add(
(ECSDI['Pedido' + str(codigoPedido)], ECSDI.codigo,
Literal(codigoPedido)))
gpedidos.add(
(ECSDI['Pedido' + str(codigoPedido)], ECSDI.estado,
Literal(1)))
gpedidos.add(
(ECSDI['Pedido' + str(codigoPedido)], ECSDI.prioridad,
Literal(urgencia)))
for item in gclientes.subjects(predicate=ECSDI.email,
object=email):
gpedidos.add((ECSDI['Pedido' + str(codigoPedido)],
ECSDI.realizada_por, URIRef(item)))
ciudad = gclientes.value(subject=item,
predicate=ECSDI.localizacion)
gcentrosLogisticos = cargar_grafo_turtle(
AgentUtil.Agents.path_centrosLogisticos)
# ciudad = gclientes.value(subject=sujetoCliente, predicate=ECSDI.localizacion)
print("ciudad " + ciudad)
# sujetoCentro = gcentrosLogisticos.subjects(predicate=ECSDI.localizacion, object=ciudad)
gbultos = Graph()
gbultos.bind('ecsdi', ECSDI)
# if not sujetoCentro is None:
for item1 in gcentrosLogisticos.subjects(
predicate=ECSDI.localizacion, object=ciudad):
print("he entrado en item 1")
l = []
for producto in gcopia.subjects(
predicate=RDF.type,
object=Literal('ProductoPropio')):
print("he entrado en for1 producto")
if (item1, ECSDI.dispone_de,
producto) in gcentrosLogisticos:
print("he entrado en anadir producto")
l.append(producto)
gcopia.remove((producto, None, None))
for producto in gcopia.subjects(
predicate=RDF.type,
object=Literal('ProductoAjenoEnvio')):
if (item1, ECSDI.dispone_de,
producto) in gcentrosLogisticos:
l.append(producto)
gcopia.remove((producto, None, None))
if not len(l) == 0:
print("he entrado en not len 0 1")
codigoBulto = random.randint(0, 999999999999)
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)], RDF.type,
Literal('BultoEnvio')))
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)], ECSDI.codigo,
Literal(codigoBulto)))
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)], ECSDI.estado,
Literal(1)))
gbultos.add((ECSDI['Bulto' + str(codigoBulto)],
ECSDI.asignado_a, URIRef(item1)))
for producto in l:
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)],
ECSDI.compuesto_por, URIRef(producto)))
gcentrosLogisticos.remove((item1, None, None))
for centro in gcentrosLogisticos.subjects(
predicate=RDF.type, object=Literal('CentroLogistico')):
l = []
for producto in gcopia.subjects(
predicate=RDF.type,
object=Literal('ProductoPropio')):
if (centro, ECSDI.dispone_de,
producto) in gcentrosLogisticos:
l.append(producto)
gcopia.remove((producto, None, None))
for producto in gcopia.subjects(
predicate=RDF.type,
object=Literal('ProductoAjenoEnvio')):
if (centro, ECSDI.dispone_de,
producto) in gcentrosLogisticos:
l.append(producto)
gcopia.remove((producto, None, None))
if not len(l) == 0:
print("he entrado en not len 0 2")
codigoBulto = random.randint(0, 999999999999)
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)], RDF.type,
Literal('BultoEnvio')))
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)], ECSDI.codigo,
Literal(codigoBulto)))
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)], ECSDI.estado,
Literal(1)))
gbultos.add((ECSDI['Bulto' + str(codigoBulto)],
ECSDI.asignado_a, URIRef(centro)))
for producto in l:
gbultos.add(
(ECSDI['Bulto' + str(codigoBulto)],
ECSDI.compuesto_por, URIRef(producto)))
for item2 in gbultos.subjects(predicate=RDF.type,
object=Literal('BultoEnvio')):
gpedidos.add((ECSDI['Pedido' + str(codigoPedido)],
ECSDI.compuesto_de, URIRef(item2)))
# gpedidos.add((ECSDI['Pedido' + str(codigoPedido)], ECSDI.realizada_por, URIRef(str(sujetoCliente))))
guardar_grafo_turtle(gpedidos, AgentUtil.Agents.path_pedidos)
gbultosTotales = cargar_grafo_turtle(
AgentUtil.Agents.path_bultos)
gbultosTotales += gbultos
guardar_grafo_turtle(gbultosTotales,
AgentUtil.Agents.path_bultos)
gr = build_message(
Graph(),
ACL.agree,
sender=AgentUtil.Agents.AgenteDistribuidorBultos.uri)
else:
gr = build_message(
Graph(),
ACL['not-understood'],
sender=AgentUtil.Agents.AgenteDistribuidorBultos.uri,
msgcnt=mss_cnt)
print("grafo")
print(gr)
# for sujeto in gr.subjects(predicate=ECSDI.tipo, object=Literal(criterios)):
# print("dentro chivato")
# variable = gr.value(subject=sujeto, predicate=ECSDI.nombre)
# print(variable)
return gr.serialize(format='xml')
def comunicacion():
"""
Entrypoint de comunicacion del agente
Simplemente retorna un objeto fijo que representa una
respuesta a una busqueda de actividades
Asumimos que se reciben siempre acciones que se refieren a lo que puede hacer
el agente (buscar con ciertas restricciones, reservar)
Las acciones se mandan siempre con un Request
Prodriamos resolver las busquedas usando una performativa de Query-ref
"""
global dsgraph
global mss_cnt
logger.info('Peticion de informacion recibida')
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=TravelServiceAgent.uri,
msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=TravelServiceAgent.uri,
msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
respuesta = Graph()
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
if accion == ECSDI.VIAJE:
c = gm.value(subject=content, predicate=ECSDI.City)
cultural = gm.value(subject=content,
predicate=ECSDI.Cultural)
festivas = gm.value(subject=content,
predicate=ECSDI.Festiva)
ludicas = gm.value(subject=content, predicate=ECSDI.Ludica)
solution = solver(c, cultural, festivas, ludicas)
for value in solution:
clave = value
valor = solution[value]
reg_obj = ECSDI[TravelServiceAgent.name + '-response' +
value]
respuesta.add((reg_obj, RDF.type, ECSDI.ACTIVITY))
respuesta.add((reg_obj, ECSDI.Nombre,
Literal(clave, datatype=XSD.string)))
respuesta.add((reg_obj, ECSDI.Tipo,
Literal(valor, datatype=XSD.string)))
gr = build_message(
respuesta,
ACL['inform'],
sender=TravelServiceAgent.uri,
msgcnt=mss_cnt,
receiver=msgdic['sender'],
)
else:
gr = build_message(
Graph(),
ACL['inform'],
sender=TravelServiceAgent.uri,
msgcnt=mss_cnt,
receiver=msgdic['sender'],
)
logger.info('Respondemos a la peticion')
mss_cnt += 1
return gr.serialize(format='xml')
def register():
"""
Entry point del agente que recibe los mensajes de registro
La respuesta es enviada al retornar la funcion,
no hay necesidad de enviar el mensaje explicitamente
Asumimos una version simplificada del protocolo FIPA-request
en la que no enviamos el mesaje Agree cuando vamos a responder
:return:
"""
def process_register():
# Si la hay extraemos el nombre del agente (FOAF.name), el URI del agente
# su direccion y su tipo
logger.info('Peticion de registro')
directory[FOAF.name] = (DSO.AgentType, DSO.Uri,
time.strftime('%Y-%m-%d %H:%M'))
agn_add = gm.value(subject=content, predicate=DSO.Address)
agn_name = gm.value(subject=content, predicate=FOAF.name)
agn_uri = gm.value(subject=content, predicate=DSO.Uri)
agn_type = gm.value(subject=content, predicate=DSO.AgentType)
# Añadimos la informacion en el grafo de registro vinculandola a la URI
# del agente y registrandola como tipo FOAF.Agent
dsgraph.add((agn_uri, RDF.type, FOAF.Agent))
dsgraph.add((agn_uri, FOAF.name, agn_name))
dsgraph.add((agn_uri, DSO.Address, agn_add))
dsgraph.add((agn_uri, DSO.AgentType, agn_type))
# Generamos un mensaje de respuesta
return build_message(Graph(),
ACL.confirm,
sender=DirectoryAgent.uri,
receiver=agn_uri,
msgcnt=mss_cnt)
def process_search():
# Asumimos que hay una accion de busqueda que puede tener
# diferentes parametros en funcion de si se busca un tipo de agente
# o un agente concreto por URI o nombre
# Podriamos resolver esto tambien con un query-ref y enviar un objeto de
# registro con variables y constantes
# Solo consideramos cuando Search indica el tipo de agente
# Buscamos una coincidencia exacta
# Retornamos el primero de la lista de posibilidades
logger.info('Peticion de busqueda')
agn_type = gm.value(subject=content, predicate=DSO.AgentType)
rsearch = dsgraph.triples((None, DSO.AgentType, agn_type))
if rsearch is not None:
agn_uri = next(rsearch)[0]
agn_add = dsgraph.value(subject=agn_uri, predicate=DSO.Address)
agn_name = dsgraph.value(subject=agn_uri, predicate=FOAF.name)
gr = Graph()
gr.bind('dso', DSO)
rsp_obj = agn['Directory-response']
gr.add((rsp_obj, DSO.Address, agn_add))
gr.add((rsp_obj, DSO.Uri, agn_uri))
gr.add((rsp_obj, DSO.Name, agn_name))
return build_message(gr,
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt,
receiver=agn_uri,
content=rsp_obj)
else:
# Si no encontramos nada retornamos un inform sin contenido
return build_message(Graph(),
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
global dsgraph
global mss_cnt
# Extraemos el mensaje y creamos un grafo con él
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if not msgdic:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
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=mss_cnt)
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 registro
if accion == DSO.Register:
gr = process_register()
# Accion de busqueda
elif accion == DSO.Search:
gr = process_search()
# No habia ninguna accion en el mensaje
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
mss_cnt += 1
return gr.serialize(format='xml')
