"jid" : { "type" : "string",

"desc" : "jabber id (user@server.tld)",

"min" : 0,

"max" : 0,

"string_values": "",

"default" : "",

"value" : "",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"priority" : { "type" : "integer",

"desc" : "Default resource priority",

"min" : 0,

"max" : 65535,

"string_values": "",

"default" : "8",

"value" : "8",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"away_priority": { "type" : "integer",

"desc" : "Resource priority on away",

"min" : 0,

"max" : 65535,

"string_values": "",

"default" : "0",

"value" : "0",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"password" : { "type" : "string",

"desc" : "password for jabber id on server",

"min" : 0,

"max" : 0,

"string_values": "",

"default" : "",

"value" : "",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"server" : { "type" : "string",

"desc" : "connect server host or ip, eg. talk.google.com",

"min" : 0,

"max" : 0,

"string_values": "",

"default" : "",

"value" : "",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"port" : { "type" : "integer",

"desc" : "connect server port, eg. 5223",

"min" : 0,

"max" : 65535,

"string_values": "",

"default" : "5222",

"value" : "5222",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"autoconnect" : { "type" : "boolean",

"desc" : "automatically connect to server when script is starting",

"min" : 0,

"max" : 0,

"string_values": "",

"default" : "off",

"value" : "off",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"autoreconnect": { "type" : "boolean",

"desc" : "automatically reconnect to server when disconnected",

"min" : 0,

"max" : 0,

"string_values": "",

"default" : "off",

"value" : "off",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"private" : { "type" : "boolean",

"desc" : "display messages in separate chat buffers instead of a single server buffer",

"min" : 0,

"max" : 0,

"string_values": "",

"default" : "on",

"value" : "on",

"check_cb" : "",

"change_cb" : "",

"delete_cb" : "",

},

"ping_interval": { "type" : "integer",

"desc" : "Number of seconds between server pings. 0 = disable",

"min" : 0,

"max" : 9999999,

"string_values": "",

"default" : "0",

"value" : "0",

"check_cb" : "ping_interval_check_cb",

"change_cb" : "",

"delete_cb" : "",

},

"ping_timeout" : { "type" : "integer",

"desc" : "Number of seconds to allow ping to respond before timing out",

"min" : 0,

"max" : 9999999,

"string_values": "",

"default" : "10",

"value" : "10",

"check_cb" : "ping_timeout_check_cb",

"change_cb" : "",

"delete_cb" : "",

},

""" Initialize config file: create sections and options in memory. """

global jabber_config_file, jabber_config_section

jabber_config_file = weechat.config_new("jabber", "jabber_config_reload_cb", "")

if not jabber_config_file:

return

# look

jabber_config_section["look"] = weechat.config_new_section(

jabber_config_file, "look", 0, 0, "", "", "", "", "", "", "", "", "", "")

if not jabber_config_section["look"]:

weechat.config_free(jabber_config_file)

return

jabber_config_option["debug"] = weechat.config_new_option(

jabber_config_file, jabber_config_section["look"],

"debug", "boolean", "display debug messages", "", 0, 0,

"off", "off", 0, "", "", "", "", "", "")

# color

jabber_config_section["color"] = weechat.config_new_section(

jabber_config_file, "color", 0, 0, "", "", "", "", "", "", "", "", "", "")

if not jabber_config_section["color"]:

weechat.config_free(jabber_config_file)

return

jabber_config_option["message_join"] = weechat.config_new_option(

jabber_config_file, jabber_config_section["color"],

"message_join", "color", "color for text in join messages", "", 0, 0,

"green", "green", 0, "", "", "", "", "", "")

jabber_config_option["message_quit"] = weechat.config_new_option(

jabber_config_file, jabber_config_section["color"],

"message_quit", "color", "color for text in quit messages", "", 0, 0,

"red", "red", 0, "", "", "", "", "", "")

# server

jabber_config_section["server"] = weechat.config_new_section(

jabber_config_file, "server", 0, 0,

"jabber_config_server_read_cb", "", "jabber_config_server_write_cb", "",

"", "", "", "", "", "")

if not jabber_config_section["server"]:

weechat.config_free(jabber_config_file)

return

jabber_config_section["jid_aliases"] = weechat.config_new_section(

jabber_config_file, "jid_aliases", 0, 0,

"jabber_config_jid_aliases_read_cb", "",

"jabber_config_jid_aliases_write_cb", "",

"", "", "", "", "", "")

if not jabber_config_section["jid_aliases"]:

weechat.config_free(jabber_config_file)

""" Read server option in config file. """

global jabber_servers

rc = weechat.WEECHAT_CONFIG_OPTION_SET_ERROR

items = option_name.split(".", 1)

if len(items) == 2:

server = jabber_search_server_by_name(items[0])

if not server:

server = Server(items[0])

jabber_servers.append(server)

if server:

rc = weechat.config_option_set(server.options[items[1]], value, 1)

""" Write server section in config file. """

global jabber_servers

weechat.config_write_line(config_file, section_name, "")

for server in jabber_servers:

for name, option in sorted(server.options.items()):

weechat.config_write_option(config_file, option)

""" Read jid_aliases option in config file. """

global jabber_jid_aliases

jabber_jid_aliases[option_name] = value

option = weechat.config_new_option(

config_file, section,

option_name, "string", "jid alias", "", 0, 0,

"", value, 0, "", "", "", "", "", "")

if not option:

return weechat.WEECHAT_CONFIG_OPTION_SET_ERROR

""" Write jid_aliases section in config file. """

global jabber_jid_aliases

weechat.config_write_line(config_file, section_name, "")

for alias, jid in sorted(jabber_jid_aliases.items()):

weechat.config_write_line(config_file, alias, jid)

""" Return True if debug is enabled. """

global jabber_config_options

if weechat.config_boolean(jabber_config_option["debug"]):

return True

""" Return color code for a jabber color option. """

global jabber_config_option

if color in jabber_config_option:

return weechat.color(weechat.config_color(jabber_config_option[color]))

global jabber_config_file, jabber_config_section

ping_interval_option = weechat.config_search_option(

jabber_config_file,

jabber_config_section["server"],

"%s.ping_interval" % (server_name)

)

ping_interval = weechat.config_integer(ping_interval_option)

if int(ping_interval) and int(value) >= int(ping_interval):

weechat.prnt("", "\njabber: unable to update 'ping_timeout' for server %s" % (server_name))

weechat.prnt("", "jabber: to prevent multiple concurrent pings, ping_interval must be greater than ping_timeout")

return weechat.WEECHAT_CONFIG_OPTION_SET_ERROR

global jabber_config_file, jabber_config_section

ping_timeout_option = weechat.config_search_option(

jabber_config_file,

jabber_config_section["server"],

"%s.ping_timeout" % (server_name)

)

ping_timeout = weechat.config_integer(ping_timeout_option)

if int(value) and int(ping_timeout) >= int(value):

weechat.prnt("", "\njabber: unable to update 'ping_interval' for server %s" % (server_name))

weechat.prnt("", "jabber: to prevent multiple concurrent pings, ping_interval must be greater than ping_timeout")

return weechat.WEECHAT_CONFIG_OPTION_SET_ERROR

""" Class to manage a server: buffer, connection, send/recv data. """

def __init__(self, name, **kwargs):

""" Init server """

global jabber_config_file, jabber_config_section, jabber_server_options

self.name = name

# create options (user can set them with /set)

self.options = {}

# if the value is provided, use it, otherwise use the default

values = {}

for option_name, props in jabber_server_options.items():

values[option_name] = props["default"]

values['name'] = name

values.update(**kwargs)

for option_name, props in jabber_server_options.items():

self.options[option_name] = weechat.config_new_option(

jabber_config_file, jabber_config_section["server"],

self.name + "." + option_name, props["type"], props["desc"],

props["string_values"], props["min"], props["max"],

props["default"], values[option_name], 0,

props["check_cb"], self.name, props["change_cb"], "",

props["delete_cb"], "")

# internal data

self.jid = None

self.client = None

self.sock = None

self.hook_fd = None

self.buffer = ""

self.chats = []

self.roster = None

self.buddies = []

self.buddy = None

self.ping_timer = None # weechat.hook_timer for sending pings

self.ping_timeout_timer = None # weechat.hook_timer for monitoring ping timeout

self.ping_up = False # Connection status as per pings.

self.presence = xmpp.protocol.Presence()

def option_string(self, option_name):

""" Return a server option, as string. """

return weechat.config_string(self.options[option_name])

def option_boolean(self, option_name):

""" Return a server option, as boolean. """

return weechat.config_boolean(self.options[option_name])

def option_integer(self, option_name):

""" Return a server option, as string. """

return weechat.config_integer(self.options[option_name])

def connect(self):

""" Connect to Jabber server. """

if not self.buffer:

bufname = "%s.server.%s" % (SCRIPT_NAME, self.name)

self.buffer = weechat.buffer_search("python", bufname)

if not self.buffer:

self.buffer = weechat.buffer_new(bufname,

"jabber_buffer_input_cb", "",

"jabber_buffer_close_cb", "")

if self.buffer:

weechat.buffer_set(self.buffer, "short_name", self.name)

weechat.buffer_set(self.buffer, "localvar_set_type", "server")

weechat.buffer_set(self.buffer, "localvar_set_server", self.name)

weechat.buffer_set(self.buffer, "nicklist", "1")

weechat.buffer_set(self.buffer, "nicklist_display_groups", "1")

weechat.buffer_set(self.buffer, "display", "auto")

self.disconnect()

if not eval_expression(self.option_string("jid")):

weechat.prnt(self.buffer, "%sjabber: JID must contain at least domain name"

% weechat.prefix("error"))

self.ping_up = False

self.client = None

return self.is_connected()

self.buddy = Buddy(jid=eval_expression(self.option_string("jid")), server=self)

server = self.option_string("server")

port = self.option_integer("port")

self.client = xmpp.Client(server=self.buddy.domain, debug=[])

conn = None

server_tuple = None

if server:

if port:

server_tuple = (server, port)

else:

server_tuple = (server)

# self.client.connect() may produce a "socket.ssl() is deprecated"

# warning. Since the code producing the warning is outside this script,

# catch it and ignore.

original_filters = warnings.filters[:]

warnings.filterwarnings("ignore",category=DeprecationWarning)

try:

conn = self.client.connect(server=server_tuple)

finally:

warnings.filters = original_filters

if conn:

weechat.prnt(self.buffer, "jabber: connection ok with %s" % conn)

res = self.buddy.resource

if not res:

res = "WeeChat"

auth = self.client.auth(self.buddy.username,

eval_expression(self.option_string("password")),

res)

if auth:

weechat.prnt(self.buffer, "jabber: authentication ok (using %s)" % auth)

self.roster = self.client.getRoster()

self.client.RegisterHandler("presence", self.presence_handler)

self.client.RegisterHandler("iq", self.iq_handler)

self.client.RegisterHandler("message", self.message_handler)

self.client.sendInitPresence(requestRoster=1)

self.sock = self.client.Connection._sock.fileno()

self.hook_fd = weechat.hook_fd(self.sock, 1, 0, 0, "jabber_fd_cb", "")

weechat.buffer_set(self.buffer, "highlight_words", self.buddy.username)

weechat.buffer_set(self.buffer, "localvar_set_nick", self.buddy.username);

hook_away = weechat.hook_command_run("/away -all*", "jabber_away_command_run_cb", "")

# setting initial presence

priority = weechat.config_integer(self.options['priority'])

self.set_presence(show="",priority=priority)

self.ping_up = True

else:

weechat.prnt(self.buffer, "%sjabber: could not authenticate"

% weechat.prefix("error"))

self.ping_up = False

self.client = None

else:

weechat.prnt(self.buffer, "%sjabber: could not connect"

% weechat.prefix("error"))

self.ping_up = False

self.client = None

return self.is_connected()

def is_connected(self):

"""Return connect status"""

if not self.client or not self.client.isConnected():

return False

else:

return True

def add_chat(self, buddy):

"""Create a chat buffer for a buddy"""

chat = Chat(self, buddy, switch_to_buffer=False)

self.chats.append(chat)

return chat

def add_buddy(self, jid):

""" Add a new buddy """

self.client.Roster.Authorize(jid)

self.client.Roster.Subscribe(jid)

def del_buddy(self, jid):

""" Remove a buddy and/or deny authorization request """

self.client.Roster.Unauthorize(jid)

self.client.Roster.Unsubscribe(jid)

def print_debug_server(self, message):

""" Print debug message on server buffer. """

if jabber_debug_enabled():

weechat.prnt(self.buffer, "%sjabber: %s" % (weechat.prefix("network"), message))

def print_debug_handler(self, handler_name, node):

""" Print debug message for a handler on server buffer. """

self.print_debug_server("%s_handler, xml message:\n%s"

% (handler_name,

node.__str__(fancy=True).encode("utf-8")))

def print_error(self, message):

""" Print error message on server buffer. """

if jabber_debug_enabled():

weechat.prnt(self.buffer, "%sjabber: %s" % (weechat.prefix("error"), message))

def presence_handler(self, conn, node):

self.print_debug_handler("presence", node)

buddy = self.search_buddy_list(node.getFrom().getStripped().encode("utf-8"), by='jid')

if not buddy:

buddy = self.add_buddy(jid=node.getFrom())

action='update'

node_type = node.getType()

if node_type in ["error", "unavailable"]:

action='remove'

if action == 'update':

away = node.getShow() in ["away", "xa"]

status = ''

if node.getStatus():

status = node.getStatus().encode("utf-8")

if self.roster:

name = self.roster.getName(buddy.bare_jid)

if name:

buddy.set_name(name.encode("utf-8"))

buddy.set_status(status=status, away=away)

self.update_nicklist(buddy=buddy, action=action)

return

def iq_handler(self, conn, node):

""" Receive iq message. """

self.print_debug_handler("iq", node)

#weechat.prnt(self.buffer, "jabber: iq handler")

if node.getFrom() == self.buddy.domain:

# type='result' => pong from server

# type='error' => error message from server

# The ping_up is set True on an error message to handle cases where

# the ping feature is not implemented on a server. It's a bit of a

# hack, but if we can receive an error from the server, we assume

# the connection to the server is up.

if node.getType() in ['result', 'error']:

self.delete_ping_timeout_timer() # Disable the timeout feature

self.ping_up = True

if not self.client.isConnected() and weechat.config_boolean(self.options['autoreconnect']):

self.connect()

def message_handler(self, conn, node):

""" Receive message. """

self.print_debug_handler("message", node)

node_type = node.getType()

if node_type not in ["message", "chat", None]:

self.print_error("unknown message type: '%s'" % node_type)

return

jid = node.getFrom()

body = node.getBody()

if not jid or not body:

return

buddy = self.search_buddy_list(self.stringify_jid(jid), by='jid')

if not buddy:

buddy = self.add_buddy(jid=jid)

# If a chat buffer exists for the buddy, receive the message with that

# buffer even if private is off. The buffer may have been created with

# /jchat.

recv_object = self

if not buddy.chat and weechat.config_boolean(self.options['private']):

self.add_chat(buddy)

if buddy.chat:

recv_object = buddy.chat

recv_object.recv_message(buddy, body.encode("utf-8"))

def recv(self):

""" Receive something from Jabber server. """

if not self.client:

return

try:

self.client.Process(1)

except xmpp.protocol.StreamError as e:

weechat.prnt('', '%s: Error from server: %s' %(SCRIPT_NAME, e))

self.disconnect()

if weechat.config_boolean(self.options['autoreconnect']):

autoreconnect_delay = 30

weechat.command('', '/wait %s /%s connect %s' %

(autoreconnect_delay, SCRIPT_COMMAND, self.name))

def recv_message(self, buddy, message):

""" Receive a message from buddy. """

weechat.prnt_date_tags(self.buffer, 0,

"notify_private,nick_%s,prefix_nick_%s,log1" %

(buddy.alias,

weechat.config_string(weechat.config_get("weechat.color.chat_nick_other"))),

"%s%s\t%s" % (weechat.color("chat_nick_other"),

buddy.alias,

message))

def print_status(self, nickname, status):

""" Print a status in server window and in chat. """

weechat.prnt_date_tags(self.buffer, 0, "no_highlight", "%s%s has status %s" %

(weechat.prefix("action"),

nickname,

status))

for chat in self.chats:

if nickname in chat.buddy.alias:

chat.print_status(status)

break

def send_message(self, buddy, message):

""" Send a message to buddy.

recipient = buddy

if isinstance(buddy, Buddy):

recipient = buddy.jid

if not self.ping_up:

weechat.prnt(self.buffer, "%sjabber: unable to send message, connection is down"

% weechat.prefix("error"))

return

if self.client:

msg = xmpp.protocol.Message(to=recipient, body=message, typ='chat')

self.client.send(msg)

def send_message_from_input(self, input=''):

""" Send a message from input text on server buffer. """

# Input must be of format "name: message" where name is a jid, bare_jid

# or alias. The colon can be replaced with a comma as well.

# Split input into name and message.

if not re.compile(r'.+[:,].+').match(input):

weechat.prnt(self.buffer, "%sjabber: %s" % (weechat.prefix("network"),

"Invalid send format. Use jid: message"

))

return

name, message = re.split('[:,]', input, maxsplit=1)

buddy = self.search_buddy_list(name, by='alias')

if not buddy:

weechat.prnt(self.buffer,

"%sjabber: Invalid jid: %s" % (weechat.prefix("network"),

name))

return

# Send activity indicates user is no longer away, set it so

if self.buddy and self.buddy.away:

self.set_away('')

self.send_message(buddy=buddy, message=message)

try:

sender = self.buddy.alias

except:

sender = self.jid

weechat.prnt_date_tags(self.buffer, 0,

"notify_none,no_highlight,nick_%s,prefix_nick_%s,log1" %

(sender,

weechat.config_string(weechat.config_get("weechat.color.chat_nick_self"))),

"%s%s\t%s" % (weechat.color("chat_nick_self"),

sender,

message.strip()))

def set_away(self, message):

""" Set/unset away on server.

if message:

show = "xa"

status = message

priority = weechat.config_integer(self.options['away_priority'])

self.buddy.set_status(away=True, status=message)

else:

show = ""

status = None

priority = weechat.config_integer(self.options['priority'])

self.buddy.set_status(away=False)

self.set_presence(show, status, priority)

def set_presence(self, show=None, status=None, priority=None):

if not show == None: self.presence.setShow(show)

if not status == None: self.presence.setStatus(status)

if not priority == None: self.presence.setPriority(priority)

self.client.send(self.presence)

def add_buddy(self, jid=None):

buddy = Buddy(jid=jid, server=self)

buddy.resource = buddy.resource.encode("utf-8")

self.buddies.append(buddy)

return buddy

def display_buddies(self):

""" Display buddies. """

weechat.prnt(self.buffer, "")

weechat.prnt(self.buffer, "Buddies:")

len_max = { 'alias': 5, 'jid': 5 }

lines = []

for buddy in sorted(self.buddies, key=lambda x: x.jid.getStripped().encode('utf-8')):

alias = ''

if buddy.alias != buddy.bare_jid:

alias = buddy.alias

buddy_jid_string = buddy.jid.getStripped().encode('utf-8')

lines.append( {

'jid': buddy_jid_string,

'alias': alias,

'status': buddy.away_string(),

})

if len(alias) > len_max['alias']:

len_max['alias'] = len(alias)

if len(buddy_jid_string) > len_max['jid']:

len_max['jid'] = len(buddy_jid_string)

prnt_format = " %s%-" + str(len_max['jid']) + "s %-" + str(len_max['alias']) + "s %s"

weechat.prnt(self.buffer, prnt_format % ('', 'JID', 'Alias', 'Status'))

for line in lines:

weechat.prnt(self.buffer, prnt_format % (weechat.color("chat_nick"),

line['jid'],

line['alias'],

line['status'],

))

def stringify_jid(self, jid, wresource=1):

""" Serialise JID into string.

if jid.node:

jid_str = jid.node + '@' + jid.domain

else:

jid_str = jid.domain

if wresource and jid.resource:

# concatenate jid with resource delimiter first and encode them

# into utf-8, else it will raise UnicodeException becaouse of

# slash character :((

return (jid_str + '/').encode("utf-8") + jid.resource.encode("utf-8")

return jid_str.encode("utf-8")

def search_buddy_list(self, name, by='jid'):

""" Search for a buddy by name.

if by == 'jid':

for buddy in self.buddies:

if self.stringify_jid(buddy.jid) == name:

return buddy

for buddy in self.buddies:

if buddy.bare_jid == name:

return buddy

else:

for buddy in self.buddies:

if buddy.alias == name:

return buddy

return None

def update_nicklist(self, buddy=None, action=None):

"""Update buddy in nicklist

if not buddy:

return

if not action in ['remove', 'update']:

return

ptr_nick_gui = weechat.nicklist_search_nick(self.buffer, "", buddy.alias)

weechat.nicklist_remove_nick(self.buffer, ptr_nick_gui)

msg = ''

prefix = ''

color = ''

away = ''

if action == 'update':

nick_color = "bar_fg"

if buddy.away:

nick_color = "weechat.color.nicklist_away"

weechat.nicklist_add_nick(self.buffer, "", buddy.alias,

nick_color, "", "", 1)

if not ptr_nick_gui:

msg = 'joined'

prefix = 'join'

color = 'message_join'

away = buddy.away_string()

if action == 'remove':

msg = 'quit'

prefix = 'quit'

color = 'message_quit'

if msg:

weechat.prnt(self.buffer, "%s%s%s%s has %s %s"

% (weechat.prefix(prefix),

weechat.color("chat_nick"),

buddy.alias,

jabber_config_color(color),

msg,

away))

return

def add_ping_timer(self):

if self.ping_timer:

self.delete_ping_timer()

if not self.option_integer('ping_interval'):

return

self.ping_timer = weechat.hook_timer( self.option_integer('ping_interval') * 1000,

0, 0, "jabber_ping_timer", self.name)

return

def delete_ping_timer(self):

if self.ping_timer:

weechat.unhook(self.ping_timer)

self.ping_time = None

return

def add_ping_timeout_timer(self):

if self.ping_timeout_timer:

self.delete_ping_timeout_timer()

if not self.option_integer('ping_timeout'):

return

self.ping_timeout_timer = weechat.hook_timer(

self.option_integer('ping_timeout') * 1000, 0, 1,

"jabber_ping_timeout_timer", self.name)

return

def delete_ping_timeout_timer(self):

if self.ping_timeout_timer:

weechat.unhook(self.ping_timeout_timer)

self.ping_timeout_timer = None

return

def ping(self):

if not self.is_connected():

if not self.connect():

return

iq = xmpp.protocol.Iq(to=self.buddy.domain, typ='get')

iq.addChild( name= "ping", namespace = "urn:xmpp:ping" )

id = self.client.send(iq)

self.print_debug_handler("ping", iq)

self.add_ping_timeout_timer()

return

def ping_time_out(self):

self.delete_ping_timeout_timer()

self.ping_up = False

# A ping timeout indicates a server connection problem. Disconnect

# completely.

try:

self.client.disconnected()

except IOError:

# An IOError is raised by the default DisconnectHandler

pass

self.disconnect()

return

def disconnect(self):

""" Disconnect from Jabber server. """

if self.hook_fd != None:

weechat.unhook(self.hook_fd)

self.hook_fd = None

if self.client != None:

#if self.client.isConnected():

# self.client.disconnect()

self.client = None

self.jid = None

self.sock = None

self.buddy = None

weechat.nicklist_remove_all(self.buffer)

def close_buffer(self):

""" Close server buffer. """

if self.buffer != "":

weechat.buffer_close(self.buffer)

self.buffer = ""

def delete(self, deleteOptions=False):

""" Delete server. """

for chat in self.chats:

chat.delete()

self.delete_ping_timer()

self.delete_ping_timeout_timer()

self.disconnect()

self.close_buffer()

if deleteOptions:

for name, option in self.options.items():

""" Return a evaluated expression """

if int(version) >= 0x00040200:

return weechat.string_eval_expression(option_name,{},{},{})

else:

""" Search a server by name. """

global jabber_servers

for server in jabber_servers:

if server.name == name:

return server

""" Search a server / chat for a buffer. """

global jabber_servers

context = { "server": None, "chat": None }

for server in jabber_servers:

if server.buffer == buffer:

context["server"] = server

return context

for chat in server.chats:

if chat.buffer == buffer:

context["server"] = server

context["chat"] = chat

return context