Slixfeed/slixfeed/xmpp/component.py

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

"""

FIXME

1) Function check_readiness or event "changed_status" is causing for
   triple status messages and also false ones that indicate of lack
   of feeds.

TODO

1) Use loop (with gather) instead of TaskGroup.

2) Assure message delivery before calling a new task.
    See https://slixmpp.readthedocs.io/en/latest/event_index.html#term-marker_acknowledged

3) XHTTML-IM
    case _ if message_lowercase.startswith("html"):
        message['html']="
Parse me!
"
        self.send_message(
            mto=jid,
            mfrom=self.boundjid.bare,
            mhtml=message
            )

NOTE

1) Self presence
    Apparently, it is possible to view self presence.
    This means that there is no need to store presences in order to switch or restore presence.
    check_readiness
    📂 Send a URL from a blog or a news website.
    JID: self.boundjid.bare
    MUC: self.alias

2) Extracting attribute using xmltodict.
    import xmltodict
    message = xmltodict.parse(str(message))
    jid = message["message"]["x"]["@jid"]

"""

import asyncio
import logging
# import os
from random import randrange
import slixmpp
import slixfeed.task as task
from time import sleep

from slixmpp.plugins.xep_0363.http_upload import FileTooBig, HTTPError, UploadServiceNotFound
# from slixmpp.plugins.xep_0402 import BookmarkStorage, Conference
from slixmpp.plugins.xep_0048.stanza import Bookmarks

# import xmltodict
# import xml.etree.ElementTree as ET
# from lxml import etree

import slixfeed.config as config
import slixfeed.sqlite as sqlite
from slixfeed.xmpp.bookmark import XmppBookmark
import slixfeed.xmpp.connect as connect
# NOTE MUC is possible for component
# import slixfeed.xmpp.muc as muc
from slixfeed.xmpp.message import XmppMessage
import slixfeed.xmpp.process as process
import slixfeed.xmpp.profile as profile
# import slixfeed.xmpp.roster as roster
# import slixfeed.xmpp.service as service
from slixfeed.xmpp.presence import XmppPresence
from slixfeed.xmpp.utility import XmppUtility
from slixmpp.xmlstream import ET
# from slixmpp.xmlstream.handler import Callback
# from slixmpp.xmlstream.matcher import MatchXPath

main_task = []
jid_tasker = {}
task_manager = {}
loop = asyncio.get_event_loop()
# asyncio.set_event_loop(loop)

# time_now = datetime.now()
# time_now = time_now.strftime("%H:%M:%S")

# def print_time():
#     # return datetime.now().strftime("%H:%M:%S")
#     now = datetime.now()
#     current_time = now.strftime("%H:%M:%S")
#     return current_time


class SlixfeedComponent(slixmpp.ComponentXMPP):
    def __init__(self, jid, secret, hostname, port, alias=None):
        slixmpp.ComponentXMPP.__init__(self, jid, secret, hostname, port)

        # The session_start event will be triggered when
        # the bot establishes its connection with the server
        # and the XML streams are ready for use. We want to
        # listen for this event so that we we can initialize
        # our roster.
        self.add_event_handler("session_start",
                               self.on_session_start)
        self.add_event_handler("session_resumed",
                               self.on_session_resumed)
        self.add_event_handler("got_offline", print("got_offline"))
        # self.add_event_handler("got_online", self.check_readiness)
        self.add_event_handler("changed_status",
                               self.on_changed_status)
        self.add_event_handler("presence_available",
                               self.on_presence_available)
        self.add_event_handler("presence_unavailable",
                               self.on_presence_unavailable)
        self.add_event_handler("chatstate_active",
                               self.on_chatstate_active)
        self.add_event_handler("chatstate_composing",
                               self.on_chatstate_composing)
        self.add_event_handler("chatstate_gone",
                               self.on_chatstate_gone)
        self.add_event_handler("chatstate_inactive",
                               self.on_chatstate_inactive)
        self.add_event_handler("chatstate_paused",
                               self.on_chatstate_paused)

        # The message event is triggered whenever a message
        # stanza is received. Be aware that that includes
        # MUC messages and error messages.
        self.add_event_handler("message",
                               self.on_message)

        self.add_event_handler("groupchat_invite",
                               self.on_groupchat_invite) # XEP_0045
        self.add_event_handler("groupchat_direct_invite",
                               self.on_groupchat_direct_invite) # XEP_0249
        # self.add_event_handler("groupchat_message", self.message)

        # self.add_event_handler("disconnected", self.reconnect)
        # self.add_event_handler("disconnected", self.inspect_connection)

        self.add_event_handler("reactions",
                               self.on_reactions)
        self.add_event_handler("presence_error",
                               self.on_presence_error)
        self.add_event_handler("presence_subscribe",
                               self.on_presence_subscribe)
        self.add_event_handler("presence_subscribed",
                               self.on_presence_subscribed)
        self.add_event_handler("presence_unsubscribed",
                               self.on_presence_unsubscribed)

        # Initialize event loop
        # self.loop = asyncio.get_event_loop()

        # handlers for connection events
        self.connection_attempts = 0
        self.max_connection_attempts = 10
        self.add_event_handler('connection_failed',
                               self.on_connection_failed)
        self.add_event_handler('session_end',
                               self.on_session_end)


    # async def on_groupchat_invite(self, message):
    #     logging.warning("on_groupchat_invite")
    #     inviter = message['from'].bare
    #     muc_jid = message['groupchat_invite']['jid']
    #     await muc.join(self, inviter, muc_jid)
    #     await bookmark.add(self, muc_jid)


    # NOTE Tested with Gajim and Psi
    # async def on_groupchat_direct_invite(self, message):
    #     inviter = message['from'].bare
    #     muc_jid = message['groupchat_invite']['jid']
    #     await muc.join(self, inviter, muc_jid)
    #     await bookmark.add(self, muc_jid)


    async def on_session_end(self, event):
        message = 'Session has ended.'
        await connect.recover_connection(self, message)


    async def on_connection_failed(self, event):
        message = 'Connection has failed.  Reason: {}'.format(event)
        await connect.recover_connection(self, message)


    async def on_session_start(self, event):
        self.send_presence()
        await self['xep_0115'].update_caps()
        # await muc.autojoin(self)
        profile.set_identity(self, 'service')
        await profile.update(self)
        task.ping_task(self)
        
        # Service.commands(self)
        # Service.reactions(self)
        
        self.service_commands()
        self.service_reactions()


    async def on_session_resumed(self, event):
        self.send_presence()
        self['xep_0115'].update_caps()
        # await muc.autojoin(self)
        profile.set_identity(self, 'service')
        
        # Service.commands(self)
        # Service.reactions(self)
        
        self.service_commands()
        self.service_reactions()


    # TODO Request for subscription
    async def on_message(self, message):
        # jid = message['from'].bare

        # if "chat" == await XmppUtility.get_chat_type(self, jid):
        #     presence_probe = ET.Element('presence')
        #     presence_probe.attrib['type'] = 'probe'
        #     presence_probe.attrib['to'] = jid
        #     print('presence_probe')
        #     print(presence_probe)
        #     self.send_raw(str(presence_probe))
        #     presence_probe.send()

        await process.message(self, message)

        # chat_type = message['type']
        # message_body = message['body']
        # message_reply = message.reply


    async def on_changed_status(self, presence):
        # await task.check_readiness(self, presence)
        jid = presence['from'].bare
        if presence['show'] in ('away', 'dnd', 'xa'):
            await task.clean_tasks_xmpp(jid, ['interval'])
            await task.start_tasks_xmpp(self, jid, ['status', 'check'])


    async def on_presence_subscribe(self, presence):
        jid = presence['from'].bare
        # XmppPresence.request(self, jid)
        XmppPresence.subscribe(self, jid)


    async def on_presence_subscribed(self, presence):
        jid = presence['from'].bare
        if await XmppUtility.get_chat_type(self, jid) == 'chat':
            message_subject = 'RSS News Bot'
            message_body = ('Greetings!\n'
                            'I am {}, the news anchor.\n'
                            'My job is to bring you the latest '
                            'news from sources you provide me with.\n'
                            'You may always reach me via xmpp:{}?message'
                            .format(self.alias, self.boundjid.bare))
            XmppMessage.send_headline(self, jid, message_subject, message_body,
                                      'chat')


    async def on_presence_available(self, presence):
        # TODO Add function to check whether task is already running or not
        # await task.start_tasks(self, presence)
        # NOTE Already done inside the start-task function
        jid = presence['from'].bare
        await task.start_tasks_xmpp(self, jid)


    async def on_presence_unsubscribed(self, presence):
        jid = presence['from'].bare
        message = 'You have been unsubscribed.'
        status_message = '🖋️ Subscribe to receive updates'
        chat_type = await XmppUtility.get_chat_type(self, jid)
        XmppMessage.send(self, jid, message, chat_type)
        XmppPresence.send(self, jid, status_message, chat_type)


    async def on_presence_unavailable(self, presence):
        jid = presence["from"].bare
        # await task.stop_tasks(self, jid)
        await task.clean_tasks_xmpp(jid)


    # TODO
    # Send message that database will be deleted within 30 days
    # Check whether JID is in bookmarks or roster
    # If roster, remove contact JID into file 
    # If bookmarks, remove groupchat JID into file 
    async def on_presence_error(self, presence):
        print("on_presence_error")
        print(presence)
        jid = presence["from"].bare
        await task.clean_tasks_xmpp(jid)


    async def on_reactions(self, message):
        print(message['from'])
        print(message['reactions']['values'])


    async def on_chatstate_active(self, message):
        if message['type'] in ('chat', 'normal'):
            jid = message['from'].bare
            # await task.clean_tasks_xmpp(jid, ['status'])
            await task.start_tasks_xmpp(self, jid, ['status'])


    async def on_chatstate_composing(self, message):
        if message['type'] in ('chat', 'normal'):
            jid = message['from'].bare
            # await task.clean_tasks_xmpp(jid, ['status'])
            status_message='Press "help" for manual, or "info" for information.'
            chat_type = await XmppUtility.get_chat_type(self, jid)
            XmppPresence.send(self, jid, status_message, chat_type)


    async def on_chatstate_gone(self, message):
        if message['type'] in ('chat', 'normal'):
            jid = message['from'].bare
            # await task.clean_tasks_xmpp(jid, ['status'])
            await task.start_tasks_xmpp(self, jid, ['status'])


    async def on_chatstate_inactive(self, message):
        if message['type'] in ('chat', 'normal'):
            jid = message['from'].bare
            # await task.clean_tasks_xmpp(jid, ['status'])
            await task.start_tasks_xmpp(self, jid, ['status'])


    async def on_chatstate_paused(self, message):
        if message['type'] in ('chat', 'normal'):
            jid = message['from'].bare
            # await task.clean_tasks_xmpp(jid, ['status'])
            await task.start_tasks_xmpp(self, jid, ['status'])


# TODO Move class Service to a separate file
# class Service(Slixfeed):
#     def __init__(self):
#         super().__init__()

# TODO https://xmpp.org/extensions/xep-0115.html
# https://xmpp.org/extensions/xep-0444.html#disco


    # TODO https://xmpp.org/extensions/xep-0444.html#disco-restricted
    def service_reactions(self):
        """
        Publish allow list of reactions.
    
        Parameters
        ----------
        None.
    
        Returns
        -------
        None.
    
        """
        form = self['xep_0004'].make_form(
            'form', 'Reactions Information'
            )


# TODO Move class Command to a separate file
# class Command(Slixfeed):
#     def __init__(self):
#         super().__init__()


    def service_commands(self):
        # self["xep_0050"].add_command(
        #     node="updates_enable",
        #     name="Enable/Disable News Updates",
        #     handler=option_enable_updates,
        #     )

        # if jid == config.get_value('accounts', 'XMPP', 'operator'):
        #     self['xep_0050'].add_command(node='bookmarks',
        #                                  name='Bookmarks',
        #                                  handler=self._handle_bookmarks)
        #     self['xep_0050'].add_command(node='roster',
        #                                  name='Roster',
        #                                  handler=self._handle_roster)
        self['xep_0050'].add_command(node='settings',
                                     name='Settings',
                                     handler=self._handle_settings)
        self['xep_0050'].add_command(node='subscriptions',
                                     name='Subscriptions',
                                     handler=self._handle_subscriptions)
        # self['xep_0050'].add_command(node='search',
        #                              name='Search',
        #                              handler=self._handle_search)
        # self['xep_0050'].add_command(node='filters',
        #                              name='Filters',
        #                              handler=self._handle_filters)


    async def _handle_subscriptions(self, iq, session):
        form = self['xep_0004'].make_form('form', 'Subscriptions')
        form['instructions'] = '📰️ Manage subscriptions.'
        # form.addField(var='interval',
        #               ftype='text-single',
        #               label='Interval period')
        options = form.add_field(var='subscriptions',
                                 ftype='list-multi',
                                 label='Select subscriptions',
                                 desc='Select subscription(s) to edit.')
        jid = session['from'].bare
        jid_file = jid
        db_file = config.get_pathname_to_database(jid_file)
        subscriptions = await sqlite.get_feeds(db_file)
        for subscription in subscriptions:
            title = subscription[0]
            url = subscription[1]
            options.addOption(title, url)
        session['payload'] = form
        session['next'] = self._handle_subscription_editor
        session['has_next'] = True
        # Other useful session values:
        # session['to']                    -- The JID that received the
        #                                     command request.
        # session['from']                  -- The JID that sent the
        #                                     command request.
        # session['has_next'] = True       -- There are more steps to complete
        # session['allow_complete'] = True -- Allow user to finish immediately
        #                                     and possibly skip steps
        # session['cancel'] = handler      -- Assign a handler for if the user
        #                                     cancels the command.
        # session['notes'] = [             -- Add informative notes about the
        #   ('info', 'Info message'),         command's results.
        #   ('warning', 'Warning message'),
        #   ('error', 'Error message')]
        return session


    # TODO Make form for a single subscription and several subscriptions
    # single: Delete, Disable, Reset and Rename
    # several: Delete, Disable, Reset
    async def _handle_subscription_editor(self, iq, session):
        form = self['xep_0004'].make_form('form', 'Subscriptions')
        form['instructions'] = '🗞️ Edit subscriptions.'
        options = form.add_field(var='enable',
                                 ftype='boolean',
                                 label='Enable',
                                 value=True)
        options = form.add_field(var='action',
                                 ftype='list-single',
                                 label='Action',
                                 value='reset')
        options.addOption('Delete', 'delete')
        options.addOption('Reset', 'reset')
        session['payload'] = form
        session['next'] = None
        session['has_next'] = False
        return session


    async def _handle_bookmarks(self, iq, session):
        form = self['xep_0004'].make_form('form', 'Bookmarks')
        form['instructions'] = '📑️ Organize bookmarks.'
        options = form.add_field(var='bookmarks',
                                 # ftype='list-multi'
                                 ftype='list-single',
                                 label='Select a bookmark',
                                 desc='Select a bookmark to edit.')
        conferences = await XmppBookmark.get(self)
        for conference in conferences:
            options.addOption(conference['jid'], conference['jid'])
        session['payload'] = form
        session['next'] = self._handle_command_complete
        session['has_next'] = False
        return session


    async def _handle_bookmarks_editor(self, iq, session):
        form = self['xep_0004'].make_form('form', 'Bookmarks')
        form['instructions'] = '📝️ Edit bookmarks.'
        form.addField(var='name',
                      ftype='text-single',
                      label='Name')
        form.addField(var='host',
                      ftype='text-single',
                      label='Host',
                      required=True)
        form.addField(var='room',
                      ftype='text-single',
                      label='Room',
                      required=True)
        form.addField(var='alias',
                      ftype='text-single',
                      label='Alias')
        form.addField(var='password',
                      ftype='text-private',
                      label='Password')
        form.add_field(var='autojoin',
                       ftype='boolean',
                       label='Auto-join',
                       value=True)
        options = form.add_field(var='action',
                       ftype='list-single',
                       label='Action',
                       value='join')
        options.addOption('Add', 'add')
        options.addOption('Join', 'join')
        options.addOption('Remove', 'remove')
        session['payload'] = form
        session['next'] = None
        session['has_next'] = False
        return session


    async def _handle_settings(self, iq, session):
        """
        Respond to the initial request for a command.
    
        Arguments:
            iq      -- The iq stanza containing the command request.
            session -- A dictionary of data relevant to the command
                       session. Additional, custom data may be saved
                       here to persist across handler callbacks.
        """
        form = self['xep_0004'].make_form('form', 'Settings')
        form['instructions'] = ('📮️ Customize news updates.')
        jid = session['from'].bare
        jid_file = jid
        db_file = config.get_pathname_to_database(jid_file)
        value = await config.get_setting_value(db_file, 'enabled')
        value = int(value)
        if value:
            value = True
        else:
            value = False
        form.add_field(var='enabled',
                       ftype='boolean',
                       label='Enable',
                       desc='Enable news updates.',
                       value=value)
        value = await config.get_setting_value(db_file, 'old')
        value = int(value)
        if value:
            value = False
        else:
            value = True
        form.add_field(var='old',
                       ftype='boolean',
                       desc='Mark items of newly added subscriptions as read.',
                       # label='Send only new items',
                       label='Include old news',
                       value=value)
        value = await config.get_setting_value(db_file, 'interval')
        value = str(int(value/60))
        options = form.add_field(var='interval',
                                 ftype='list-single',
                                 label='Interval',
                                 desc='Set interval update (in hours).',
                                 value=value)
        i = 60
        while i <= 2880:
            var = str(i)
            lab = str(int(i/60))
            options.addOption(lab, var)
            i += 60
        value = await config.get_setting_value(db_file, 'archive')
        value = str(value)
        options = form.add_field(var='archive',
                                 ftype='list-single',
                                 label='Archive',
                                 desc='Number of news items to archive.',
                                 value=value)
        i = 0
        while i <= 500:
            x = str(i)
            options.addOption(x, x)
            i += 1
        value = await config.get_setting_value(db_file, 'quantum')
        value = str(value)
        options = form.add_field(var='quantum',
                                 ftype='list-single',
                                 label='Amount',
                                 desc='Set amount of updates per update.',
                                 value='3')
        i = 1
        while i <= 10:
            x = str(i)
            options.addOption(x, x)
            i += 1
        session['payload'] = form
        session['next'] = self._handle_settings_complete
        session['has_next'] = False
        return session


    async def _handle_settings_complete(self, payload, session):
        """
        Process a command result from the user.

        Arguments:
            payload -- Either a single item, such as a form, or a list
                       of items or forms if more than one form was
                       provided to the user. The payload may be any
                       stanza, such as jabber:x:oob for out of band
                       data, or jabber:x:data for typical data forms.
            session -- A dictionary of data relevant to the command
                       session. Additional, custom data may be saved
                       here to persist across handler callbacks.
        """

        jid = session['from'].bare
        jid_file = jid
        db_file = config.get_pathname_to_database(jid_file)
        # In this case (as is typical), the payload is a form
        form = payload
        values = form['values']
        for value in values:
            key = value
            val = values[value]
            if await sqlite.get_settings_value(db_file, key):
                await sqlite.update_settings_value(db_file, [key, val])
            else:
                await sqlite.set_settings_value(db_file, [key, val])
            match value:
                case 'enabled':
                    pass
                case 'interval':
                    pass
        # Having no return statement is the same as unsetting the 'payload'
        # and 'next' session values and returning the session.
        # Unless it is the final step, always return the session dictionary.
        session['payload'] = None
        session['next'] = None
        return session