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