255 lines
9.6 KiB
Python
Executable file
255 lines
9.6 KiB
Python
Executable file
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# SàT plugin for managing text commands
|
|
# Copyright (C) 2009, 2010, 2011, 2012, 2013 Jérôme Poisson (goffi@goffi.org)
|
|
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from twisted.words.protocols.jabber import jid
|
|
from logging import debug, info, warning, error
|
|
|
|
PLUGIN_INFO = {
|
|
"name": "Text commands",
|
|
"import_name": "TEXT-COMMANDS",
|
|
"type": "Misc",
|
|
"protocols": [],
|
|
"dependencies": ["XEP-0045", "EXP-PARROT"],
|
|
"main": "TextCommands",
|
|
"handler": "no",
|
|
"description": _("""IRC like text commands""")
|
|
}
|
|
|
|
|
|
class TextCommands(object):
|
|
#FIXME: doc strings for commands have to be translatable
|
|
# plugins need a dynamic translation system (translation
|
|
# should be downloadable independently)
|
|
|
|
def __init__(self, host):
|
|
info(_("Text commands initialization"))
|
|
self.host = host
|
|
host.trigger.add("sendMessage", self.sendMessageTrigger)
|
|
|
|
def sendMessageTrigger(self, mess_data, profile):
|
|
""" Check text commands in message, and react consequently """
|
|
msg = mess_data["message"]
|
|
if msg:
|
|
if msg[0] == '/':
|
|
command = msg[1:].partition(' ')[0].lower()
|
|
if command.isalpha():
|
|
# looks like an actual command, we try to call the corresponding method
|
|
try:
|
|
mess_data["unparsed"] = msg[1 + len(command):] # part not yet parsed of the message
|
|
return getattr(self, "cmd_%s" % command)(mess_data, profile)
|
|
except AttributeError:
|
|
pass
|
|
elif msg[0] == '\\': # we have escape char
|
|
try:
|
|
if msg[1] in ('/', '\\'): # we have '\/' or '\\', we escape to '/' or '\'
|
|
mess_data["message"] = msg[1:]
|
|
except IndexError:
|
|
pass
|
|
return True
|
|
|
|
def _getRoomJID(self, arg, service_jid):
|
|
"""Return a room jid with a shortcut
|
|
@param arg: argument: can be a full room jid (e.g.: sat@chat.jabberfr.org)
|
|
or a shortcut (e.g.: sat or sat@ for sat on current service)
|
|
@param service_jid: jid of the current service (e.g.: chat.jabberfr.org)
|
|
"""
|
|
nb_arobas = arg.count('@')
|
|
if nb_arobas == 1:
|
|
if arg[-1] != '@':
|
|
return jid.JID(arg)
|
|
return jid.JID(arg + service_jid)
|
|
return jid.JID(u"%s@%s" % (arg, service_jid))
|
|
|
|
def _feedBack(self, message, mess_data, profile):
|
|
"""Give a message back to the user"""
|
|
if mess_data["type"] == 'groupchat':
|
|
_from = mess_data["to"].userhostJID()
|
|
else:
|
|
_from = self.host.getJidNStream(profile)[0]
|
|
|
|
self.host.bridge.newMessage(unicode(mess_data["to"]), message, mess_data['type'], unicode(_from), {}, profile=profile)
|
|
|
|
def cmd_nick(self, mess_data, profile):
|
|
"""change nickname"""
|
|
debug("Catched nick command")
|
|
|
|
if mess_data['type'] != "groupchat":
|
|
#/nick command does nothing if we are not on a group chat
|
|
info("Ignoring /nick command on a non groupchat message")
|
|
|
|
return True
|
|
|
|
nick = mess_data["unparsed"].strip()
|
|
room = mess_data["to"]
|
|
|
|
self.host.plugins["XEP-0045"].nick(room, nick, profile)
|
|
|
|
return False
|
|
|
|
def cmd_join(self, mess_data, profile):
|
|
"""join a new room (on the same service if full jid is not specified)"""
|
|
debug("Catched join command")
|
|
|
|
if mess_data['type'] != "groupchat":
|
|
#/leave command does nothing if we are not on a group chat
|
|
info("Ignoring /join command on a non groupchat message")
|
|
return True
|
|
|
|
if mess_data["unparsed"].strip():
|
|
room = self._getRoomJID(mess_data["unparsed"].strip(), mess_data["to"].host)
|
|
nick = (self.host.plugins["XEP-0045"].getRoomNick(mess_data["to"].userhost(), profile) or
|
|
self.host.getClient(profile).jid.user)
|
|
self.host.plugins["XEP-0045"].join(room, nick, {}, profile)
|
|
|
|
return False
|
|
|
|
def cmd_leave(self, mess_data, profile):
|
|
"""quit a room"""
|
|
debug("Catched leave command")
|
|
|
|
if mess_data['type'] != "groupchat":
|
|
#/leave command does nothing if we are not on a group chat
|
|
info("Ignoring /leave command on a non groupchat message")
|
|
return True
|
|
|
|
if mess_data["unparsed"].strip():
|
|
room = self._getRoomJID(mess_data["unparsed"].strip(), mess_data["to"].host)
|
|
else:
|
|
room = mess_data["to"]
|
|
|
|
self.host.plugins["XEP-0045"].leave(room, profile)
|
|
|
|
return False
|
|
|
|
def cmd_part(self, mess_data, profile):
|
|
"""just a synonym of /leave"""
|
|
return self.cmd_leave(mess_data, profile)
|
|
|
|
def cmd_title(self, mess_data, profile):
|
|
"""change room's subject"""
|
|
debug("Catched title command")
|
|
|
|
if mess_data['type'] != "groupchat":
|
|
#/leave command does nothing if we are not on a group chat
|
|
info("Ignoring /title command on a non groupchat message")
|
|
return True
|
|
|
|
subject = mess_data["unparsed"].strip()
|
|
|
|
if subject:
|
|
room = mess_data["to"]
|
|
self.host.plugins["XEP-0045"].subject(room, subject, profile)
|
|
|
|
return False
|
|
|
|
def cmd_topic(self, mess_data, profile):
|
|
"""just a synonym of /title"""
|
|
return self.cmd_title(mess_data, profile)
|
|
|
|
def cmd_parrot(self, mess_data, profile):
|
|
"""activate Parrot mode between 2 entities, in both directions."""
|
|
#TODO: these commands must not be hardcoded, an interface should be made
|
|
# to allow plugins to register simple commands like this.
|
|
|
|
debug("Catched parrot command")
|
|
|
|
try:
|
|
link_left_jid = jid.JID(mess_data["unparsed"].strip())
|
|
if not link_left_jid.user or not link_left_jid.host:
|
|
raise jid.InvalidFormat
|
|
except jid.InvalidFormat:
|
|
self._feedBack("Can't activate Parrot mode for invalid jid", mess_data, profile)
|
|
return False
|
|
|
|
link_right_jid = mess_data['to']
|
|
|
|
self.host.plugins["EXP-PARROT"].addParrot(link_left_jid, link_right_jid, profile)
|
|
self.host.plugins["EXP-PARROT"].addParrot(link_right_jid, link_left_jid, profile)
|
|
|
|
self._feedBack("Parrot mode activated for %s" % (unicode(link_left_jid), ), mess_data, profile)
|
|
|
|
return False
|
|
|
|
def cmd_unparrot(self, mess_data, profile):
|
|
"""remove Parrot mode between 2 entities, in both directions."""
|
|
debug("Catched unparrot command")
|
|
|
|
try:
|
|
link_left_jid = jid.JID(mess_data["unparsed"].strip())
|
|
if not link_left_jid.user or not link_left_jid.host:
|
|
raise jid.InvalidFormat
|
|
except jid.InvalidFormat:
|
|
self._feedBack("Can't deactivate Parrot mode for invalid jid", mess_data, profile)
|
|
return False
|
|
|
|
link_right_jid = mess_data['to']
|
|
|
|
self.host.plugins["EXP-PARROT"].removeParrot(link_left_jid, profile)
|
|
self.host.plugins["EXP-PARROT"].removeParrot(link_right_jid, profile)
|
|
|
|
self._feedBack("Parrot mode deactivated for %s and %s" % (unicode(link_left_jid), unicode(link_right_jid)), mess_data, profile)
|
|
|
|
return False
|
|
|
|
def cmd_whois(self, mess_data, profile):
|
|
"""show informations on entity"""
|
|
debug("Catched whois command")
|
|
|
|
entity = mess_data["unparsed"].strip()
|
|
|
|
if mess_data['type'] == "groupchat":
|
|
room = mess_data["to"]
|
|
if self.host.plugins["XEP-0045"].isNickInRoom(room, entity, profile):
|
|
entity = u"%s/%s" % (room, entity)
|
|
|
|
if not entity:
|
|
target_jid = mess_data["to"]
|
|
else:
|
|
try:
|
|
target_jid = jid.JID(entity)
|
|
if not target_jid.user or not target_jid.host:
|
|
raise jid.InvalidFormat
|
|
except (jid.InvalidFormat, RuntimeError):
|
|
self._feedBack(_("Invalid jid, can't whois"), mess_data, profile)
|
|
return False
|
|
|
|
whois_msg = [_(u"whois for %(jid)s") % {'jid': target_jid}]
|
|
#TODO: add informations here (client version, vcard, etc)
|
|
|
|
self._feedBack(u"\n".join(whois_msg), mess_data, profile)
|
|
|
|
return False
|
|
|
|
def cmd_help(self, mess_data, profile):
|
|
"""show help on available commands"""
|
|
commands = filter(lambda method: method.startswith('cmd_'), dir(self))
|
|
longuest = max([len(command) for command in commands])
|
|
help_cmds = []
|
|
|
|
for command in commands:
|
|
method = getattr(self, command)
|
|
try:
|
|
help_str = method.__doc__.split('\n')[0]
|
|
except AttributeError:
|
|
help_str = ''
|
|
spaces = (longuest - len(command)) * ' '
|
|
help_cmds.append(" /%s: %s %s" % (command[4:], spaces, help_str))
|
|
|
|
help_mess = _(u"Text commands available:\n%s") % (u'\n'.join(help_cmds), )
|
|
self._feedBack(help_mess, mess_data, profile)
|