def send(self, sender): print("Hi", sender, "would you like to hear some music?") yes = zoe.MessageBuilder({ "dst": "relay", "relayto": "welcome", "sender": sender, "tag": ["music", "yes"] }) no = zoe.MessageBuilder({ "dst": "relay", "relayto": "welcome", "sender": sender, "tag": ["music", "no"] }) zoe.state.Command(sender, "yes /please", yes) zoe.state.Command(sender, "no /thanks", no)
def messagefromjabber(self, msg): print("msg = ", msg) if not (msg['type'] in ('chat', 'normal')): self._listener.log("jabber", "WARNING", "received an unknown jabber message type") return text = msg["body"] jid = msg["from"] sender = self.finduser(jid) if not sender: self._listener.log( "jabber", "WARNING", "received a jabber message from an unknown user: "******"@" + jid.domain) print("Received a message from an unknown user:"******"@" + jid.domain) msg.reply( "Lo siento, no me permiten hablar con desconocidos. Si eres un usuario, tu Jabber ID ha quedado registrado en los logs, configura tu usuario correctamente" ).send() return text64 = base64.standard_b64encode( text.encode('utf-8')).decode('utf-8') aMap = { "dst": "relay", "relayto": "natural", "src": "jabber", "tag": ["command", "relay"], "sender": sender["id"], "jid": str(jid), "cmd": text64 } self._listener.log("jabber", "DEBUG", "Relaying the jabber message to the natural agent") self._listener.sendbus(zoe.MessageBuilder(aMap).msg())
def incoming_message(self, ...): # The incoming message, as a str text = ... # The person who sent the message emitter = ... # Normally we will not attend anyone's message, only messages from our users. # We have to find a user who matches the emitter value. # It will probably look for all users in zoe-users.conf and find one with # the identity of the emitter. user = self.finduser(emitter) if not user: # Not recognized print('Received message from unknown user: '******'utf-8')).decode('utf-8') # This is the resulting message. natural_msg = { 'dst' : 'relay', 'relayto' : 'natural', 'src' : NAME, 'tag' : ['command', 'relay'], 'sender' : user['id'], 'cmd' : text64, # you can add more data you need, like the channel context (say, chat room) 'room' : ... } self.sendbus(zoe.MessageBuilder(natural_msg).msg())
def feedback(self, msg, user, dst=None, subject=None, att=None): """ Send a message or mail to a given user. msg - message text or attachment user - user to send the feedback to subject - if using mail feedback, subject for the mail dst - destination of the message: 'jabber' or 'tg' att - mail attachment """ if not user: return to_send = {"dst": "relay", "to": user} if not subject: to_send["relayto"] = dst to_send["msg"] = msg else: to_send["relayto"] = "mail" if att: to_send["att"] = att.str() to_send["txt"] = msg or "" to_send["subject"] = subject return zoe.MessageBuilder(to_send)
def send(self, version, name, sender, to=None): """ Send a document to the user or the provided email address. """ base_path = self.get_path() doc_path = path(base_path, name, version) if not os.path.isdir(doc_path): message = "Didn't find version %s for document %s" % (version, name) return self.feedback(message, sender, "jabber") self.clean_state(sender) # Obtain list of files flist = sorted([ f for f in os.listdir(doc_path) if os.path.isfile(path(doc_path, f)) ]) if not flist: message = "There are no files for this document in this version" return self.feedback(message, sender, "jabber") for f in flist: state_msg = zoe.MessageBuilder({ "dst": "relay", "relayto": "docversion", "sender": sender, "tag": "docfile", "version": version, "name": name, "filename": f, "to": to or sender }) bus_msg = zoe.MessageBuilder({ "dst": "relay", "tag": "relay", "relayto": "jabber", "to": sender, "msg": f }) # Commands created are the names of the files that are # available for the document in the given version. zoe.state.Command(sender, f, state_msg) self.logger._listener.sendbus(bus_msg.msg())
def mail(self, msg, user): self.logger.info("Mail to " + user) return zoe.MessageBuilder({ "dst": "mail", "subject": "Message from Zoe", "to": user, "txt": msg })
def unregister(self): aMap = { "dst": "server", "tag": "unregister", "name": self._name, "topic": self._topic } self._listener.sendbus(zoe.MessageBuilder(aMap).msg())
def receive_and_answer(self, name): print( "I will send back a message to Zoe (that will also be sent to this agent)" ) return zoe.MessageBuilder({ 'dst': 'test', 'tag': 'hello', 'name': name })
def register(self): self._host = self._listener._host self._port = self._listener._port aMap = { "dst": "server", "tag": "register", "name": self._name, "host": self._host, "port": str(self._port), "topic": self._topic } self._listener.sendbus(zoe.MessageBuilder(aMap).msg())
def launch(self, name, sender=None, locale="en"): """ Launch an agent. """ self.set_locale(locale) if not self.has_permissions(sender): print(MSG_NO_PERM) return self.feedback(MSG_NO_PERM, sender) if self.running(name): msg = _("Agent %s is already running") % name print(msg) return self.feedback(msg, sender) agent_dir = path(env["ZOE_HOME"], "agents", name) if not os.path.isdir(agent_dir): msg = _("Agent %s does not exist!") % name print(msg) return self.feedback(msg, sender) # Redirect stdout and stderr to zam's log log_file = open(path(env["ZOE_LOGS"], "zam.log"), "a") proc = subprocess.Popen( [path(env["ZOE_HOME"], "zoe.sh"), "launch-agent", name], stdout=log_file, stderr=log_file, cwd=env["ZOE_HOME"]) zconf = self.read_conf() # Force the agent to register port = zconf["agent " + name]["port"] launch_msg = { "dst": "server", "tag": "register", "name": name, "host": env["ZOE_SERVER_HOST"], "port": port } return [ self.feedback(_("Launching agent %s") % name, sender), zoe.MessageBuilder(launch_msg) ]
def feedback(self, message, user): """ If there is a sender, send feedback message with status through Jabber. message -- message to send user -- user to send the message to """ if not user: return to_send = { "dst": "relay", "tag": "relay", "relayto": "jabber", "to": user, "msg": message } return zoe.MessageBuilder(to_send)
def feedback(self, data, user, relayto, subject=None): """ Send feedback to the user data -- may be text or an attachment for e-mail user -- user to send the feedback to relayto -- either 'jabber' or 'mail' subject -- subject of the e-mail """ to_send = { "dst": "relay", "tag": "relay", "relayto": relayto, "to": user, } if relayto == "jabber": to_send["msg"] = data else: to_send["att"] = data.str() to_send["subject"] = subject return zoe.MessageBuilder(to_send)
def messagefromtg(self, json): msgtime = json["date"] if msgtime < self._starttime: #print("Skipping (old message)") return if not 'text' in json: #print("Skipping (no text)") return fromuser = json["from"]["id"] fromtype = json["from"]["type"] fromfull = "%s#%s" % (fromtype, fromuser) totype = json["to"]["type"] text = json["text"] #print("Message from: ", fromfull) user = self.finduser(fromfull) if not user: #print("Ignored") return if totype == "chat": #print ("In-chat not yet implemented") return if text[0:3].lower() != "zoe": return text = text[3:] text64 = base64.standard_b64encode( text.encode('utf-8')).decode('utf-8') aMap = { "dst": "relay", "relayto": "natural", "src": "tg", "tag": ["command", "relay"], "sender": user["id"], "tguser": "******" % (fromtype, fromuser), "cmd": text64 } self.sendbus(zoe.MessageBuilder(aMap).msg())
def _feedback(self, message, user, dst=None, subject=None): """Send a message or mail to the given user. Args: message (str): Message to send. user (str): Unique ID of the user. dst (str): Destination of the message. subject (str): If using email, subject for the mail. """ to_send = {'dst': 'relay', 'to': user} # Check destination if not dst: # If no preferred is found, default to mail users = zoe.Users() if user not in users.subjects(): self.loger.info('Cannot send message, user %s not found' % user) return relayto = users.subject(user).get('preferred', 'mail') else: relayto = dst to_send['relayto'] = relayto if relayto == 'mail': to_send['subject'] = subject or 'Zoe ICE' to_send['txt'] = message else: to_send['msg'] = message return zoe.MessageBuilder(to_send)
def receive(self, parser): """ Called from self._listener when a message arrives. The message is represented by the parser. Messages are key-value pairs: key1 -> value1 key2 -> value2.1, value2.2, value2.3 The parser works as follows: parser.get("...") -> returns the value for the given key, which can be a string or a list of strings parser.get("key1") -> "value1" parser.get("key2") -> ["value2.1", "value2.2", "value2.3"] parser.list("...") -> return the value for the given key as a list, whatever its real class is parser.list("key1") -> ["value1"] parser.list("key2") -> ["value2.1", "value2.2", "value2.3"] """ # read input parameters name = parser.get("name") email = parser.get("email") # create a new message # we could create it with a plain old string: msg = "dst=mail&to=%s&subject=Hello from Zoe&txt=Hi, %s" % (email, name) # but for long messages it is more convenient to generate it from a map: aMap = { "dst": "mail", "to": email, "subject": "Hello from Zoe", "txt": "Hi, " + name } msg = zoe.MessageBuilder(aMap).msg() # send back the new message self._listener.sendbus(msg)
def jabber(self, msg, user): self.logger.info("Jabber to " + user) return zoe.MessageBuilder({"dst": "jabber", "to": user, "msg": msg})
def _tg_msg(self, messages): """Listener for telegram messages.""" for msg in messages: if msg.date < self._starttime: # Skip old messages continue if msg.content_type not in ACCEPTED_TYPES: # Only work with accepted types continue from_user = msg.from_user.id from_username = msg.from_user.username from_chat = msg.chat.id from_full = [] if msg.chat.type == 'group': # Group chat from_full.append('group#%s' % from_chat) from_full.append('user#%s' % from_user) if from_username: # Check also the unique username from_full.append(from_username) used_id, user = self.finduser(from_full) if not user: # Not recognized print( 'Received message from unknown IDs: ', from_full) print( 'Chat/User name was: ', msg.chat.title if from_chat < 0 else msg.from_user.first_name) continue if '#' not in used_id: # This is not a unique ID, notify the user so that they can # add it to their user configuration # API only allows IDs when sending messages self.bot.send_message(from_user, 'Please add "user#%s" to your zoe-users.conf' % from_user) # Remove @BOT_USERNAME from text text = msg.text.replace('@%s' % self._bot_me.username, '').strip() text64 = base64.standard_b64encode( text.encode('utf-8')).decode('utf-8') # We need the chat ID for the answer natural_msg = { 'dst' : 'relay', 'relayto' : 'natural', 'src' : 'tg', 'tag' : ['command', 'relay'], 'sender' : user['id'], 'tguser' : 'user#%s' % from_user, 'tgchat' : str(from_chat), 'cmd' : text64 } self.sendbus(zoe.MessageBuilder(natural_msg).msg())
def tg(self, msg, user): self.logger.info("Telegram to " + user) return zoe.MessageBuilder({"dst": "tg", "to": user, "msg": msg})
def tweet(self, msg, user): self.logger.info("Twit to " + user) return zoe.MessageBuilder({"dst": "twitter", "to": user, "msg": msg})
def notify(self, original=None): users = self._model.asmap() tags = ["users", "notification"] aMap = {"src": "users", "topic": "users", "tag": tags} msg = zoe.MessageBuilder(dict(aMap, **users), original).msg() self._listener.sendbus(msg)
def log(self, source, level, msg, original=None): aMap = {"dst": "log", "src": source, "lvl": level, "msg": msg} m = zoe.MessageBuilder(aMap, original).msg() self.sendbus(m)