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, task

import config
from logs import Log

# 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)
        # Loop call
        self.loop = task.LoopingCall(self.timer)
        self.loop.start(config.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()

    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
                            self.loop.start(config.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)
            if command=="help":
                self.send_message(
                    user,
                    """Bravo!
                    Tu viens d'entrer dans le monde récursif où l'aide sert à expliciter l'aide."""
                )
            elif command=="rp":
                self.send_message(
                    user,
                    """Cette commande sert à ajouter un article à la Revue de Presse (https://wiki.laquadrature.net/Revue_de_presse)
                    L'utilisation se fait sous la forme: ~rp(cpa) <url de l'article à ajouter>"""
                )
            elif command=="status":
                self.send_message(
                    user,
                    """Cette commande sert à retrouver les informations concernant un article ajouté à la Revue de Presse (https://wiki.laquadrature.net/Revue_de_presse)
                    L'utilisation se fait sous la forme: ~status <url de l'article>"""
                )
            elif command=="stats":
                self.send_message(
                    user,
                    """Cette commande permet de fournir quelques statistiques sur la Revue de Presse (https://wiki.laquadrature.net/Revue_de_presse)
                    Les statistiques sont calculées sur des notes supérieurs ou égales à 0, 3, et 4. Et sur les 1, 3, 7, et 15 derniers jours."""
                )
            elif command=="kill":
                self.send_message(
                    user,
                    """*Attention* seuls les vrais rp-jedis ont accès à cette commande <3
                    Fixe la note de l'article donné en paramètre à -100.
                    Utile en cas d'erreur ou pour s'assurer que l'article ne sera pas publié dans la RP
                    Utilisation: ~kill <url de l'article>"""
                )
            elif command=="admin":
                self.send_message(
                    user,
                    """*Attention* seuls les vrais rp-jedis ont accès à cette commande <3
                    Permet de gérer la liste des utilisateurs ayant un accès privilégié. Il n'y a qu'un seul niveau de privilège.
                    Utilisations:
                    ~admin list => Fournit la liste des utilisateurs privilégiés
                    ~admin add user[, user]> => Ajoute un ou plusieurs utilisateurs à la liste
                    ~admin del user[, user] => Supprime un ou plusieurs utilisateurs de la liste
                    ~admin timer => Relance un timer pour gérer le topic et les tweets"""
                )
            else:
                self.send_message(
                    user,
                    """Désolé, je ne connais pas cette commande."""
                )
        else:
            self.send_message(
                user,
                """Mes commandes sont : ~help ~rp(cpa) ~status ~kill ~stats et ~admin.
                Pour plus d'informations, voir ici: https://wiki.laquadrature.net/Wantzel
                Pour obtenir de l'aide sur une commande en particulier, il suffit de taper ~help <commande>"""
            )


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