def stream(self):
r = self.backend.streamAPIRequest('rooms/%s/chatMessages' %
self.room.idd)
log.debug("connected %s" % self.room.name)
try:
self.reset_reconnection_count()
for line in r.iter_lines(
chunk_size=1): # it fails with anything else than 1.
if line.strip():
json_message = json.loads(line.decode('utf-8'))
from_user = json_message['fromUser']
log.debug("Raw message from room %s: %s" %
(self.room.name, json_message))
m = Message(json_message['text'],
extras={'id': json_message['id']})
if self.room._uri == from_user['url']:
m.to = self.backend.bot_identifier
else:
m.to = self.room
m.frm = GitterRoomOccupant.build_from_json(
self.room, from_user)
self.backend.callback_message(m)
else:
log.debug('Received keep-alive on %s', self.room.name)
except:
log.exception('An exception occured while streaming the room: ')
async def on_message(self, msg: discord.Message):
err_msg = Message(msg.content, extras=msg.embeds)
if isinstance(msg.channel, discord.abc.PrivateChannel):
err_msg.frm = DiscordPerson(msg.author.id)
err_msg.to = self.bot_identifier
else:
err_msg.to = DiscordRoom.from_id(msg.channel.id)
err_msg.frm = DiscordRoomOccupant(msg.author.id, msg.channel.id)
if self.process_message(err_msg):
# Message contains a command
recipient = err_msg.frm
if not isinstance(recipient, DiscordSender):
raise ValueError("Message object from is not a DiscordSender")
async with recipient.get_discord_object().typing():
self._dispatch_to_plugins("callback_message", err_msg)
if msg.mentions:
self.callback_mention(
err_msg,
[
DiscordRoomOccupant(mention.id, msg.channel.id)
for mention in msg.mentions
],
)
def build_msg(self, msg):
text = msg['content']
user = msg['frm']
sendu = msg['send']
ttuser = msg['frm1']
touser = msg['to']
room = msg['room']
msgs = Message(text)
if msg["type"] == "ren":
msgs.frm = wechatPerson(sendu, touser)
else:
msgs.frm = wechatRoomOccupant(userid=sendu, roomid=room)
#self.usrname=ttuser
if ttuser.startswith('@@'):
#msgs.to=wechatPerson(userid=ttuser)
msgs.to = WechatRoom(name=room)
msgs.id = "group"
log.info(msgs.to.name)
else:
msgs.to = wechatPerson(userid=ttuser)
msgs.id = "user"
msgs.send = sendu
log.info('---------------- %s---------%s' % (msgs.to, msgs.frm))
log.info('ssssssssssssssss %s' % msgs)
log.info('ssssssssssssssss %s' % msgs.is_group)
self.callback_message(msgs)
def _message_event_handler(self, event):
"""Event handler for the 'message' event"""
channel = event['channel']
if channel[0] not in 'CGD':
log.warning("Unknown message type! Unable to handle %s", channel)
return
subtype = event.get('subtype', None)
if subtype == "message_deleted":
log.debug("Message of type message_deleted, ignoring this event")
return
if subtype == "message_changed" and 'attachments' in event['message']:
# If you paste a link into Slack, it does a call-out to grab details
# from it so it can display this in the chatroom. These show up as
# message_changed events with an 'attachments' key in the embedded
# message. We should completely ignore these events otherwise we
# could end up processing bot commands twice (user issues a command
# containing a link, it gets processed, then Slack triggers the
# message_changed event and we end up processing it again as a new
# message. This is not what we want).
log.debug(
"Ignoring message_changed event with attachments, likely caused "
"by Slack auto-expanding a link")
return
if 'message' in event:
text = event['message']['text']
user = event['message'].get('user', event.get('bot_id'))
else:
text = event['text']
user = event.get('user', event.get('bot_id'))
text, mentioned = self.process_mentions(text)
text = self.sanitize_uris(text)
log.debug("Saw an event: %s" % pprint.pformat(event))
log.debug("Escaped IDs event text: %s" % text)
msg = Message(text, extras={'attachments': event.get('attachments')})
if channel.startswith('D'):
msg.frm = SlackPerson(self.sc, user, event['channel'])
msg.to = SlackPerson(
self.sc, self.username_to_userid(self.sc.server.username),
event['channel'])
else:
msg.frm = SlackRoomOccupant(self.sc,
user,
event['channel'],
bot=self)
msg.to = SlackRoom(channelid=event['channel'], bot=self)
self.callback_message(msg)
if mentioned:
self.callback_mention(msg, mentioned)
def _message_event_handler(self, event):
"""Event handler for the 'message' event"""
channel = event['channel']
if channel[0] not in 'CGD':
log.warning("Unknown message type! Unable to handle %s", channel)
return
subtype = event.get('subtype', None)
if subtype == "message_deleted":
log.debug("Message of type message_deleted, ignoring this event")
return
if subtype == "message_changed" and 'attachments' in event['message']:
# If you paste a link into Slack, it does a call-out to grab details
# from it so it can display this in the chatroom. These show up as
# message_changed events with an 'attachments' key in the embedded
# message. We should completely ignore these events otherwise we
# could end up processing bot commands twice (user issues a command
# containing a link, it gets processed, then Slack triggers the
# message_changed event and we end up processing it again as a new
# message. This is not what we want).
log.debug(
"Ignoring message_changed event with attachments, likely caused "
"by Slack auto-expanding a link"
)
return
if 'message' in event:
text = event['message']['text']
user = event['message'].get('user', event.get('bot_id'))
else:
text = event['text']
user = event.get('user', event.get('bot_id'))
text, mentioned = self.process_mentions(text)
text = self.sanitize_uris(text)
log.debug("Saw an event: %s" % pprint.pformat(event))
log.debug("Escaped IDs event text: %s" % text)
msg = Message(
text,
extras={'attachments': event.get('attachments')})
if channel.startswith('D'):
msg.frm = SlackPerson(self.sc, user, event['channel'])
msg.to = SlackPerson(self.sc, self.username_to_userid(self.sc.server.username),
event['channel'])
else:
msg.frm = SlackRoomOccupant(self.sc, user, event['channel'], bot=self)
msg.to = SlackRoom(channelid=event['channel'], bot=self)
self.callback_message(msg)
if mentioned:
self.callback_mention(msg, mentioned)
def _message_event_handler(self, event):
"""Event handler for the 'message' event"""
channel = event['channel']
if channel.startswith('C'):
log.debug("Handling message from a public channel")
message_type = 'groupchat'
elif channel.startswith('G'):
log.debug("Handling message from a private group")
message_type = 'groupchat'
elif channel.startswith('D'):
log.debug("Handling message from a user")
message_type = 'chat'
else:
log.warning("Unknown message type! Unable to handle")
return
subtype = event.get('subtype', None)
if subtype == "message_deleted":
log.debug("Message of type message_deleted, ignoring this event")
return
if subtype == "message_changed" and 'attachments' in event['message']:
# If you paste a link into Slack, it does a call-out to grab details
# from it so it can display this in the chatroom. These show up as
# message_changed events with an 'attachments' key in the embedded
# message. We should completely ignore these events otherwise we
# could end up processing bot commands twice (user issues a command
# containing a link, it gets processed, then Slack triggers the
# message_changed event and we end up processing it again as a new
# message. This is not what we want).
log.debug(
"Ignoring message_changed event with attachments, likely caused "
"by Slack auto-expanding a link")
return
if 'message' in event:
text = event['message']['text']
user = event['message']['user']
else:
text = event['text']
user = event['user']
text = re.sub("<[^>]*>", self.remove_angle_brackets_from_uris, text)
msg = Message(text, type_=message_type)
if message_type == 'chat':
msg.frm = SlackIdentifier(self.sc, user, event['channel'])
msg.to = SlackIdentifier(
self.sc, self.username_to_userid(self.sc.server.username),
event['channel'])
else:
msg.frm = SlackMUCOccupant(self.sc, user, event['channel'])
msg.to = SlackMUCOccupant(
self.sc, self.username_to_userid(self.sc.server.username),
event['channel'])
self.callback_message(msg)
def _message_event_handler(self, event):
"""Event handler for the 'message' event"""
channel = event['channel']
if channel.startswith('C'):
log.debug("Handling message from a public channel")
message_type = 'groupchat'
elif channel.startswith('G'):
log.debug("Handling message from a private group")
message_type = 'groupchat'
elif channel.startswith('D'):
log.debug("Handling message from a user")
message_type = 'chat'
else:
log.warning("Unknown message type! Unable to handle")
return
subtype = event.get('subtype', None)
if subtype == "message_deleted":
log.debug("Message of type message_deleted, ignoring this event")
return
if subtype == "message_changed" and 'attachments' in event['message']:
# If you paste a link into Slack, it does a call-out to grab details
# from it so it can display this in the chatroom. These show up as
# message_changed events with an 'attachments' key in the embedded
# message. We should completely ignore these events otherwise we
# could end up processing bot commands twice (user issues a command
# containing a link, it gets processed, then Slack triggers the
# message_changed event and we end up processing it again as a new
# message. This is not what we want).
log.debug(
"Ignoring message_changed event with attachments, likely caused "
"by Slack auto-expanding a link"
)
return
if 'message' in event:
text = event['message']['text']
user = event['message']['user']
else:
text = event['text']
user = event['user']
text = re.sub("<[^>]*>", self.remove_angle_brackets_from_uris, text)
msg = Message(text, type_=message_type)
if message_type == 'chat':
msg.frm = SlackIdentifier(self.sc, user, event['channel'])
msg.to = SlackIdentifier(self.sc, self.username_to_userid(self.sc.server.username),
event['channel'])
else:
msg.frm = SlackMUCOccupant(self.sc, user, event['channel'])
msg.to = SlackMUCOccupant(self.sc, self.username_to_userid(self.sc.server.username),
event['channel'])
self.callback_message(msg)
def on_message(self, msg: discord.Message):
err_msg = Message(msg.content)
if msg.channel.is_private:
err_msg.frm = DiscordPerson.from_user(msg.author)
err_msg.to = self.bot_identifier
else:
err_msg.to = DiscordRoom.from_channel(msg.channel)
err_msg.frm = DiscordRoomOccupant.from_user_and_channel(msg.author, msg.channel)
log.debug('Received message %s' % msg)
self.callback_message(err_msg)
if msg.mentions:
self.callback_mention(err_msg,
[DiscordRoomOccupant.from_user_and_channel(mention, msg.channel)
for mention in msg.mentions])
def on_message(self, msg: discord.Message):
err_msg = Message(msg.content)
if msg.channel.is_private:
err_msg.frm = DiscordPerson.from_user(msg.author)
err_msg.to = self.bot_identifier
else:
err_msg.to = DiscordRoom.from_channel(msg.channel)
err_msg.frm = DiscordRoomOccupant.from_user_and_channel(msg.author, msg.channel)
log.debug('Received message %s' % msg)
self.callback_message(err_msg)
if msg.mentions:
self.callback_mention(err_msg,
[DiscordRoomOccupant.from_user_and_channel(mention, msg.channel)
for mention in msg.mentions])
def send_command(self, text):
self.app.new_message(text, False)
msg = Message(text)
msg.frm = self.build_identifier(self.bot_config.BOT_ADMINS[0]) # assume this is the admin talking
msg.to = self.bot_identifier # To me only
self.callback_message(msg)
self.app.input.clear()
def on_group_message(self, group_number, friend_group_number, message):
logging.debug('TOX: Group-%i User-%i: %s' % (group_number, friend_group_number, message))
msg = Message(message, type_='groupchat')
msg.frm = Identifier(node=str(group_number), resource=str(friend_group_number))
msg.to = self.backend.jid
logging.debug('TOX: callback with type = %s' % msg.type)
self.backend.callback_message(msg)
def _message_event_handler(self, event):
"""Event handler for the 'message' event"""
channel = event['channel']
if channel.startswith('C'):
logging.debug("Handling message from a public channel")
message_type = 'groupchat'
elif channel.startswith('G'):
logging.debug("Handling message from a private group")
message_type = 'groupchat'
elif channel.startswith('D'):
logging.debug("Handling message from a user")
message_type = 'chat'
else:
logging.warning("Unknown message type! Unable to handle")
return
msg = Message(event['text'], type_=message_type)
msg.frm = SlackIdentifier(
node=self.channelid_to_channelname(event['channel']),
domain=self.sc.server.domain,
resource=self.userid_to_username(event['user'])
)
msg.to = SlackIdentifier(
node=self.channelid_to_channelname(event['channel']),
domain=self.sc.server.domain,
resource=self.sc.server.username
)
msg.nick = msg.frm.resource
self.callback_message(msg)
def serve_forever(self):
me = self.build_identifier(self.bot_config.BOT_ADMINS[0])
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=me, status=ONLINE))
try:
while True:
if ANSI:
entry = input('\n' + str(fg.cyan) + ' >>> ' +
str(fx.reset))
else:
entry = input('\n>>> ')
msg = Message(entry)
msg.frm = me
msg.to = self.bot_identifier
self.callback_message(msg)
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
# simulate some real presence
self.callback_presence(Presence(identifier=me, status=OFFLINE))
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
def _handle_message(self, message):
try:
data = json.loads(message.data.decode('utf-8'))
except Exception:
log.warning('Receieved malformed message: {}'.format(message.data))
message.ack()
return
if not data.get('message'):
message.ack()
return
sender_blob = data['message']['sender']
sender = HangoutsChatUser(sender_blob['name'],
sender_blob['displayName'],
sender_blob['email'], sender_blob['type'])
message_body = data['message']['text']
message.ack()
context = {
'space_id': data['space']['name'],
'thread_id': data['message']['thread']['name']
}
msg = Message(body=message_body.strip(), frm=sender, extras=context)
is_dm = data['message']['space']['type'] == 'DM'
if is_dm:
msg.to = self.bot_identifier
self.callback_message(msg)
def serve_forever(self):
me = self.build_identifier(self.bot_config.BOT_ADMINS[0])
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=me, status=ONLINE))
try:
while True:
if ANSI:
entry = input("\n" + str(fg.cyan) + " >>> " + str(fx.reset))
else:
entry = input("\n>>> ")
msg = Message(entry)
msg.frm = me
msg.to = self.bot_identifier
self.callback_message(msg)
mentioned = [
self.build_identifier(word[1:]) for word in re.findall(r"@[\w']+", entry) if word.startswith("@")
]
if mentioned:
self.callback_mention(msg, mentioned)
sleep(0.5)
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
# simulate some real presence
self.callback_presence(Presence(identifier=me, status=OFFLINE))
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
def msg_event_handler(self, msg):
global text, mentioned
if msg['group']:
try:
text = msg['content'][0]
except:
text = 'Null'
user = msg['send_uid']
touser = msg['to_uid']
group = msg['group']
else:
try:
text = msg['content'][0]
except:
text = 'Null'
user = msg['send_uid']
touser = msg['to_uid']
group = None
text, mentioned = self.process_mentions(text)
msg = Message(text)
msg.frm = QqSlackPerson(self.sc, user, group)
msg.to = QqSlackPerson(self.sc, touser, group)
self.callback_message(msg)
if mentioned:
self.callback_mention(msg, mentioned)
def serve_forever(self):
self.connect_callback() # notify that the connection occured
try:
while True:
print('waiting on queue')
stanza_type, entry = self.incoming_stanza_queue.get()
print('message received')
if entry == QUIT_MESSAGE:
log.info("Stop magic message received, quitting...")
break
if stanza_type is STZ_MSG:
msg = Message(entry)
msg.frm = self.sender
msg.to = self.bot_identifier # To me only
self.callback_message(msg)
elif stanza_type is STZ_PRE:
log.info("Presence stanza received.")
self.callback_presence(entry)
elif stanza_type is STZ_IQ:
log.info("IQ stanza received.")
else:
log.error("Unknown stanza type.")
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
def send_command(self, text):
self.app.new_message(text, False)
msg = Message(text)
msg.frm = config.BOT_ADMINS[0] # assume this is the admin talking
msg.to = self.jid # To me only
self.callback_message(msg)
self.app.input.clear()
def on_group_message(self, group_number, friend_group_number, message):
log.debug('TOX: Group-%i User-%i: %s' % (group_number, friend_group_number, message))
msg = Message(message, type_='groupchat')
msg.frm = ToxIdentifier(group_number=str(group_number), friend_group_number=str(friend_group_number))
msg.to = self.backend.bot_identifier
log.debug('TOX: callback with type = %s' % msg.type)
self.backend.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
msg.frm = self.build_identifier(xmppmsg['from'].full)
msg.to = self.build_identifier(xmppmsg['to'].full)
log.debug("incoming_message frm : %s" % msg.frm)
if xmppmsg['type'] == 'groupchat':
room = XMPPRoom(msg.frm.node + '@' + msg.frm.domain, self)
msg.frm = XMPPRoomOccupant(msg.frm.node, msg.frm.domain, msg.frm.resource, room)
msg.to = room
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr('stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def serve_forever(self):
import config
self.jid = Identifier('Err') # whatever
self.connect_callback() # notify that the connection occured
self.sender = config.BOT_ADMINS[0] # By default, assume this is the admin talking
try:
while True:
stanza_type, entry = incoming_stanza_queue.get()
if entry == QUIT_MESSAGE:
logging.info("Stop magic message received, quitting...")
break
if stanza_type is STZ_MSG:
msg = Message(entry)
msg.frm = self.sender
msg.to = self.jid # To me only
self.callback_message(msg)
elif stanza_type is STZ_PRE:
logging.info("Presence stanza received.")
self.callback_presence(entry)
elif stanza_type is STZ_IQ:
logging.info("IQ stanza received.")
else:
logging.error("Unknown stanza type.")
except EOFError as _:
pass
except KeyboardInterrupt as _:
pass
finally:
logging.debug("Trigger disconnect callback")
self.disconnect_callback()
logging.debug("Trigger shutdown")
self.shutdown()
def serve_forever(self):
self.jid = Identifier('Err')
me = Identifier(config.BOT_ADMINS[0])
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=me, status=ONLINE))
try:
while True:
if ANSI:
entry = input('\n' + A_CYAN + ' >>> ' + A_RESET)
else:
entry = input('\n>>> ')
msg = Message(entry)
msg.frm = me
msg.to = self.jid
self.callback_message(msg)
except EOFError as eof:
pass
except KeyboardInterrupt as ki:
pass
finally:
# simulate some real presence
self.callback_presence(Presence(identifier=me, status=OFFLINE))
logging.debug("Trigger disconnect callback")
self.disconnect_callback()
logging.debug("Trigger shutdown")
self.shutdown()
def on_pubmsg(self, _, e):
msg = Message(e.arguments[0], type_='groupchat')
msg.frm = e.target
msg.to = self.callback.jid
msg.nick = e.source.split('!')[
0] # FIXME find the real nick in the channel
self.callback.callback_message(msg)
def serve_forever(self):
me = self.build_identifier(self.bot_config.BOT_ADMINS[0])
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=me, status=ONLINE))
try:
while True:
if ANSI:
entry = input('\n' + str(fg.cyan) + ' >>> ' + str(fx.reset))
else:
entry = input('\n>>> ')
msg = Message(entry)
msg.frm = me
msg.to = self.bot_identifier
self.callback_message(msg)
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
# simulate some real presence
self.callback_presence(Presence(identifier=me, status=OFFLINE))
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
def serve_once(self):
"""
チャットシステムから新着メッセージを受け取り処理を行うメソッド
このserve_onceメソッドはErrBotから定期的にコールされる
似たようなオーバーライド対象メソッドにserve_foreverもある
ref. http://errbot.io/en/latest/errbot.backends.base.html#errbot.backends.base.Backend.serve_forever
"""
# 新着メッセージを取得
mess = self.client.new_messages()
# 取得したメッセージを順番に処理
# メッセージにはユーザー名と発言されたルーム名も格納されている
for msg in mess:
# Messageオブジェクトを構築
m = Message(msg)
m.frm = HogeRoomOccupant(msg.username, msg.roomname, self)
m.to = HogeRoom(msg.roomname, self)
# メッセージのコールバックを呼び出す
self.callback_message(m)
# @<username>が含まれている場合はcallback_mentionも呼び出す
# 詳細な実装を省いているので注意
if '@' in msg:
mentions = [HogeUser(username, self), ...]
self.callback_mention(m, mentions)
def serve_forever(self):
import config
self.jid = Identifier('Err') # whatever
self.connect_callback() # notify that the connection occured
self.sender = config.BOT_ADMINS[
0] # By default, assume this is the admin talking
try:
while True:
stanza_type, entry = incoming_stanza_queue.get()
if entry == QUIT_MESSAGE:
logging.info("Stop magic message received, quitting...")
break
if stanza_type is STZ_MSG:
msg = Message(entry)
msg.frm = self.sender
msg.to = self.jid # To me only
self.callback_message(msg)
elif stanza_type is STZ_PRE:
logging.info("Presence stanza received.")
self.callback_presence(entry)
elif stanza_type is STZ_IQ:
logging.info("IQ stanza received.")
else:
logging.error("Unknown stanza type.")
except EOFError as _:
pass
except KeyboardInterrupt as _:
pass
finally:
logging.debug("Trigger disconnect callback")
self.disconnect_callback()
logging.debug("Trigger shutdown")
self.shutdown()
def handle_event_MESSAGE(self, data):
# https://developers.google.com/chat/api/guides/message-formats/events#message
sender_blob = data.get('message', {}).get('sender', {})
sender = HangoutsChatUser(sender_blob.get('name', ''),
sender_blob.get('displayName', ''),
sender_blob.get('email', ''),
sender_blob.get('type', ''))
message_body = data['message'].get('text','')
context = {
'space_id': data['space']['name'],
'thread_id': data['message']['thread']['name']
}
if 'attachment' in data['message']:
context['attachment'] = data['message']['attachment']
# pass httplib2.Http() authenticated handler to errbot. uselful to download attachments
context['downloader'] = self.chat_api._download
msg = Message(body=message_body.strip(), frm=sender, extras=context)
is_dm = data['message']['space']['type'] == 'DM'
if is_dm:
msg.to = self.bot_identifier
self.callback_message(msg)
def _handle_message(self, message):
message_instance = Message(message[6],
extras={'forward_messages': message[1]})
if message[3] > 2000000000:
# conference chat
room = VKRoom(id=message[3] - 2000000000, title=message[5])
user_id = message[7].get("from", "?")
user = self.get_user_query(user_id)
message_instance.frm = VKMUCOccupant(id=user_id,
room=room,
first_name=user["first_name"],
last_name=user["last_name"],
username="******")
message_instance.to = message[3]
else:
# private
user_id = str(message[3])
user = self.get_user_query(user_id)
if user:
message_instance.frm = VKPerson(id=str(message[3]),
first_name=user["first_name"],
last_name=user["last_name"],
username="******")
else:
message_instance.frm = VKPerson(id=str(message[3]),
first_name=None,
last_name=None,
username="******")
message_instance.to = message[3]
log.info("[{}]: {}".format(message[3], message[6]))
message_instance.extras["forward_messages"] = message[1]
if message[7].get("source_act", None):
if message[7].get("source_act", None) == "chat_invite_user":
if int(message[7]["source_mid"]) == int(
self.bot_identifier.id):
self.callback_room_joined(self)
else:
self.callback_message(message_instance)
def on_group_message(self, group_number, friend_group_number, message):
log.debug('TOX: Group-%i User-%i: %s' %
(group_number, friend_group_number, message))
msg = Message(message, type_='groupchat')
msg.frm = ToxIdentifier(group_number=str(group_number),
friend_group_number=str(friend_group_number))
msg.to = self.backend.bot_identifier
log.debug('TOX: callback with type = %s' % msg.type)
self.backend.callback_message(msg)
def build_reply(self,
msg: Message,
text=None,
private: bool = False,
threaded: bool = False) -> Message:
msg = self.build_message(text)
msg.frm = self.bot_identifier
msg.to = msg.frm
return msg
def msg_callback(self, message):
logging.debug('Incoming message [%s]' % message)
user = ""
if message.user:
user = message.user.name
if message.is_text():
msg = Message(message.body, type_='groupchat') # it is always a groupchat in campfire
msg.frm = user + '@' + message.room.get_data()['name'] + '/' + user
msg.to = self.jid # assume it is for me
self.callback_message(msg)
def msg_callback(self, message):
log.debug("Incoming message [%s]" % message)
user = ""
if message.user:
user = message.user.name
if message.is_text():
msg = Message(message.body, type_="groupchat") # it is always a groupchat in campfire
msg.frm = user + "@" + message.room.get_data()["name"] + "/" + user
msg.to = self.jid # assume it is for me
self.callback_message(msg)
def background():
log.debug("thread for %s started" % room.idd)
r = self.streamAPIRequest('rooms/%s/chatMessages' % room.idd)
log.debug("connected %s" % room.name)
for line in r.iter_lines(chunk_size=1): # it fails with anything else than 1.
if line.strip():
json_message = json.loads(line.decode('utf-8'))
from_user = json_message['fromUser']
log.debug("Raw message from room %s: %s" % (room.name, json_message))
if room._uri == from_user['url']:
m = Message(json_message['text'])
m.to = self.bot_identifier
else:
m = Message(json_message['text'])
m.to = room
m.frm = GitterRoomOccupant.build_from_json(room, from_user)
self.callback_message(m)
else:
log.debug('Received keep-alive on %s', room.name)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
msg = Message(xmppmsg["body"])
if "html" in xmppmsg.keys():
msg.html = xmppmsg["html"]
msg.frm = self.build_identifier(xmppmsg["from"].full)
msg.to = self.build_identifier(xmppmsg["to"].full)
log.debug("incoming_message frm : %s" % msg.frm)
log.debug("incoming_message frm node: %s" % msg.frm.node)
log.debug("incoming_message frm domain: %s" % msg.frm.domain)
log.debug("incoming_message frm resource: %s" % msg.frm.resource)
msg.type = xmppmsg["type"]
if msg.type == "groupchat":
# those are not simple identifiers, they are muc occupants.
msg.frm = XMPPMUCOccupant(msg.frm.node, msg.frm.domain, msg.frm.resource)
msg.to = XMPPMUCOccupant(msg.to.node, msg.to.domain, msg.to.resource)
msg.nick = xmppmsg["mucnick"]
msg.delayed = bool(xmppmsg["delay"]._get_attr("stamp")) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def on_pubmsg(self, _, e):
msg = Message(e.arguments[0], type_='groupchat')
nick = e.source.split('!')[0]
room = e.target
if room[0] != '#' and room[0] != '$':
raise Exception('[%s] is not a room' % room)
msg.frm = IRCMUCOccupant(nick, room)
msg.to = self.callback.bot_identifier
msg.nick = nick # FIXME find the real nick in the channel
self.callback.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
msg.frm = self.build_identifier(xmppmsg['from'].full)
msg.to = self.build_identifier(xmppmsg['to'].full)
log.debug("incoming_message frm : %s" % msg.frm)
log.debug("incoming_message frm node: %s" % msg.frm.node)
log.debug("incoming_message frm domain: %s" % msg.frm.domain)
log.debug("incoming_message frm resource: %s" % msg.frm.resource)
msg.type = xmppmsg['type']
if msg.type == 'groupchat':
# those are not simple identifiers, they are muc occupants.
msg.frm = XMPPMUCOccupant(msg.frm.node, msg.frm.domain, msg.frm.resource)
msg.to = XMPPMUCOccupant(msg.to.node, msg.to.domain, msg.to.resource)
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr('stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def msg_callback(self, message):
log.debug('Incoming message [%s]' % message)
user = ""
if message.user:
user = message.user.name
if message.is_text():
msg = Message(message.body, type_='groupchat') # it is always a groupchat in campfire
msg.frm = CampfireIdentifier(user)
msg.to = self.bot_identifier # assume it is for me
self.callback_message(msg)
def on_pubmsg(self, _, e):
msg = Message(e.arguments[0], type_='groupchat')
nick = e.source.split('!')[0]
room = e.target
if room[0] != '#' and room[0] != '$':
raise Exception('[%s] is not a room' % room)
msg.frm = IRCMUCOccupant(nick, room)
msg.to = self.callback.bot_identifier
msg.nick = nick # FIXME find the real nick in the channel
self.callback.callback_message(msg)
def msg_callback(self, message):
logging.debug('Incoming message [%s]' % message)
user = ""
if message.user:
user = message.user.name
if message.is_text():
msg = Message(message.body, type_='groupchat') # it is always a groupchat in campfire
msg.frm = user + '@' + message.room.get_data()['name'] + '/' + user
msg.to = self.jid # assume it is for me
self.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
msg.frm = xmppmsg['from'].full
msg.to = xmppmsg['to'].full
msg.type = xmppmsg['type']
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr('stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
msg.frm = xmppmsg['from'].full
msg.to = xmppmsg['to'].full
msg.type = xmppmsg['type']
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr('stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
if xmppmsg['type'] == "error":
log.warning("Received error message: %s", xmppmsg)
return
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
log.debug("incoming_message from: %s", msg.frm)
if xmppmsg['type'] == 'groupchat':
msg.frm = self._build_room_occupant(xmppmsg['from'].full)
msg.to = msg.frm.room
else:
msg.frm = self._build_person(xmppmsg['from'].full)
msg.to = self._build_person(xmppmsg['to'].full)
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr('stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
if xmppmsg["type"] == "error":
log.warning("Received error message: %s", xmppmsg)
return
msg = Message(xmppmsg["body"])
if "html" in xmppmsg.keys():
msg.html = xmppmsg["html"]
log.debug("incoming_message from: %s", msg.frm)
if xmppmsg["type"] == "groupchat":
msg.frm = self._build_room_occupant(xmppmsg["from"].full)
msg.to = msg.frm.room
else:
msg.frm = self._build_person(xmppmsg["from"].full)
msg.to = self._build_person(xmppmsg["to"].full)
msg.nick = xmppmsg["mucnick"]
msg.delayed = bool(xmppmsg["delay"]._get_attr(
"stamp")) # this is a bug in slixmpp it should be ['from']
self.callback_message(msg)
def background():
log.debug("thread for %s started" % room.idd)
r = self.streamAPIRequest('rooms/%s/chatMessages' % room.idd)
log.debug("connected %s" % room.name)
for line in r.iter_lines(
chunk_size=1): # it fails with anything else than 1.
if line.strip():
json_message = json.loads(line.decode('utf-8'))
from_user = json_message['fromUser']
log.debug("Raw message from room %s: %s" %
(room.name, json_message))
if room._uri == from_user['url']:
m = Message(json_message['text'])
m.to = self.bot_identifier
else:
m = Message(json_message['text'])
m.to = room
m.frm = GitterRoomOccupant.build_from_json(room, from_user)
self.callback_message(m)
else:
log.debug('Received keep-alive on %s', room.name)
def callback(self, *events):
for event in events:
log.debug("Saw event %s.", event)
if event["type"] == "m.room.message":
content = event["content"]
sender = event["sender"]
if content["msgtype"] == "m.text":
msg = Message(content["body"],
extras={'room_id': event["room_id"]})
msg.frm = MatrixPerson(self._client, sender)
msg.to = self.bot_identifier
self.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
if xmppmsg['type'] == "error":
log.warning("Received error message: %s", xmppmsg)
return
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
log.debug("incoming_message from: %s", msg.frm)
if xmppmsg['type'] == 'groupchat':
msg.frm = self._build_room_occupant(xmppmsg['from'].full)
msg.to = msg.frm.room
else:
msg.frm = self._build_person(xmppmsg['from'].full)
msg.to = self._build_person(xmppmsg['to'].full)
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr(
'stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def _message_event_handler(self, message):
"""
Event handler for the 'message' event
"""
roomid = message.get('room', {}).get('id')
text = message.get('text', '')
owner = message.get('owner', {}).get('username')
text, mentioned = self._extract_mentions_from(text)
msg = Message(text)
msg.frm = LetschatRoomOccupant(self.client, owner, roomid, self)
if self.bot_identifier in mentioned:
msg.to = self.bot_identifier
else:
msg.to = LetschatRoom(roomid=roomid, bot=self)
self.callback_message(msg)
if mentioned:
self.callback_mention(msg, mentioned)
def send_command(self, text):
self.app.new_message(text, False)
msg = Message(text)
msg.frm = self.user
msg.to = self.bot_identifier # To me only
self.callback_message(msg)
# implements the mentions.
mentioned = [self.build_identifier(word[1:]) for word in re.findall(r"@[\w']+", text) if word.startswith("@")]
if mentioned:
self.callback_mention(msg, mentioned)
self.app.input.clear()
def incoming_message(self, xmppmsg):
"""Callback for message events"""
if xmppmsg['type'] == "error":
log.warning("Received error message: %s", xmppmsg)
return
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
msg.frm = self.build_identifier(xmppmsg['from'].full)
msg.to = self.build_identifier(xmppmsg['to'].full)
log.debug("incoming_message from: %s", msg.frm)
if xmppmsg['type'] == 'groupchat':
room = self.room_factory(msg.frm.node + '@' + msg.frm.domain, self)
msg.frm = self.roomoccupant_factory(msg.frm.node, msg.frm.domain,
msg.frm.resource, room)
msg.to = room
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr(
'stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def incoming_message(self, xmppmsg):
"""Callback for message events"""
msg = Message(xmppmsg['body'])
if 'html' in xmppmsg.keys():
msg.html = xmppmsg['html']
msg.frm = self.build_identifier(xmppmsg['from'].full)
msg.to = self.build_identifier(xmppmsg['to'].full)
log.debug("incoming_message frm : %s" % msg.frm)
log.debug("incoming_message frm node: %s" % msg.frm.node)
log.debug("incoming_message frm domain: %s" % msg.frm.domain)
log.debug("incoming_message frm resource: %s" % msg.frm.resource)
msg.type = xmppmsg['type']
if msg.type == 'groupchat':
# those are not simple identifiers, they are muc occupants.
msg.frm = XMPPMUCOccupant(msg.frm.node, msg.frm.domain,
msg.frm.resource)
msg.to = XMPPMUCOccupant(msg.to.node, msg.to.domain,
msg.to.resource)
msg.nick = xmppmsg['mucnick']
msg.delayed = bool(xmppmsg['delay']._get_attr(
'stamp')) # this is a bug in sleekxmpp it should be ['from']
self.callback_message(msg)
def send_command(self, text):
self.app.new_message(text, False)
msg = Message(text)
msg.frm = self.build_identifier(self.bot_config.BOT_ADMINS[0]) # assume this is the admin talking
msg.to = self.bot_identifier # To me only
self.callback_message(msg)
# implements the mentions.
mentioned = [self.build_identifier(word[1:]) for word in re.findall(r"@[\w']+", text)
if word.startswith('@')]
if mentioned:
self.callback_mention(msg, mentioned)
self.app.input.clear()
def on_pubmsg(self, _, e):
msg = Message(e.arguments[0], type_='groupchat')
room = e.target
if room[0] != '#' and room[0] != '$':
raise Exception('[%s] is not a room' % room)
msg.frm = IRCMUCOccupant(e.source, room)
msg.to = self.callback.bot_identifier
msg.nick = msg.frm.nick # FIXME find the real nick in the channel
self.callback.callback_message(msg)
possible_mentions = re.findall(IRC_NICK_REGEX, e.arguments[0])
room_users = self.channels[room].users()
mentions = filter(lambda x: x in room_users, possible_mentions)
if mentions:
mentions = [self.build_identifier(mention) for mention in mentions]
self.callback.callback_mention(msg, mentions)
def _pubmsg(self, e, notice=False):
msg = Message(e.arguments[0], extras={'notice': notice})
room_name = e.target
if room_name[0] != '#' and room_name[0] != '$':
raise Exception(f'[{room_name}] is not a room')
room = IRCRoom(room_name, self.bot)
msg.frm = IRCRoomOccupant(e.source, room)
msg.to = room
msg.nick = msg.frm.nick # FIXME find the real nick in the channel
self.bot.callback_message(msg)
possible_mentions = re.findall(IRC_NICK_REGEX, e.arguments[0])
room_users = self.channels[room_name].users()
mentions = filter(lambda x: x in room_users, possible_mentions)
if mentions:
mentions = [self.bot.build_identifier(mention) for mention in mentions]
self.bot.callback_mention(msg, mentions)
def serve_forever(self):
self.connect_callback() # notify that the connection occured
try:
while True:
print("waiting on queue")
stanza_type, entry = self.incoming_stanza_queue.get()
print("message received")
if entry == QUIT_MESSAGE:
log.info("Stop magic message received, quitting...")
break
if stanza_type is STZ_MSG:
msg = Message(entry)
msg.frm = self.sender
msg.to = self.bot_identifier # To me only
self.callback_message(msg)
# implements the mentions.
mentioned = [self.build_identifier(word[1:]) for word in entry.split() if word.startswith("@")]
if mentioned:
self.callback_mention(msg, mentioned)
elif stanza_type is STZ_PRE:
log.info("Presence stanza received.")
self.callback_presence(entry)
elif stanza_type is STZ_IQ:
log.info("IQ stanza received.")
else:
log.error("Unknown stanza type.")
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
def serve_forever(self):
if self.demo_mode:
# disable the console logging once it is serving in demo mode.
root = logging.getLogger()
root.removeHandler(err.console_hdlr)
root.addHandler(logging.NullHandler())
me = self.build_identifier(self.bot_config.BOT_ADMINS[0])
self.connect_callback() # notify that the connection occured
self.callback_presence(Presence(identifier=me, status=ONLINE))
try:
while True:
if ANSI or self.demo_mode:
entry = input('\n' + str(fg.cyan) + ' >>> ' + str(fx.reset))
else:
entry = input('\n>>> ')
msg = Message(entry)
msg.frm = me
msg.to = self.bot_identifier
self.callback_message(msg)
mentioned = [self.build_identifier(word[1:]) for word in re.findall(r"@[\w']+", entry)
if word.startswith('@')]
if mentioned:
self.callback_mention(msg, mentioned)
sleep(.5)
except EOFError:
pass
except KeyboardInterrupt:
pass
finally:
# simulate some real presence
self.callback_presence(Presence(identifier=me, status=OFFLINE))
log.debug("Trigger disconnect callback")
self.disconnect_callback()
log.debug("Trigger shutdown")
self.shutdown()
def on_privmsg(self, _, e):
msg = Message(e.arguments[0])
msg.frm = IRCPerson(e.source)
msg.to = IRCPerson(e.target)
self.bot.callback_message(msg)
