libervia-backend/src/plugins/plugin_exp_parrot.py

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

# SAT plugin for parrot mode (experimental)
# Copyright (C) 2009-2016 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 sat.core.i18n import _
from sat.core.constants import Const as C
from sat.core.log import getLogger
log = getLogger(__name__)
from twisted.words.protocols.jabber import jid

from sat.core.exceptions import UnknownEntityError
#from sat.tools import trigger

PLUGIN_INFO = {
    "name": "Parrot Plugin",
    "import_name": "EXP-PARROT",
    "type": "EXP",
    "protocols": [],
    "dependencies": ["XEP-0045"],
    "recommendations": [C.TEXT_CMDS],
    "main": "Exp_Parrot",
    "handler": "no",
    "description": _("""Implementation of parrot mode (repeat messages between 2 entities)""")
}


class Exp_Parrot(object):
    """Parrot mode plugin: repeat messages from one entity or MUC room to another one"""
    #XXX: This plugin can be potentially dangerous if we don't trust entities linked
    #     this is specially true if we have other triggers.
    #     messageSendTrigger avoid other triggers execution, it's deactivated to allow
    #     /unparrot command in text commands plugin.

    def __init__(self, host):
        log.info(_("Plugin Parrot initialization"))
        self.host = host
        host.trigger.add("MessageReceived", self.MessageReceivedTrigger, priority=100)
        #host.trigger.add("messageSend", self.messageSendTrigger, priority=100)
        try:
            self.host.plugins[C.TEXT_CMDS].registerTextCommands(self)
        except KeyError:
            log.info(_("Text commands not available"))

    #def messageSendTrigger(self, client, mess_data, treatments):
    #    """ Deactivate other triggers if recipient is in parrot links """
    #    try:
    #        _links = client.parrot_links
    #    except AttributeError:
    #        return True
    #
    #    if mess_data['to'].userhostJID() in _links.values():
    #        log.debug("Parrot link detected, skipping other triggers")
    #        raise trigger.SkipOtherTriggers

    def MessageReceivedTrigger(self, client, message_elt, post_treat):
        """ Check if source is linked and repeat message, else do nothing  """
        # TODO: many things are not repeated (subject, thread, etc)
        profile = client.profile
        client = self.host.getClient(profile)
        from_jid = message_elt["from"]

        try:
            _links = client.parrot_links
        except AttributeError:
            return True

        if not from_jid.userhostJID() in _links:
            return True

        message = {}
        for e in message_elt.elements(C.NS_CLIENT, 'body'):
            body = unicode(e)
            lang = e.getAttribute('lang') or ''

            try:
                entity_type = self.host.memory.getEntityData(from_jid, ['type'], profile)["type"]
            except (UnknownEntityError, KeyError):
                entity_type = "contact"
            if entity_type == 'chatroom':
                src_txt = from_jid.resource
                if src_txt == self.host.plugins["XEP-0045"].getRoomNick(client, from_jid.userhostJID()):
                    #we won't repeat our own messages
                    return True
            else:
                src_txt = from_jid.user
            message[lang] = u"[{}] {}".format(src_txt, body)

            linked = _links[from_jid.userhostJID()]

            self.host.messageSend(jid.JID(unicode(linked)), message, None, "auto", no_trigger=True, profile_key=profile)

        return True

    def addParrot(self, client, source_jid, dest_jid):
        """Add a parrot link from one entity to another one

        @param source_jid: entity from who messages will be repeated
        @param dest_jid: entity where the messages will be repeated
        """
        try:
            _links = client.parrot_links
        except AttributeError:
            _links = client.parrot_links = {}

        _links[source_jid.userhostJID()] = dest_jid
        log.info(u"Parrot mode: %s will be repeated to %s" % (source_jid.userhost(), unicode(dest_jid)))

    def removeParrot(self, client, source_jid):
        """Remove parrot link

        @param source_jid: this entity will no more be repeated
        """
        try:
            del client.parrot_links[source_jid.userhostJID()]
        except (AttributeError, KeyError):
            pass

    def cmd_parrot(self, client, mess_data):
        """activate Parrot mode between 2 entities, in both directions."""
        log.debug("Catched parrot command")
        txt_cmd = self.host.plugins[C.TEXT_CMDS]

        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 (RuntimeError, jid.InvalidFormat, AttributeError):
            txt_cmd.feedBack(client, "Can't activate Parrot mode for invalid jid", mess_data)
            return False

        link_right_jid = mess_data['to']

        self.addParrot(client, link_left_jid, link_right_jid)
        self.addParrot(client, link_right_jid, link_left_jid)

        txt_cmd.feedBack(client, "Parrot mode activated for {}".format(unicode(link_left_jid)), mess_data)

        return False

    def cmd_unparrot(self, client, mess_data):
        """remove Parrot mode between 2 entities, in both directions."""
        log.debug("Catched unparrot command")
        txt_cmd = self.host.plugins[C.TEXT_CMDS]

        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:
            txt_cmd.feedBack(client, u"Can't deactivate Parrot mode for invalid jid", mess_data)
            return False

        link_right_jid = mess_data['to']

        self.removeParrot(client, link_left_jid)
        self.removeParrot(client, link_right_jid)

        txt_cmd.feedBack(client, u"Parrot mode deactivated for {} and {}".format(unicode(link_left_jid), unicode(link_right_jid)), mess_data)

        return False