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():
global dsgraph
global mss_cnt
gr = None
logger.info('Peticion de info recibida')
# Extraemos el mensaje que nos envian
mensaje = request.args['content']
gm = Graph()
gm.parse(data=mensaje)
msgdic = get_message_properties(gm)
# Comprobacion del mensaje
if msgdic is None:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteComprador.uri,
msgcnt=get_n_message())
else:
performative = msgdic['performative']
if performative != ACL.request:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteComprador.uri,
msgcnt=get_n_message())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
logger.info('Recibida una petición en AgenteComprador')
print('Recibida una petición en AgenteComprador')
if accion == ECSDI.Peticion_compra:
logger.info('Recibida peticion compra')
compra = None
for item in gm.subjects(RDF.type, ECSDI.Compra):
compra = item
gm.remove((content, None, None))
for item in gm.subjects(RDF.type, ACL.FipaAclMessage):
gm.remove((item, None, None))
registerSells(gm)
payDelivery(compra)
logger.info('Envio la factura de la venda con id ' + compra +
'al usuario comprador.')
gr = sendSell(gm, compra)
logger.info('Respondemos a la peticion')
return gr.serialize(format='xml'), 200
pass
def comunicacion():
global dsgraph
global mss_cnt
gr = None
logger.info('Peticion de recomendacion recibida')
# Extraemos el mensaje que nos envian
mensaje = request.args['content']
gm = Graph()
gm.parse(data=mensaje)
msgdic = get_message_properties(gm)
#Comprobacion del mensaje
if msgdic is None:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteValoraciones.uri,
msgcnt=get_count())
else:
performative = msgdic['performative']
if performative != ACL.request:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteValoraciones.uri,
msgcnt=get_count())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
if accion == ECSDI.Peticion_Valorados:
get_all_sells()
if compras.__len__() == 0:
g = Graph()
serialize = g.serialize(format='xml')
return serialize, 200
gr = findValProducts()
logger.info('Respondemos a la peticion')
print('Respondemos a la peticion')
serialize = gr.serialize(format='xml')
return serialize, 200
elif accion == ECSDI.Peticion_valorar:
print('Valoramos los productos')
for item in gm.subjects(RDF.type, ACL.FipaAclMessage):
gm.remove((item, None, None))
for item in gm.subjects(RDF.type, ECSDI.Peticion_valorar):
gm.remove((item, None, None))
guardarValoraciones(gm)
serialize = gm.serialize(format='xml')
return serialize, 200
def comunicacion():
"""
Entrypoint de comunicacion del agente
"""
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=ExternalTransportAgent1.uri,
msgcnt=mss_cnt)
else:
if msgdic['performative'] == ACL['accept-proposal']:
logger.info('Nuestra oferta ha sido aceptada')
print('Nuestra oferta ha sido aceptada')
return build_message(
Graph(), perf=ACL.inform,
sender=ExternalTransportAgent1.uri).serialize()
if msgdic['performative'] == ACL['reject-proposal']:
logger.info('La oferta ha sido rechazada')
print('La oferta ha sido rechazada')
ExternalTransportAgent1.reset()
return build_message(
Graph(), perf=ACL.inform,
sender=ExternalTransportAgent1.uri).serialize()
if msgdic['performative'] == ACL['counter-proposal']:
logger.info('Transporte 1 recibe una contraoferta')
print('Transporte 1 recibe una contraoferta')
return counterproposal(gm, msgdic['content']).serialize()
if msgdic['performative'] == ACL['call-for-proposal']:
logger.info('Tranporte 1 recibe una solicitud de propuestas')
print('Transporte 1 recibe una solicitud de propuestas')
return proposal(gm, msgdic['content']).serialize()
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia
# de registro
return build_message(
Graph(),
ACL['not-understood'],
sender=ExternalTransportAgent1.uri).serialize()
return
def comunicacion():
"""
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)
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteNegociador.uri,
msgcnt=get_count())
else:
# Obtenemos la performativa
if msgdic['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_count())
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia
# de registro
content = msgdic['content']
# Averiguamos el tipo de la accion
accion = gm.value(subject=content, predicate=RDF.type)
# Accion de busqueda
if accion == ECSDI.Peticion_Transporte:
logger.info("Negociamos con los transportistas")
print("Negociamos con los transportistas")
respondePeticion(gm, content)
gr = Graph()
# No habia ninguna accion en el mensaje
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_count())
logger.info('Respondemos a la peticion')
return gr.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 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 acceptOffer(offer):
resp = send_message(
build_message(Graph(),
ACL['accept-proposal'],
sender=AgenteNegociador.uri), offer.address)
msg = get_message_properties(resp)
return msg['performative'] == ACL.inform
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))
logger.info('Registrado agente: ' + agn_name + ' - tipus:' + agn_type)
# Generamos un mensaje de respuesta
return build_message(Graph(),
ACL.confirm,
sender=DirectoryAgent.uri,
receiver=agn_uri,
msgcnt=mss_cnt)
def comunicacion():
global dsgraph
global mss_cnt
gr = None
logger.info('Peticion de recomendacion recibida')
# Extraemos el mensaje que nos envian
mensaje = request.args['content']
gm = Graph()
gm.parse(data=mensaje)
msgdic = get_message_properties(gm)
#Comprobacion del mensaje
if msgdic is None:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteRecomendador.uri,
msgcnt=get_count())
else:
performative = msgdic['performative']
if performative != ACL.request:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteRecomendador.uri,
msgcnt=get_count())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
if accion == ECSDI.Peticion_Recomendados:
logger.info("Enviamos una serie de productos recomendados")
print("Enviamos una serie de productos recomendados")
compras = get_all_sells()
if compras.__len__() == 0:
gr = Graph()
serialize = gr.serialize(format='xml')
return serialize, 200
gr = findRecProducts(compras)
logger.info('Respondemos a la peticion')
serialize = gr.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))
gr = Graph()
gr.bind('dso', DSO)
bag = BNode()
gr.add((bag, RDF.type, RDF.Bag))
i = 0
for agn_uri in rsearch:
agn_add = dsgraph.value(subject=agn_uri[0], predicate=DSO.Address)
agn_name = dsgraph.value(subject=agn_uri[0], predicate=FOAF.name)
rsp_obj = agn['Directory-response' + str(i)]
gr.add((rsp_obj, DSO.Address, agn_add))
gr.add((rsp_obj, DSO.Uri, agn_uri[0]))
gr.add((rsp_obj, FOAF.name, agn_name))
gr.add((bag,
URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#_' +
str(i)), rsp_obj))
i += 1
logger.info("Agente encontrado: " + agn_name)
if rsearch is not None:
return build_message(gr,
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt,
content=bag)
else:
# Si no encontramos nada retornamos un inform sin contenido
return build_message(Graph(),
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
def comunicacion():
global dsgraph
global mss_cnt
gr = None
logger.info('Peticion de info recibida')
# Extraemos el mensaje que nos envian
mensaje = request.args['content']
gm = Graph()
gm.parse(data=mensaje)
msgdic = get_message_properties(gm)
# Comprobacion del mensaje
if msgdic is None:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgentePublicador.uri,
msgcnt=get_count())
else:
performative = msgdic['performative']
if performative != ACL.request:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgentePublicador.uri,
msgcnt=get_count())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
# Aqui realizariamos lo que pide la accion
if accion == ECSDI.Registrar_productos:
gr = recordExternalProduct(gm)
logger.info('Respondemos a la peticion')
print('Productos externos publicados')
return gr.serialize(format='xml'), 200
pass
def counter_offer(offer):
logger.info('Asking counter-offer to ' + offer.address)
gr = Graph()
subject = ECSDI['contra-oferta']
gr.add((subject, RDF.type, ECSDI.Contraoferta))
new_price = offer.price - 2
gr.add((subject, ECSDI.Precio_envio, Literal(new_price)))
resp = send_message(build_message(gr, ACL['counter-proposal'], content=subject, sender=AgenteNegociador.uri),
offer.address)
msg = get_message_properties(resp)
if 'performative' not in msg or msg['performative'] == ACL.refuse:
logger.warn('An agent rejected us :(')
return None
elif msg['performative'] == ACL.agree:
return Offer(address=offer.address, price=new_price)
else:
logger.error('I can\'t understand:(')
return None
def requestOffer(agent, peso, fecha, destino):
gr = Graph()
subject = ECSDI['peticion-oferta']
gr.add((subject, RDF.type, ECSDI.Pedir_oferta_transporte))
gr.add((subject, ECSDI.Destino, Literal(destino)))
gr.add((subject, ECSDI.Plazo_maximo_entrega, Literal(fecha)))
gr.add((subject, ECSDI.Peso_envio, Literal(peso)))
resp = send_message(build_message(gr, ACL['call-for-proposal'], content=subject, receiver=agent.uri,
sender=AgenteNegociador.uri), agent.address)
msg = get_message_properties(resp)
if 'performative' not in msg or msg['performative'] == ACL.refuse:
logger.warn('Nos ha rechazado un agente')
return None
elif msg['performative'] == ACL.propose:
precio = resp.value(msg['content'], ECSDI.Precio_envio)
return Offer(address=agent.address, price=precio.toPython())
logger.error('No se entiende')
return None
def returnSell(gm, sell):
content = ECSDI['Recoger_devolucion_' + str(get_count())]
gm.add((content, RDF.type, ECSDI.Recoger_devolucion))
for item in sell:
gm.add((content, ECSDI.compra_a_devolver, URIRef(item)))
logistic = get_agent_info(agn.AgenteCentroLogistico, DirectoryAgent,
AgenteDevoluciones, get_count())
gr = send_message(
build_message(gm,
perf=ACL.request,
sender=AgenteDevoluciones.uri,
receiver=logistic.uri,
msgcnt=get_count(),
content=content), logistic.address)
return gr
def browser_retorna():
global compras, count, counts
if request.method == 'GET':
logger.info('Mostramos las compras realizadas')
count, counts = get_all_sells()
return render_template('devolucion.html',
compras=compras,
count=count,
sizes=counts)
else:
logger.info('Empezamos el proceso de devolucion')
sells_checked = []
for item in request.form.getlist("checkbox"):
sells_checked.append(compras[int(item)][0])
if sells_checked.__len__() == 0:
return render_template('devolucion.html',
compras=compras,
count=count,
sizes=counts)
logger.info("Creando la peticion de compra")
g = Graph()
content = ECSDI['Peticion_retorno_' + str(get_count())]
g.add((content, RDF.type, ECSDI.Peticion_retorno))
for item in sells_checked:
g.add((content, ECSDI.CompraRetornada, URIRef(item)))
AgenteDevoluciones = get_agent_info(agn.AgenteDevoluciones,
DirectoryAgent, UserClient,
get_count())
send_message(
build_message(g,
perf=ACL.request,
sender=UserClient.uri,
receiver=AgenteDevoluciones.uri,
msgcnt=get_count(),
content=content), AgenteDevoluciones.address)
return render_template('DevolucionCompleta.html')
def sendSell(gm, sell):
logger.info('Nos comunicamos con el Centro Logistico')
content = ECSDI['Enviar_venta_' + str(get_n_message())]
gm.add((content, RDF.type, ECSDI.Enviar_venta))
gm.add((content, ECSDI.identificador_Compra, URIRef(sell)))
centro_logistico = get_agent_info(agn.AgenteCentroLogistico,
DirectoryAgent, AgenteComprador,
get_n_message())
gr = send_message(
build_message(gm,
perf=ACL.request,
sender=AgenteComprador.uri,
receiver=centro_logistico.uri,
msgcnt=get_n_message(),
content=content), centro_logistico.address)
return gr
pass
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:
"""
logger.info('Nos registramos')
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=DirectoryAgent.uri,
content=reg_obj,
msgcnt=mss_cnt), DirectoryAgent.address)
mss_cnt += 1
return gr
def requestTransport(date, peso):
logger.info('Pedimos el transporte')
# Content of the message
content = ECSDI['Peticion_de_transporte_' + str(get_n_message())]
# Graph creation
gr = Graph()
gr.add((content, RDF.type, ECSDI.Peticion_Transporte))
# Anadir fecha y peso
gr.add((content, ECSDI.Fecha, Literal(date, datatype=XSD.float)))
gr.add((content, ECSDI.Peso_envio, Literal(peso, datatype=XSD.float)))
Negociador = get_agent_info(agn.AgenteNegociador, DirectoryAgent,
AgenteCentroLogistico, get_n_message())
gr = send_message(
build_message(gr,
perf=ACL.request,
sender=AgenteCentroLogistico.uri,
receiver=Negociador.uri,
msgcnt=get_n_message(),
content=content), Negociador.address)
def comunicacion():
global dsgraph
global mss_cnt
gr = None
logger.info('Peticion de info recibida')
# Extraemos el mensaje que nos envian
mensaje = request.args['content']
gm = Graph()
gm.parse(data=mensaje)
msgdic = get_message_properties(gm)
#Comprobacion del mensaje
if msgdic is None:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteBuscador.uri,
msgcnt=get_count())
else:
performative = msgdic['performative']
if performative != ACL.request:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteBuscador.uri,
msgcnt=get_count())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
if accion == ECSDI.Peticion_Busqueda:
logger.info(
'Agente Buscador recibe una peticion de búsqueda, la tratamos'
)
print(
'Agente Buscador recibe una peticion de búsqueda, la tratamos'
)
restricciones = gm.objects(content, ECSDI.Restricciones)
restricciones_vec = {}
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_vec['brand'] = 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_vec['modelo'] = modelo
elif gm.value(subject=restriccion,
predicate=RDF.type) == ECSDI.Rango_precio:
preu_max = gm.value(subject=restriccion,
predicate=ECSDI.Precio_max)
preu_min = gm.value(subject=restriccion,
predicate=ECSDI.Precio_min)
if preu_min:
logger.info('Preu minim: ' + preu_min)
restricciones_vec['min_price'] = preu_min.toPython(
)
if preu_max:
logger.info('Preu maxim: ' + preu_max)
restricciones_vec['max_price'] = preu_max.toPython(
)
gr = findProducts(**restricciones_vec)
logger.info('Respondemos a la peticion')
serialize = gr.serialize(format='xml')
return serialize, 200
def comunicacion():
global dsgraph
global mss_cnt
gr = None
logger.info('Peticion de info recibida')
# Extraemos el mensaje que nos envian
mensaje = request.args['content']
gm = Graph()
gm.parse(data=mensaje)
msgdic = get_message_properties(gm)
# Comprobacion del mensaje
if msgdic is None:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteDevoluciones.uri,
msgcnt=get_count())
else:
performative = msgdic['performative']
if performative != ACL.request:
gr = build_message(Graph(),
ACL['no_entendido'],
sender=AgenteDevoluciones.uri,
msgcnt=get_count())
else:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
# peticion de devolucion
if accion == ECSDI.Peticion_retorno:
logger.info(
"Recibida una peticion de retorno en AgenteDevoluciones")
print("Recibida una peticion de retorno en AgenteDevoluciones")
for item in gm.subjects(RDF.type, ACL.FipaAclMessage):
gm.remove((item, None, None))
venta = []
for item in gm.objects(subject=content,
predicate=ECSDI.CompraRetornada):
venta.append(item)
payDelivery()
gm.remove((content, None, None))
gr = returnSell(gm, venta)
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_count())
logger.info('Respondemos a la peticion')
serialize = gr.serialize(format='xml')
return serialize, 200
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))
logger.info('Registrado agente: ' + agn_name + ' - tipus:' + 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)
agn_name = dsgraph.value(subject=agn_uri, predicate=FOAF.name)
gr = Graph()
gr.bind('dso', DSO)
rsp_obj = agn['Directory-response']
gr.add((rsp_obj, DSO.Address, agn_add))
gr.add((rsp_obj, DSO.Uri, agn_uri))
gr.add((rsp_obj, FOAF.name, agn_name))
return build_message(gr,
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt,
receiver=agn_uri,
content=rsp_obj)
else:
# Si no encontramos nada retornamos un inform sin contenido
return build_message(Graph(),
ACL.inform,
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
global dsgraph
global mss_cnt
# Extraemos el mensaje y creamos un grafo con él
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if not msgdic:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
else:
# Obtenemos la performativa
if msgdic['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia
# de registro
content = msgdic['content']
# Averiguamos el tipo de la accion
accion = gm.value(subject=content, predicate=RDF.type)
# Accion de registro
if accion == DSO.Register:
gr = process_register()
# Accion de busqueda
elif accion == DSO.Search:
gr = process_search()
# No habia ninguna accion en el mensaje
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=mss_cnt)
mss_cnt += 1
return gr.serialize(format='xml')
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=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')
return gr.serialize(format='xml')
def rejectOffer(offer):
resp = send_message(
build_message(Graph(),
ACL['reject-proposal'],
sender=AgenteNegociador.uri), offer.address)
msg = get_message_properties(resp)
def browser_registrarProducto():
"""
Permite la comunicacion con el agente via un navegador
via un formulario
"""
if request.method == 'GET':
return render_template('registrarProductos.html')
else:
Marca = request.form['Marca']
Nombre = request.form['Nombre']
Modelo = request.form['Modelo']
Precio = request.form['Precio']
Peso = request.form['Peso']
vendido = 0
# Content of the message
content = ECSDI['Registrar_productos_' + str(get_count())]
# Graph creation
gr = Graph()
gr.add((content, RDF.type, ECSDI.Registrar_productos))
# Anadir nuevo producto externo al grafo
subjectProd = ECSDI['Producto_externo_' +
str(random.randint(1, sys.float_info.max))]
gr.add((subjectProd, RDF.type, ECSDI.Producto_externo))
gr.add((subjectProd, ECSDI.Nombre, Literal(Nombre,
datatype=XSD.string)))
gr.add((subjectProd, ECSDI.Marca, Literal(Marca, datatype=XSD.string)))
gr.add((subjectProd, ECSDI.Modelo, Literal(Modelo,
datatype=XSD.string)))
gr.add((subjectProd, ECSDI.Precio, Literal(Precio,
datatype=XSD.float)))
gr.add((subjectProd, ECSDI.Peso, Literal(Peso, datatype=XSD.float)))
gr.add((subjectProd, ECSDI.Vendido, Literal(vendido)))
gr.add((content, ECSDI.producto, subjectProd))
publicador = get_agent_info(agn.AgentePublicador, DirectoryAgent,
VendedorExterno, get_count())
send_message(
build_message(gr,
perf=ACL.request,
sender=VendedorExterno.uri,
receiver=publicador.uri,
msgcnt=get_count(),
content=content), publicador.address)
producto_registrado = {
'Marca': request.form['Marca'],
'Nombre': request.form['Nombre'],
'Modelo': request.form['Modelo'],
'Precio': request.form['Precio'],
'Peso': request.form['Peso']
}
return render_template('ProductoRegistrado.html',
producto=producto_registrado)
def communication():
global dsgraph
gr = None
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=AgenteCentroLogistico.uri,
msgcnt=get_n_message())
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=AgenteCentroLogistico.uri,
msgcnt=get_n_message())
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)
# Aqui realizariamos lo que pide la accion
if accion == ECSDI.Enviar_venta:
logger.info('Recibimos la peticion para enviar la venta')
print('Recibimos la peticion para enviar la venta')
products = obtainProducts(gm)
gr = create_and_sendProducts(products)
elif accion == ECSDI.Recoger_devolucion:
logger.info(
'Recibimos la peticion de recoger la devolucion, para ello contratamos un envio'
)
print(
'Recibimos la peticion de recoger la devolucion, para ello contratamos un envio'
)
date = dateToMillis(datetime.datetime.utcnow() +
datetime.timedelta(days=9))
for item in gm.objects(subject=content,
predicate=ECSDI.compra_a_devolver):
peso = crearEnvio(item, date)
requestTransport(date, peso)
logger.info('Eliminamos la venta de nuestro registro')
ventas = Graph()
ventas.parse(open('../Datos/Compras'), format='turtle')
ventas.remove((item, None, None))
ventas.serialize(destination='../Datos/Compras',
format='turtle')
gr = Graph()
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_n_message())
logger.info('Respondemos a la peticion')
return gr.serialize(format='xml'), 200
pass
def browser_valorar():
global val_list
global product_list3, product_list4
if request.method == 'GET':
product_list3 = []
contentResult = ECSDI['Peticion_Valoracion' + str(get_count())]
gr = Graph()
gr.add((contentResult, RDF.type, ECSDI.Peticion_Valorados))
Valorador = get_agent_info(agn.AgenteValorador, DirectoryAgent,
UserClient, get_count())
gr4 = send_message(
build_message(gr,
perf=ACL.request,
sender=UserClient.uri,
receiver=Valorador.uri,
msgcnt=get_count(),
content=contentResult), Valorador.address)
index = 0
subject_pos = {}
for s, p, o in gr4:
if s not in subject_pos:
subject_pos[s] = index
product_list3.append({})
index += 1
if s in subject_pos:
subject_dict = product_list3[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ECSDI.Marca:
subject_dict['marca'] = o
elif p == ECSDI.Modelo:
subject_dict['modelo'] = o
elif p == ECSDI.Precio:
subject_dict['precio'] = o
elif p == ECSDI.Nombre:
subject_dict['nombre'] = o
elif p == ECSDI.Peso:
subject_dict['peso'] = o
product_list3[subject_pos[s]] = subject_dict
return render_template('valorados.html', products=product_list3)
elif request.method == 'POST':
product_list4 = []
# Peticio de cerca
if request.form['submit'] == 'Valorar':
products_checked = []
for item in request.form.getlist("checkbox"):
item_checked = []
item_map = product_list3[int(item)]
item_checked.append(item_map['marca'])
item_checked.append(item_map['modelo'])
item_checked.append(item_map['nombre'])
item_checked.append(item_map['precio'])
item_checked.append(item_map['url'])
item_checked.append(item_map['peso'])
item_checked.append(
request.form.getlist("puntuacion")[int(item)])
products_checked.append(item_checked)
if products_checked.__len__() > 0:
# Content of the message
content = ECSDI['Peticion_Valorar_' + str(get_count())]
# Graph creation
gr = Graph()
gr.add((content, RDF.type, ECSDI.Peticion_valorar))
for item in products_checked:
# Creacion del producto --------------------------------------------------------------------------------
subject_producto = item[4]
gr.add((subject_producto, RDF.type, ECSDI.Producto))
gr.add((subject_producto, ECSDI.Marca,
Literal(item[0], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Modelo,
Literal(item[1], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Nombre,
Literal(item[2], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Precio,
Literal(item[3], datatype=XSD.float)))
gr.add((subject_producto, ECSDI.Peso,
Literal(item[5], datatype=XSD.float)))
gr.add((subject_producto, ECSDI.Valoracion,
Literal(item[6], datatype=XSD.number)))
gr.add((content, ECSDI.Productos, URIRef(subject_producto)))
Valorador = get_agent_info(agn.AgenteValorador, DirectoryAgent,
UserClient, get_count())
gr5 = send_message(
build_message(gr,
perf=ACL.request,
sender=UserClient.uri,
receiver=Valorador.uri,
msgcnt=get_count(),
content=content), Valorador.address)
product_list4 = []
index = 0
subject_pos = {}
for s, p, o in gr5:
if s not in subject_pos:
subject_pos[s] = index
product_list4.append({})
index += 1
if s in subject_pos:
subject_dict = product_list4[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ECSDI.Marca:
subject_dict['marca'] = o
elif p == ECSDI.Modelo:
subject_dict['modelo'] = o
elif p == ECSDI.Precio:
subject_dict['precio'] = o
elif p == ECSDI.Nombre:
subject_dict['nombre'] = o
elif p == ECSDI.Peso:
subject_dict['peso'] = o
elif p == ECSDI.Valoracion:
subject_dict['puntuacion'] = o
product_list4[subject_pos[s]] = subject_dict
return render_template('ValoracionFinalizada.html',
products=product_list4)
else:
return render_template('valorados.html',
products=product_list3)
def browser_cerca():
"""
Permite la comunicacion con el agente via un navegador
via un formulario
"""
global product_list
global product_list2
if request.method == 'GET':
contentResult = ECSDI['Peticion_Recomendacion' + str(get_count())]
gr = Graph()
gr.add((contentResult, RDF.type, ECSDI.Peticion_Recomendados))
Recomendador = get_agent_info(agn.AgenteRecomendador, DirectoryAgent,
UserClient, get_count())
gr3 = send_message(
build_message(gr,
perf=ACL.request,
sender=UserClient.uri,
receiver=Recomendador.uri,
msgcnt=get_count(),
content=contentResult), Recomendador.address)
index = 0
subject_pos = {}
product_list2 = []
for s, p, o in gr3:
if s not in subject_pos:
subject_pos[s] = index
product_list2.append({})
index += 1
if s in subject_pos:
subject_dict = product_list2[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ECSDI.Marca:
subject_dict['marca'] = o
elif p == ECSDI.Modelo:
subject_dict['modelo'] = o
elif p == ECSDI.Precio:
subject_dict['precio'] = o
elif p == ECSDI.Nombre:
subject_dict['nombre'] = o
elif p == ECSDI.Peso:
subject_dict['peso'] = o
product_list2[subject_pos[s]] = subject_dict
return render_template('busqueda.html',
productos_recomendados=product_list2,
products=None)
elif request.method == 'POST':
# Peticio de cerca
if request.form['submit'] == 'Buscar':
logger.info("Enviando peticion de busqueda")
# Content of the message
contentResult = ECSDI['Peticion_Busqueda' + str(get_count())]
# Graph creation
gr = Graph()
gr.add((contentResult, RDF.type, ECSDI.Peticion_Busqueda))
# Add restriccio nom
nombre = request.form['nombre']
if nombre:
# Subject nom
subject_nom = ECSDI['RestriccionNombre' + str(get_count())]
gr.add((subject_nom, RDF.type, ECSDI.Restriccion_Nombre))
gr.add((subject_nom, ECSDI.name,
Literal(nombre, datatype=XSD.string)))
# Add restriccio to content
gr.add(
(contentResult, ECSDI.Restricciones, URIRef(subject_nom)))
marca = request.form['marca']
if marca:
Sujeto_marca = ECSDI['Restriccion_Marca_' + str(get_count())]
gr.add((Sujeto_marca, RDF.type, ECSDI.Restriccion_Marca))
gr.add((Sujeto_marca, ECSDI.Marca,
Literal(marca, datatype=XSD.string)))
gr.add(
(contentResult, ECSDI.Restricciones, URIRef(Sujeto_marca)))
min_price = request.form['min_price']
max_price = request.form['max_price']
if min_price or max_price:
Sujeto_precios = ECSDI['Restriccion_Precios_' +
str(get_count())]
gr.add((Sujeto_precios, RDF.type, ECSDI.Rango_precio))
if min_price:
gr.add(
(Sujeto_precios, ECSDI.Precio_min, Literal(min_price)))
if max_price:
gr.add(
(Sujeto_precios, ECSDI.Precio_max, Literal(max_price)))
gr.add((contentResult, ECSDI.Restricciones,
URIRef(Sujeto_precios)))
Buscador = get_agent_info(agn.AgenteBuscador, DirectoryAgent,
UserClient, get_count())
gr2 = send_message(
build_message(gr,
perf=ACL.request,
sender=UserClient.uri,
receiver=Buscador.uri,
msgcnt=get_count(),
content=contentResult), Buscador.address)
index = 0
subject_pos = {}
product_list = []
for s, p, o in gr2:
if s not in subject_pos:
subject_pos[s] = index
product_list.append({})
index += 1
if s in subject_pos:
subject_dict = product_list[subject_pos[s]]
if p == RDF.type:
subject_dict['url'] = s
elif p == ECSDI.Marca:
subject_dict['marca'] = o
elif p == ECSDI.Modelo:
subject_dict['modelo'] = o
elif p == ECSDI.Precio:
subject_dict['precio'] = o
elif p == ECSDI.Nombre:
subject_dict['nombre'] = o
elif p == ECSDI.Peso:
subject_dict['peso'] = o
product_list[subject_pos[s]] = subject_dict
return render_template('busqueda.html',
products=product_list,
productos_recomendados=product_list2)
# Peticion de compra
elif request.form['submit'] == 'Comprar':
products_checked = []
products_checked2 = []
for item in request.form.getlist("checkbox"):
item_checked = []
item_map = product_list[int(item)]
item_checked.append(item_map['marca'])
item_checked.append(item_map['modelo'])
item_checked.append(item_map['nombre'])
item_checked.append(item_map['precio'])
item_checked.append(item_map['peso'])
products_checked2.append(item_checked)
for item in request.form.getlist("checkbox"):
item_checked = []
item_map = product_list[int(item)]
item_checked.append(item_map['marca'])
item_checked.append(item_map['modelo'])
item_checked.append(item_map['nombre'])
item_checked.append(item_map['precio'])
item_checked.append(item_map['url'])
item_checked.append(item_map['peso'])
products_checked.append(item_checked)
if products_checked2.__len__() == 0:
return render_template('busqueda.html',
products=product_list,
productos_recomendados=product_list2)
logger.info("Creando la peticion de compra")
# Content of the message
content = ECSDI['Peticion_compra_' + str(get_count())]
# Graph creation
gr = Graph()
gr.add((content, RDF.type, ECSDI.Peticion_compra))
# Asignar prioridad a la peticion (asignamos el contador de mensaje)
gr.add((content, ECSDI.Prioridad,
Literal(get_count(), datatype=XSD.integer)))
# Creacion de la ciudad (por ahora Barcelona) --------------------------------------------------------------
subject_ciudad = ECSDI['Ciudad_' +
str(random.randint(1, sys.float_info.max))]
gr.add((subject_ciudad, RDF.type, ECSDI.Ciudad))
gr.add((subject_ciudad, ECSDI.Nombre,
Literal('Barcelona', datatype=XSD.string)))
gr.add((subject_ciudad, ECSDI.Longitud,
Literal(41.398373, datatype=XSD.float)))
gr.add((subject_ciudad, ECSDI.Latitud,
Literal(2.188247, datatype=XSD.float)))
# Creacion del sobre (Compra) ------------------------------------------------------------------------------
subject_sobre = ECSDI['Compra_' +
str(random.randint(1, sys.float_info.max))]
gr.add((subject_sobre, RDF.type, ECSDI.Compra))
gr.add(
(subject_sobre, ECSDI.Pagado, Literal(0,
datatype=XSD.integer)))
gr.add((subject_sobre, ECSDI.Enviar_a, URIRef(subject_ciudad)))
total_price = 0.0
for item in products_checked:
total_price += float(item[3])
# Creacion del producto --------------------------------------------------------------------------------
subject_producto = item[4]
gr.add((subject_producto, RDF.type, ECSDI.Producto))
gr.add((subject_producto, ECSDI.Marca,
Literal(item[0], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Modelo,
Literal(item[1], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Nombre,
Literal(item[2], datatype=XSD.string)))
gr.add((subject_producto, ECSDI.Precio,
Literal(item[3], datatype=XSD.float)))
gr.add((subject_producto, ECSDI.Peso,
Literal(item[5], datatype=XSD.float)))
gr.add(
(subject_sobre, ECSDI.Productos, URIRef(subject_producto)))
gr.add((subject_sobre, ECSDI.Precio_total,
Literal(total_price, datatype=XSD.float)))
gr.add(
(content, ECSDI.Paquete_de_productos, URIRef(subject_sobre)))
Comprador = get_agent_info(agn.AgenteComprador, DirectoryAgent,
UserClient, get_count())
respuesta = send_message(
build_message(gr,
perf=ACL.request,
sender=UserClient.uri,
receiver=Comprador.uri,
msgcnt=get_count(),
content=content), Comprador.address)
return render_template('CompraRealizada.html',
products=products_checked2)
