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 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 hacer_factura_externa(productos, precio, marca, tienda, id_compra,
id_usuario, direccion, codigo_postal, fecha_compra):
global mss_cnt
mss_cnt = mss_cnt + 1
graph = Graph()
factura = agn['factura_' + str(mss_cnt)]
graph.add((factura, RDF.type, Literal('factura')))
graph.add((factura, agn.id_compra, Literal(id_compra)))
fecha_recepcion = "Por definir"
graph.add((factura, agn.fecha_recepcion, Literal(fecha_recepcion)))
transportista = ""
First = True
for i in range(0, len(tienda), 1):
if (First):
transportista += str(tienda[i])
First = False
else:
transportista += ", " + str(tienda[i])
graph.add((factura, agn.transportista, Literal(transportista)))
# id usuario
graph.add((factura, agn.id_usuario, Literal(str(id_usuario))))
# prioridad envio
graph.add((factura, agn.prioridad_envio, Literal(0)))
# Direccion
graph.add((factura, agn.direccion, Literal(str(direccion))))
# Codigo postal
graph.add((factura, agn.codigo_postal, Literal(str(codigo_postal))))
# Fecha de compra
graph.add((factura, agn.fecha_compra, Literal(fecha_compra)))
# Productos
precio_total = 0
for i in range(0, len(productos), 1):
subject_producto = agn[productos[i] + '_' + str(i)]
graph.add((subject_producto, RDF.type, agn.product))
graph.add((subject_producto, agn.nombre, Literal(productos[i])))
graph.add((subject_producto, agn.precio, Literal(str(precio[i]))))
precio_total += int(precio[i])
graph.add((subject_producto, agn.tieneMarca, Literal(str(marca[i]))))
#afegir factura
graph.add((factura, agn.precio_total, Literal(precio_total)))
# Enviar mensaje
agente_ext_usuario = AsistenteCompra.directory_search(
DirectoryAgent, agn.AgenteExtUsuario)
message = build_message(graph,
perf=Literal('request'),
sender=AsistenteCompra.uri,
receiver=agente_ext_usuario.uri,
msgcnt=mss_cnt,
content=factura)
send_message(message, agente_ext_usuario.address)
return Graph().serialize(format='xml')
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 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 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 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 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():
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 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_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 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 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 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 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 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 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 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 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 express_behavior():
global mss_cnt
while True:
# Cada 3 minutos (mock) enviamos un mensaje al agente de "Enviar lotes preparados"
gr = Graph()
gr.bind('ab', AB)
content = AB[AgentUtil.Agents.AgenteCentroLogistico.name +
'-enviar-lotes']
gr.add((content, AB.prioridad, Literal('express')))
msg = build_message(
gr,
perf=ACL.request,
sender=AgentUtil.Agents.AgenteCentroLogistico.uri,
receiver=AgentUtil.Agents.AgenteCentroLogistico.uri,
content=content,
msgcnt=mss_cnt)
send_message(msg, AgentUtil.Agents.AgenteCentroLogistico.address)
mss_cnt += 1
time.sleep(60)
pass
pass
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 anadir_producto(request):
logger.info("Analizando petición de añadir producto")
id_producto = uuid.uuid4() #generate a random id
vendedor = request.form["id_vendedor"]
nombre = request.form["nombre_producto"]
precio = int(int(request.form["precio_producto"]) * 100)
peso = int(request.form["peso"])
marca = request.form["marca"]
categoria = request.form["categoria"]
descripcion = request.form["descripcion_producto"]
unidades = request.form["unidades"]
tarjeta = request.form["tarjeta"]
sujeto = ECSDIAmazon["Anadir_producto" + str(get_message_count())]
grafo = Graph()
grafo.add((sujeto, RDF.type, ECSDIAmazon.Anadir_producto))
grafo.add((sujeto, ECSDIAmazon.Id_producto,
Literal(id_producto, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Vendedor, Literal(vendedor, datatype=XSD.string)))
grafo.add((sujeto, ECSDIAmazon.Nombre_producto,
Literal(nombre, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Precio_producto, Literal(precio,
datatype=XSD.int)))
grafo.add((sujeto, ECSDIAmazon.Descripcion_producto,
Literal(descripcion, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Categoria, Literal(categoria,
datatype=XSD.string)))
grafo.add((sujeto, ECSDIAmazon.Marca, Literal(marca, datatype=XSD.string)))
grafo.add(
(sujeto, ECSDIAmazon.Peso_producto, Literal(peso, datatype=XSD.int)))
grafo.add(
(sujeto, ECSDIAmazon.Tarjeta, Literal(tarjeta, datatype=XSD.string)))
grafo.add((sujeto, ECSDIAmazon.Unidades, Literal(unidades,
datatype=XSD.int)))
# logger.info("Cogiendo informacion del AgenteGestorDeProductos")
agente = get_agent_info(agn.AgenteGestorDeProductos, DirectoryAgent,
AgenteVendedorExterno, get_message_count())
logger.info(
"Enviando peticion de anadir producto al AgenteGestorDeProductos")
respuesta_msg = send_message(
build_message(grafo,
perf=ACL.request,
sender=AgenteVendedorExterno.uri,
receiver=agente.uri,
msgcnt=get_message_count(),
content=sujeto), agente.address)
return render_template('prod_anadido.html')
def 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 informar_envio_iniciado(compras_enviadas, transportista, fecha_recepcion):
global mss_cnt
logging.info('Transportista del pedido: ' + transportista.name)
for id_compra in compras_enviadas:
mss_cnt = mss_cnt + 1
graph = Graph()
logging.info(str(id_compra))
predicado = agn['informar_envio_iniciado_' + str(mss_cnt)]
graph.add((predicado, RDF.type, Literal('Informar_Envio_Iniciado')))
graph.add((predicado, agn.id_compra, Literal(id_compra)))
graph.add((predicado, agn.transportista, Literal(transportista.name)))
graph.add((predicado, agn.fecha_recepcion, Literal(fecha_recepcion)))
asistente_compra = CentroLogistico.directory_search(
DirectoryAgent, agn.AsistenteCompra)
message = build_message(graph,
perf=Literal('request'),
sender=CentroLogistico.uri,
receiver=asistente_compra.uri,
msgcnt=mss_cnt,
content=predicado)
send_message(message, asistente_compra.address)
def notificar_cobro(req, content):
global mss_cnt
mss_cnt = mss_cnt + 1
tienda = req.value(content, agn.tienda)
logging.info("Se informará del cobro a la tienda externa " + str(tienda))
precio = req.value(content, agn.precio)
TiendaExterna = ComunicadorExterno.directory_search(
DirectoryAgent, agn.AgenteExtTiendaExterna)
gNotificarCobro = Graph()
notificarCobro = agn['notificarCobro_' + str(mss_cnt)]
gNotificarCobro.add((notificarCobro, RDF.type, Literal('NotificarCobro')))
gNotificarCobro.add((notificarCobro, agn.precio, Literal(precio)))
TiendaExterna = TiendaExterna.directory_search(DirectoryAgent,
agn.AgenteExtTiendaExterna)
message = build_message(gNotificarCobro,
perf=Literal('request'),
sender=ComunicadorExterno.uri,
receiver=TiendaExterna.uri,
msgcnt=mss_cnt,
content=notificarCobro)
send_message(message, TiendaExterna.address)
return Graph().serialize(format='xml')
def envia_prod_tiendaExt(direccion, codigo_postal, nombre, prioridad_envio,
peso, tienda):
global mss_cnt
mss_cnt = mss_cnt + 1
gEnviaProd = Graph()
enviaProd = agn['enviar_prod_tienda_externa_' + str(mss_cnt)]
gEnviaProd.add((enviaProd, RDF.type, Literal('EnviarProdTiendaExterna')))
gEnviaProd.add((enviaProd, agn.nombre_prod, Literal(nombre)))
gEnviaProd.add((enviaProd, agn.peso, Literal(peso)))
gEnviaProd.add((enviaProd, agn.direccion, Literal(direccion)))
gEnviaProd.add((enviaProd, agn.cp, Literal(codigo_postal)))
gEnviaProd.add((enviaProd, agn.prioridad_envio, Literal(prioridad_envio)))
gEnviaProd.add((enviaProd, agn.tienda, Literal(tienda)))
comunicadorExterno = AsistenteCompra.directory_search(
DirectoryAgent, agn.ComunicadorExterno)
message = build_message(gEnviaProd,
perf=Literal('request'),
sender=AsistenteCompra.uri,
receiver=comunicadorExterno.uri,
msgcnt=mss_cnt,
content=enviaProd)
send_message(message, comunicadorExterno.address)
def buscarActivitats(destino, ludicas, festivas, cultural, q3):
global mss_cnt
global actividades
global activ
gr = directory_search_message(DSO.TravelServiceAgent)
logger.info('Enviamos informacion a activitats')
grafo = Graph()
reg_obj = ECSDI[Solver.name + '-info-sendAc']
grafo.add((reg_obj, RDF.type, ECSDI.VIAJE))
grafo.add((reg_obj, ECSDI.City, Literal(destino, datatype=XSD.string)))
grafo.add((reg_obj, ECSDI.Cultural, Literal(cultural,
datatype=XSD.string)))
grafo.add((reg_obj, ECSDI.Festiva, Literal(festivas, datatype=XSD.string)))
grafo.add((reg_obj, ECSDI.Ludica, Literal(ludicas, datatype=XSD.string)))
msg = gr.value(predicate=RDF.type, object=ACL.FipaAclMessage)
content = gr.value(subject=msg, predicate=ACL.content)
ragn_addr = gr.value(subject=content, predicate=DSO.Address)
ragn_uri = gr.value(subject=content, predicate=DSO.Uri)
msg = build_message(grafo,
perf=ACL.request,
sender=Solver.uri,
receiver=ragn_uri,
content=reg_obj,
msgcnt=mss_cnt)
gr_act = send_message(msg, ragn_addr)
i = 0
for objects in gr_act.subjects(RDF.type, ECSDI.ACTIVITY):
nom = gr_act.value(subject=objects, predicate=ECSDI.Nombre)
tipo = gr_act.value(subject=objects, predicate=ECSDI.Tipo)
actividades[i] = [nom, tipo]
i += 1
logger.info('Respuesta activitats recibida')
mss_cnt += 1
for i in range(len(actividades)):
if str(actividades[i][1]) == "L":
actividades[i][1] = "Lúdica"
elif str(actividades[i][1]) == "F":
actividades[i][1] = "Festiva"
elif str(actividades[i][1]) == "C":
actividades[i][1] = "Cultural"
else:
actividades[i][1] = "Lúdica"
activ[i] = [
'REQACTIVITAT', destino, actividades[i][0], actividades[i][1],
"01/01/1970", "------"
]
q3.put(activ)
def comprarRecomendado(grRecomendado):
logger.info("Comprando producto recomendado")
gmess = Graph()
sj_contenido = agn[AgenteCliente.name + '-Peticion_Compra-' + str(mss_cnt)]
gmess.add((sj_contenido, RDF.type, AM2.Peticion_Compra))
gmess.add((sj_contenido, AM2.username, Literal(username)))
productSubject = grRecomendado.value(predicate=RDF.type,
object=AM2.Producto)
gmess.add((productSubject, RDF.type, AM2['Producto']))
gmess += grRecomendado.triples((productSubject, None, None))
gmess.add((sj_contenido, AM2.Productos, URIRef(productSubject)))
vendedor = directory_search_agent(DSO.AgenteVentaProductos, AgenteCliente,
DirectoryAgent, mss_cnt)[0]
msg = build_message(gmess,
perf=ACL.request,
sender=AgenteCliente.uri,
receiver=vendedor.uri,
content=sj_contenido,
msgcnt=mss_cnt)
# print("message BUILD")
send_message(msg, vendedor.address)
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 infoagent_search_message(addr, ragn_uri, gmess, msgResult):
"""
Envia una accion a un agente de informacion
"""
logger.info('Hacemos una peticion al servicio de informacion')
msg = build_message(gmess, perf=ACL.request,
sender=AgentTiendaExterna.uri,
receiver=ragn_uri,
msgcnt=get_count(),
content=msgResult)
gr = send_message(msg, addr)
logger.info('Recibimos respuesta a la peticion al servicio de informacion')
return gr
def buscarAllotjament(fecha_ini, fecha_fin, destino, q2):
"""
Un comportamiento del agente
:return:
"""
# Buscamos en el directorio
# un agente de hoteles
global mss_cnt
global alojamientos
global allot
gr = directory_search_message(DSO.HotelsAgent)
logger.info('Enviamos informacion a allotjament')
grafo = Graph()
reg_obj = ECSDI[Solver.name + '-info-sendAl']
grafo.add((reg_obj, RDF.type, ECSDI.VIAJE))
grafo.add((reg_obj, ECSDI.City, Literal(destino, datatype=XSD.string)))
msg = gr.value(predicate=RDF.type, object=ACL.FipaAclMessage)
content = gr.value(subject=msg, predicate=ACL.content)
ragn_addr = gr.value(subject=content, predicate=DSO.Address)
ragn_uri = gr.value(subject=content, predicate=DSO.Uri)
msg = build_message(grafo,
perf=ACL.request,
sender=Solver.uri,
receiver=ragn_uri,
content=reg_obj,
msgcnt=mss_cnt)
gr_transp = send_message(msg, ragn_addr)
i = 0
for objects in gr_transp.subjects(RDF.type, ECSDI.ALOJAMIENTO):
nom = gr_transp.value(subject=objects, predicate=ECSDI.Nombre)
precio = gr_transp.value(subject=objects, predicate=ECSDI.Precio)
alojamientos[i] = [nom, precio]
i += 1
logger.info('Respuesta allotjament recibida')
mss_cnt += 1
for i in range(len(alojamientos)):
allot[i] = [
'REQALLOTJAMENT', fecha_ini, fecha_fin, destino,
alojamientos[i][0], alojamientos[i][1]
]
q2.put(allot)
def sendProductoRecomendado(productoRecomendado, agenteCliente):
grecommend = Graph()
sj_contenido = AM2[AgenteRecomendador.name + '-Recomendacion-' +
str(mss_cnt)]
grecommend.add((sj_contenido, RDF.type, AM2.Recomendacion))
grecommend += productoRecomendado
grm = build_message(grecommend,
perf=ACL.request,
sender=AgenteRecomendador.uri,
receiver=agenteCliente.uri,
content=sj_contenido,
msgcnt=mss_cnt)
gr = send_message(grm, agenteCliente.address)
logger.info('Se ha enviado una recomendacion a un cliente')
def buscarTransport(fecha_ini, fecha_fin, origen, destino, q1):
global mss_cnt
global transportes
global transp
gr = directory_search_message(DSO.FlightsAgent)
logger.info('Enviamos informacion a transport')
grafo = Graph()
reg_obj = ECSDI[Solver.name + '-info-sendTran']
grafo.add((reg_obj, RDF.type, ECSDI.VIAJE))
grafo.add(
(reg_obj, ECSDI.FechaInicio, Literal(fecha_ini, datatype=XSD.string)))
grafo.add(
(reg_obj, ECSDI.FechaFinal, Literal(fecha_fin, datatype=XSD.string)))
grafo.add((reg_obj, ECSDI.CityIN, Literal(origen, datatype=XSD.string)))
grafo.add((reg_obj, ECSDI.CityFIN, Literal(destino, datatype=XSD.string)))
msg = gr.value(predicate=RDF.type, object=ACL.FipaAclMessage)
content = gr.value(subject=msg, predicate=ACL.content)
ragn_addr = gr.value(subject=content, predicate=DSO.Address)
ragn_uri = gr.value(subject=content, predicate=DSO.Uri)
msg = build_message(grafo,
perf=ACL.request,
sender=Solver.uri,
receiver=ragn_uri,
content=reg_obj,
msgcnt=mss_cnt)
gr_allot = send_message(msg, ragn_addr)
i = 0
for objects in gr_allot.subjects(RDF.type, ECSDI.Transporte):
nom = gr_allot.value(subject=objects, predicate=ECSDI.Nombre)
precio = gr_allot.value(subject=objects, predicate=ECSDI.Precio)
transportes[i] = [nom, precio]
i += 1
logger.info('Respuesta transport recibida')
mss_cnt += 1
for i in range(len(transportes)):
transp[i] = [
'REQTRANSPORT', fecha_ini, fecha_fin, origen, destino,
transportes[i][0], transportes[i][1], 0.00
]
q1.put(transp)
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 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
"""
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 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
