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 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 recomendarProductosClientes():
agentesCliente = directory_search_agent(DSO.AgenteCliente,
AgenteRecomendador, DirectoryAgent,
mss_cnt)
for agenteCliente in agentesCliente:
#buscamos los productos de tipo que ha comprado el cliente y que este no haya comprado aun
productoRecomendado = buscaProductosRecomendables(agenteCliente.name)
#elegimos de entre los productos relevantes uno al azar y enviamos la recomendacion al cliente
sendProductoRecomendado(productoRecomendado, agenteCliente)
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 ponerALaVenta(request):
global mss_cnt
gmess = Graph()
sj_contenido = agn[AgenteVendedorExterno.name + 'Add_producto_externo_' +
str(mss_cnt)]
gmess.add((sj_contenido, RDF.type, AM2.Add_producto_externo))
nombre = request.form['nombre']
marca = request.form['marca']
tipoProducto = request.form['tipoProducto']
precio = request.form['precio']
modelo = request.form['modelo']
tipoEnvio = request.form['tipoEnvio']
if nombre and marca and tipoProducto and precio and modelo and tipoEnvio:
sujeto = AM2['Producto_externo_' + str(random.randint(0, 500000))]
gmess.add((sujeto, RDF.type, AM2.Producto))
gmess.add((sujeto, AM2.Nombre, Literal(nombre)))
gmess.add((sujeto, AM2.Marca, Literal(marca)))
gmess.add((sujeto, AM2.TipoProducto, Literal(tipoProducto)))
gmess.add((sujeto, AM2.Precio, Literal(precio)))
gmess.add((sujeto, AM2.Modelo, Literal(modelo)))
gmess.add((sujeto, AM2.TipoEnvio, Literal(tipoEnvio)))
mostrador = directory_search_agent(DSO.AgenteProductosExternos,
AgenteVendedorExterno,
DirectoryAgent, mss_cnt)[0]
msg = build_message(gmess,
perf=ACL.request,
sender=AgenteVendedorExterno.uri,
receiver=mostrador.uri,
content=sj_contenido,
msgcnt=mss_cnt)
puesto_a_la_venta = send_message(msg, mostrador.address)
mss_cnt += 1
logger.info(
'Recibimos respuesta a la peticion al servicio de informacion')
return render_template('ponerALaVenta.html', vendido=puesto_a_la_venta)
else:
return render_template('ponerALaVenta.html', vendido="Error")
def comprar(request):
global mss_cnt
global current_products
global username
logger.info("Comprando productos")
print(request.form.getlist('productsToBuy'))
gmess = Graph()
# Creamos el sujeto -> contenido del mensaje
sj_contenido = agn[AgenteCliente.name + '-Peticion_Compra-' + str(mss_cnt)]
# le damos un tipo
gmess.add((sj_contenido, RDF.type, AM2.Peticion_Compra))
gmess.add((sj_contenido, AM2.username, Literal(username)))
# sujetoProductos = AM2["Productos"]
# gmess.add((sujetoProductos,))
for id in request.form.getlist('productsToBuy'):
# print("Ids: %s"%id)
productSubject = current_products.value(predicate=AM2.Id,
object=Literal(
id, datatype=XSD.int))
gmess.add((productSubject, RDF.type, AM2['Producto']))
gmess += current_products.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")
gr = send_message(msg, vendedor.address)
# print("message SENT")
mss_cnt += 1
#msgdic = get_message_properties(gr)
#content = msgdic['content']
#accion = gr.value(subject=content, predicate=RDF.type)
#logger.info(accion)
product_list = getProductListFromGraph(gr)
return render_template('cestaCompra.html', products=product_list)
def agentbehavior1(cola):
"""
Un comportamiento del agente
:return:
"""
global mss_cnt
# Registramos el agente
gr = register_message(DSO.AgenteRecomendador, AgenteRecomendador,
DirectoryAgent, mss_cnt)
# Escuchando la cola hasta que llegue un 0
fin = False
schedule.every(25).seconds.do(recomendarProductosClientes)
while not fin:
while cola.empty():
schedule.run_pending()
pass
v = cola.get()
if v == 0:
fin = True
else:
agenteCliente = directory_search_agent(DSO.AgenteCliente,
AgenteRecomendador,
DirectoryAgent, mss_cnt)[0]
content = v.value(predicate=RDF.type,
object=AM2.Peticion_valoracion)
grm = build_message(v,
perf=ACL.request,
sender=AgenteRecomendador.uri,
receiver=agenteCliente.uri,
content=content,
msgcnt=mss_cnt)
gRespuesta = send_message(grm, agenteCliente.address)
logger.info(
'Se ha enviado una peticion de valoraciones al cliente')
gValoraciones = Graph()
for s in gRespuesta.subjects(RDF.type, AM2.Producto):
print("------------------>%s" % (s))
gValoraciones += gRespuesta.triples((s, None, None))
addValoracionToBD(gValoraciones)
logger.info('Se ha añadido la valoracion a la base de datos')
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 comunicacion():
"""
Entrypoint de comunicacion
"""
global dsgraph
global mss_cnt
# Extraemos el mensaje y creamos un grafo con el
message = request.args['content']
gm = Graph()
gm.parse(data=message)
msgdic = get_message_properties(gm)
# Comprobamos que sea un mensaje FIPA ACL
if msgdic is None:
# Si no es, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
else:
# Obtenemos la performativa
perf = msgdic['performative']
if perf != ACL.request:
# Si no es un request, respondemos que no hemos entendido el mensaje
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
else:
# Extraemos el objeto del contenido que ha de ser una accion de la ontologia de acciones del agente
# de registro
# Averiguamos el tipo de la accion
if 'content' in msgdic:
content = msgdic['content']
accion = gm.value(subject=content, predicate=RDF.type)
# Aqui realizariamos lo que pide la accion
if accion == AM2.Solicitud_envio:
logger.info("Petición de envio recibida")
productsInternos = Graph()
productsExternos = Graph()
# Productos recibidos
hayExterno = False
hayInterno = False
for s in gm.subjects(RDF.type, AM2["Producto"]):
tipoEnvio = gm.value(s, AM2.TipoEnvio)
if str(tipoEnvio) == 'Interno':
hayInterno = True
productsInternos += gm.triples((s, None, None))
else:
hayExterno = True
productsExternos += gm.triples((s, None, None))
if hayExterno and not hayInterno:
gr = confirmaEnvio(msgdic, productsExternos)
colaAvisarAgenteVendedorExterno(productsExternos)
else:
gmess = Graph()
sj_contenido = MSG[AgenteLogistico.name +
'-Realiza_envio-' + str(mss_cnt)]
gmess.add((sj_contenido, RDF.type, AM2.Realiza_envio))
gmess += productsInternos
agenteAlmacen = directory_search_agent(
DSO.AgenteAlmacen, AgenteLogistico, DirectoryAgent,
mss_cnt)[0]
grm = build_message(gmess,
perf=ACL.request,
sender=AgenteLogistico.uri,
receiver=agenteAlmacen.uri,
content=sj_contenido,
msgcnt=mss_cnt)
gr = send_message(grm, agenteAlmacen.address)
logger.info(
'Se ha informado al almacen que debe realizar envio'
)
if hayExterno:
gmess2 = Graph()
sj_contenido = MSG[
AgenteLogistico.name +
'-Confirmacion_envio_externo_interno-' +
str(mss_cnt)]
gmess2.add(
(sj_contenido, RDF.type,
AM2.Confirmacion_envio_externo_interno))
gr = build_message(gmess2,
ACL['inform-done'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt,
content=sj_contenido,
receiver=msgdic['sender'])
colaAvisarAgenteVendedorExterno(productsExternos)
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
else:
gr = build_message(Graph(),
ACL['not-understood'],
sender=AgenteLogistico.uri,
msgcnt=mss_cnt)
mss_cnt += 1
logger.info('Respondemos a la solicitud de envio')
return gr.serialize(format='xml')
def agentbehavior1(cola):
"""
Un comportamiento del agente
:return:
"""
global mss_cnt
logger.info('Nos registramos en el servicio de registro')
register_message(DSO.AgenteVentaProductos, AgenteVentaProductos,
DirectoryAgent, mss_cnt)
fin = False
while not fin:
while cola.empty():
pass
v = cola.get()
if v == 0:
fin = True
else:
sj_avisar_recomendador = v.value(predicate=RDF.type,
object=AM2.Nueva_compra)
sj_solicitud_envio = v.value(predicate=RDF.type,
object=AM2.Solicitud_envio)
print("-------->sj_avisar_recomendador-->%s" %
(sj_avisar_recomendador))
print("-------->sj_solicitud_envio-->%s" % (sj_solicitud_envio))
if sj_solicitud_envio != None:
#enviamos mensaje
agenteLogistico = directory_search_agent(
DSO.AgenteLogistico, AgenteVentaProductos, DirectoryAgent,
mss_cnt)[0]
grm = build_message(v,
perf=ACL.request,
sender=AgenteVentaProductos.uri,
receiver=agenteLogistico.uri,
content=sj_solicitud_envio,
msgcnt=mss_cnt)
logger.info(
'Se ha enviado al centro logístico la solicitud de envio')
gr = send_message(grm, agenteLogistico.address)
logger.info(
'Se ha recibido la respuesta del centro logístico, notificando al cliente'
)
agenteCliente = directory_search_agent(DSO.AgenteCliente,
AgenteVentaProductos,
DirectoryAgent,
mss_cnt)[0]
msgdic = get_message_properties(gr)
content = msgdic['content']
confirmacion = gr.value(subject=content, predicate=RDF.type)
if confirmacion == AM2.Confirmacion_envio:
logger.info("Confirmacion del envio")
elif confirmacion == AM2.Confirmacion_envio_externo:
logger.info("Confirmacion del envio externo")
elif confirmacion == AM2.Confirmacion_envio_externo_interno:
logger.info("Confirmacion del envio externo e interno")
gmess = Graph()
sj_contenido = AM2[AgenteVentaProductos.name +
'-Factura_Compra-' + str(mss_cnt)]
gmess.add((sj_contenido, RDF.type, AM2.Emitir_factura))
grm = build_message(gmess,
perf=ACL.request,
sender=AgenteVentaProductos.uri,
receiver=agenteCliente.uri,
content=sj_contenido,
msgcnt=mss_cnt)
send_message(grm, agenteCliente.address)
logger.info(
'Se han enviado los detalles de la entrega al cliente')
elif sj_avisar_recomendador != None:
#avisar al recomendador
agenteRecomendador = directory_search_agent(
DSO.AgenteRecomendador, AgenteVentaProductos,
DirectoryAgent, mss_cnt)[0]
grm = build_message(v,
perf=ACL.request,
sender=AgenteVentaProductos.uri,
receiver=agenteRecomendador.uri,
content=sj_avisar_recomendador,
msgcnt=mss_cnt)
send_message(grm, agenteRecomendador.address)
logger.info(
'El AgenteRecomendador ha sido notificado de la compra')
def mostrarProductosFiltrados(request):
global mss_cnt
global current_products
logger.info("Creando peticion de productos disponibles")
gmess = Graph()
# Creamos el sujeto -> contenido del mensaje
sj_contenido = agn[AgenteCliente.name + 'Peticion_productos_disponibles' +
str(mss_cnt)]
#le damos un tipo
gmess.add((sj_contenido, RDF.type, AM2.Peticion_productos_disponibles))
#Añadimos restricciones
nombre = request.form['nombre']
if nombre:
sj_nombre = AM2[
'Nombre' +
str(mss_cnt)] #creamos una instancia con nombre Modelo1..2.
gmess.add(
(sj_nombre, RDF.type,
AM2['Restricciones_cliente'])) # indicamos que es de tipo Modelo
gmess.add((sj_nombre, AM2.nombreRestriccion,
Literal(nombre))) #le damos valor a su data property
#añadimos el modelo al conenido con su object property
gmess.add(
(sj_contenido, AM2.Restricciones_clientes, URIRef(sj_nombre)))
marca = request.form['marca']
if marca:
sj_marca = AM2['Marca' + str(mss_cnt)]
gmess.add((sj_marca, RDF.type, AM2['Restricciones_cliente']))
gmess.add((sj_marca, AM2.marcaRestriccion, Literal(marca)))
gmess.add((sj_contenido, AM2.Restricciones_clientes, URIRef(sj_marca)))
tipo = request.form['tipo']
if tipo:
sj_tipo = AM2['Tipo' + str(mss_cnt)]
gmess.add((sj_tipo, RDF.type, AM2['Restricciones_cliente']))
gmess.add((sj_tipo, AM2.tipoProductoRestriccion, Literal(tipo)))
gmess.add((sj_contenido, AM2.Restricciones_clientes, URIRef(sj_tipo)))
modelo = request.form['modelo']
if modelo:
sj_modelo = AM2['Modelo' + str(mss_cnt)]
gmess.add((sj_modelo, RDF.type, AM2['Restricciones_cliente']))
gmess.add((sj_modelo, AM2.modeloRestriccion, Literal(modelo)))
gmess.add(
(sj_contenido, AM2.Restricciones_clientes, URIRef(sj_modelo)))
precio = request.form['precio']
if precio:
sj_precio = AM2['Precio' + str(mss_cnt)]
gmess.add((sj_precio, RDF.type, AM2['Restricciones_cliente']))
gmess.add((sj_precio, AM2.precioMaxRestriccion, Literal(precio)))
gmess.add(
(sj_contenido, AM2.Restricciones_clientes, URIRef(sj_precio)))
mostrador = directory_search_agent(DSO.AgenteMostrarProductos,
AgenteCliente, DirectoryAgent,
mss_cnt)[0]
msg = build_message(gmess,
perf=ACL.request,
sender=AgenteCliente.uri,
receiver=mostrador.uri,
content=sj_contenido,
msgcnt=mss_cnt)
current_products = send_message(msg, mostrador.address)
mss_cnt += 1
logger.info('Recibimos respuesta a la peticion al servicio de informacion')
product_list = getProductListFromGraph(current_products)
# print("EEUUU: %s"%(product_list))
return render_template('busquedaYCompra.html', products=product_list)
