diff options
Diffstat (limited to 'weechat/python/autoload/wee_slack.py')
| -rw-r--r-- | weechat/python/autoload/wee_slack.py | 2557 |
1 files changed, 2557 insertions, 0 deletions
diff --git a/weechat/python/autoload/wee_slack.py b/weechat/python/autoload/wee_slack.py new file mode 100644 index 0000000..5f4833a --- /dev/null +++ b/weechat/python/autoload/wee_slack.py @@ -0,0 +1,2557 @@ +# -*- coding: utf-8 -*- +# + +from functools import wraps + +import time +import json +import os +import pickle +import sha +import re +import urllib +import HTMLParser +import sys +import traceback +import collections +import ssl + +from websocket import create_connection, WebSocketConnectionClosedException + +# hack to make tests possible.. better way? +try: + import weechat as w +except: + pass + +SCRIPT_NAME = "slack_extension" +SCRIPT_AUTHOR = "Ryan Huber <rhuber@gmail.com>" +SCRIPT_VERSION = "0.99.9" +SCRIPT_LICENSE = "MIT" +SCRIPT_DESC = "Extends weechat for typing notification/search/etc on slack.com" + +BACKLOG_SIZE = 200 +SCROLLBACK_SIZE = 500 + +CACHE_VERSION = "4" + +SLACK_API_TRANSLATOR = { + "channel": { + "history": "channels.history", + "join": "channels.join", + "leave": "channels.leave", + "mark": "channels.mark", + "info": "channels.info", + }, + "im": { + "history": "im.history", + "join": "im.open", + "leave": "im.close", + "mark": "im.mark", + }, + "group": { + "history": "groups.history", + "join": "channels.join", + "leave": "groups.leave", + "mark": "groups.mark", + } + +} + +NICK_GROUP_HERE = "0|Here" +NICK_GROUP_AWAY = "1|Away" + +sslopt_ca_certs = {} +if hasattr(ssl, "get_default_verify_paths") and callable(ssl.get_default_verify_paths): + ssl_defaults = ssl.get_default_verify_paths() + if ssl_defaults.cafile is not None: + sslopt_ca_certs = {'ca_certs': ssl_defaults.cafile} + + +def dbg(message, fout=False, main_buffer=False): + """ + send debug output to the slack-debug buffer and optionally write to a file. + """ + message = "DEBUG: {}".format(message) + # message = message.encode('utf-8', 'replace') + if fout: + file('/tmp/debug.log', 'a+').writelines(message + '\n') + if main_buffer: + w.prnt("", "slack: " + message) + else: + if slack_debug is not None: + w.prnt(slack_debug, message) + + +class SearchList(list): + """ + A normal python list with some syntactic sugar for searchability + """ + def __init__(self): + self.hashtable = {} + super(SearchList, self).__init__(self) + + def find(self, name): + if name in self.hashtable: + return self.hashtable[name] + # this is a fallback to __eq__ if the item isn't in the hashtable already + if name in self: + self.update_hashtable() + return self[self.index(name)] + + def append(self, item, aliases=[]): + super(SearchList, self).append(item) + self.update_hashtable(item) + + def update_hashtable(self, item=None): + if item is not None: + try: + for alias in item.get_aliases(): + if alias is not None: + self.hashtable[alias] = item + except AttributeError: + pass + else: + for child in self: + try: + for alias in child.get_aliases(): + if alias is not None: + self.hashtable[alias] = child + except AttributeError: + pass + + def find_by_class(self, class_name): + items = [] + for child in self: + if child.__class__ == class_name: + items.append(child) + return items + + def find_by_class_deep(self, class_name, attribute): + items = [] + for child in self: + if child.__class__ == self.__class__: + items += child.find_by_class_deep(class_name, attribute) + else: + items += (eval('child.' + attribute).find_by_class(class_name)) + return items + + +class SlackServer(object): + """ + Root object used to represent connection and state of the connection to a slack group. + """ + def __init__(self, token): + self.nick = None + self.name = None + self.team = None + self.domain = None + self.server_buffer_name = None + self.login_data = None + self.buffer = None + self.token = token + self.ws = None + self.ws_hook = None + self.users = SearchList() + self.bots = SearchList() + self.channels = SearchList() + self.connecting = False + self.connected = False + self.connection_attempt_time = 0 + self.communication_counter = 0 + self.message_buffer = {} + self.ping_hook = None + self.alias = None + + self.identifier = None + self.connect_to_slack() + + def __eq__(self, compare_str): + if compare_str == self.identifier or compare_str == self.token or compare_str == self.buffer: + return True + else: + return False + + def __str__(self): + return "{}".format(self.identifier) + + def __repr__(self): + return "{}".format(self.identifier) + + def add_user(self, user): + self.users.append(user, user.get_aliases()) + users.append(user, user.get_aliases()) + + def add_bot(self, bot): + self.bots.append(bot) + + def add_channel(self, channel): + self.channels.append(channel, channel.get_aliases()) + channels.append(channel, channel.get_aliases()) + + def get_aliases(self): + aliases = filter(None, [self.identifier, self.token, self.buffer, self.alias]) + return aliases + + def find(self, name, attribute): + attribute = eval("self." + attribute) + return attribute.find(name) + + def get_communication_id(self): + if self.communication_counter > 999: + self.communication_counter = 0 + self.communication_counter += 1 + return self.communication_counter + + def send_to_websocket(self, data, expect_reply=True): + data["id"] = self.get_communication_id() + message = json.dumps(data) + try: + if expect_reply: + self.message_buffer[data["id"]] = data + self.ws.send(message) + dbg("Sent {}...".format(message[:100])) + except: + dbg("Unexpected error: {}\nSent: {}".format(sys.exc_info()[0], data)) + self.connected = False + + def ping(self): + request = {"type": "ping"} + self.send_to_websocket(request) + + def should_connect(self): + """ + If we haven't tried to connect OR we tried and never heard back and it + has been 125 seconds consider the attempt dead and try again + """ + if self.connection_attempt_time == 0 or self.connection_attempt_time + 125 < int(time.time()): + return True + else: + return False + + def connect_to_slack(self): + t = time.time() + # Double check that we haven't exceeded a long wait to connect and try again. + if self.connecting and self.should_connect(): + self.connecting = False + if not self.connecting: + async_slack_api_request("slack.com", self.token, "rtm.start", {"ts": t}) + self.connection_attempt_time = int(time.time()) + self.connecting = True + + def connected_to_slack(self, login_data): + if login_data["ok"]: + self.team = login_data["team"]["domain"] + self.domain = login_data["team"]["domain"] + ".slack.com" + dbg("connected to {}".format(self.domain)) + self.identifier = self.domain + + alias = w.config_get_plugin("server_alias.{}".format(login_data["team"]["domain"])) + if alias: + self.server_buffer_name = alias + self.alias = alias + else: + self.server_buffer_name = self.domain + + self.nick = login_data["self"]["name"] + self.create_local_buffer() + + if self.create_slack_websocket(login_data): + if self.ping_hook: + w.unhook(self.ping_hook) + self.communication_counter = 0 + self.ping_hook = w.hook_timer(1000 * 5, 0, 0, "slack_ping_cb", self.domain) + if len(self.users) == 0 or len(self.channels) == 0: + self.create_slack_mappings(login_data) + + self.connected = True + self.connecting = False + + self.print_connection_info(login_data) + if len(self.message_buffer) > 0: + for message_id in self.message_buffer.keys(): + if self.message_buffer[message_id]["type"] != 'ping': + resend = self.message_buffer.pop(message_id) + dbg("Resent failed message.") + self.send_to_websocket(resend) + # sleep to prevent being disconnected by websocket server + time.sleep(1) + else: + self.message_buffer.pop(message_id) + return True + else: + token_start = self.token[:10] + error = """ +!! slack.com login error: {} + The problematic token starts with {} + Please check your API token with + "/set plugins.var.python.slack_extension.slack_api_token (token)" + +""".format(login_data["error"], token_start) + w.prnt("", error) + self.connected = False + + def print_connection_info(self, login_data): + self.buffer_prnt('Connected to Slack', backlog=True) + self.buffer_prnt('{:<20} {}'.format("Websocket URL", login_data["url"]), backlog=True) + self.buffer_prnt('{:<20} {}'.format("User name", login_data["self"]["name"]), backlog=True) + self.buffer_prnt('{:<20} {}'.format("User ID", login_data["self"]["id"]), backlog=True) + self.buffer_prnt('{:<20} {}'.format("Team name", login_data["team"]["name"]), backlog=True) + self.buffer_prnt('{:<20} {}'.format("Team domain", login_data["team"]["domain"]), backlog=True) + self.buffer_prnt('{:<20} {}'.format("Team id", login_data["team"]["id"]), backlog=True) + + def create_local_buffer(self): + if not w.buffer_search("", self.server_buffer_name): + self.buffer = w.buffer_new(self.server_buffer_name, "buffer_input_cb", "", "", "") + if w.config_string(w.config_get('irc.look.server_buffer')) == 'merge_with_core': + w.buffer_merge(self.buffer, w.buffer_search_main()) + w.buffer_set(self.buffer, "nicklist", "1") + + def create_slack_websocket(self, data): + web_socket_url = data['url'] + try: + self.ws = create_connection(web_socket_url, sslopt=sslopt_ca_certs) + self.ws_hook = w.hook_fd(self.ws.sock._sock.fileno(), 1, 0, 0, "slack_websocket_cb", self.identifier) + self.ws.sock.setblocking(0) + return True + except Exception as e: + print("websocket connection error: {}".format(e)) + return False + + def create_slack_mappings(self, data): + + for item in data["users"]: + self.add_user(User(self, item["name"], item["id"], item["presence"], item["deleted"], is_bot=item.get('is_bot', False))) + + for item in data["bots"]: + self.add_bot(Bot(self, item["name"], item["id"], item["deleted"])) + + for item in data["channels"]: + if "last_read" not in item: + item["last_read"] = 0 + if "members" not in item: + item["members"] = [] + if "topic" not in item: + item["topic"] = {} + item["topic"]["value"] = "" + if not item["is_archived"]: + self.add_channel(Channel(self, item["name"], item["id"], item["is_member"], item["last_read"], "#", item["members"], item["topic"]["value"])) + for item in data["groups"]: + if "last_read" not in item: + item["last_read"] = 0 + if not item["is_archived"]: + if item["name"].startswith("mpdm-"): + self.add_channel(MpdmChannel(self, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]["value"])) + else: + self.add_channel(GroupChannel(self, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]["value"])) + for item in data["ims"]: + if "last_read" not in item: + item["last_read"] = 0 + if item["unread_count"] > 0: + item["is_open"] = True + name = self.users.find(item["user"]).name + self.add_channel(DmChannel(self, name, item["id"], item["is_open"], item["last_read"])) + for item in data['self']['prefs']['muted_channels'].split(','): + if item == '': + continue + if self.channels.find(item) is not None: + self.channels.find(item).muted = True + + for item in self.channels: + item.get_history() + + def buffer_prnt(self, message='no message', user="SYSTEM", backlog=False): + message = message.encode('ascii', 'ignore') + if backlog: + tags = "no_highlight,notify_none,logger_backlog_end" + else: + tags = "" + if user == "SYSTEM": + user = w.config_string(w.config_get('weechat.look.prefix_network')) + if self.buffer: + w.prnt_date_tags(self.buffer, 0, tags, "{}\t{}".format(user, message)) + else: + pass + # w.prnt("", "%s\t%s" % (user, message)) + + +def buffer_input_cb(b, buffer, data): + channel = channels.find(buffer) + if not channel: + return w.WEECHAT_RC_OK_EAT + reaction = re.match("^\s*(\d*)(\+|-):(.*):\s*$", data) + if reaction: + if reaction.group(2) == "+": + channel.send_add_reaction(int(reaction.group(1) or 1), reaction.group(3)) + elif reaction.group(2) == "-": + channel.send_remove_reaction(int(reaction.group(1) or 1), reaction.group(3)) + elif data.startswith('s/'): + try: + old, new, flags = re.split(r'(?<!\\)/', data)[1:] + except ValueError: + pass + else: + # Replacement string in re.sub() is a string, not a regex, so get + # rid of escapes. + new = new.replace(r'\/', '/') + old = old.replace(r'\/', '/') + channel.change_previous_message(old.decode("utf-8"), new.decode("utf-8"), flags) + else: + channel.send_message(data) + # channel.buffer_prnt(channel.server.nick, data) + channel.mark_read(True) + return w.WEECHAT_RC_ERROR + + +class Channel(object): + """ + Represents a single channel and is the source of truth + for channel <> weechat buffer + """ + def __init__(self, server, name, identifier, active, last_read=0, prepend_name="", members=[], topic=""): + self.name = prepend_name + name + self.current_short_name = prepend_name + name + self.identifier = identifier + self.active = active + self.last_read = float(last_read) + self.members = set(members) + self.topic = topic + + self.members_table = {} + self.channel_buffer = None + self.type = "channel" + self.server = server + self.typing = {} + self.last_received = None + self.messages = [] + self.scrolling = False + self.last_active_user = None + self.muted = False + if active: + self.create_buffer() + self.attach_buffer() + self.create_members_table() + self.update_nicklist() + self.set_topic(self.topic) + buffer_list_update_next() + + def __str__(self): + return self.name + + def __repr__(self): + return self.name + + def __eq__(self, compare_str): + if compare_str == self.fullname() or compare_str == self.name or compare_str == self.identifier or compare_str == self.name[1:] or (compare_str == self.channel_buffer and self.channel_buffer is not None): + return True + else: + return False + + def get_aliases(self): + aliases = [self.fullname(), self.name, self.identifier, self.name[1:], ] + if self.channel_buffer is not None: + aliases.append(self.channel_buffer) + return aliases + + def create_members_table(self): + for user in self.members: + self.members_table[user] = self.server.users.find(user) + + def create_buffer(self): + channel_buffer = w.buffer_search("", "{}.{}".format(self.server.server_buffer_name, self.name)) + if channel_buffer: + self.channel_buffer = channel_buffer + else: + self.channel_buffer = w.buffer_new("{}.{}".format(self.server.server_buffer_name, self.name), "buffer_input_cb", self.name, "", "") + if self.type == "im": + w.buffer_set(self.channel_buffer, "localvar_set_type", 'private') + else: + w.buffer_set(self.channel_buffer, "localvar_set_type", 'channel') + if self.server.alias: + w.buffer_set(self.channel_buffer, "localvar_set_server", self.server.alias) + else: + w.buffer_set(self.channel_buffer, "localvar_set_server", self.server.team) + w.buffer_set(self.channel_buffer, "localvar_set_channel", self.name) + w.buffer_set(self.channel_buffer, "short_name", self.name) + buffer_list_update_next() + + def attach_buffer(self): + channel_buffer = w.buffer_search("", "{}.{}".format(self.server.server_buffer_name, self.name)) + if channel_buffer != main_weechat_buffer: + self.channel_buffer = channel_buffer + w.buffer_set(self.channel_buffer, "localvar_set_nick", self.server.nick) + w.buffer_set(self.channel_buffer, "highlight_words", self.server.nick) + else: + self.channel_buffer = None + channels.update_hashtable() + self.server.channels.update_hashtable() + + def detach_buffer(self): + if self.channel_buffer is not None: + w.buffer_close(self.channel_buffer) + self.channel_buffer = None + channels.update_hashtable() + self.server.channels.update_hashtable() + + def update_nicklist(self, user=None): + if not self.channel_buffer: + return + + w.buffer_set(self.channel_buffer, "nicklist", "1") + + # create nicklists for the current channel if they don't exist + # if they do, use the existing pointer + here = w.nicklist_search_group(self.channel_buffer, '', NICK_GROUP_HERE) + if not here: + here = w.nicklist_add_group(self.channel_buffer, '', NICK_GROUP_HERE, "weechat.color.nicklist_group", 1) + afk = w.nicklist_search_group(self.channel_buffer, '', NICK_GROUP_AWAY) + if not afk: + afk = w.nicklist_add_group(self.channel_buffer, '', NICK_GROUP_AWAY, "weechat.color.nicklist_group", 1) + + if user: + user = self.members_table[user] + nick = w.nicklist_search_nick(self.channel_buffer, "", user.name) + # since this is a change just remove it regardless of where it is + w.nicklist_remove_nick(self.channel_buffer, nick) + # now add it back in to whichever.. + if user.presence == 'away': + w.nicklist_add_nick(self.channel_buffer, afk, user.name, user.color_name, "", "", 1) + else: + w.nicklist_add_nick(self.channel_buffer, here, user.name, user.color_name, "", "", 1) + + # if we didn't get a user, build a complete list. this is expensive. + else: + try: + for user in self.members: + user = self.members_table[user] + if user.deleted: + continue + if user.presence == 'away': + w.nicklist_add_nick(self.channel_buffer, afk, user.name, user.color_name, "", "", 1) + else: + w.nicklist_add_nick(self.channel_buffer, here, user.name, user.color_name, "", "", 1) + except Exception as e: + dbg("DEBUG: {} {} {}".format(self.identifier, self.name, e)) + + def fullname(self): + return "{}.{}".format(self.server.server_buffer_name, self.name) + + def has_user(self, name): + return name in self.members + + def user_join(self, name): + self.members.add(name) + self.create_members_table() + self.update_nicklist() + + def user_leave(self, name): + if name in self.members: + self.members.remove(name) + self.create_members_table() + self.update_nicklist() + + def set_active(self): + self.active = True + + def set_inactive(self): + self.active = False + + def set_typing(self, user): + if self.channel_buffer: + if w.buffer_get_integer(self.channel_buffer, "hidden") == 0: + self.typing[user] = time.time() + buffer_list_update_next() + + def unset_typing(self, user): + if self.channel_buffer: + if w.buffer_get_integer(self.channel_buffer, "hidden") == 0: + try: + del self.typing[user] + buffer_list_update_next() + except: + pass + + def send_message(self, message): + message = self.linkify_text(message) + dbg(message) + request = {"type": "message", "channel": self.identifier, "text": message, "_server": self.server.domain} + self.server.send_to_websocket(request) + + def linkify_text(self, message): + message = message.split(' ') + for item in enumerate(message): + targets = re.match('.*([@#])([\w.]+\w)(\W*)', item[1]) + if targets and targets.groups()[0] == '@': + named = targets.groups() + if named[1] in ["group", "channel", "here"]: + message[item[0]] = "<!{}>".format(named[1]) + if self.server.users.find(named[1]): + message[item[0]] = "<@{}>{}".format(self.server.users.find(named[1]).identifier, named[2]) + if targets and targets.groups()[0] == '#': + named = targets.groups() + if self.server.channels.find(named[1]): + message[item[0]] = "<#{}|{}>{}".format(self.server.channels.find(named[1]).identifier, named[1], named[2]) + dbg(message) + return " ".join(message) + + def set_topic(self, topic): + self.topic = topic.encode('utf-8') + w.buffer_set(self.channel_buffer, "title", self.topic) + + def open(self, update_remote=True): + self.create_buffer() + self.active = True + self.get_history() + if "info" in SLACK_API_TRANSLATOR[self.type]: + async_slack_api_request(self.server.domain, self.server.token, SLACK_API_TRANSLATOR[self.type]["info"], {"name": self.name.lstrip("#")}) + if update_remote: + if "join" in SLACK_API_TRANSLATOR[self.type]: + async_slack_api_request(self.server.domain, self.server.token, SLACK_API_TRANSLATOR[self.type]["join"], {"name": self.name.lstrip("#")}) + + def close(self, update_remote=True): + # remove from cache so messages don't reappear when reconnecting + if self.active: + self.active = False + self.current_short_name = "" + self.detach_buffer() + if update_remote: + async_slack_api_request(self.server.domain, self.server.token, SLACK_API_TRANSLATOR[self.type]["leave"], {"channel": self.identifier}) + + def closed(self): + self.channel_buffer = None + self.last_received = None + self.close() + + def is_someone_typing(self): + for user in self.typing.keys(): + if self.typing[user] + 4 > time.time(): + return True + if len(self.typing) > 0: + self.typing = {} + buffer_list_update_next() + return False + + def get_typing_list(self): + typing = [] + for user in self.typing.keys(): + if self.typing[user] + 4 > time.time(): + typing.append(user) + return typing + + def mark_read(self, update_remote=True): + if self.channel_buffer: + w.buffer_set(self.channel_buffer, "unread", "") + if update_remote: + self.last_read = time.time() + self.update_read_marker(self.last_read) + + def update_read_marker(self, time): + async_slack_api_request(self.server.domain, self.server.token, SLACK_API_TRANSLATOR[self.type]["mark"], {"channel": self.identifier, "ts": time}) + + def rename(self): + if self.is_someone_typing(): + new_name = ">{}".format(self.name[1:]) + else: + new_name = self.name + if self.channel_buffer: + if self.current_short_name != new_name: + self.current_short_name = new_name + w.buffer_set(self.channel_buffer, "short_name", new_name) + + def buffer_prnt(self, user='unknown_user', message='no message', time=0): + """ + writes output (message) to a buffer (channel) + """ + set_read_marker = False + time_float = float(time) + tags = "nick_" + user + user_obj = self.server.users.find(user) + # XXX: we should not set log1 for robots. + if time_float != 0 and self.last_read >= time_float: + tags += ",no_highlight,notify_none,logger_backlog_end" + set_read_marker = True + elif message.find(self.server.nick.encode('utf-8')) > -1: + tags += ",notify_highlight,log1" + elif user != self.server.nick and self.name in self.server.users: + tags += ",notify_private,notify_message,log1,irc_privmsg" + elif self.muted: + tags += ",no_highlight,notify_none,logger_backlog_end" + elif user in [x.strip() for x in w.prefix("join"), w.prefix("quit")]: + tags += ",irc_smart_filter" + else: + tags += ",notify_message,log1,irc_privmsg" + # don't write these to local log files + # tags += ",no_log" + time_int = int(time_float) + if self.channel_buffer: + prefix_same_nick = w.config_string(w.config_get('weechat.look.prefix_same_nick')) + if user == self.last_active_user and prefix_same_nick != "": + if colorize_nicks and user_obj: + name = user_obj.color + prefix_same_nick + else: + name = prefix_same_nick + else: + nick_prefix = w.config_string(w.config_get('weechat.look.nick_prefix')) + nick_prefix_color_name = w.config_string(w.config_get('weechat.color.chat_nick_prefix')) + nick_prefix_color = w.color(nick_prefix_color_name) + + nick_suffix = w.config_string(w.config_get('weechat.look.nick_suffix')) + nick_suffix_color_name = w.config_string(w.config_get('weechat.color.chat_nick_prefix')) + nick_suffix_color = w.color(nick_suffix_color_name) + + if user_obj: + name = user_obj.formatted_name() + self.last_active_user = user + # XXX: handle bots properly here. + else: + name = user + self.last_active_user = None + name = nick_prefix_color + nick_prefix + w.color("reset") + name + nick_suffix_color + nick_suffix + w.color("reset") + name = name.decode('utf-8') + # colorize nicks in each line + chat_color = w.config_string(w.config_get('weechat.color.chat')) + if type(message) is not unicode: + message = message.decode('UTF-8', 'replace') + curr_color = w.color(chat_color) + if colorize_nicks and colorize_messages and user_obj: + curr_color = user_obj.color + message = curr_color + message + for user in self.server.users: + if user.name in message: + message = user.name_regex.sub( + r'\1\2{}\3'.format(user.formatted_name() + curr_color), + message) + + message = HTMLParser.HTMLParser().unescape(message) + data = u"{}\t{}".format(name, message).encode('utf-8') + w.prnt_date_tags(self.channel_buffer, time_int, tags, data) + + if set_read_marker: + self.mark_read(False) + else: + self.open(False) + self.last_received = time + self.unset_typing(user) + + def buffer_redraw(self): + if self.channel_buffer and not self.scrolling: + w.buffer_clear(self.channel_buffer) + self.messages.sort() + for message in self.messages: + process_message(message.message_json, False) + + def set_scrolling(self): + self.scrolling = True + + def unset_scrolling(self): + self.scrolling = False + + def has_message(self, ts): + return self.messages.count(ts) > 0 + + def change_message(self, ts, text=None, suffix=''): + if self.has_message(ts): + message_index = self.messages.index(ts) + + if text is not None: + self.messages[message_index].change_text(text) + text = render_message(self.messages[message_index].message_json, True) + + # if there is only one message with this timestamp, modify it directly. + # we do this because time resolution in weechat is less than slack + int_time = int(float(ts)) + if self.messages.count(str(int_time)) == 1: + modify_buffer_line(self.channel_buffer, text + suffix, int_time) + # otherwise redraw the whole buffer, which is expensive + else: + self.buffer_redraw() + return True + + def add_reaction(self, ts, reaction, user): + if self.has_message(ts): + message_index = self.messages.index(ts) + self.messages[message_index].add_reaction(reaction, user) + self.change_message(ts) + return True + + def remove_reaction(self, ts, reaction, user): + if self.has_message(ts): + message_index = self.messages.index(ts) + self.messages[message_index].remove_reaction(reaction, user) + self.change_message(ts) + return True + + def send_add_reaction(self, msg_number, reaction): + self.send_change_reaction("reactions.add", msg_number, reaction) + + def send_remove_reaction(self, msg_number, reaction): + self.send_change_reaction("reactions.remove", msg_number, reaction) + + def send_change_reaction(self, method, msg_number, reaction): + if 0 < msg_number < len(self.messages): + timestamp = self.messages[-msg_number].message_json["ts"] + data = {"channel": self.identifier, "timestamp": timestamp, "name": reaction} + async_slack_api_request(self.server.domain, self.server.token, method, data) + + def change_previous_message(self, old, new, flags): + message = self.my_last_message() + if new == "" and old == "": + async_slack_api_request(self.server.domain, self.server.token, 'chat.delete', {"channel": self.identifier, "ts": message['ts']}) + else: + num_replace = 1 + if 'g' in flags: + num_replace = 0 + new_message = re.sub(old, new, message["text"], num_replace) + if new_message != message["text"]: + async_slack_api_request(self.server.domain, self.server.token, 'chat.update', {"channel": self.identifier, "ts": message['ts'], "text": new_message.encode("utf-8")}) + + def my_last_message(self): + for message in reversed(self.messages): + if "user" in message.message_json and "text" in message.message_json and message.message_json["user"] == self.server.users.find(self.server.nick).identifier: + return message.message_json + + def cache_message(self, message_json, from_me=False): + if from_me: + message_json["user"] = self.server.users.find(self.server.nick).identifier + self.messages.append(Message(message_json)) + if len(self.messages) > SCROLLBACK_SIZE: + self.messages = self.messages[-SCROLLBACK_SIZE:] + + def get_history(self): + if self.active: + for message in message_cache[self.identifier]: + process_message(json.loads(message), True) + if self.last_received is not None: + async_slack_api_request(self.server.domain, self.server.token, SLACK_API_TRANSLATOR[self.type]["history"], {"channel": self.identifier, "oldest": self.last_received, "count": BACKLOG_SIZE}) + else: + async_slack_api_request(self.server.domain, self.server.token, SLACK_API_TRANSLATOR[self.type]["history"], {"channel": self.identifier, "count": BACKLOG_SIZE}) + + +class GroupChannel(Channel): + + def __init__(self, server, name, identifier, active, last_read=0, prepend_name="", members=[], topic=""): + super(GroupChannel, self).__init__(server, name, identifier, active, last_read, prepend_name, members, topic) + self.type = "group" + + +class MpdmChannel(Channel): + + def __init__(self, server, name, identifier, active, last_read=0, prepend_name="", members=[], topic=""): + name = "|".join("-".join(name.split("-")[1:-1]).split("--")) + super(MpdmChannel, self).__init__(server, name, identifier, active, last_read, prepend_name, members, topic) + self.type = "group" + + +class DmChannel(Channel): + + def __init__(self, server, name, identifier, active, last_read=0, prepend_name=""): + super(DmChannel, self).__init__(server, name, identifier, active, last_read, prepend_name) + self.type = "im" + + def rename(self): + global colorize_private_chats + + if self.server.users.find(self.name).presence == "active": + new_name = self.server.users.find(self.name).formatted_name('+', colorize_private_chats) + else: + new_name = self.server.users.find(self.name).formatted_name(' ', colorize_private_chats) + + if self.channel_buffer: + if self.current_short_name != new_name: + self.current_short_name = new_name + w.buffer_set(self.channel_buffer, "short_name", new_name) + + def update_nicklist(self, user=None): + pass + + +class User(object): + + def __init__(self, server, name, identifier, presence="away", deleted=False, is_bot=False): + self.server = server + self.name = name + self.identifier = identifier + self.deleted = deleted + self.presence = presence + + self.channel_buffer = w.info_get("irc_buffer", "{}.{}".format(domain, self.name)) + self.update_color() + self.name_regex = re.compile(r"([\W]|\A)(@{0,1})" + self.name + "('s|[^'\w]|\Z)") + self.is_bot = is_bot + + if deleted: + return + self.nicklist_pointer = w.nicklist_add_nick(server.buffer, "", self.name, self.color_name, "", "", 1) + if self.presence == 'away': + w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "visible", "0") + else: + w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "visible", "1") +# w.nicklist_add_nick(server.buffer, "", self.formatted_name(), "", "", "", 1) + + def __str__(self): + return self.name + + def __repr__(self): + return self.name + + def __eq__(self, compare_str): + try: + if compare_str == self.name or compare_str == self.identifier: + return True + elif compare_str[0] == '@' and compare_str[1:] == self.name: + return True + else: + return False + except: + return False + + def get_aliases(self): + return [self.name, "@" + self.name, self.identifier] + + def set_active(self): + if self.deleted: + return + + self.presence = "active" + for channel in self.server.channels: + if channel.has_user(self.identifier): + channel.update_nicklist(self.identifier) + w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "visible", "1") + dm_channel = self.server.channels.find(self.name) + if dm_channel and dm_channel.active: + buffer_list_update_next() + + def set_inactive(self): + if self.deleted: + return + + self.presence = "away" + for channel in self.server.channels: + if channel.has_user(self.identifier): + channel.update_nicklist(self.identifier) + w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "visible", "0") + dm_channel = self.server.channels.find(self.name) + if dm_channel and dm_channel.active: + buffer_list_update_next() + + def update_color(self): + if colorize_nicks: + if self.name == self.server.nick: + self.color_name = w.config_string(w.config_get('weechat.color.chat_nick_self')) + else: + self.color_name = w.info_get('irc_nick_color_name', self.name) + self.color = w.color(self.color_name) + else: + self.color = "" + self.color_name = "" + + def formatted_name(self, prepend="", enable_color=True): + if colorize_nicks and enable_color: + print_color = self.color + else: + print_color = "" + return print_color + prepend + self.name + + def create_dm_channel(self): + async_slack_api_request(self.server.domain, self.server.token, "im.open", {"user": self.identifier}) + + +class Bot(object): + + def __init__(self, server, name, identifier, deleted=False): + self.server = server + self.name = name + self.identifier = identifier + self.deleted = deleted + self.update_color() + + def __eq__(self, compare_str): + if compare_str == self.identifier or compare_str == self.name: + return True + else: + return False + + def __str__(self): + return "{}".format(self.identifier) + + def __repr__(self): + return "{}".format(self.identifier) + + def update_color(self): + if colorize_nicks: + self.color_name = w.info_get('irc_nick_color_name', self.name.encode('utf-8')) + self.color = w.color(self.color_name) + else: + self.color_name = "" + self.color = "" + + def formatted_name(self, prepend="", enable_color=True): + if colorize_nicks and enable_color: + print_color = self.color + else: + print_color = "" + return print_color + prepend + self.name + + +class Message(object): + + def __init__(self, message_json): + self.message_json = message_json + self.ts = message_json['ts'] + # split timestamp into time and counter + self.ts_time, self.ts_counter = message_json['ts'].split('.') + + def change_text(self, new_text): + if not isinstance(new_text, unicode): + new_text = unicode(new_text, 'utf-8') + self.message_json["text"] = new_text + + def add_reaction(self, reaction, user): + if "reactions" in self.message_json: + found = False + for r in self.message_json["reactions"]: + if r["name"] == reaction and user not in r["users"]: + r["users"].append(user) + found = True + + if not found: + self.message_json["reactions"].append({u"name": reaction, u"users": [user]}) + else: + self.message_json["reactions"] = [{u"name": reaction, u"users": [user]}] + + def remove_reaction(self, reaction, user): + if "reactions" in self.message_json: + for r in self.message_json["reactions"]: + if r["name"] == reaction and user in r["users"]: + r["users"].remove(user) + else: + pass + + def __eq__(self, other): + return self.ts_time == other or self.ts == other + + def __repr__(self): + return "{} {} {} {}\n".format(self.ts_time, self.ts_counter, self.ts, self.message_json) + + def __lt__(self, other): + return self.ts < other.ts + + +def slack_buffer_or_ignore(f): + """ + Only run this function if we're in a slack buffer, else ignore + """ + @wraps(f) + def wrapper(current_buffer, *args, **kwargs): + server = servers.find(current_domain_name()) + if not server: + return w.WEECHAT_RC_OK + return f(current_buffer, *args, **kwargs) + return wrapper + + +def slack_command_cb(data, current_buffer, args): + a = args.split(' ', 1) + if len(a) > 1: + function_name, args = a[0], " ".join(a[1:]) + else: + function_name, args = a[0], None + + try: + cmds[function_name](current_buffer, args) + except KeyError: + w.prnt("", "Command not found: " + function_name) + return w.WEECHAT_RC_OK + + +@slack_buffer_or_ignore +def me_command_cb(data, current_buffer, args): + if channels.find(current_buffer): + # channel = channels.find(current_buffer) + # nick = channel.server.nick + message = "_{}_".format(args) + buffer_input_cb("", current_buffer, message) + return w.WEECHAT_RC_OK + + +@slack_buffer_or_ignore +def join_command_cb(data, current_buffer, args): + args = args.split() + if len(args) < 2: + w.prnt(current_buffer, "Missing channel argument") + return w.WEECHAT_RC_OK_EAT + elif command_talk(current_buffer, args[1]): + return w.WEECHAT_RC_OK_EAT + else: + return w.WEECHAT_RC_OK + + +@slack_buffer_or_ignore +def part_command_cb(data, current_buffer, args): + if channels.find(current_buffer) or servers.find(current_buffer): + args = args.split() + if len(args) > 1: + channel = args[1:] + servers.find(current_domain_name()).channels.find(channel).close(True) + else: + channels.find(current_buffer).close(True) + return w.WEECHAT_RC_OK_EAT + else: + return w.WEECHAT_RC_OK + + +# Wrap command_ functions that require they be performed in a slack buffer +def slack_buffer_required(f): + @wraps(f) + def wrapper(current_buffer, *args, **kwargs): + server = servers.find(current_domain_name()) + if not server: + w.prnt(current_buffer, "This command must be used in a slack buffer") + return w.WEECHAT_RC_ERROR + return f(current_buffer, *args, **kwargs) + return wrapper + + +def command_register(current_buffer, args): + CLIENT_ID = "2468770254.51917335286" + CLIENT_SECRET = "dcb7fe380a000cba0cca3169a5fe8d70" # this is not really a secret + if not args: + message = """ +# ### Retrieving a Slack token via OAUTH #### + +1) Paste this into a browser: https://slack.com/oauth/authorize?client_id=2468770254.51917335286&scope=client +2) Select the team you wish to access from wee-slack in your browser. +3) Click "Authorize" in the browser **IMPORTANT: the redirect will fail, this is expected** +4) Copy the "code" portion of the URL to your clipboard +5) Return to weechat and run `/slack register [code]` +6) Add the returned token per the normal wee-slack setup instructions + + +""" + w.prnt(current_buffer, message) + else: + aargs = args.split(None, 2) + if len(aargs) != 1: + w.prnt(current_buffer, "ERROR: invalid args to register") + else: + # w.prnt(current_buffer, "https://slack.com/api/oauth.access?client_id={}&client_secret={}&code={}".format(CLIENT_ID, CLIENT_SECRET, aargs[0])) + ret = urllib.urlopen("https://slack.com/api/oauth.access?client_id={}&client_secret={}&code={}".format(CLIENT_ID, CLIENT_SECRET, aargs[0])).read() + d = json.loads(ret) + if d["ok"] == True: + w.prnt(current_buffer, "Success! Access token is: " + d['access_token']) + else: + w.prnt(current_buffer, "Failed! Error is: " + d['error']) + + +@slack_buffer_or_ignore +def msg_command_cb(data, current_buffer, args): + dbg("msg_command_cb") + aargs = args.split(None, 2) + who = aargs[1] + + command_talk(current_buffer, who) + + if len(aargs) > 2: + message = aargs[2] + server = servers.find(current_domain_name()) + if server: + channel = server.channels.find(who) + channel.send_message(message) + return w.WEECHAT_RC_OK_EAT + + +@slack_buffer_required +def command_upload(current_buffer, args): + """ + Uploads a file to the current buffer + /slack upload [file_path] + """ + post_data = {} + channel = current_buffer_name(short=True) + domain = current_domain_name() + token = servers.find(domain).token + + if servers.find(domain).channels.find(channel): + channel_identifier = servers.find(domain).channels.find(channel).identifier + + if channel_identifier: + post_data["token"] = token + post_data["channels"] = channel_identifier + post_data["file"] = args + async_slack_api_upload_request(token, "files.upload", post_data) + + +def command_talk(current_buffer, args): + """ + Open a chat with the specified user + /slack talk [user] + """ + + server = servers.find(current_domain_name()) + if server: + channel = server.channels.find(args) + if channel is None: + user = server.users.find(args) + if user: + user.create_dm_channel() + else: + server.buffer_prnt("User or channel {} not found.".format(args)) + else: + channel.open() + if w.config_get_plugin('switch_buffer_on_join') != '0': + w.buffer_set(channel.channel_buffer, "display", "1") + return True + else: + return False + + +def command_join(current_buffer, args): + """ + Join the specified channel + /slack join [channel] + """ + domain = current_domain_name() + if domain == "": + if len(servers) == 1: + domain = servers[0] + else: + w.prnt(current_buffer, "You are connected to multiple Slack instances, please execute /join from a server buffer. i.e. (domain).slack.com") + return + channel = servers.find(domain).channels.find(args) + if channel is not None: + servers.find(domain).channels.find(args).open() + else: + w.prnt(current_buffer, "Channel not found.") + + +@slack_buffer_required +def command_channels(current_buffer, args): + """ + List all the channels for the slack instance (name, id, active) + /slack channels + """ + server = servers.find(current_domain_name()) + for channel in server.channels: + line = "{:<25} {} {}".format(channel.name, channel.identifier, channel.active) + server.buffer_prnt(line) + + +def command_nodistractions(current_buffer, args): + global hide_distractions + hide_distractions = not hide_distractions + if distracting_channels != ['']: + for channel in distracting_channels: + try: + channel_buffer = channels.find(channel).channel_buffer + if channel_buffer: + w.buffer_set(channels.find(channel).channel_buffer, "hidden", str(int(hide_distractions))) + except: + dbg("Can't hide channel {} .. removing..".format(channel), main_buffer=True) + distracting_channels.pop(distracting_channels.index(channel)) + save_distracting_channels() + + +def command_distracting(current_buffer, args): + global distracting_channels + distracting_channels = [x.strip() for x in w.config_get_plugin("distracting_channels").split(',')] + if channels.find(current_buffer) is None: + w.prnt(current_buffer, "This command must be used in a channel buffer") + return + fullname = channels.find(current_buffer).fullname() + if distracting_channels.count(fullname) == 0: + distracting_channels.append(fullname) + else: + distracting_channels.pop(distracting_channels.index(fullname)) + save_distracting_channels() + + +def save_distracting_channels(): + new = ','.join(distracting_channels) + w.config_set_plugin('distracting_channels', new) + + +@slack_buffer_required +def command_users(current_buffer, args): + """ + List all the users for the slack instance (name, id, away) + /slack users + """ + server = servers.find(current_domain_name()) + for user in server.users: + line = "{:<40} {} {}".format(user.formatted_name(), user.identifier, user.presence) + server.buffer_prnt(line) + + +def command_setallreadmarkers(current_buffer, args): + """ + Sets the read marker for all channels + /slack setallreadmarkers + """ + for channel in channels: + channel.mark_read() + + +def command_changetoken(current_buffer, args): + w.config_set_plugin('slack_api_token', args) + + +def command_test(current_buffer, args): + w.prnt(current_buffer, "worked!") + + +@slack_buffer_required +def command_away(current_buffer, args): + """ + Sets your status as 'away' + /slack away + """ + server = servers.find(current_domain_name()) + async_slack_api_request(server.domain, server.token, 'presence.set', {"presence": "away"}) + + +@slack_buffer_required +def command_back(current_buffer, args): + """ + Sets your status as 'back' + /slack back + """ + server = servers.find(current_domain_name()) + async_slack_api_request(server.domain, server.token, 'presence.set', {"presence": "active"}) + + +@slack_buffer_required +def command_markread(current_buffer, args): + """ + Marks current channel as read + /slack markread + """ + # refactor this - one liner i think + channel = current_buffer_name(short=True) + domain = current_domain_name() + if servers.find(domain).channels.find(channel): + servers.find(domain).channels.find(channel).mark_read() + + +@slack_buffer_required +def command_slash(current_buffer, args): + """ + Support for custom slack commands + /slack slash /customcommand arg1 arg2 arg3 + """ + + server = servers.find(current_domain_name()) + channel = current_buffer_name(short=True) + domain = current_domain_name() + + if args is None: + server.buffer_prnt("Usage: /slack slash /someslashcommand [arguments...].") + return + + split_args = args.split(None, 1) + + command = split_args[0] + text = split_args[1] if len(split_args) > 1 else "" + + if servers.find(domain).channels.find(channel): + channel_identifier = servers.find(domain).channels.find(channel).identifier + + if channel_identifier: + async_slack_api_request(server.domain, server.token, 'chat.command', {'command': command, 'text': text, 'channel': channel_identifier}) + else: + server.buffer_prnt("User or channel not found.") + + +def command_flushcache(current_buffer, args): + global message_cache + message_cache = collections.defaultdict(list) + cache_write_cb("", "") + + +def command_cachenow(current_buffer, args): + cache_write_cb("", "") + + +def command_neveraway(current_buffer, args): + global never_away + if never_away: + never_away = False + dbg("unset never_away", main_buffer=True) + else: + never_away = True + dbg("set never_away", main_buffer=True) + + +def command_printvar(current_buffer, args): + w.prnt("", "{}".format(eval(args))) + + +def command_p(current_buffer, args): + w.prnt("", "{}".format(eval(args))) + + +def command_debug(current_buffer, args): + create_slack_debug_buffer() + + +def command_debugstring(current_buffer, args): + global debug_string + if args == '': + debug_string = None + else: + debug_string = args + + +def command_search(current_buffer, args): + pass +# if not slack_buffer: +# create_slack_buffer() +# w.buffer_set(slack_buffer, "display", "1") +# query = args +# w.prnt(slack_buffer,"\nSearched for: %s\n\n" % (query)) +# reply = slack_api_request('search.messages', {"query":query}).read() +# data = json.loads(reply) +# for message in data['messages']['matches']: +# message["text"] = message["text"].encode('ascii', 'ignore') +# formatted_message = "%s / %s:\t%s" % (message["channel"]["name"], message['username'], message['text']) +# w.prnt(slack_buffer,str(formatted_message)) + + +def command_nick(current_buffer, args): + pass +# urllib.urlopen("https://%s/account/settings" % (domain)) +# browser.select_form(nr=0) +# browser.form['username'] = args +# reply = browser.submit() + + +def command_help(current_buffer, args): + help_cmds = {k[8:]: v.__doc__ for k, v in globals().items() if k.startswith("command_")} + + if args: + try: + help_cmds = {args: help_cmds[args]} + except KeyError: + w.prnt("", "Command not found: " + args) + return + + for cmd, helptext in help_cmds.items(): + w.prnt('', w.color("bold") + cmd) + w.prnt('', (helptext or 'No help text').strip()) + w.prnt('', '') + +# Websocket handling methods + + +def command_openweb(current_buffer, args): + trigger = w.config_get_plugin('trigger_value') + if trigger != "0": + if args is None: + channel = channels.find(current_buffer) + url = "{}/messages/{}".format(channel.server.server_buffer_name, channel.name) + topic = w.buffer_get_string(channel.channel_buffer, "title") + w.buffer_set(channel.channel_buffer, "title", "{}:{}".format(trigger, url)) + w.hook_timer(1000, 0, 1, "command_openweb", json.dumps({"topic": topic, "buffer": current_buffer})) + else: + # TODO: fix this dirty hack because i don't know the right way to send multiple args. + args = current_buffer + data = json.loads(args) + channel_buffer = channels.find(data["buffer"]).channel_buffer + w.buffer_set(channel_buffer, "title", data["topic"]) + return w.WEECHAT_RC_OK + + +@slack_buffer_or_ignore +def topic_command_cb(data, current_buffer, args): + n = len(args.split()) + if n < 2: + channel = channels.find(current_buffer) + if channel: + w.prnt(current_buffer, 'Topic for {} is "{}"'.format(channel.name, channel.topic)) + return w.WEECHAT_RC_OK_EAT + elif command_topic(current_buffer, args.split(None, 1)[1]): + return w.WEECHAT_RC_OK_EAT + else: + return w.WEECHAT_RC_ERROR + + +def command_topic(current_buffer, args): + """ + Change the topic of a channel + /slack topic [<channel>] [<topic>|-delete] + """ + server = servers.find(current_domain_name()) + if server: + arrrrgs = args.split(None, 1) + if arrrrgs[0].startswith('#'): + channel = server.channels.find(arrrrgs[0]) + topic = arrrrgs[1] + else: + channel = server.channels.find(current_buffer) + topic = args + + if channel: + if topic == "-delete": + async_slack_api_request(server.domain, server.token, 'channels.setTopic', {"channel": channel.identifier, "topic": ""}) + else: + async_slack_api_request(server.domain, server.token, 'channels.setTopic', {"channel": channel.identifier, "topic": topic}) + return True + else: + return False + else: + return False + + +def slack_websocket_cb(server, fd): + try: + data = servers.find(server).ws.recv() + message_json = json.loads(data) + # this magic attaches json that helps find the right dest + message_json['_server'] = server + except WebSocketConnectionClosedException: + servers.find(server).ws.close() + return w.WEECHAT_RC_OK + except Exception: + dbg("socket issue: {}\n".format(traceback.format_exc())) + return w.WEECHAT_RC_OK + # dispatch here + if "reply_to" in message_json: + function_name = "reply" + elif "type" in message_json: + function_name = message_json["type"] + else: + function_name = "unknown" + try: + proc[function_name](message_json) + except KeyError: + if function_name: + dbg("Function not implemented: {}\n{}".format(function_name, message_json)) + else: + dbg("Function not implemented\n{}".format(message_json)) + w.bar_item_update("slack_typing_notice") + return w.WEECHAT_RC_OK + + +def process_reply(message_json): + global unfurl_ignore_alt_text + + server = servers.find(message_json["_server"]) + identifier = message_json["reply_to"] + item = server.message_buffer.pop(identifier) + if 'text' in item and type(item['text']) is not unicode: + item['text'] = item['text'].decode('UTF-8', 'replace') + if "type" in item: + if item["type"] == "message" and "channel" in item.keys(): + item["ts"] = message_json["ts"] + channels.find(item["channel"]).cache_message(item, from_me=True) + text = unfurl_refs(item["text"], ignore_alt_text=unfurl_ignore_alt_text) + + channels.find(item["channel"]).buffer_prnt(item["user"], text, item["ts"]) + dbg("REPLY {}".format(item)) + + +def process_pong(message_json): + pass + + +def process_pref_change(message_json): + server = servers.find(message_json["_server"]) + if message_json['name'] == u'muted_channels': + muted = message_json['value'].split(',') + for c in server.channels: + if c.identifier in muted: + c.muted = True + else: + c.muted = False + else: + dbg("Preference change not implemented: {}\n".format(message_json['name'])) + + +def process_team_join(message_json): + server = servers.find(message_json["_server"]) + item = message_json["user"] + server.add_user(User(server, item["name"], item["id"], item["presence"])) + server.buffer_prnt("New user joined: {}".format(item["name"])) + + +def process_manual_presence_change(message_json): + process_presence_change(message_json) + + +def process_presence_change(message_json): + server = servers.find(message_json["_server"]) + identifier = message_json.get("user", server.nick) + if message_json["presence"] == 'active': + server.users.find(identifier).set_active() + else: + server.users.find(identifier).set_inactive() + + +def process_channel_marked(message_json): + channel = channels.find(message_json["channel"]) + channel.mark_read(False) + w.buffer_set(channel.channel_buffer, "hotlist", "-1") + + +def process_group_marked(message_json): + channel = channels.find(message_json["channel"]) + channel.mark_read(False) + w.buffer_set(channel.channel_buffer, "hotlist", "-1") + + +def process_channel_created(message_json): + server = servers.find(message_json["_server"]) + item = message_json["channel"] + if server.channels.find(message_json["channel"]["name"]): + server.channels.find(message_json["channel"]["name"]).open(False) + else: + item = message_json["channel"] + server.add_channel(Channel(server, item["name"], item["id"], False, prepend_name="#")) + server.buffer_prnt("New channel created: {}".format(item["name"])) + + +def process_channel_left(message_json): + server = servers.find(message_json["_server"]) + server.channels.find(message_json["channel"]).close(False) + + +def process_channel_join(message_json): + server = servers.find(message_json["_server"]) + channel = server.channels.find(message_json["channel"]) + text = unfurl_refs(message_json["text"], ignore_alt_text=False) + channel.buffer_prnt(w.prefix("join").rstrip(), text, message_json["ts"]) + channel.user_join(message_json["user"]) + + +def process_channel_topic(message_json): + server = servers.find(message_json["_server"]) + channel = server.channels.find(message_json["channel"]) + text = unfurl_refs(message_json["text"], ignore_alt_text=False) + channel.buffer_prnt(w.prefix("network").rstrip(), text, message_json["ts"]) + channel.set_topic(message_json["topic"]) + + +def process_channel_joined(message_json): + server = servers.find(message_json["_server"]) + if server.channels.find(message_json["channel"]["name"]): + server.channels.find(message_json["channel"]["name"]).open(False) + else: + item = message_json["channel"] + server.add_channel(Channel(server, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]["value"])) + + +def process_channel_leave(message_json): + server = servers.find(message_json["_server"]) + channel = server.channels.find(message_json["channel"]) + text = unfurl_refs(message_json["text"], ignore_alt_text=False) + channel.buffer_prnt(w.prefix("quit").rstrip(), text, message_json["ts"]) + channel.user_leave(message_json["user"]) + + +def process_channel_archive(message_json): + server = servers.find(message_json["_server"]) + channel = server.channels.find(message_json["channel"]) + channel.detach_buffer() + + +def process_group_join(message_json): + process_channel_join(message_json) + + +def process_group_leave(message_json): + process_channel_leave(message_json) + + +def process_group_topic(message_json): + process_channel_topic(message_json) + + +def process_group_left(message_json): + server = servers.find(message_json["_server"]) + server.channels.find(message_json["channel"]).close(False) + + +def process_group_joined(message_json): + server = servers.find(message_json["_server"]) + if server.channels.find(message_json["channel"]["name"]): + server.channels.find(message_json["channel"]["name"]).open(False) + else: + item = message_json["channel"] + if item["name"].startswith("mpdm-"): + server.add_channel(MpdmChannel(server, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]["value"])) + else: + server.add_channel(GroupChannel(server, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]["value"])) + + +def process_group_archive(message_json): + channel = server.channels.find(message_json["channel"]) + channel.detach_buffer() + + +def process_mpim_close(message_json): + server = servers.find(message_json["_server"]) + server.channels.find(message_json["channel"]).close(False) + + +def process_mpim_open(message_json): + server = servers.find(message_json["_server"]) + server.channels.find(message_json["channel"]).open(False) + + +def process_im_close(message_json): + server = servers.find(message_json["_server"]) + server.channels.find(message_json["channel"]).close(False) + + +def process_im_open(message_json): + server = servers.find(message_json["_server"]) + server.channels.find(message_json["channel"]).open() + + +def process_im_marked(message_json): + channel = channels.find(message_json["channel"]) + channel.mark_read(False) + if channel.channel_buffer is not None: + w.buffer_set(channel.channel_buffer, "hotlist", "-1") + + +def process_im_created(message_json): + server = servers.find(message_json["_server"]) + item = message_json["channel"] + channel_name = server.users.find(item["user"]).name + if server.channels.find(channel_name): + server.channels.find(channel_name).open(False) + else: + item = message_json["channel"] + server.add_channel(DmChannel(server, channel_name, item["id"], item["is_open"], item["last_read"])) + server.buffer_prnt("New direct message channel created: {}".format(item["name"])) + + +def process_user_typing(message_json): + server = servers.find(message_json["_server"]) + channel = server.channels.find(message_json["channel"]) + if channel: + channel.set_typing(server.users.find(message_json["user"]).name) + + +def process_bot_enable(message_json): + process_bot_integration(message_json) + + +def process_bot_disable(message_json): + process_bot_integration(message_json) + + +def process_bot_integration(message_json): + server = servers.find(message_json["_server"]) + channel = server.channels.find(message_json["channel"]) + + time = message_json['ts'] + text = "{} {}".format(server.users.find(message_json['user']).formatted_name(), + render_message(message_json)) + bot_name = get_user(message_json, server) + bot_name = bot_name.encode('utf-8') + channel.buffer_prnt(bot_name, text, time) + +# todo: does this work? + + +def process_error(message_json): + pass + + +def process_reaction_added(message_json): + if message_json["item"].get("type") == "message": + channel = channels.find(message_json["item"]["channel"]) + channel.add_reaction(message_json["item"]["ts"], message_json["reaction"], message_json["user"]) + else: + dbg("Reaction to item type not supported: " + str(message_json)) + + +def process_reaction_removed(message_json): + if message_json["item"].get("type") == "message": + channel = channels.find(message_json["item"]["channel"]) + channel.remove_reaction(message_json["item"]["ts"], message_json["reaction"], message_json["user"]) + else: + dbg("Reaction to item type not supported: " + str(message_json)) + + +def create_reaction_string(reactions): + count = 0 + if not isinstance(reactions, list): + reaction_string = " [{}]".format(reactions) + else: + reaction_string = ' [' + for r in reactions: + if len(r["users"]) > 0: + count += 1 + if show_reaction_nicks: + nicks = [resolve_ref("@{}".format(user)) for user in r["users"]] + users = "({})".format(",".join(nicks)) + else: + users = len(r["users"]) + reaction_string += ":{}:{} ".format(r["name"], users) + reaction_string = reaction_string[:-1] + ']' + if count == 0: + reaction_string = '' + return reaction_string + + +def modify_buffer_line(buffer, new_line, time): + time = int(float(time)) + # get a pointer to this buffer's lines + own_lines = w.hdata_pointer(w.hdata_get('buffer'), buffer, 'own_lines') + if own_lines: + # get a pointer to the last line + line_pointer = w.hdata_pointer(w.hdata_get('lines'), own_lines, 'last_line') + # hold the structure of a line and of line data + struct_hdata_line = w.hdata_get('line') + struct_hdata_line_data = w.hdata_get('line_data') + + while line_pointer: + # get a pointer to the data in line_pointer via layout of struct_hdata_line + data = w.hdata_pointer(struct_hdata_line, line_pointer, 'data') + if data: + date = w.hdata_time(struct_hdata_line_data, data, 'date') + # prefix = w.hdata_string(struct_hdata_line_data, data, 'prefix') + + if int(date) == int(time): + # w.prnt("", "found matching time date is {}, time is {} ".format(date, time)) + w.hdata_update(struct_hdata_line_data, data, {"message": new_line}) + break + else: + pass + # move backwards one line and try again - exit the while if you hit the end + line_pointer = w.hdata_move(struct_hdata_line, line_pointer, -1) + return w.WEECHAT_RC_OK + + +def render_message(message_json, force=False): + global unfurl_ignore_alt_text + # If we already have a rendered version in the object, just return that. + if not force and message_json.get("_rendered_text", ""): + return message_json["_rendered_text"] + else: + # server = servers.find(message_json["_server"]) + + if "fallback" in message_json: + text = message_json["fallback"] + elif "text" in message_json: + if message_json['text'] is not None: + text = message_json["text"] + else: + text = u"" + else: + text = u"" + + text = unfurl_refs(text, ignore_alt_text=unfurl_ignore_alt_text) + + text_before = (len(text) > 0) + text += unfurl_refs(unwrap_attachments(message_json, text_before), ignore_alt_text=unfurl_ignore_alt_text) + + text = text.lstrip() + text = text.replace("\t", " ") + text = text.replace("<", "<") + text = text.replace(">", ">") + text = text.replace("&", "&") + text = text.encode('utf-8') + + if "reactions" in message_json: + text += create_reaction_string(message_json["reactions"]) + message_json["_rendered_text"] = text + return text + + +def process_message(message_json, cache=True): + try: + # send these subtype messages elsewhere + known_subtypes = ["message_changed", 'message_deleted', 'channel_join', 'channel_leave', 'channel_topic', 'group_join', 'group_leave', 'group_topic', 'bot_enable', 'bot_disable'] + if "subtype" in message_json and message_json["subtype"] in known_subtypes: + proc[message_json["subtype"]](message_json) + + else: + server = servers.find(message_json["_server"]) + channel = channels.find(message_json["channel"]) + + # do not process messages in unexpected channels + if not channel.active: + channel.open(False) + dbg("message came for closed channel {}".format(channel.name)) + return + + time = message_json['ts'] + text = render_message(message_json) + name = get_user(message_json, server) + name = name.encode('utf-8') + + # special case with actions. + if text.startswith("_") and text.endswith("_"): + text = text[1:-1] + if name != channel.server.nick: + text = name + " " + text + channel.buffer_prnt(w.prefix("action").rstrip(), text, time) + + else: + suffix = '' + if 'edited' in message_json: + suffix = ' (edited)' + channel.buffer_prnt(name, text + suffix, time) + + if cache: + channel.cache_message(message_json) + + except Exception: + channel = channels.find(message_json["channel"]) + dbg("cannot process message {}\n{}".format(message_json, traceback.format_exc())) + if channel and ("text" in message_json) and message_json['text'] is not None: + channel.buffer_prnt('unknown', message_json['text']) + + +def process_message_changed(message_json): + m = message_json["message"] + if "message" in message_json: + if "attachments" in m: + message_json["attachments"] = m["attachments"] + if "text" in m: + if "text" in message_json: + message_json["text"] += m["text"] + dbg("added text!") + else: + message_json["text"] = m["text"] + if "fallback" in m: + if "fallback" in message_json: + message_json["fallback"] += m["fallback"] + else: + message_json["fallback"] = m["fallback"] + + text_before = (len(m['text']) > 0) + m["text"] += unwrap_attachments(message_json, text_before) + channel = channels.find(message_json["channel"]) + if "edited" in m: + channel.change_message(m["ts"], m["text"], ' (edited)') + else: + channel.change_message(m["ts"], m["text"]) + + +def process_message_deleted(message_json): + channel = channels.find(message_json["channel"]) + channel.change_message(message_json["deleted_ts"], "(deleted)") + + +def unwrap_attachments(message_json, text_before): + attachment_text = '' + if "attachments" in message_json: + if text_before: + attachment_text = u'\n' + for attachment in message_json["attachments"]: + # Attachments should be rendered roughly like: + # + # $pretext + # $author: (if rest of line is non-empty) $title ($title_link) OR $from_url + # $author: (if no $author on previous line) $text + # $fields + t = [] + prepend_title_text = '' + if 'author_name' in attachment: + prepend_title_text = attachment['author_name'] + ": " + if 'pretext' in attachment: + t.append(attachment['pretext']) + if "title" in attachment: + if 'title_link' in attachment: + t.append('%s%s (%s)' % (prepend_title_text, attachment["title"], attachment["title_link"],)) + else: + t.append(prepend_title_text + attachment["title"]) + prepend_title_text = '' + elif "from_url" in attachment: + t.append(attachment["from_url"]) + if "text" in attachment: + tx = re.sub(r' *\n[\n ]+', '\n', attachment["text"]) + t.append(prepend_title_text + tx) + prepend_title_text = '' + if 'fields' in attachment: + for f in attachment['fields']: + if f['title'] != '': + t.append('%s %s' % (f['title'], f['value'],)) + else: + t.append(f['value']) + if t == [] and "fallback" in attachment: + t.append(attachment["fallback"]) + attachment_text += "\n".join([x.strip() for x in t if x]) + return attachment_text + + +def resolve_ref(ref): + if ref.startswith('@U') or ref.startswith('@W'): + if users.find(ref[1:]): + try: + return "@{}".format(users.find(ref[1:]).name) + except: + dbg("NAME: {}".format(ref)) + elif ref.startswith('#C'): + if channels.find(ref[1:]): + try: + return "{}".format(channels.find(ref[1:]).name) + except: + dbg("CHANNEL: {}".format(ref)) + + # Something else, just return as-is + return ref + + +def unfurl_ref(ref, ignore_alt_text=False): + id = ref.split('|')[0] + display_text = ref + if ref.find('|') > -1: + if ignore_alt_text: + display_text = resolve_ref(id) + else: + if id.startswith("#C") or id.startswith("@U"): + display_text = ref.split('|')[1] + else: + url, desc = ref.split('|', 1) + display_text = u"{} ({})".format(url, desc) + else: + display_text = resolve_ref(ref) + return display_text + + +def unfurl_refs(text, ignore_alt_text=False): + """ + input : <@U096Q7CQM|someuser> has joined the channel + ouput : someuser has joined the channel + """ + # Find all strings enclosed by <> + # - <https://example.com|example with spaces> + # - <#C2147483705|#otherchannel> + # - <@U2147483697|@othernick> + # Test patterns lives in ./_pytest/test_unfurl.py + matches = re.findall(r"(<[@#]?(?:[^<]*)>)", text) + for m in matches: + # Replace them with human readable strings + text = text.replace(m, unfurl_ref(m[1:-1], ignore_alt_text)) + return text + + +def get_user(message_json, server): + if 'bot_id' in message_json and message_json['bot_id'] is not None: + name = u"{} :]".format(server.bots.find(message_json["bot_id"]).formatted_name()) + elif 'user' in message_json: + u = server.users.find(message_json['user']) + if u.is_bot: + name = u"{} :]".format(u.formatted_name()) + else: + name = u.name + elif 'username' in message_json: + name = u"-{}-".format(message_json["username"]) + elif 'service_name' in message_json: + name = u"-{}-".format(message_json["service_name"]) + else: + name = u"" + return name + +# END Websocket handling methods + + +def typing_bar_item_cb(data, buffer, args): + typers = [x for x in channels if x.is_someone_typing()] + if len(typers) > 0: + direct_typers = [] + channel_typers = [] + for dm in channels.find_by_class(DmChannel): + direct_typers.extend(dm.get_typing_list()) + direct_typers = ["D/" + x for x in direct_typers] + current_channel = w.current_buffer() + channel = channels.find(current_channel) + try: + if channel and channel.__class__ != DmChannel: + channel_typers = channels.find(current_channel).get_typing_list() + except: + w.prnt("", "Bug on {}".format(channel)) + typing_here = ", ".join(channel_typers + direct_typers) + if len(typing_here) > 0: + color = w.color('yellow') + return color + "typing: " + typing_here + return "" + + +def typing_update_cb(data, remaining_calls): + w.bar_item_update("slack_typing_notice") + return w.WEECHAT_RC_OK + + +def buffer_list_update_cb(data, remaining_calls): + global buffer_list_update + + now = time.time() + if buffer_list_update and previous_buffer_list_update + 1 < now: + # gray_check = False + # if len(servers) > 1: + # gray_check = True + for channel in channels: + channel.rename() + buffer_list_update = False + return w.WEECHAT_RC_OK + + +def buffer_list_update_next(): + global buffer_list_update + buffer_list_update = True + + +def hotlist_cache_update_cb(data, remaining_calls): + # this keeps the hotlist dupe up to date for the buffer switch, but is prob technically a race condition. (meh) + global hotlist + prev_hotlist = hotlist + hotlist = w.infolist_get("hotlist", "", "") + w.infolist_free(prev_hotlist) + return w.WEECHAT_RC_OK + + +def buffer_closing_cb(signal, sig_type, data): + if channels.find(data): + channels.find(data).closed() + return w.WEECHAT_RC_OK + + +def buffer_opened_cb(signal, sig_type, data): + channels.update_hashtable() + return w.WEECHAT_RC_OK + + +def buffer_switch_cb(signal, sig_type, data): + global previous_buffer, hotlist + # this is to see if we need to gray out things in the buffer list + if channels.find(previous_buffer): + channels.find(previous_buffer).mark_read() + + # channel_name = current_buffer_name() + previous_buffer = data + return w.WEECHAT_RC_OK + + +def typing_notification_cb(signal, sig_type, data): + if len(w.buffer_get_string(data, "input")) > 8: + global typing_timer + now = time.time() + if typing_timer + 4 < now: + channel = channels.find(current_buffer_name()) + if channel: + identifier = channel.identifier + request = {"type": "typing", "channel": identifier} + channel.server.send_to_websocket(request, expect_reply=False) + typing_timer = now + return w.WEECHAT_RC_OK + + +def slack_ping_cb(data, remaining): + """ + Periodic websocket ping to detect broken connection. + """ + servers.find(data).ping() + return w.WEECHAT_RC_OK + + +def slack_connection_persistence_cb(data, remaining_calls): + """ + Reconnect if a connection is detected down + """ + for server in servers: + if not server.connected: + server.buffer_prnt("Disconnected from slack, trying to reconnect..") + if server.ws_hook is not None: + w.unhook(server.ws_hook) + server.connect_to_slack() + return w.WEECHAT_RC_OK + + +def slack_never_away_cb(data, remaining): + global never_away + if never_away: + for server in servers: + identifier = server.channels.find("slackbot").identifier + request = {"type": "typing", "channel": identifier} + # request = {"type":"typing","channel":"slackbot"} + server.send_to_websocket(request, expect_reply=False) + return w.WEECHAT_RC_OK + + +def nick_completion_cb(data, completion_item, buffer, completion): + """ + Adds all @-prefixed nicks to completion list + """ + + channel = channels.find(buffer) + if channel is None or channel.members is None: + return w.WEECHAT_RC_OK + for m in channel.members: + user = channel.server.users.find(m) + w.hook_completion_list_add(completion, "@" + user.name, 1, w.WEECHAT_LIST_POS_SORT) + return w.WEECHAT_RC_OK + + +def complete_next_cb(data, buffer, command): + """Extract current word, if it is equal to a nick, prefix it with @ and + rely on nick_completion_cb adding the @-prefixed versions to the + completion lists, then let Weechat's internal completion do its + thing + + """ + + channel = channels.find(buffer) + if channel is None or channel.members is None: + return w.WEECHAT_RC_OK + input = w.buffer_get_string(buffer, "input") + current_pos = w.buffer_get_integer(buffer, "input_pos") - 1 + input_length = w.buffer_get_integer(buffer, "input_length") + word_start = 0 + word_end = input_length + # If we're on a non-word, look left for something to complete + while current_pos >= 0 and input[current_pos] != '@' and not input[current_pos].isalnum(): + current_pos = current_pos - 1 + if current_pos < 0: + current_pos = 0 + for l in range(current_pos, 0, -1): + if input[l] != '@' and not input[l].isalnum(): + word_start = l + 1 + break + for l in range(current_pos, input_length): + if not input[l].isalnum(): + word_end = l + break + word = input[word_start:word_end] + for m in channel.members: + user = channel.server.users.find(m) + if user.name == word: + # Here, we cheat. Insert a @ in front and rely in the @ + # nicks being in the completion list + w.buffer_set(buffer, "input", input[:word_start] + "@" + input[word_start:]) + w.buffer_set(buffer, "input_pos", str(w.buffer_get_integer(buffer, "input_pos") + 1)) + return w.WEECHAT_RC_OK_EAT + return w.WEECHAT_RC_OK + + +# Slack specific requests +def async_slack_api_request(domain, token, request, post_data, priority=False): + if not STOP_TALKING_TO_SLACK: + post_data["token"] = token + url = 'url:https://{}/api/{}?{}'.format(domain, request, urllib.urlencode(post_data)) + context = pickle.dumps({"request": request, "token": token, "post_data": post_data}) + params = {'useragent': 'wee_slack {}'.format(SCRIPT_VERSION)} + dbg("URL: {} context: {} params: {}".format(url, context, params)) + w.hook_process_hashtable(url, params, slack_timeout, "url_processor_cb", context) + + +def async_slack_api_upload_request(token, request, post_data, priority=False): + if not STOP_TALKING_TO_SLACK: + url = 'https://slack.com/api/{}'.format(request) + file_path = os.path.expanduser(post_data["file"]) + command = 'curl -F file=@{} -F channels={} -F token={} {}'.format(file_path, post_data["channels"], token, url) + context = pickle.dumps({"request": request, "token": token, "post_data": post_data}) + w.hook_process(command, slack_timeout, "url_processor_cb", context) + + +# funny, right? +big_data = {} + + +def url_processor_cb(data, command, return_code, out, err): + global big_data + data = pickle.loads(data) + identifier = sha.sha("{}{}".format(data, command)).hexdigest() + if identifier not in big_data: + big_data[identifier] = '' + big_data[identifier] += out + if return_code == 0: + try: + my_json = json.loads(big_data[identifier]) + except: + dbg("request failed, doing again...") + dbg("response length: {} identifier {}\n{}".format(len(big_data[identifier]), identifier, data)) + my_json = False + + big_data.pop(identifier, None) + + if my_json: + if data["request"] == 'rtm.start': + servers.find(data["token"]).connected_to_slack(my_json) + servers.update_hashtable() + + else: + if "channel" in data["post_data"]: + channel = data["post_data"]["channel"] + token = data["token"] + if "messages" in my_json: + my_json["messages"].reverse() + for message in my_json["messages"]: + message["_server"] = servers.find(token).domain + message["channel"] = servers.find(token).channels.find(channel).identifier + process_message(message) + if "channel" in my_json: + if "members" in my_json["channel"]: + channels.find(my_json["channel"]["id"]).members = set(my_json["channel"]["members"]) + else: + if return_code != -1: + big_data.pop(identifier, None) + dbg("return code: {}, data: {}, output: {}, error: {}".format(return_code, data, out, err)) + + return w.WEECHAT_RC_OK + + +def cache_write_cb(data, remaining): + cache_file = open("{}/{}".format(WEECHAT_HOME, CACHE_NAME), 'w') + cache_file.write(CACHE_VERSION + "\n") + for channel in channels: + if channel.active: + for message in channel.messages: + cache_file.write("{}\n".format(json.dumps(message.message_json))) + return w.WEECHAT_RC_OK + + +def cache_load(): + global message_cache + try: + file_name = "{}/{}".format(WEECHAT_HOME, CACHE_NAME) + cache_file = open(file_name, 'r') + if cache_file.readline() == CACHE_VERSION + "\n": + dbg("Loading messages from cache.", main_buffer=True) + for line in cache_file: + j = json.loads(line) + message_cache[j["channel"]].append(line) + dbg("Completed loading messages from cache.", main_buffer=True) + except ValueError: + w.prnt("", "Failed to load cache file, probably illegal JSON.. Ignoring") + pass + except IOError: + w.prnt("", "cache file not found") + pass + +# END Slack specific requests + +# Utility Methods + + +def current_domain_name(): + buffer = w.current_buffer() + if servers.find(buffer): + return servers.find(buffer).domain + else: + # number = w.buffer_get_integer(buffer, "number") + name = w.buffer_get_string(buffer, "name") + name = ".".join(name.split(".")[:-1]) + return name + + +def current_buffer_name(short=False): + buffer = w.current_buffer() + # number = w.buffer_get_integer(buffer, "number") + name = w.buffer_get_string(buffer, "name") + if short: + try: + name = name.split('.')[-1] + except: + pass + return name + + +def closed_slack_buffer_cb(data, buffer): + global slack_buffer + slack_buffer = None + return w.WEECHAT_RC_OK + + +def create_slack_buffer(): + global slack_buffer + slack_buffer = w.buffer_new("slack", "", "", "closed_slack_buffer_cb", "") + w.buffer_set(slack_buffer, "notify", "0") + # w.buffer_set(slack_buffer, "display", "1") + return w.WEECHAT_RC_OK + + +def closed_slack_debug_buffer_cb(data, buffer): + global slack_debug + slack_debug = None + return w.WEECHAT_RC_OK + + +def create_slack_debug_buffer(): + global slack_debug, debug_string + if slack_debug is not None: + w.buffer_set(slack_debug, "display", "1") + else: + debug_string = None + slack_debug = w.buffer_new("slack-debug", "", "", "closed_slack_debug_buffer_cb", "") + w.buffer_set(slack_debug, "notify", "0") + + +def config_changed_cb(data, option, value): + global slack_api_token, distracting_channels, colorize_nicks, colorize_private_chats, slack_debug, debug_mode, \ + unfurl_ignore_alt_text, colorize_messages, show_reaction_nicks, slack_timeout + + slack_api_token = w.config_get_plugin("slack_api_token") + + if slack_api_token.startswith('${sec.data'): + slack_api_token = w.string_eval_expression(slack_api_token, {}, {}, {}) + + distracting_channels = [x.strip() for x in w.config_get_plugin("distracting_channels").split(',')] + colorize_nicks = w.config_get_plugin('colorize_nicks') == "1" + colorize_messages = w.config_get_plugin("colorize_messages") == "1" + debug_mode = w.config_get_plugin("debug_mode").lower() + if debug_mode != '' and debug_mode != 'false': + create_slack_debug_buffer() + colorize_private_chats = w.config_string_to_boolean(w.config_get_plugin("colorize_private_chats")) + show_reaction_nicks = w.config_string_to_boolean(w.config_get_plugin("show_reaction_nicks")) + + unfurl_ignore_alt_text = False + if w.config_get_plugin('unfurl_ignore_alt_text') != "0": + unfurl_ignore_alt_text = True + + slack_timeout = int(w.config_get_plugin('slack_timeout')) + + return w.WEECHAT_RC_OK + + +def quit_notification_cb(signal, sig_type, data): + stop_talking_to_slack() + + +def script_unloaded(): + stop_talking_to_slack() + return w.WEECHAT_RC_OK + + +def stop_talking_to_slack(): + """ + Prevents a race condition where quitting closes buffers + which triggers leaving the channel because of how close + buffer is handled + """ + global STOP_TALKING_TO_SLACK + STOP_TALKING_TO_SLACK = True + cache_write_cb("", "") + return w.WEECHAT_RC_OK + + +def scrolled_cb(signal, sig_type, data): + try: + if w.window_get_integer(data, "scrolling") == 1: + channels.find(w.current_buffer()).set_scrolling() + else: + channels.find(w.current_buffer()).unset_scrolling() + except: + pass + return w.WEECHAT_RC_OK + +# END Utility Methods + + +# Main +if __name__ == "__main__": + + if w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, + SCRIPT_DESC, "script_unloaded", ""): + + version = w.info_get("version_number", "") or 0 + if int(version) < 0x1030000: + w.prnt("", "\nERROR: Weechat version 1.3+ is required to use {}.\n\n".format(SCRIPT_NAME)) + else: + + WEECHAT_HOME = w.info_get("weechat_dir", "") + CACHE_NAME = "slack.cache" + STOP_TALKING_TO_SLACK = False + + if not w.config_get_plugin('slack_api_token'): + w.config_set_plugin('slack_api_token', "INSERT VALID KEY HERE!") + if not w.config_get_plugin('distracting_channels'): + w.config_set_plugin('distracting_channels', "") + if not w.config_get_plugin('debug_mode'): + w.config_set_plugin('debug_mode', "") + if not w.config_get_plugin('colorize_nicks'): + w.config_set_plugin('colorize_nicks', "1") + if not w.config_get_plugin('colorize_messages'): + w.config_set_plugin('colorize_messages', "0") + if not w.config_get_plugin('colorize_private_chats'): + w.config_set_plugin('colorize_private_chats', "0") + if not w.config_get_plugin('trigger_value'): + w.config_set_plugin('trigger_value', "0") + if not w.config_get_plugin('unfurl_ignore_alt_text'): + w.config_set_plugin('unfurl_ignore_alt_text', "0") + if not w.config_get_plugin('switch_buffer_on_join'): + w.config_set_plugin('switch_buffer_on_join', "1") + if not w.config_get_plugin('show_reaction_nicks'): + w.config_set_plugin('show_reaction_nicks', "0") + if not w.config_get_plugin('slack_timeout'): + w.config_set_plugin('slack_timeout', "20000") + if w.config_get_plugin('channels_not_on_current_server_color'): + w.config_option_unset('channels_not_on_current_server_color') + + # Global var section + slack_debug = None + config_changed_cb("", "", "") + + cmds = {k[8:]: v for k, v in globals().items() if k.startswith("command_")} + proc = {k[8:]: v for k, v in globals().items() if k.startswith("process_")} + + typing_timer = time.time() + domain = None + previous_buffer = None + slack_buffer = None + + buffer_list_update = False + previous_buffer_list_update = 0 + + never_away = False + hide_distractions = False + hotlist = w.infolist_get("hotlist", "", "") + main_weechat_buffer = w.info_get("irc_buffer", "{}.{}".format(domain, "DOESNOTEXIST!@#$")) + + message_cache = collections.defaultdict(list) + cache_load() + + servers = SearchList() + for token in slack_api_token.split(','): + server = SlackServer(token) + servers.append(server) + channels = SearchList() + users = SearchList() + + w.hook_config("plugins.var.python." + SCRIPT_NAME + ".*", "config_changed_cb", "") + w.hook_timer(3000, 0, 0, "slack_connection_persistence_cb", "") + + # attach to the weechat hooks we need + w.hook_timer(1000, 0, 0, "typing_update_cb", "") + w.hook_timer(1000, 0, 0, "buffer_list_update_cb", "") + w.hook_timer(1000, 0, 0, "hotlist_cache_update_cb", "") + w.hook_timer(1000 * 60 * 29, 0, 0, "slack_never_away_cb", "") + w.hook_timer(1000 * 60 * 5, 0, 0, "cache_write_cb", "") + w.hook_signal('buffer_closing', "buffer_closing_cb", "") + w.hook_signal('buffer_opened', "buffer_opened_cb", "") + w.hook_signal('buffer_switch', "buffer_switch_cb", "") + w.hook_signal('window_switch', "buffer_switch_cb", "") + w.hook_signal('input_text_changed', "typing_notification_cb", "") + w.hook_signal('quit', "quit_notification_cb", "") + w.hook_signal('window_scrolled', "scrolled_cb", "") + w.hook_command( + # Command name and description + 'slack', 'Plugin to allow typing notification and sync of read markers for slack.com', + # Usage + '[command] [command options]', + # Description of arguments + 'Commands:\n' + + '\n'.join(cmds.keys()) + + '\nUse /slack help [command] to find out more\n', + # Completions + '|'.join(cmds.keys()), + # Function name + 'slack_command_cb', '') + # w.hook_command('me', 'me_command_cb', '') + w.hook_command('me', '', 'stuff', 'stuff2', '', 'me_command_cb', '') + w.hook_command_run('/query', 'join_command_cb', '') + w.hook_command_run('/join', 'join_command_cb', '') + w.hook_command_run('/part', 'part_command_cb', '') + w.hook_command_run('/leave', 'part_command_cb', '') + w.hook_command_run('/topic', 'topic_command_cb', '') + w.hook_command_run('/msg', 'msg_command_cb', '') + w.hook_command_run("/input complete_next", "complete_next_cb", "") + w.hook_completion("nicks", "complete @-nicks for slack", + "nick_completion_cb", "") + w.bar_item_new('slack_typing_notice', 'typing_bar_item_cb', '') + # END attach to the weechat hooks we need |