aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--weechat/python/autojoin_on_invite.py119
-rw-r--r--weechat/python/wee_slack.py1690
2 files changed, 0 insertions, 1809 deletions
diff --git a/weechat/python/autojoin_on_invite.py b/weechat/python/autojoin_on_invite.py
deleted file mode 100644
index 45adab5..0000000
--- a/weechat/python/autojoin_on_invite.py
+++ /dev/null
@@ -1,119 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (c) 2009 by xt <xt@bash.no>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-#
-
-#
-# (this script requires WeeChat 0.3.0 or newer)
-#
-# History:
-# 2015-10-11, Simmo Saan <simmo.saan@gmail.com>
-# version 0.6: allow joining channels with keys in autojoin
-# 2013-12-21, Sebastien Helleu <flashcode@flashtux.org>
-# version 0.5: fix parsing of INVITE message
-# 2013-11-28, sakkemo <scajanus@gmail.com>
-# version 0.4: add whitelist for nicks/channels
-# 2009-11-09, xt <xt@bash.no>
-# version 0.3: add ignore option for channels
-# 2009-10-29, xt <xt@bash.no>
-# version 0.2: add ignore option
-# 2009-10-28, xt <xt@bash.no>
-# version 0.1: initial release
-
-import weechat as w
-import re
-
-SCRIPT_NAME = "autojoin_on_invite"
-SCRIPT_AUTHOR = "xt <xt@bash.no>"
-SCRIPT_VERSION = "0.6"
-SCRIPT_LICENSE = "GPL3"
-SCRIPT_DESC = "Auto joins channels when invited"
-
-# script options
-settings = {
- 'whitelist_nicks': '', # comma separated list of nicks,
- # overrides ignore_nicks
- 'whitelist_channels': '', # comma separated list of channels,
- # overrides ignore_channels
- 'ignore_nicks': '', # comma separated list of nicks
- #that we will not accept auto invite from
- 'ignore_channels': '', # comma separated list of channels to not join
- 'autojoin_key': 'on', # use channel keys from server's autojoin list
-}
-
-if w.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE,
- SCRIPT_DESC, "", ""):
- for option, default_value in settings.iteritems():
- if not w.config_is_set_plugin(option):
- w.config_set_plugin(option, default_value)
-
- w.hook_signal('*,irc_in2_invite', 'invite_cb', '')
-
-def join(server, channel):
- key = None
-
- if w.config_string_to_boolean(w.config_get_plugin('autojoin_key')):
- autojoin = w.config_string(w.config_get('irc.server.%s.autojoin' % server)).split(' ', 1)
-
- if len(autojoin) > 1: # any keys specified
- autojoin_keys = dict(zip(autojoin[0].split(','), autojoin[1].split(',')))
- key = autojoin_keys.get(channel) # defaults to None when not set
-
- if key:
- w.command('', '/quote -server %s JOIN %s %s' % (server, channel, key))
- else:
- w.command('', '/quote -server %s JOIN %s' % (server, channel))
-
-def invite_cb(data, signal, signal_data):
- server = signal.split(',')[0] # EFNet,irc_in_INVITE
- channel = signal_data.split()[-1].lstrip(':') # :nick!ident@host.name INVITE yournick :#channel
- from_nick = re.match(':(?P<nick>.+)!', signal_data).groups()[0]
-
- if len(w.config_get_plugin('whitelist_nicks')) > 0 and len(w.config_get_plugin('whitelist_channels')) > 0: # if there's two whitelists, accept both
- if from_nick in w.config_get_plugin('whitelist_nicks').split(',') or channel in w.config_get_plugin('whitelist_channels').split(','):
- w.prnt('', 'Automatically joining %s on server %s, invitation from %s (whitelist).' \
- %(channel, server, from_nick))
- join(server, channel)
- else:
- w.prnt('', 'Ignoring invite from %s to channel %s. Neither inviter nor channel in whitelist.' %(from_nick, channel))
-
- elif len(w.config_get_plugin('whitelist_nicks')) > 0: # if there's a whitelist, accept nicks in it
- if from_nick in w.config_get_plugin('whitelist_nicks').split(','):
- w.prnt('', 'Automatically joining %s on server %s, invitation from %s (whitelist).' \
- %(channel, server, from_nick))
- join(server, channel)
- else:
- w.prnt('', 'Ignoring invite from %s to channel %s. Inviter not in whitelist.' %(from_nick, channel))
-
- elif len(w.config_get_plugin('whitelist_channels')) > 0: # if there's a whitelist, accept channels in it
- if channel in w.config_get_plugin('whitelist_channels').split(','):
- w.prnt('', 'Automatically joining %s on server %s, invitation from %s (whitelist).' \
- %(channel, server, from_nick))
- join(server, channel)
- else:
- w.prnt('', 'Ignoring invite from %s to channel %s. Channel not in whitelist.' %(from_nick, channel))
-
- else: # use the ignore lists to make the decision
- if from_nick in w.config_get_plugin('ignore_nicks').split(','):
- w.prnt('', 'Ignoring invite from %s to channel %s. Invite from ignored inviter.' %(from_nick, channel))
- elif channel in w.config_get_plugin('ignore_channels').split(','):
- w.prnt('', 'Ignoring invite from %s to channel %s. Invite to ignored channel.' %(from_nick, channel))
- else:
- w.prnt('', 'Automatically joining %s on server %s, invitation from %s.' \
- %(channel, server, from_nick))
- join(server, channel)
-
- return w.WEECHAT_RC_OK
diff --git a/weechat/python/wee_slack.py b/weechat/python/wee_slack.py
deleted file mode 100644
index c2e8cb3..0000000
--- a/weechat/python/wee_slack.py
+++ /dev/null
@@ -1,1690 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-from functools import wraps
-import time
-import json
-import pickle
-import sha
-import re
-import urllib
-import urlparse
-import HTMLParser
-from websocket import create_connection
-
-# 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.97.22"
-SCRIPT_LICENSE = "MIT"
-SCRIPT_DESC = "Extends weechat for typing notification/search/etc on slack.com"
-
-BACKLOG_SIZE = 200
-
-SLACK_API_TRANSLATOR = {
- "channel": {
- "history": "channels.history",
- "join": "channels.join",
- "leave": "channels.leave",
- "mark": "channels.mark",
- "info": "channels.info",
- },
- "im": {
- "history": "im.history",
- "leave": "im.close",
- "mark": "im.mark",
- },
- "group": {
- "history": "groups.history",
- "join": "channels.join",
- "leave": "groups.leave",
- "mark": "groups.mark",
- }
-
-}
-
-def dbg(message, fout=False, main_buffer=False):
- 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("", message)
- else:
- if slack_debug is not None:
- w.prnt(slack_debug, message)
-
-# hilarious, i know
-
-
-class Meta(list):
-
- def __init__(self, attribute, search_list):
- self.attribute = attribute
- self.search_list = search_list
-
- def __str__(self):
- string = ''
- for each in self.search_list.get_all(self.attribute):
- string += "{} ".format(each)
- return string
-
- def __repr__(self):
- self.search_list.get_all(self.attribute)
-
- def __getitem__(self, index):
- things = self.get_all()
- return things[index]
-
- def __iter__(self):
- things = self.get_all()
- for channel in things:
- yield channel
-
- def get_all(self):
- items = []
- items += self.search_list.get_all(self.attribute)
- return items
-
- def find(self, name):
- items = self.search_list.find_deep(name, self.attribute)
- items = [x for x in items if x is not None]
- if len(items) == 1:
- return items[0]
- elif len(items) == 0:
- pass
- else:
- dbg("probably something bad happened with meta items: {}".format(items))
- return items
- #raise AmbiguousProblemError
-
- def find_first(self, name):
- items = self.find(name)
- if items.__class__ == list:
- return items[0]
- else:
- return False
-
- def find_by_class(self, class_name):
- items = self.search_list.find_by_class_deep(class_name, self.attribute)
- return items
-
-
-class SearchList(list):
-
- def find(self, name):
- items = []
- for child in self:
- if child.__class__ == self.__class__:
- items += child.find(name)
- else:
- if child == name:
- items.append(child)
- if len(items) == 1:
- return items[0]
- elif items != []:
- return items
-
- def find_deep(self, name, attribute):
- items = []
- for child in self:
- if child.__class__ == self.__class__:
- if items is not None:
- items += child.find_deep(name, attribute)
- elif dir(child).count('find') == 1:
- if items is not None:
- items.append(child.find(name, attribute))
- if items != []:
- return items
-
- def get_all(self, attribute):
- items = []
- for child in self:
- if child.__class__ == self.__class__:
- items += child.get_all(attribute)
- else:
- items += (eval("child." + attribute))
- return items
-
- 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):
-
- def __init__(self, token):
- self.nick = None
- self.name = None
- self.domain = None
- self.login_data = None
- self.buffer = None
- self.token = token
- self.ws = None
- self.ws_hook = None
- self.users = SearchList()
- self.channels = SearchList()
- self.connecting = False
- self.connected = False
- self.communication_counter = 0
- self.message_buffer = {}
- self.ping_hook = None
- self.failed_message = 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 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):
- data["id"] = self.get_communication_id()
- message = json.dumps(data)
- try:
- self.message_buffer[data["id"]] = data
- self.ws.send(message)
- dbg("Sent {}...".format(message[:100]))
- except:
- self.failed_message = data
- self.connected = False
-
- def ping(self):
- request = {"type": "ping"}
- self.send_to_websocket(request)
-
- def connect_to_slack(self):
- t = time.time()
- if not self.connecting:
- async_slack_api_request("slack.com", self.token, "rtm.start", {"ts": t})
- self.connecting = True
-
- def connected_to_slack(self, login_data):
- if login_data["ok"]:
- self.domain = login_data["team"]["domain"] + ".slack.com"
- dbg("connected to {}".format(self.domain))
- self.identifier = 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) and 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 self.failed_message:
- dbg("Resent failed message.")
- self.send_to_websocket(self.failed_message)
- self.failed_message = None
- return True
- else:
- w.prnt("", "\n!! slack.com login error: " + login_data["error"] + "\n Please check your API token with\n \"/set plugins.var.python.slack_extension.slack_api_token (token)\"\n\n ")
- 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.domain):
- self.buffer = w.buffer_new(self.domain, "buffer_input_cb", "", "", "")
- 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)
- 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:
- return False
-
- def create_slack_mappings(self, data):
-
- for item in data["users"]:
- self.users.append(User(self, item["name"], item["id"], item["presence"]))
-
- 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.channels.append(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"]:
- self.channels.append(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
- name = self.users.find(item["user"]).name
- self.channels.append(DmChannel(self, name, item["id"], item["is_open"], item["last_read"]))
-
- 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 self.buffer:
- w.prnt_date_tags(self.buffer, 0, tags, "{}\t{}".format(user, message))
- else:
- pass
- #w.prnt("", "%s\t%s" % (user, message))
-
-
-class SlackThing(object):
-
- def __init__(self, name, identifier):
- self.name = name
- self.identifier = identifier
- self.channel_buffer = None
-
- def __str__(self):
- return self.name
-
- def __repr__(self):
- return self.name
-
-
-def buffer_input_cb(b, buffer, data):
- if not data.startswith('s/'):
- channel = channels.find(buffer)
- channel.send_message(data)
- channel.buffer_prnt(channel.server.nick, data)
- elif data.count('/') == 3:
- old, new = data.split('/')[1:3]
- channel = channels.find(buffer)
- channel.change_previous_message(old, new)
- channel.mark_read(True)
- return w.WEECHAT_RC_ERROR
-
-
-class Channel(SlackThing):
-
- def __init__(self, server, name, identifier, active, last_read=0, prepend_name="", members=[], topic=""):
- super(Channel, self).__init__(name, identifier)
- self.type = "channel"
- self.server = server
- self.name = prepend_name + self.name
- self.typing = {}
- self.active = active
- self.opening = False
- self.members = set(members)
- self.topic = topic
- self.last_read = float(last_read)
- self.last_received = None
- if active:
- self.create_buffer()
- self.attach_buffer()
- self.update_nicklist()
- self.set_topic(self.topic)
- buffer_list_update_next()
-
- 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 create_buffer(self):
- channel_buffer = w.buffer_search("", "{}.{}".format(self.server.domain, self.name))
- if channel_buffer:
- self.channel_buffer = channel_buffer
- else:
- self.channel_buffer = w.buffer_new("{}.{}".format(self.server.domain, 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')
- w.buffer_set(self.channel_buffer, "short_name", 'loading..')
-
- def attach_buffer(self):
- channel_buffer = w.buffer_search("", "{}.{}".format(self.server.domain, self.name))
- if channel_buffer != main_weechat_buffer:
- self.channel_buffer = channel_buffer
-# w.buffer_set(self.channel_buffer, "highlight_words", self.server.nick)
- else:
- self.channel_buffer = None
-
- def detach_buffer(self):
- if self.channel_buffer is not None:
- w.buffer_close(self.channel_buffer)
- self.channel_buffer = None
-
- def update_nicklist(self):
- if self.channel_buffer:
- w.buffer_set(self.channel_buffer, "nicklist", "1")
- w.nicklist_remove_all(self.channel_buffer)
- try:
- for user in self.members:
- user = self.server.users.find(user)
- if user.presence == 'away':
- w.nicklist_add_nick(self.channel_buffer, "", user.name, user.color_name, " ", "", 1)
- else:
- w.nicklist_add_nick(self.channel_buffer, "", user.name, user.color_name, "+", "", 1)
- except:
- print "DEBUG: {} {}".format(self.identifier,self.name)
-
- def fullname(self):
- return "{}.{}".format(self.server.domain, self.name)
-
- def has_user(self, name):
- return name in self.members
-
- def user_join(self, name):
- self.members.add(name)
- self.update_nicklist()
-
- def user_leave(self, name):
- if name in self.members:
- self.members.remove(name)
- self.update_nicklist()
-
- def set_active(self):
- self.active = True
-
- def set_inactive(self):
- self.active = False
-
- def set_typing(self, user):
- self.typing[user] = time.time()
- buffer_list_update_next()
-
- def unset_typing(self, user):
- 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, "myserver": self.server.domain}
- self.server.send_to_websocket(request)
-
- def linkify_text(self, message):
- message = message.split(' ')
- for item in enumerate(message):
- if item[1].startswith('@'):
- named = re.match('.*[@#](\w+)(\W*)', item[1]).groups()
- if named[0] in ["group", "channel"]:
- message[item[0]] = "<!{}>".format(named[0])
- if self.server.users.find(named[0]):
- message[item[0]] = "<@{}>{}".format(self.server.users.find(named[0]).identifier, named[1])
- if item[1].startswith('#') and self.server.channels.find(item[1]):
- named = re.match('.*[@#](\w+)(\W*)', item[1]).groups()
- if self.server.channels.find(named[0]):
- message[item[0]] = "<#{}>{}".format(self.server.channels.find(named[0]).identifier, named[1])
- dbg(message)
- return " ".join(message)
-
- def set_topic(self, topic):
- topic = topic.encode('ascii', 'ignore')
- w.buffer_set(self.channel_buffer, "title", topic)
-
- def open(self, update_remote=True):
- self.opening = 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("#")})
- self.opening = False
-
- def close(self, update_remote=True):
- #remove from cache so messages don't reappear when reconnecting
- if self.active:
- self.active = False
- self.detach_buffer()
- if update_remote:
- t = time.time()
- async_slack_api_request(self.server.domain, self.server.token, SLACK_API_TRANSLATOR[self.type]["leave"], {"channel": self.identifier})
-
- def closed(self):
- message_cache.pop(self.identifier)
- 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):
- t = time.time()
-
- 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 current_domain_name() != self.server.domain and channels_not_on_current_server_color:
- color = w.color(channels_not_on_current_server_color)
- else:
- color = ""
- if self.is_someone_typing():
- new_name = ">{}".format(self.name[1:])
- else:
- new_name = self.name
- if self.channel_buffer:
- if w.buffer_get_string(self.channel_buffer, "short_name") != (color + new_name):
- w.buffer_set(self.channel_buffer, "short_name", color + new_name)
-
- def buffer_prnt_changed(self, user, text, time, append=""):
- if user:
- if self.server.users.find(user):
- name = self.server.users.find(user).formatted_name()
- else:
- name = user
- name = name.decode('utf-8')
- modify_buffer_line(self.channel_buffer, name, text, time, append)
- else:
- modify_buffer_line(self.channel_buffer, None, text, time, append)
- return False
-
- def buffer_prnt(self, user='unknown user', message='no message', time=0):
- set_read_marker = False
- time_float = float(time)
- 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"
- elif user != self.server.nick and self.name in self.server.users:
- tags = "notify_private,notify_message"
- else:
- tags = "notify_message"
- time_int = int(time_float)
- if self.channel_buffer:
- if self.server.users.find(user):
- name = self.server.users.find(user).formatted_name()
- else:
- name = user
- name = name.decode('utf-8')
- #colorize nicks in each line
- chat_color = w.config_string(w.config_get('weechat.color.chat'))
- message = message.decode('UTF-8', 'replace')
- for user in self.server.users:
- if user.name in message:
- message = user.name_regex.sub(
- r'\1\2{}\3'.format(user.formatted_name() + w.color(chat_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 change_previous_message(self, old, new):
- 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:
- new_message = message["text"].replace(old, new)
- async_slack_api_request(self.server.domain, self.server.token, 'chat.update', {"channel": self.identifier, "ts": message['ts'], "text": new_message})
-
- def my_last_message(self):
- for message in reversed(message_cache[self.identifier]):
- if "user" in message and "text" in message and message["user"] == self.server.users.find(self.server.nick).identifier:
- return message
-
- def get_history(self):
- if self.active:
- if self.identifier in message_cache.keys():
- for message in message_cache[self.identifier]:
- process_message(message)
- if self.last_received != 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 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):
- if current_domain_name() != self.server.domain and channels_not_on_current_server_color:
- force_color = w.color(channels_not_on_current_server_color)
- else:
- force_color = None
-
- if self.server.users.find(self.name).presence == "active":
- new_name = self.server.users.find(self.name).formatted_name('+', force_color)
- else:
- new_name = self.server.users.find(self.name).formatted_name(' ', force_color)
-
- if self.channel_buffer:
- w.buffer_set(self.channel_buffer, "short_name", new_name)
-
-
-class User(SlackThing):
-
- def __init__(self, server, name, identifier, presence="away"):
- super(User, self).__init__(name, identifier)
- self.channel_buffer = w.info_get("irc_buffer", "{}.{}".format(domain, self.name))
- self.presence = presence
- self.server = server
- self.update_color()
- self.name_regex = re.compile(r"([\W]|\A)(@{0,1})" + self.name + "('s|[^'\w]|\Z)")
- if self.presence == 'away':
- self.nicklist_pointer = w.nicklist_add_nick(server.buffer, "", self.name, self.color_name, " ", "", 0)
- else:
- self.nicklist_pointer = w.nicklist_add_nick(server.buffer, "", self.name, self.color_name, "+", "", 1)
-# w.nicklist_add_nick(server.buffer, "", self.formatted_name(), "", "", "", 1)
-
- def __eq__(self, compare_str):
- if compare_str == self.name or compare_str == "@" + self.name or compare_str == self.identifier:
- return True
- else:
- return False
-
- def set_active(self):
- self.presence = "active"
- for channel in self.server.channels:
- if channel.has_user(self.identifier):
- channel.update_nicklist()
- w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "prefix", "+")
- w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "visible", "1")
- buffer_list_update_next()
-
- def set_inactive(self):
- self.presence = "away"
- for channel in self.server.channels:
- if channel.has_user(self.identifier):
- channel.update_nicklist()
- w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "prefix", " ")
- w.nicklist_nick_set(self.server.buffer, self.nicklist_pointer, "visible", "0")
- buffer_list_update_next()
-
- def update_color(self):
- if colorize_nicks:
- self.color = w.info_get('irc_nick_color', self.name)
- self.color_name = w.info_get('irc_nick_color_name', self.name)
- else:
- self.color = ""
- self.color_name = ""
-
- def formatted_name(self, prepend="", force_color=None):
- if colorize_nicks:
- if self.name == self.server.nick:
- return prepend + self.name
- elif not force_color:
- print_color = self.color
- else:
- print_color = force_color
- return print_color + prepend + self.name
- else:
- return prepend + self.name
-
- def open(self):
- t = time.time() + 1
- #reply = async_slack_api_request("im.open", {"channel":self.identifier,"ts":t})
- async_slack_api_request(self.server.domain, self.server.token, "im.open", {"user": self.identifier, "ts": t})
-
-
-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:
- command = cmds[function_name](current_buffer, args)
- except KeyError:
- w.prnt("", "Command not found: " + function_name)
-
- return w.WEECHAT_RC_OK
-
-
-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)
- message = message.encode('utf-8')
- buffer_input_cb("", current_buffer, message)
- return w.WEECHAT_RC_OK
-
-
-def join_command_cb(data, current_buffer, args):
- if channels.find(current_buffer) or servers.find(current_buffer):
- channel = args.split()[1]
- servers.find(current_domain_name()).channels.find(channel).open()
- return w.WEECHAT_RC_OK_EAT
- else:
- return w.WEECHAT_RC_OK
-
-
-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
- return f(current_buffer, *args, **kwargs)
- return wrapper
-
-
-@slack_buffer_required
-def command_talk(current_buffer, args):
- """
- Open a chat with the specified user
- /slack talk [user]
- """
- servers.find(current_domain_name()).users.find(args).open()
-
-
-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 != 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[0] != "":
- for channel in distracting_channels:
- try:
- w.buffer_set(channels.find(channel).channel_buffer, "hidden", str(int(hide_distractions)))
- except:
- dbg("Can't hide channel {}".format(channel), main_buffer=True)
-
-
-@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()
-
-def command_cacheinfo(current_buffer, args):
- for channel in message_cache.keys():
- c = channels.find(channel)
- w.prnt("", "{} {}".format(channels.find(channel), len(message_cache[channel])))
-# server.buffer_prnt("{} {}".format(channels.find(channel), len(message_cache[channel])))
-
-def command_flushcache(current_buffer, args):
- global message_cache
- message_cache = {}
- cache_write_cb("","")
-
-def command_uncache(current_buffer, args):
- identifier = channels.find(current_buffer).identifier
- message_cache.pop(identifier)
- 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.domain, 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
-
-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['myserver'] = server
- except:
- 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)
- # dbg(function_name)
- 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):
- server = servers.find(message_json["myserver"])
- identifier = message_json["reply_to"]
- item = server.message_buffer.pop(identifier)
- if "type" in item:
- if item["type"] == "message":
- item["ts"] = message_json["ts"]
- cache_message(item, from_me=True)
- dbg("REPLY {}".format(item))
-
-def process_pong(message_json):
- pass
-
-
-def process_team_join(message_json):
- server = servers.find(message_json["myserver"])
- item = message_json["user"]
- server.users.append(User(server, item["name"], item["id"], item["presence"]))
- server.buffer_prnt(server.buffer, "New user joined: {}".format(item["name"]))
-
-
-def process_presence_change(message_json):
- buffer_name = "{}.{}".format(domain, message_json["user"])
- buf_ptr = w.buffer_search("", buffer_name)
- if message_json["presence"] == 'active':
- users.find(message_json["user"]).set_active()
- else:
- users.find(message_json["user"]).set_inactive()
-
-
-def process_channel_marked(message_json):
- channel = channels.find(message_json["channel"])
- channel.mark_read(False)
- if not legacy_mode:
- w.buffer_set(channel.channel_buffer, "hotlist", "-1")
-
-
-def process_group_marked(message_json):
- channel = channels.find(message_json["channel"])
- channel.mark_read(False)
- if not legacy_mode:
- w.buffer_set(channel.channel_buffer, "hotlist", "-1")
-
-
-def process_channel_created(message_json):
- server = servers.find(message_json["myserver"])
- 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.channels.append(Channel(server, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]))
- server.buffer_prnt("New channel created: {}".format(item["name"]))
-
-
-def process_channel_left(message_json):
- server = servers.find(message_json["myserver"])
- server.channels.find(message_json["channel"]).close(False)
-
-
-def process_channel_join(message_json):
- server = servers.find(message_json["myserver"])
- channel = server.channels.find(message_json["channel"])
- channel.user_join(message_json["user"])
-
-
-def process_channel_topic(message_json):
- server = servers.find(message_json["myserver"])
- channel = server.channels.find(message_json["channel"])
- channel.set_topic(message_json["topic"])
-
-
-def process_channel_joined(message_json):
- server = servers.find(message_json["myserver"])
- if server.channels.find(message_json["channel"]["name"]):
- server.channels.find(message_json["channel"]["name"]).open(False)
- else:
- item = message_json["channel"]
- server.channels.append(Channel(server, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]))
-
-
-def process_channel_leave(message_json):
- server = servers.find(message_json["myserver"])
- channel = server.channels.find(message_json["channel"])
- channel.user_leave(message_json["user"])
-
-
-def process_group_left(message_json):
- server = servers.find(message_json["myserver"])
- server.channels.find(message_json["channel"]).close(False)
-
-
-def process_group_joined(message_json):
- server = servers.find(message_json["myserver"])
- if server.channels.find(message_json["channel"]["name"]):
- server.channels.find(message_json["channel"]["name"]).open(False)
- else:
- item = message_json["channel"]
- server.channels.append(GroupChannel(server, item["name"], item["id"], item["is_open"], item["last_read"], "#", item["members"], item["topic"]))
-
-
-def process_im_close(message_json):
- server = servers.find(message_json["myserver"])
- server.channels.find(message_json["channel"]).close(False)
-
-
-def process_im_open(message_json):
- server = servers.find(message_json["myserver"])
- server.channels.find(message_json["channel"]).open(False)
-
-
-def process_im_marked(message_json):
- channel = channels.find(message_json["channel"])
- channel.mark_read(False)
- if not legacy_mode:
- w.buffer_set(channel.channel_buffer, "hotlist", "-1")
-
-
-def process_im_created(message_json):
- server = servers.find(message_json["myserver"])
- 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.channels.append(DmChannel(server, channel_name, item["id"], item["is_open"], item["last_read"]))
- server.buffer_prnt("New channel created: {}".format(item["name"]))
-
-
-def process_user_typing(message_json):
- server = servers.find(message_json["myserver"])
- server.channels.find(message_json["channel"]).set_typing(server.users.find(message_json["user"]).name)
-
-# todo: does this work?
-
-
-def process_error(message_json):
- pass
- #connected = False
-
-# def process_message_changed(message_json):
-# process_message(message_json)
-
-def cache_message(message_json, from_me=False):
- global message_cache
- if from_me:
- server = channels.find(message_json["channel"]).server
- message_json["user"] = server.users.find(server.nick).identifier
- channel = message_json["channel"]
- if channel not in message_cache:
- message_cache[channel] = []
- if message_json not in message_cache[channel]:
- message_cache[channel].append(message_json)
- if len(message_cache[channel]) > BACKLOG_SIZE:
- message_cache[channel] = message_cache[channel][-BACKLOG_SIZE:]
-
-
-def modify_buffer_line(buffer, user, new_message, time, append):
- time = int(float(time))
- own_lines = w.hdata_pointer(w.hdata_get('buffer'), buffer, 'own_lines')
- if own_lines:
- line = w.hdata_pointer(w.hdata_get('lines'), own_lines, 'last_line')
- hdata_line = w.hdata_get('line')
- hdata_line_data = w.hdata_get('line_data')
-
- while line:
- data = w.hdata_pointer(hdata_line, line, 'data')
- if data:
- date = w.hdata_time(hdata_line_data, data, 'date')
- prefix = w.hdata_string(hdata_line_data, data, 'prefix')
- if user and (int(date) == int(time) and user == prefix):
-# w.prnt("", "found matching time date is {}, time is {} ".format(date, time))
- w.hdata_update(hdata_line_data, data, {"message": "{}{}".format(new_message, append)})
- break
- elif not user and (int(date) == int(time)):
- w.hdata_update(hdata_line_data, data, {"message": "{}{}".format(new_message, append)})
- else:
- pass
- line = w.hdata_move(hdata_line, line, -1)
- return w.WEECHAT_RC_OK
-
-
-def process_message(message_json):
- try:
- # send these messages elsewhere
- known_subtypes = ['channel_join', 'channel_leave', 'channel_topic']
- if "subtype" in message_json and message_json["subtype"] in known_subtypes:
- proc[message_json["subtype"]](message_json)
-
- # move message properties down to root of json object
- message_json = unwrap_message(message_json)
-
- server = servers.find(message_json["myserver"])
- 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
-
- cache_message(message_json)
-
- time = message_json['ts']
- if "fallback" in message_json:
- text = message_json["fallback"]
- elif "text" in message_json:
- text = message_json["text"]
- else:
- text = ""
-
- text = unfurl_refs(text)
- if "attachments" in message_json:
- text += u" --- {}".format(unwrap_attachments(message_json))
- text = text.lstrip()
- text = text.replace("\t", " ")
- name = get_user(message_json, server)
-
- text = text.encode('utf-8')
- name = name.encode('utf-8')
-
- if "subtype" in message_json and message_json["subtype"] == "message_changed":
- if "edited" in message_json["message"]:
- append = " (edited)"
- else:
- append = ''
- channel.buffer_prnt_changed(message_json["message"]["user"], text, message_json["message"]["ts"], append)
- elif "subtype" in message_json and message_json["subtype"] == "message_deleted":
- append = "(deleted)"
- text = ""
- channel.buffer_prnt_changed(None, text, message_json["deleted_ts"], append)
- else:
- channel.buffer_prnt(name, text, time)
- except:
- dbg("cannot process message {}".format(message_json))
-
-
-def unwrap_message(message_json):
- if "message" in message_json:
- if "attachments" in message_json["message"]:
- message_json["attachments"] = message_json["message"]["attachments"]
- if "text" in message_json["message"]:
- if "text" in message_json:
- message_json["text"] += message_json["message"]["text"]
- dbg("added text!")
- else:
- message_json["text"] = message_json["message"]["text"]
- if "fallback" in message_json["message"]:
- if "fallback" in message_json:
- message_json["fallback"] += message_json["message"]["fallback"]
- else:
- message_json["fallback"] = message_json["message"]["fallback"]
- return message_json
-
-
-def unwrap_attachments(message_json):
- attachment_text = ''
- for attachment in message_json["attachments"]:
- if "fallback" in attachment:
- attachment_text += attachment["fallback"]
-# attachment_text = attachment_text.encode('ascii', 'ignore')
- return attachment_text
-
-
-def unfurl_refs(text):
- if text.find('<') > -1:
- newtext = []
- text = text.split(" ")
- for item in text:
- # dbg(item)
- start = item.find('<')
- end = item.find('>')
- if start > -1 and end > -1:
- item = item[start + 1:end]
- if item.find('|') > -1:
- item = item.split('|')[0]
- if item.startswith('@U'):
- if users.find(item[1:]):
- try:
- item = "@{}".format(users.find(item[1:]).name)
- except:
- dbg("NAME: {}".format(item))
- if item.startswith('#C'):
- if channels.find(item[1:]):
- item = "{}".format(channels.find(item[1:]).name)
- newtext.append(item)
- text = " ".join(newtext)
- return text
- else:
- return text
-
-
-def get_user(message_json, server):
- if 'user' in message_json:
- name = server.users.find(message_json['user']).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"])
- elif 'bot_id' in message_json:
- name = u"-{}-".format(message_json["bot_id"])
- else:
- name = u""
- return name
-
-# END Websocket handling methods
-
-
-def typing_bar_item_cb(data, buffer, args):
- typers = [x for x in channels.get_all() 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.find_by_class(Channel) + channels.find_by_class(GroupChannel):
- 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_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
- buffer_list_update_next()
- 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)
- typing_timer = now
- return w.WEECHAT_RC_OK
-
-# NOTE: figured i'd do this because they do
-
-
-def slack_ping_cb(data, remaining):
- servers.find(data).ping()
- return w.WEECHAT_RC_OK
-
-
-def slack_connection_persistence_cb(data, remaining_calls):
- 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)
- return w.WEECHAT_RC_OK
-
-# Slack specific requests
-
-# NOTE: switched to async/curl because sync slowed down the UI
-
-
-def async_slack_api_request(domain, token, request, post_data, priority=False):
- if not STOP_TALKING_TO_SLACK:
- post_data["token"] = token
- url = 'https://{}/api/{}'.format(domain, request)
- command = 'curl -A "wee_slack {}" -s --data "{}" {}'.format(SCRIPT_VERSION, urllib.urlencode(post_data), url)
- context = pickle.dumps({"request": request, "token": token, "post_data": post_data})
- w.hook_process(command, 20000, "url_processor_cb", context)
-
-# funny, right?
-big_data = {}
-
-def url_processor_cb(data, command, return_code, out, err):
- global big_data, message_cache
- 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("curl failed, doing again...")
- dbg("curl 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)
-
- else:
- if "channel" in data["post_data"]:
- channel = data["post_data"]["channel"]
- token = data["token"]
- if "messages" in my_json:
- messages = my_json["messages"].reverse()
- for message in my_json["messages"]:
- message["myserver"] = 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"])
- elif return_code != -1:
- big_data.pop(identifier, None)
- dbg("return code: {}".format(return_code))
-
- return w.WEECHAT_RC_OK
-
-def cache_write_cb(data, remaining):
- open("{}/{}".format(WEECHAT_HOME, CACHE_NAME), 'w').write(json.dumps(message_cache))
- return w.WEECHAT_RC_OK
-
-
-
-# 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, channels_not_on_current_server_color, colorize_nicks, slack_debug, debug_mode
- 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(',')]
- channels_not_on_current_server_color = w.config_get_plugin("channels_not_on_current_server_color")
- if channels_not_on_current_server_color == "0":
- channels_not_on_current_server_color = False
- colorize_nicks = w.config_get_plugin('colorize_nicks') == "1"
- debug_mode = w.config_get_plugin("debug_mode").lower()
- if debug_mode != '' and debug_mode != 'false':
- create_slack_debug_buffer()
- return w.WEECHAT_RC_OK
-
-def quit_notification_cb(signal, sig_type, data):
- global STOP_TALKING_TO_SLACK
- STOP_TALKING_TO_SLACK = True
- cache_write_cb("", "")
- return w.WEECHAT_RC_OK
-
-def script_unloaded():
- global STOP_TALKING_TO_SLACK
- STOP_TALKING_TO_SLACK = True
- cache_write_cb("", "")
- 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", ""):
-
- 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('channels_not_on_current_server_color'):
- w.config_set_plugin('channels_not_on_current_server_color', "0")
- 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('trigger_value'):
- w.config_set_plugin('trigger_value', "0")
-
- version = w.info_get("version_number", "") or 0
- if int(version) >= 0x00040400:
- legacy_mode = False
- else:
- legacy_mode = True
-
- # 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
-
- #name = None
- never_away = False
- hide_distractions = False
- hotlist = w.infolist_get("hotlist", "", "")
- main_weechat_buffer = w.info_get("irc_buffer", "{}.{}".format(domain, "DOESNOTEXIST!@#$"))
-
- try:
- cache_file = open("{}/{}".format(WEECHAT_HOME, CACHE_NAME), 'r')
- message_cache = json.loads(cache_file.read())
- except (IOError, ValueError):
- message_cache = {}
- # End global var section
-
- #channels = SearchList()
- servers = SearchList()
- for token in slack_api_token.split(','):
- servers.append(SlackServer(token))
- channels = Meta('channels', servers)
- users = Meta('users', servers)
-
- 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_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_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.bar_item_new('slack_typing_notice', 'typing_bar_item_cb', '')
- # END attach to the weechat hooks we need