ubuntu-bots/Webcal/plugin.py

# -*- Encoding: utf-8 -*-
###
# Copyright (c) 2005-2007 Dennis Kaarsemaker
# Copyright (c) 2008-2010 Terence Simpson
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of version 2 of the GNU General Public License as
# published by the Free Software Foundation.
#
# 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 General Public License for more details.
#
###

import supybot.utils as utils
from supybot.commands import *
import supybot.plugins as plugins
import supybot.ircutils as ircutils
import supybot.callbacks as callbacks
import supybot.schedule as schedule
import supybot.ircmsgs as ircmsgs
import supybot.ircdb as ircdb
import supybot.conf as conf

def checkIgnored(hostmask, recipient='', users=ircdb.users, channels=ircdb.channels):
    if ircdb.ignores.checkIgnored(hostmask):
        return True
    try:
        id = ircdb.users.getUserId(hostmask)
        user = users.getUser(id)
    except KeyError:
        # If there's no user...
        if ircutils.isChannel(recipient):
            channel = channels.getChannel(recipient)
            if channel.checkIgnored(hostmask):
                return True
            else:
                return False
        else:
            return False
    if user._checkCapability('owner'):
        # Owners shouldn't ever be ignored.
        return False
    elif user.ignore:
        return True
    elif recipient:
        if ircutils.isChannel(recipient):
            channel = ircdb.channels.getChannel(recipient)
            if channel.checkIgnored(hostmask):
                return True
            else:
                return False
        else:
            return False
    else:
        return False

import pytz
import ical
reload(ical)
import datetime, shelve, re
import cPickle as pickle

class Webcal(callbacks.Plugin):
    """@schedule <timezone>
    display the schedule in your timezone
    """
    threaded = True
    noIgnore = True

    def __init__(self, irc):
        parent = super(Webcal, self)
        parent.__init__(irc)
        self.irc = irc
        self.cache = {}
        self.firstevent = {}
        try:
            schedule.removeEvent(self.name())
            schedule.removeEvent(self.name() + 'b')
        except AssertionError:
            pass
        except KeyError:
            pass
        try:
            schedule.addPeriodicEvent(self.refresh_cache,  60 * 20, name=self.name())
            schedule.addPeriodicEvent(self.autotopics,     60, name=self.name() + 'b')
        except AssertionError:
            pass

    def die(self):
        try:
            schedule.removeEvent(self.name())
            schedule.removeEvent(self.name() + 'b')
        except AssertionError:
            pass
        self.cache.clear()

    def reset(self):
        self.cache.clear()

    def update(self, url):
        data = utils.web.getUrl(url)
        parser = ical.ICalReader(data)
        self.cache[url] = parser.events

    def refresh_cache(self):
        for c in self.irc.state.channels:
            url = self.registryValue('url', c)
            if url:
                self.update(url)

    def autotopics(self):
        for c in self.irc.state.channels:
            url = self.registryValue('url', c)
            if url and self.registryValue('doTopic', c):
                if url not in self.cache:
                    self.update(url)
                events = self.filter(self.cache[url], c)
                #if events[0].is_on() and self.firstevent[c].summary == events[0].summary:
                #    continue
                newtopic = self.maketopic(c, template=self.registryValue('topic',c))
                if newtopic.strip() != self.irc.state.getTopic(c).strip():
                    self.irc.queueMsg(ircmsgs.topic(c, newtopic))

    def filter(self, events, channel):
        now = datetime.datetime.now(pytz.UTC)
        fword = self.registryValue('filter', channel)
        ret = [x for x in events if fword.lower() in x.raw_data.lower() and x.seconds_ago() < 1800]
        ret = [x for x in ret if self.filterChannel(x)]
        ret.sort()
        ret.sort()
        return ret

    def filterChannel(self, event):
        desc = event['description']
        where = u'#ubuntu-meeting'
        if "Location\\:" in desc:
            where = desc.split('<')[1].split()[-1]
            if where[0] != u'#':
                where = u'#ubuntu-meeting'
        return where == u'#ubuntu-meeting'

    def maketopic(self, c, tz=None, template='%s', num_events=6):
        url = self.registryValue('url',c)
        if not tz:
            tz = 'UTC'
        if url not in self.cache.keys():
            self.update(url)

        now = datetime.datetime.now(pytz.UTC)
        events = self.filter(self.cache[url],c)[:num_events]
#        events.sort()
        preamble = ''
        if not len(events):
            return template % "No meetings scheduled"
        # The standard slack of 30 minutes after the meeting will be an
        # error if there are 2 conscutive meetings, so remove the first 
        # one in that case
        if len(events) > 1 and events[1].startTime() < now:
                events = events[1:]
        ev0 = events[0]
        if ev0.seconds_to_go() < 600:
            preamble = 'Current meeting: %s ' % ev0.summary.replace('Meeting','').strip()
            if num_events == 1:
                return preamble + (template % '')
            events = events[1:]

        if num_events == 1:
            ev = events[0]
            return template % ('Next meeting: %s in %s' % (ev.summary.replace(' Meeting','').strip(), ev.time_to_go()))

        events = [x.schedule(tz) for x in events]
        return preamble + (template % ' | '.join(events))
        
    # Now the commands
    def topic(self, irc, msg, args):
        """No args
        Updates the topics in the channel
        """
        c = msg.args[0]
        url = self.registryValue('url', c)
        if not url or not self.registryValue('doTopic',channel=c):
            return
        self.update(url)

        events = self.filter(self.cache[url], c)
        if events and events[0].is_on():
            irc.error("Won't update topic while a meeting is in progress")
            return
            
        newtopic = self.maketopic(c, template=self.registryValue('topic',c))
        if not (newtopic.strip() == irc.state.getTopic(c).strip()):
            irc.queueMsg(ircmsgs.topic(c, newtopic))
    topic = wrap(topic, [('checkCapability', 'admin')])

    def _tzfilter(self, tz, ud):
        if tz == ud:
            return True
        pos = tz.find('/')
        while not (pos == -1):
            if tz[pos+1:] == ud:
                return True
            pos = tz.find('/',pos+1)
        # Repeat, with spaces replaced by underscores
        ud = ud.replace(' ','_')
        if tz == ud:
            return True
        pos = tz.find('/')
        while not (pos == -1):
            if tz[pos+1:] == ud:
                return True
            pos = tz.find('/',pos+1)
        
        return False

    def schedule(self, irc, msg, args, tz):
        """[<timezone>]
        Retrieve the date/time of scheduled meetings in a specific timezone, defaults to UTC
        """
        if not tz:
            tz = 'utc'
        if irc.isChannel(msg.args[0]):
            c = msg.args[0]
        else:
            c = self.registryValue('defaultChannel')
            if not c:
                return
        url = self.registryValue('url', c)
        if not url:
            c = self.registryValue('defaultChannel')
            url = self.registryValue('url', c)
        if not url:
            return
        tzs = filter(lambda x: self._tzfilter(x.lower(),tz.lower()), pytz.all_timezones)
        if not tzs:
            irc.error('Unknown timezone: %s - Full list: %s' % (tz, self.registryValue('tzUrl') or 'Value not set'))
            return
        newtopic = self.maketopic(c,tz=tzs[0])
        events = self.filter(self.cache[url], msg.args[0])
        if events and events[0].is_on(): # FIXME channel filter
            irc.error('Please don\'t use @schedule during a meeting')
            irc.reply('Schedule for %s: %s' % (tzs[0], newtopic), private=True)
        else:
            irc.reply('Schedule for %s: %s' % (tzs[0], newtopic))
    schedule = wrap(schedule, [additional('text')])

    def now(self, irc, msg, args, tz):
        """[<timezone>]
        Display the current time, <timezone> defaults to UTC
        """
        if not tz:
            tz = 'utc'
        if irc.isChannel(msg.args[0]):
            c = msg.args[0]
        else:
            c = self.registryValue('defaultChannel')
            if not c:
                return
        url = self.registryValue('url', c)
        if not url:
            c = self.registryValue('defaultChannel')
            url = self.registryValue('url', c)
        if not url:
            return
        tzs = filter(lambda x: self._tzfilter(x.lower(),tz.lower()), pytz.all_timezones)
        if not tzs:
            irc.error('Unknown timezone: %s - Full list: %s' % (tz, self.registryValue('tzUrl') or 'Value not set'))
            return
        now = datetime.datetime.now(pytz.UTC)
        newtopic = self.maketopic(c,tz=tzs[0],num_events=1)
        events = self.filter(self.cache[url], msg.args[0])
        newtopic = 'Current time in %s: %s - %s' % \
            (tzs[0], datetime.datetime.now(pytz.UTC).astimezone(pytz.timezone(tzs[0])).strftime("%B %d %Y, %H:%M:%S"), newtopic)

        if events and events[0].is_on(): # Fixme -- channel filter
            irc.error('Please don\'t use @schedule during a meeting')
            irc.reply(newtopic, private=True)
        else:
            irc.reply(newtopic)
    now = wrap(now, [additional('text')])
    time = now

    # Warn people that you manage the topic
    def doTopic(self, irc, msg):
        c = msg.args[0]
        if not self.registryValue('doTopic', c):
            return
        url = self.registryValue('url', c)
        irc.reply("The topic of %s is managed by me and filled with the contents of %s - please don't change manually" % 
                  (msg.args[0],url), private=True)

    def callPrecedence(self, irc):
        before = []
        for cb in irc.callbacks:
            if cb.name() == 'IRCLogin':
                before.append(cb)
        return (before, [])

    def inFilter(self, irc, msg):
        if not msg.command == 'PRIVMSG':
            return msg
        if not conf.supybot.defaultIgnore():
            return msg
        s = callbacks.addressed(irc.nick, msg)
        if not s:
            return msg
        if checkIgnored(msg.prefix):
            return msg
        try:
            if ircdb.users.getUser(msg.prefix):
                return msg
        except:
            pass
        cmd, args = (s.split(None, 1) + [None])[:2]
        if cmd and cmd[0] in str(conf.supybot.reply.whenAddressedBy.chars.get(msg.args[0])):
            cmd = cmd[1:]
        if cmd in self.listCommands():
            tokens = callbacks.tokenize(s, channel=msg.args[0])
            self.Proxy(irc, msg, tokens)
        return msg

Class = Webcal