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():
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 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)
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)
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 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)
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():
"""
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 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
"""
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():
"""
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 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 negociaEnvio():
logger.info('Negociando el envio con transportistas')
global mss_cnt
gmess = Graph()
sj_contenido = MSG[AgenteAlmacen.name + '-Pedir_precio_envio-' + str(mss_cnt)]
gmess.add((sj_contenido, RDF.type, AM2.Pedir_precio_envio))
agentesTransportistas = directory_search_agent(DSO.AgenteTransportista,AgenteAlmacen,DirectoryAgent,mss_cnt)
mejorOferta = sys.maxint
for agenteTransportista in agentesTransportistas:
grm = build_message(gmess,
perf=ACL.request,
sender=AgenteAlmacen.uri,
receiver=agenteTransportista.uri,
content=sj_contenido,
msgcnt=mss_cnt)
gr = send_message(grm,agenteTransportista.address)
sj_precios = gr.value(predicate = RDF.type, object = AM2['Precios_envio'])
precio = gr.value(sj_precios,AM2.precioEnvioTransportista)
if int(precio)<mejorOferta:
mejorOferta = int(precio)
agenteElegido = agenteTransportista
logger.info(agenteElegido.name)
transportistaContraoferta = contraOfertaEnvio(mejorOferta,agentesTransportistas)
if(agenteElegido.name != transportistaContraoferta.name):
logger.info("Se ha mejorado la oferta")
logger.info(transportistaContraoferta.name)
def contraOfertaEnvio(mejorOferta, agentesTransportistas):
logger.info("Realizando Contraoferta")
gmess = Graph
precioContraoferta = mejorOferta -10
gmess = Graph()
sj_contenido = MSG[AgenteAlmacen.name + '-Contraoferta_envio-' + str(mss_cnt)]
gmess.add((sj_contenido, RDF.type, AM2.Contraoferta_envio))
sj_contraoferta = AM2['Contraoferta' + str(mss_cnt)]
gmess.add((sj_contraoferta, RDF.type, AM2['Contraoferta']))
gmess.add((sj_contraoferta, AM2.precioContraoferta, Literal(precioContraoferta)))
gmess.add((sj_contenido, AM2.tieneContraoferta, URIRef(sj_contraoferta)))
for agenteTransportista in agentesTransportistas:
grm= build_message(gmess,
perf=ACL.request,
sender=AgenteAlmacen.uri,
receiver=agenteTransportista.uri,
content=sj_contenido,
msgcnt=mss_cnt)
gr = send_message(grm,agenteTransportista.address)
sj_precios = gr.value(predicate = RDF.type, object = AM2['Precios_envio'])
precio = gr.value(sj_precios,AM2.precioEnvioTransportista)
if int(precio)<mejorOferta:
mejorOferta = int(precio)
agenteElegidoContraoferta = agenteTransportista
return agenteElegidoContraoferta
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 pagarTiendaExterna(req, content):
global mss_cnt
mss_cnt = mss_cnt + 1
logging.info("Se empezará a realizar el pago a la tienda externa")
cuenta_bancaria = req.value(content, agn.cuenta_bancaria)
precio = req.value(content, agn.precio)
nombreProd = req.value(content, agn.nombre_prod)
AgenteExtEntidadBancaria = Pagador.directory_search(DirectoryAgent, agn.AgenteExtEntidadBancaria)
gCobrarP = Graph()
cobrarP = agn['pagar_tienda_externa' + str(mss_cnt)]
gCobrarP.add((cobrarP, RDF.type, Literal('PagarTiendaExterna')))
gCobrarP.add((cobrarP, agn.cuenta_bancaria, Literal(cuenta_bancaria)))
gCobrarP.add((cobrarP, agn.precio, Literal(precio)))
gCobrarP.add((cobrarP, agn.nombre_prod, Literal(nombreProd)))
message = build_message(
gCobrarP,
perf=Literal('request'),
sender=Pagador.uri,
receiver=AgenteExtEntidadBancaria.uri,
msgcnt=mss_cnt,
content=cobrarP
)
response = send_message(message, AgenteExtEntidadBancaria.address)
respuesta_cobro = ""
for item in response.subjects(RDF.type, Literal('PagoRealizado')):
for cobroRelalizado in response.objects(item, agn.respuesta):
respuesta_cobro = str(cobroRelalizado)
logging.info(respuesta_cobro)
gRespuestaCobro = Graph()
RespuestaCobro = agn['RespuestaPago' + str(mss_cnt)]
gRespuestaCobro.add((RespuestaCobro, RDF.type, Literal('RespuestaPago')))
gRespuestaCobro.add((RespuestaCobro, agn.respuesta_cobro, Literal(respuesta_cobro)))
return gRespuestaCobro.serialize(format='xml')
def notificar_envio_tienda_externa(req, content):
global mss_cnt
mss_cnt = mss_cnt + 1
tienda = req.value(content, agn.tienda)
nombreProd = req.value(content, agn.nombre_prod)
logging.info("Se informará a la tienda " + str(tienda) +
" sobre el enviamento del producto " + str(nombreProd))
peso = req.value(content, agn.peso)
cp = req.value(content, agn.cp)
direccion = req.value(content, agn.direccion)
prioridad_envio = req.value(content, agn.prioridad_envio)
TiendaExterna = ComunicadorExterno.directory_search(
DirectoryAgent, agn.AgenteExtTiendaExterna)
gEnvio = Graph()
envio = agn['envio_tienda_externa' + str(mss_cnt)]
gEnvio.add((envio, RDF.type, Literal('EnvioTiendaExterna')))
gEnvio.add((envio, agn.nombre_prod, Literal(nombreProd)))
gEnvio.add((envio, agn.peso, Literal(peso)))
gEnvio.add((envio, agn.cp, Literal(cp)))
gEnvio.add((envio, agn.direccion, Literal(direccion)))
gEnvio.add((envio, agn.prioridad_envio, Literal(prioridad_envio)))
message = build_message(gEnvio,
perf=Literal('request'),
sender=ComunicadorExterno.uri,
receiver=TiendaExterna.uri,
msgcnt=mss_cnt,
content=envio)
send_message(message, TiendaExterna.address)
return Graph().serialize(format='xml')
def directory_search_message(type):
"""
Busca en el servicio de registro mandando un
mensaje de request con una accion Seach del servicio de directorio
Podria ser mas adecuado mandar un query-ref y una descripcion de registo
con variables
:param type:
:return:
"""
global mss_cnt
logger.info('Buscamos en el servicio de registro')
gmess = Graph()
gmess.bind('foaf', FOAF)
gmess.bind('dso', DSO)
reg_obj = agn[AgentePersonal.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=AgentePersonal.uri,
receiver=DirectoryAgent.uri,
content=reg_obj,
msgcnt=mss_cnt)
gr = send_message(msg, DirectoryAgent.address)
mss_cnt += 1
logger.info('Recibimos informacion del agente')
return gr
def directory_search_message(type):
"""
Busca en el servicio de registro mandando un
mensaje de request con una accion Seach del servicio de directorio
Podria ser mas adecuado mandar un query-ref y una descripcion de registo
con variables
:param type:
:return:
"""
logger.info('Buscamos en el servicio de registro')
gmess = Graph()
gmess.bind('foaf', FOAF)
gmess.bind('dso', DSO)
reg_obj = agn[AgentClient.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=AgentClient.uri,
receiver=DirectoryAgent.uri,
content=reg_obj,
msgcnt=get_count())
gr = send_message(msg, DirectoryAgent.address)
logger.info('Recibimos informacion del agente')
return gr
def agentbehavior1(cola):
"""
Un comportamiento del agente
:return:
"""
global mss_cnt
logger.info('Nos registramos en el servicio de registro')
register_message(DSO.AgenteLogistico, AgenteLogistico, DirectoryAgent,
mss_cnt)
fin = False
while not fin:
while cola.empty():
pass
gmess = cola.get()
if gmess == 0:
fin = True
else:
agenteVendedorExterno = directory_search_agent(
DSO.AgenteVendedorExterno, AgenteLogistico, DirectoryAgent,
mss_cnt)[0]
content = gmess.value(predicate=RDF.type,
object=AM2.Avisar_vendedor_externo_envio)
grm = build_message(gmess,
perf=ACL.request,
sender=AgenteLogistico.uri,
receiver=agenteVendedorExterno.uri,
content=content,
msgcnt=mss_cnt)
send_message(grm, agenteVendedorExterno.address)
logger.info(
'Se ha notificado al vendedor externo para que se encargue del envio'
)
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 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 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 register_message():
"""
Envia un mensaje de registro al servicio de registro
usando una performativa Request y una accion Register del
servicio de directorio
:param gmess:
:return:
"""
global mss_cnt
gmess = Graph()
# Construimos el mensaje de registro
gmess.bind('foaf', FOAF)
gmess.bind('dso', DSO)
reg_obj = agn[InfoAgent.name+'-Register']
gmess.add((reg_obj, RDF.type, DSO.Register))
gmess.add((reg_obj, DSO.Uri, InfoAgent.uri))
gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name)))
gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address)))
gmess.add((reg_obj, DSO.AgentType, DSO.HotelsAgent))
# Lo metemos en un envoltorio FIPA-ACL y lo enviamos
gr = send_message(
build_message(gmess, perf= ACL.request,
sender= InfoAgent.uri,
receiver= AgentDirectori.uri,
content= reg_obj,
msgcnt= mss_cnt),
AgentDirectori.address)
mss_cnt += 1
return gr
def cobrar(req, content):
global mss_cnt
mss_cnt = mss_cnt + 1
logging.info("Se empezará a cobrar el pedido")
tarjeta_bancaria = req.value(content, agn.tarjeta_bancaria)
precio_total = req.value(content, agn.precio_total)
AgenteExtEntidadBancaria = Pagador.directory_search(DirectoryAgent, agn.AgenteExtEntidadBancaria)
gCobrarP = Graph()
cobrarP = agn['cobrarP_' + str(mss_cnt)]
gCobrarP.add((cobrarP, RDF.type, Literal('CobrarP')))
gCobrarP.add((cobrarP, agn.tarjeta_bancaria, Literal(tarjeta_bancaria)))
gCobrarP.add((cobrarP, agn.precio_total, Literal(precio_total)))
message = build_message(
gCobrarP,
perf=Literal('request'),
sender=Pagador.uri,
receiver=AgenteExtEntidadBancaria.uri,
msgcnt=mss_cnt,
content=cobrarP
)
response = send_message(message, AgenteExtEntidadBancaria.address)
respuesta_cobro = ""
for item in response.subjects(RDF.type, Literal('CobroRealizado')):
for cobroRelalizado in response.objects(item, agn.respuesta):
respuesta_cobro = str(cobroRelalizado)
logging.info(respuesta_cobro)
gRespuestaCobro = Graph()
RespuestaCobro = agn['RespuestaCobro_' + str(mss_cnt)]
gRespuestaCobro.add((RespuestaCobro, RDF.type, Literal('RespuestaCobro')))
gRespuestaCobro.add((RespuestaCobro, agn.respuesta_cobro, Literal(respuesta_cobro)))
return gRespuestaCobro.serialize(format='xml')
def infoagent_search_message(addr, ragn_uri):
"""
Envia una accion a un agente de informacion
"""
global mss_cnt
logger.info('Hacemos una peticion al servicio de informacion')
gmess = Graph()
# Supuesta ontologia de acciones de agentes de informacion
IAA = Namespace('IAActions')
gmess.bind('foaf', FOAF)
gmess.bind('iaa', IAA)
reg_obj = agn[AgentePersonal.name + '-info-search']
gmess.add((reg_obj, RDF.type, IAA.Search))
msg = build_message(gmess, perf=ACL.request,
sender=AgentePersonal.uri,
receiver=ragn_uri,
msgcnt=mss_cnt)
gr = send_message(msg, addr)
mss_cnt += 1
logger.info('Recibimos respuesta a la peticion al servicio de informacion')
return gr
def infoagent_search_message(addr, ragn_uri):
"""
Envia una accion a un agente de informacion
"""
global mss_cnt
logger.info('Hacemos una peticion al servicio de informacion')
gmess = Graph()
# Supuesta ontologia de acciones de agentes de informacion
IAA = Namespace('IAActions')
gmess.bind('foaf', FOAF)
gmess.bind('iaa', IAA)
reg_obj = agn[AgenteCliente.name + '-info-search']
gmess.add((reg_obj, RDF.type, IAA.Search))
msg = build_message(gmess,
perf=ACL.request,
sender=AgenteCliente.uri,
receiver=ragn_uri,
msgcnt=mss_cnt)
gr = send_message(msg, addr)
mss_cnt += 1
logger.info('Recibimos respuesta a la peticion al servicio de informacion')
return gr
def register():
global mss_cnt
logger.info("Nos registramos")
gmess = Graph()
gmess.bind('foaf', FOAF)
gmess.bind('dso', DSO)
reg_obj = agn[AgenteNegociadorTiendasExternas.name + '-Register']
gmess.add((reg_obj, RDF.type, DSO.Register))
gmess.add((reg_obj, DSO.Uri, AgenteNegociadorTiendasExternas.uri))
gmess.add(
(reg_obj, FOAF.name, Literal(AgenteNegociadorTiendasExternas.name)))
gmess.add((reg_obj, DSO.Address,
Literal(AgenteNegociadorTiendasExternas.address)))
gmess.add((reg_obj, DSO.AgentType, agn.AgenteNegociadorTiendasExternas))
gr = send_message(
build_message(gmess,
perf=ACL.request,
sender=AgenteNegociadorTiendasExternas.uri,
receiver=AgenteDirectorio.uri,
content=reg_obj,
msgcnt=mss_cnt), AgenteDirectorio.address)
mss_cnt += 1
return gr
def proponer_oferta(oferta):
global mss_cnt
transportista = AgentUtil.Agents.AgenteTransportista if str(oferta.transportista) == 'SEUR' else \
AgentUtil.Agents.AgenteTransportista2
gmess = Graph()
gmess.bind('ab', AB)
nuevo_precio = float(oferta.precio) - (float(oferta.precio) / 10.0)
content = AB[AgentUtil.Agents.AgenteCentroLogistico.name +
'-proponer-oferta']
gmess.add((content, AB.id, Literal(oferta.id)))
gmess.add((content, AB.precio, Literal(nuevo_precio)))
logger.info("[#] Proponiendo oferta a %s y bajando el precio de %s a %s" %
(oferta.transportista, oferta.precio, nuevo_precio))
msg = build_message(gmess,
perf=ACL.propose,
sender=AgentUtil.Agents.AgenteCentroLogistico.uri,
receiver=transportista.uri,
content=content,
msgcnt=mss_cnt)
res = send_message(msg, transportista.address)
mss_cnt += 1
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 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():
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 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 browser_purchase():
global mss_cnt
gmess = Graph()
msg = build_message(gmess,
perf=ACL.inform,
sender=AgentUtil.Agents.AgenteVendedor.uri,
receiver=AgentUtil.Agents.AgenteCentroLogistico.uri,
msgcnt=mss_cnt)
gr = send_message(msg, AgentUtil.Agents.AgenteCentroLogistico.address)
mss_cnt += 1
return gr
def demanar_paquet (gmess):
"""
Envia la peticio d'un paquet vacances amb les preferencies de l'usuari
"""
global mss_cnt
msg = build_message(gmess, perf=ACL.request,
sender=AgentUsuari.uri,
receiver=AgentSistema.uri,
msgcnt=mss_cnt)
gr = send_message(msg, AgentSistema.address)
mss_cnt += 1
return gr
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 process_register():
# Si la hay extraemos el nombre del agente (FOAF.Name), el URI del agente
# su direccion y su tipo
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=AgentDirectori.uri,
receiver=agn_uri,
msgcnt=mss_cnt)
def test():
gmess = Graph()
# Construimos el mensaje de registro
gmess.bind('foaf', FOAF)
gmess.bind('dso', DSO)
reg_obj = agn[InfoAgent.name + '-Register']
gmess.add((reg_obj, RDF.type, DSO.Register))
gmess.add((reg_obj, DSO.Uri, InfoAgent.uri))
gmess.add((reg_obj, FOAF.Name, Literal(InfoAgent.name)))
gmess.add((reg_obj, DSO.Address, Literal(InfoAgent.address)))
gmess.add((reg_obj, DSO.AgentType, DSO.HotelsAgent))
# Lo metemos en un envoltorio FIPA-ACL y lo enviamos
gr = send_message(
build_message(gmess, perf=ACL.request,
sender=InfoAgent.uri,
receiver=DirectoryAgent.uri,
content=reg_obj,
msgcnt=mss_cnt),
DirectoryAgent.address)
def infoagent_search_message(addr, ragn_uri, gmess):
"""
Envia una accion a un agente de informacion
"""
global mss_cnt
"""gmess = Graph()
# Supuesta ontologia de acciones de agentes de informacion
IAA = Namespace('IAActions')
gmess.bind('foaf', FOAF)
gmess.bind('iaa', IAA)
reg_obj = agn[AgentSistema.name+'-info-search']
gmess.add((reg_obj, RDF.type, IAA.Search))"""
msg = build_message(gmess, perf=ACL.request,
sender=AgentSistema.uri,
receiver=ragn_uri,
msgcnt=mss_cnt)
gr = send_message(msg, addr)
mss_cnt += 1
return gr
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
"""
res_obj= agn['Planificador-responde']
gr = Graph()
gr.add((res_obj, DSO.AddressList, Literal(cont)))
gr = build_message(gr,
ACL.inform,
sender=AgentBuscador.uri,
content=res_obj,
msgcnt=mss_cnt
)
resp = gr.serialize(format='xml')
return resp
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 comu():
global mss_cnt
# Graph para buscador
gmess = Graph()
gmess.bind('myns_pet', myns_pet)
gmess.bind('myns_atr', myns_atr)
###########################################################
# Comunicar con buscador
print "Los parametros hardcoreado"
#############################################################
destination = "Madrid, Spain"
actividades= [types.TYPE_MOVIE_THEATER, types.TYPE_CASINO, types.TYPE_MUSEUM]
radius = 20000
departureDate="2015-08-20"
returnDate="2015-08-30"
maxPrice=500
originCity="Amsterdam"
destinationCity="Barcelona"
destinationCountry="Spain"
searchRadius=2
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))
###########################################################
# 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
# 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
return grep
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
#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=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
## Por ahora simplemente retornamos un Inform-done
#gr = build_message(Graph(),
#ACL['inform-done'],
#sender=InfoAgent.uri,
#msgcnt=mss_cnt,
#receiver=msgdic['sender'], )
#mss_cnt += 1
#logger.info('Respondemos a la peticion')
# gr = build_message(gmess, perf=ACL.request,
# sender=AgentePlanificador.uri,
# receiver=AgenteBuscador.uri,
# content=bus_obj,
# msgcnt=mss_cnt),
# AgenteBuscador.address)
res_obj= agn['Planificador-responde']
gr = Graph()
gr.add((res_obj, DSO.AddressList, Literal(cont)))
gr = build_message(gr,
ACL.inform,
sender=AgentBuscador.uri,
content=res_obj,
msgcnt=mss_cnt
)
resp = gr.serialize(format='xml')
return resp
def message_dialogador(cityOrigin = "Barcelona",
cityDestination = "London",
departureDate = datetime.date(2015, 9, 8),
returnDate = datetime.date(2015, 9, 20),
maxPrice = 500,
numberOfStars = 3,
actividades = ["Movie", "Casino", "Theater"]
):
#Preguntamos al usuario sus preferencias
print ('Welcome to Bestrip! The best trip search engine in the world!' + '\n')
print ('Please, answer these questions to find your trip!' + '\n')
# cityDestination = raw_input ('Where do you want to go?' + '\n')
# cityOrigin = raw_input ('Where are you?' + '\n')
# departureDate = raw_input ('When do you want to go? (Format : dd/mm/yyyy)' + '\n' )
# returnDate = raw_input ('When do you want to return? (Format : dd/mm/yyyy)' + '\n' )
# maxPrice = raw_input('Which is the maximum price that a trip must have?' + '\n')
# numberOfStars = raw_input ('How many stars the hotel must have ?' + '\n')
# activities = raw_input ('Tell us about the kind of activities you like! (Format:separate using commas for each preference)' + '\n')
# transport = raw_input ('Would you like to use public transport during your trip? (Yes / No)' + '\n')
print ('Thank you very much, finding the best trip according to your preferences ... ' + '\n')
#cont = city + "#" + departureDate + "#" + returnDate + "#" + maxPrice + "#" + numberOfStars + "#" + activities + "#" + transport
gmess = Graph()
gmess.bind('myns_pet', myns_pet)
gmess.bind('myns_atr', myns_atr)
peticion = myns_pet["Dialogador-pide-paquete"]
gmess.add((peticion, myns_atr.originCity, Literal(cityOrigin)))
gmess.add((peticion, myns_atr.destinationCity, Literal(cityDestination)))
gmess.add((peticion, myns_atr.departureDate, Literal(departureDate)))
gmess.add((peticion, myns_atr.returnDate, Literal(returnDate)))
gmess.add((peticion, myns_atr.maxPrice, Literal(maxPrice)))
gmess.add((peticion, myns_atr.propertyCategory, Literal(numberOfStars)))
#for a in activities
i = 0
for a in actividades:
i+= 1
actv = "actividad" + str(i)
gmess.add((peticion, myns_atr.actividad, myns_act.actv))
gmess.add((myns_act.actv, myns_atr.tipo, Literal(a)))
#gmess.add((peticion, myns_atr.useTransportPublic, Literal(transport)))
# # Construimos el mensaje de registro
gmess.bind('amo', AMO)
bus_obj = agn[AgenteDialog.name + '-Request']
gmess.add((bus_obj, AMO.requestType, Literal('Actividad')))
# Lo metemos en un envoltorio FIPA-ACL y lo enviamos
gr = send_message(
build_message(gmess, perf=ACL.request,
sender=AgenteDialog.uri,
receiver=AgentePlanificador.uri,
content=bus_obj,
msgcnt=mss_cnt),
AgentePlanificador.address)
return gr
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 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')
