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 create_and_sendProducts(gr):
logger.info('Enviamos los productos')
content = ECSDI['Enviar_lot' + str(get_n_message())]
gr.add((content, RDF.type, ECSDI.Enviar_lot))
subjectLoteProducto = ECSDI['Lote_producto' +
str(random.randint(1, sys.float_info.max))]
gr.add((subjectLoteProducto, RDF.type, ECSDI.Lote_producto))
gr.add(
(subjectLoteProducto, ECSDI.Prioridad, Literal(1,
datatype=XSD.integer)))
for item in gr.subjects(RDF.type, ECSDI.Producto):
gr.add((subjectLoteProducto, ECSDI.productos, URIRef(item)))
gr.add((content, ECSDI.a_enviar, URIRef(subjectLoteProducto)))
# Se ha creado el envio de un lato de productos, ahora se procedede a negociar el envio y enviarlo
logger.info('Se envia el lote de productos')
print('Se envia el lote de productos')
date = dateToMillis(datetime.datetime.utcnow() +
datetime.timedelta(days=9))
urlEnvio = writeSends(gr, date)
peso = obtenerPesoTotal(urlEnvio)
requestTransport(date, peso)
gr = prepareSellResponse(urlEnvio)
return gr
def requestTransports(peso, fecha, destino):
agents = get_bag_agent_info(agn.ExternalTransportAgent,
ExternalTransportDirectory, AgenteNegociador,
192310291)
offers = []
for agent in agents:
offer = requestOffer(agent, peso, fecha, destino)
logger.info('Offer received of ' + str(offer.price))
if offer:
offers += [offer]
offers2 = []
for i, offer in enumerate(offers):
offer2 = counter_offer(offer)
if offer2:
logger.info('Counter offer accepted at ' + str(offer2.price))
offers2 += [offer2]
else:
logger.info('Counter offer rejected by ' + str(offer.address))
offers2 += [offer]
best_offer = min(offers2, key=lambda a: a.price)
logger.info('La mejor oferta es la de ' + str(best_offer.price) + '€')
end = False
for offer in offers2:
if offer == best_offer:
end = acceptOffer(best_offer)
else:
rejectOffer(offer)
if end:
logger.info('La negociacion se ha realizado con exito')
return best_offer
else:
return None
def obtainProducts(gm):
logger.info("Obtenemos los productos")
products = Graph()
sell = None
for item in gm.subjects(RDF.type, ECSDI.Compra):
sell = item
sellsGraph = Graph()
sellsGraph.parse(open('../data/compres'), format='turtle')
for item in sellsGraph.objects(sell, ECSDI.Productos):
marca = sellsGraph.value(subject=item, predicate=ECSDI.Marca)
nombre = sellsGraph.value(subject=item, predicate=ECSDI.Nombre)
modelo = sellsGraph.value(subject=item, predicate=ECSDI.Modelo)
precio = sellsGraph.value(subject=item, predicate=ECSDI.Precio)
peso = sellsGraph.value(subject=item, predicate=ECSDI.Peso)
products.add((item, RDF.type, ECSDI.Producto))
products.add((item, ECSDI.Marca, Literal(marca, datatype=XSD.string)))
products.add((item, ECSDI.Nombre, Literal(nombre,
datatype=XSD.string)))
products.add((item, ECSDI.Modelo, Literal(modelo,
datatype=XSD.string)))
products.add((item, ECSDI.Precio, Literal(precio, datatype=XSD.float)))
products.add((item, ECSDI.Peso, Literal(peso, datatype=XSD.float)))
return products
def sendProducts(gr):
logger.info('Enviamos los productos')
content = ECSDI['Enviar_lot' + str(get_count())]
gr.add((content, RDF.type, ECSDI.Enviar_lot))
subjectLoteProducto = ECSDI['Lote_producto' +
str(random.randint(1, sys.float_info.max))]
gr.add((subjectLoteProducto, RDF.type, ECSDI.Lote_producto))
gr.add(
(subjectLoteProducto, ECSDI.Prioridad, Literal(1,
datatype=XSD.integer)))
for item in gr.subjects(RDF.type, ECSDI.Producto):
gr.add((subjectLoteProducto, ECSDI.productos, URIRef(item)))
gr.add((content, ECSDI.a_enviar, URIRef(subjectLoteProducto)))
logistic = get_agent_info(agn.LogisticHubAgent, DirectoryAgent,
ProductsAgent, get_count())
gr = send_message(
build_message(gr,
perf=ACL.request,
sender=ProductsAgent.uri,
receiver=logistic.uri,
msgcnt=get_count(),
content=content), logistic.address)
return gr
def requestAvailability(graph):
logger.info('Comprobamos disponibilidad')
content = ECSDI['Pedir_disponibilidad' + str(get_count())]
graph.add((content, RDF.type, ECSDI.Pedir_disponibilidad))
subjectExiste = ECSDI['Existencia_' + str(get_count())]
graph.add((subjectExiste, RDF.type, ECSDI.Existencia))
graph.add((subjectExiste, ECSDI.Cantidad, Literal(1,
datatype=XSD.integer)))
for item in graph.subjects(RDF.type, ECSDI.Producto):
graph.add((subjectExiste, ECSDI.Tiene, URIRef(item)))
graph.add((content, ECSDI.Existe, URIRef(subjectExiste)))
logistic = get_agent_info(agn.LogisticHubAgent, DirectoryAgent,
ProductsAgent, get_count())
send_message(
build_message(graph,
perf=ACL.request,
sender=ProductsAgent.uri,
receiver=logistic.uri,
msgcnt=get_count(),
content=content), logistic.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=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 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')
gr = register_agent(AgenteNegociador, DirectoryAgent, AgenteNegociador.uri, get_count())
return gr
def communication():
"""
Communication Entrypoint
"""
logger.info('Peticion de informacion recibida')
global dsGraph
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=QualifierAgent.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.todo_accion:
# TODO Tratar accion deseada
return
# 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 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')
gr = register_agent(QualifierAgent, DirectoryAgent, QualifierAgent.uri, get_count())
return gr
def sendSell(gm, sell):
logger.info('Nos comunicamos con el ProductsAgent')
content = ECSDI['Enviar_venta_' + str(get_count())]
gm.add((content, RDF.type, ECSDI.Enviar_venta))
gm.add((content, ECSDI.identificador_Compra, URIRef(sell)))
products = get_agent_info(agn.ProductsAgent, DirectoryAgent, FinancialAgent, get_count())
gr = send_message(
build_message(gm, perf=ACL.request, sender=FinancialAgent.uri, receiver=products.uri,
msgcnt=get_count(),
content=content), products.address)
return gr
def returnSell(gm, sell):
logger.info('Nos comunicamos con el ProductsAgent')
content = ECSDI['Recoger_venta_' + str(get_count())]
gm.add((content, RDF.type, ECSDI.Recoger_venta))
for item in sell:
gm.add((content, ECSDI.compra_a_retornar, URIRef(item)))
logistic = get_agent_info(agn.LogisticHubAgent, DirectoryAgent, FinancialAgent, get_count())
gr = send_message(
build_message(gm, perf=ACL.request, sender=FinancialAgent.uri, receiver=logistic.uri,
msgcnt=get_count(),
content=content), logistic.address)
return gr
def communication():
"""
Communication Entrypoint
"""
logger.info('Peticion de informacion recibida')
global dsGraph
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=QualifierAgent.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.todo_accion:
# TODO Tratar accion deseada
return
# 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 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 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 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 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 comunicacion():
"""
Entrypoint de comunicacion
"""
logger.info('Peticion de plan recibida')
global dsGraph
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = None
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=AgenteAlojamiento.uri, msgcnt=get_count())
else:
# Obtenemos la performativa
if msgdic['performative'] != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=DirectoryAgent.uri,
msgcnt=get_count())
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia
# de registro
content = msgdic['content']
# Averiguamos el tipo de la accion
accion = gm.value(subject=content, predicate=RDF.type)
# Accion de busqueda
if accion == ECSDI.Peticion_Alojamiento:
gr = findHoteles()
logger.info('Api usada')
serialize = gr.serialize(format='xml')
logger.info("bye bye")
return serialize, 200
def payDelivery():
logger.info('Transferencia aceptada')
print('Transferencia aceptada')
pass
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 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=ProductsAgent.uri,
msgcnt=get_count())
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=ProductsAgent.uri,
msgcnt=get_count())
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.Registra_productes:
gr = recordExternalProduct(gm)
elif accion == ECSDI.Enviar_venta:
logger.info("Recibe comunicación del FinancialAgent")
products = obtainProducts(gm)
requestAvailability(products)
products = obtainProducts(gm)
gr = sendProducts(products)
# 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'), 200
def register_message():
logger.info("Registrando Agente CentroLogistico...")
gr = register_agent(AgenteCentroLogistico, DirectoryAgent,
AgenteCentroLogistico.uri, get_n_message())
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 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 payDelivery(compra_url):
logger.info('Se acepta la transferencia de' + compra_url)
print('Se acepta la transferencia de' + compra_url)
def register_message():
logger.info('Registrando Agente Comprador...')
gr = register_agent(AgenteComprador, DirectoryAgent, AgenteComprador.uri,
get_n_message())
def communication():
"""
Communication Entrypoint
"""
global dsGraph
logger.info('Peticion de informacion recibida')
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
gr = None
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(), ACL['not-understood'], sender=FinancialAgent.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 enviar venta
if accion == ECSDI.Vull_comprar:
gm.remove((content, None, None))
for item in gm.subjects(RDF.type, ACL.FipaAclMessage):
gm.remove((item, None, None))
sell = None
for item in gm.subjects(RDF.type, ECSDI.Compra):
sell = item
registerSells(gm)
payDelivery(sell)
deliverReceipt(sell)
gr = sendSell(gm, sell)
# Accion de retorno
elif accion == ECSDI.Peticion_retorno:
for item in gm.subjects(RDF.type, ACL.FipaAclMessage):
gm.remove((item, None, None))
sell = []
for item in gm.objects(subject=content, predicate=ECSDI.CompraRetornada):
sell.append(item)
for item in sell:
payDelivery(item)
gm.remove((content, None, None))
gr = returnSell(gm, sell)
# Ninguna accion a realizar
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'), 200
def deliverReceipt(sell):
logger.info('Envio la factura de la venda con id ' + sell + 'al usuario comprador.')
