wantzel.py

# encoding: utf-8
"""
Bot Wantzel from La Quadrature du Net.

License : AGPLv3
Doc     : https://wiki.laquadrature.net/Wantzel
"""

import re

from irc import IrcClientFactory
from twisted.internet import reactor
from twitter import Twitter, OAuth

import config
from logs import Log
from messages import messages

# bot modules
from admin import Admin
from fun import fun
from monitor import Monitor
from op import Op
from rp import Rp

class Wantzel(object):
    """
    Wantzel bot.
    """
    def __init__(self):
        """
        Initialization of all utility objects and bot over IRC.
        """
        self.admin = Admin()
        self.monitor = Monitor()
        self.op = Op()
        self.rp = Rp()
        # Connection to IRC
        self.irc = IrcClientFactory(config)
        self.irc.set_privmsg = self.set_privmsg
        reactor.connectTCP(config.server, config.port, self.irc)
        # Prepare timer
        reactor.callLater(config.timer, self.timer)

    def timer(self):
        """
        This method launches function regularly (see config.timer).
        """
        Log.debug("Timer called")
        # Tweeting Press reviews f necessary
        self.rp.tweet()
        # Bot tries to list RP channel users, if it can't, then it is no more an op and shall
        # complain
        self.irc.client.sendLine("NAMES %s" % config.RP_CHANNEL)
        # Update topic based on number of articles waiting in queue 
        topic = self.rp.count_articles()
        if topic != "":
            self.irc.client.topic(config.RP_CHANNEL, topic)
        # Tell on channel if a wiki was modified since last time
        self.send_message("#lqdn-travail", self.monitor.wiki_updates())
        # Cleaning points of mastering rp
        self.rp.clean_master_rp()
        # Recalling the timer
        reactor.callLater(config.timer, self.timer)

    def set_privmsg(self):
        """
        This method set the methods to call for each callback received from IRC.
        """
        # When receiving a message
        self.irc.client.privmsg = self.on_privmsg
        # When the bot discover it is no more op
        self.irc.client.irc_unknown = self.irc_unknown
        # When bot mode is changed
        self.irc.client.modeChanged = self.mode_changed

    def mode_changed(self, user, channel, flag_set, modes, args):
        """
        Callback called whenever bot mode is changed.
        """
        Log.debug("Mode changed : %s %s %s %s %s" % (user, channel, flag_set, modes, args))
        if "o" in modes and self.irc.client.nickname in args:
            self.send_message(channel, self.op.get_op_mode(user, flag_set))

    def irc_unknown(self, prefix, command, params):
        """
        This Callback is called whenever the bot tries to perform the command "NAMES" on the
        RP_CHANNEL channel. If it occurs, then the bot knows that it is no more op and beg for
        a mode change to actual operators on the channel.
        """
        Log.debug("UNKNOWN %s %s %s" % (prefix, command, params))
        if command=="RPL_NAMREPLY":
            # Beg for operator mode ?
            self.send_message(params[2], self.op.need_op_mode("@"+self.irc.client.nickname, params))

    def send_message(self, channel, multiline_message=""):
        """
        Sends a message on specified channel, cutting each line in a new message
        """
        if isinstance(multiline_message, list):
            multiline_message = "\n".join(multiline_message)
        for message in multiline_message.splitlines():
            self.irc.client.msg(channel, message)

    def on_privmsg(self, user, channel, msg):
        """
        Wantzel can understand a lot of commands. Commands followed by a (*)
        are accessible only to moderators:
        - help
            Returns a message about how to use the bot.
            If a command is passed after help, the message explains how to use
            the command.
            Bot answers in private in order not to spam channel
        - rp(acp) <url>
            Add an article in the database with a specific flag
        - status <url>
            Retrieve some informations about an article in the database
        - stats
            Show some statistics about the RP
        - kill (*)
            Kill an article by giving it a score of -100
        - admin list (*)
            List rights in private
        - admin add (*)
            Add one or more new moderator to list
        - admin del (*)
            Delete one or more moderator from list
        - admin timer
            Relaunch a timer
        """
        # Cleaning user name
        user = re.search("([^!]*)!", user).group(1)
        Log.debug("Message received: %s %s %s" % (user, channel, msg))
        # Never answer to botself
        if user!=config.nickname:
            # If it's a query, bot should answer to the user as the channel
            if "#" not in channel:
                channel = user
            # Help command, specific
            if "wantzel" in msg and ("help" in msg or "aide" in msg):
                self.help(user, channel, msg)
            # Find known command
            command = re.search("[!~](rp[acp]*|status|kill|help|stats|admin)", msg)
            Log.debug("Command: %s" % command)
            if command:
                Log.debug("group(0): %s" % command.group(0))
                command = command.group(1)
                Log.debug("Command: %s" % command)
                if command.startswith("rp"):
                    Log.debug("Calling self.rp")
                    self.send_message(channel, self.rp.rp(command, user, channel, msg))
                if command.startswith("status"):
                    Log.debug("Calling self.status")
                    self.send_message(channel, self.rp.status(user, msg))
                elif command == "help":
                    Log.debug("Calling self.help")
                    self.help(user, channel, msg)
                elif command == "kill":
                    Log.debug("Calling self.kill")
                    self.send_message(channel, self.rp.kill(user, msg))
                elif command == "stats":
                    Log.debug("Calling self.stats")
                    self.send_message(channel, self.rp.stats())
                elif command == "admin":
                    Log.debug("Calling self.admin")
                    result = self.admin.admin(user, msg)
                    if result=="REACTOR":
                        try:
                            # Recalling the timer
                            reactor.callLater(config.timer, self.timer)
                        except Exception:
                            pass
                    else:
                        self.send_message(channel, result)
            self.send_message(channel, fun(user, channel, msg))

    def help(self, user, channel, msg):
        """
        Show global help.
        If a known command is behind the ~!help command, an adequate message is
        returned.
        """
        Log.debug("help command")
        # Searching for a command after help keyword
        command = re.search("[!~]help (help|rp|status|stats|kill|admin)", msg)
        if command:
            command = command.group(1)
            self.send_message(user, messages["help_"+command])
        else:
            self.send_message(user, messages["help"])


if __name__ == '__main__':
    Wantzel()
    reactor.run()