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)
