~gtg-contributors/gtg/tracks

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

'''Command line user interface for manipulating tasks in gtg.

Copyright (C) 2010 Bryce W. Harrington

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2 of the License, or (at your
option) any later version.  See http://www.gnu.org/copyleft/gpl.html for
the full text of the license.
'''

import re
import sys
import os
import dbus
import cgi
import getopt
import textwrap
from datetime import datetime, date, timedelta
from string import split

def _(text):
    return text

def usage():
    f = "  %-30s %s\n"
    progname = sys.argv[0]

    text = _("gtcli -- a command line interface to gtg\n")
    text += "\n"

    text += _("Options:\n")
    text += f%( "-h, --help", _("This help") )
    text += "\n"

    text += _("Basic commands:\n")
    text += f%( "gtcli new", _("Create a new task") )
    text += f%( "gtcli show <tid>", _("Display detailed information on given task id") )
    text += f%( "gtcli edit <tid>", _("Opens the GUI editor for the given task id") )
    text += f%( "gtcli delete <tid>", _("Removes task identified by tid") )
    text += f%( "gtcli list [all|today|<filter>|<tag>]...", _("List tasks") )
    text += f%( "gtcli count [all|today|<filter>|<tag>]...", _("Number of tasks") )
    text += f%( "gtcli summary [all|today|<filter>|<tag>]...", _("Report how many tasks starting/due each day") )
    text += f%( "gtcli postpone <tid> <date>", _("Updates the start date of task") )
    text += f%( "gtcli close <tid>", _("Sets state of task identified by tid to closed") )
    text += f%( "gtcli browse [hide|show]", _("Hides or shows the task browser window"))

    text += "\n"
    text += "http://gtg.fritalk.com/\n"
    sys.stderr.write( text )

def die(code=1, err=None):
    if err:
        sys.stderr.write(str(err))
    sys.exit(code)

def connect_to_gtg():
    try:
        bus = dbus.SessionBus()
    except dbus.exceptions.DBusException, e:
        if "X11 initialization failed" in e.get_dbus_message():
            os.environ['DISPLAY'] = ":0"
            bus = dbus.SessionBus()
        else:
            print "dbus exception: '%s'" %(err)
            raise

    liste = bus.list_names()
    busname = "org.gnome.GTG"
    remote_object = bus.get_object(busname,"/org/gnome/GTG")
    return dbus.Interface(remote_object,dbus_interface="org.gnome.GTG")

def new_task(title, body):
    """ Retrieve task via dbus """
    timi = connect_to_gtg()
    timi.NewTask("Active", title, '', '', '', [], body, [])

def delete_task(tid):
    """ Remove a task via dbus """
    timi = connect_to_gtg()
    timi.DeleteTask(tid)

def close_task(tid):
    """ Marks a task closed """
    timi = connect_to_gtg()
    task_data = timi.GetTask(tid)
    task_data['status'] = "Done"
    timi.ModifyTask(tid, task_data)

def show_task(tid):
    """ Displays a given task """
    timi = connect_to_gtg()
    task_data = timi.GetTask(tid)
    content_regex = re.compile(r"<content>(.+)</content>", re.DOTALL)

    content = task_data['text'] + "\n(unknown)"
    m = content_regex.match(task_data['text'])
    if m:
        content = m.group(1)

    print task_data['title']
    if len(task_data['tags'])>0:
        print " %-12s %s" %('tags:', task_data['tags'][0])
    for k in ['id', 'startdate', 'duedate', 'status']:
        print " %-12s %s" %(k+":", task_data[k])
    if len(task_data['parents'])>0:
        print " %-12s %s" %('parents:', task_data['parents'][0])
    print
    print content

def postpone(identifier, startdate):
    """ Change the start date of a task """
    timi = connect_to_gtg()
    
    tasks = []
    if identifier[0] == '@':
        filters = _criteria_to_filters(identifier)
        filters.extend(['active','workview'])
        timi = connect_to_gtg()
        tasks = timi.GetTasksFiltered(filters)
    else:
        tasks = [ timi.GeTask(identifier) ]

    for task in tasks:
        task['startdate'] = startdate
        print "%-12s %-20s %s" %(task['id'], ", ".join(task['tags']), task['title'])
        timi.ModifyTask(task['id'], task)

def open_task_editor(tid):
    """ Load task in the task editor gui """
    timi = connect_to_gtg()
    task_data = timi.OpenTaskEditor(tid)

def toggle_browser_visibility(state):
    """ Cause the task browser to be displayed """
    timi = connect_to_gtg()
    if state == "hide":
        timi.HideTaskBrowser()
    elif state == "minimize" or state == "iconify":
        if not timi.IsTaskBrowserVisible():
            timi.ShowTaskBrowser()
        timi.IconifyTaskBrowser()
    else:
        timi.ShowTaskBrowser()

def _criteria_to_filters(criteria):
    if not criteria:
        filters = ['active']
    else:
        filters = split(criteria, ' ')
    
    # Special case 'today' filter
    if 'today' in filters:
        filters.extend(['active', 'workview'])
        filters.remove('today')
    return filters

def count_tasks(criteria):
    """ Print a simple count of tasks matching criteria """

    filters = _criteria_to_filters(criteria)
    timi = connect_to_gtg()
    tasks = timi.GetTasksFiltered(filters)

    total = 0
    for task in tasks:
        if 'title' not in task:
            continue
        total += 1

    print total
    return total

def summary_of_tasks(criteria):
    """ Print report showing number of tasks starting and due each day """

    if not criteria:
        criteria = 'workable'

    filters = _criteria_to_filters(criteria)
    filters.append('active')
    timi = connect_to_gtg()
    tasks = timi.GetTasksFiltered(filters)

    report = { }
    for t in tasks:
        if not t['startdate']:
            startdate = 'unscheduled'
        elif datetime.strptime(t['startdate'], "%Y-%m-%d") < datetime.today():
            startdate = date.today().strftime("%Y-%m-%d")
        else:
            startdate = t['startdate']

        if startdate not in report:
            report[startdate] = { 'starting':0, 'due':0 }
        report[startdate]['starting'] += 1

        duedate = t['duedate'] or 'never'
        if duedate not in report:
            report[duedate] = { 'starting':0, 'due':0 }
        report[duedate]['due'] += 1

    day = date.today()
    print "%-20s %5s %5s" %("", "Start", "Due")
    if report.has_key('unscheduled'):
        print "%-20s %5d %5d" %('unscheduled', 
                                report['unscheduled']['starting'],
                                report['unscheduled']['due'])
    num_days = 22
    fmt = "%a  %-m-%-d"
    if criteria and 'today' in criteria:
        num_days = 1
    for i in range(0, num_days):
        d = day + timedelta(i)
        dstr = str(d)
        if dstr in report:
            print "%-20s %5d %5d" %(d.strftime(fmt),
                                    report[dstr]['starting'],
                                    report[dstr]['due'])
        else:
            print "%-20s %5d %5d" %(d.strftime(fmt), 0, 0)
            

def list_tasks(criteria, count_only=False):
    """ Display a listing of tasks 
    
    Accepts any filter or combination of filters or tags to limit the
    set of tasks shown.  If multiple tags specified, it lists only tasks
    that have all the tags.  If no filters or tags are specified,
    defaults to showing all active tasks.
    """

    filters = _criteria_to_filters(criteria)
    timi = connect_to_gtg()
    tasks = timi.GetTasksFiltered(filters)

    tasks_tree = { }
    notag = '@__notag'
    for task in tasks:
        if 'title' not in task:
            continue
        if not task['tags'] or len(task['tags']) == 0:
            if notag not in tasks_tree:
                tasks_tree[notag] = []
            tasks_tree[notag].append(task)
        else:
            tags = []
            for tag in list(task['tags']):
                tags.append(tag)
                if tag not in tasks_tree:
                    tasks_tree[tag] = []
                tasks_tree[tag].append(task)

    # If any tags were specified, use only those as the categories
    keys = [t for t in filters if t[0]=='@']
    if not keys:
        keys = tasks_tree.keys()
        keys.sort()

    for key in keys:
        if key not in tasks_tree:
            continue
        if key != notag:
            print "%s:" %(key[1:])
        for task in tasks_tree[key]:
            text = textwrap.fill(task['title'], 
                                 initial_indent='',
                                 subsequent_indent='                                        ')
            print "  %-36s  %s" %(task['id'], text)

if __name__ == '__main__':
    try:
        opts, args = getopt.gnu_getopt(sys.argv[1:], "h", ["help"])
    except getopt.GetoptError, err:
        sys.stderr.write("Error: " + str(err) + "\n\n")
        usage()
        sys.exit(2)
    for o, a in opts:
        if o in ("-h", "--help"):
            usage()
            sys.exit(0)
        else:
            assert False, "unhandled option"

    if len(args) < 1:
        usage()
        sys.exit(2)

    command = args[0]

    if command == "new" or command == "add":
        subject_regex = re.compile("^Subject: (.*)$", re.M | re.I)

        title = " ".join(args[1:])
        body = sys.stdin.read()
        if subject_regex.search(body):
            subject = subject_regex.findall(body)[0]
            title = title + ": " + subject

        new_task(title, cgi.escape(body))

    elif command == "list":
        criteria = None
        if len(args)>1:
            criteria = ' '.join(args[1:])
        list_tasks(criteria, False)

    elif command == "count":
        criteria = None
        if len(args)>1:
            criteria = ' '.join(args[1:])
        count_tasks(criteria)

    elif command == "summary":
        criteria = None
        if len(args)>1:
            criteria = ' '.join(args[1:])
        summary_of_tasks(criteria)

    elif command == "rm" or command == "delete":
        if len(args)<2:
            usage()
            sys.exit(1)
        for tid in args[1:]:
            delete_task(tid)

    elif command == "close":
        if len(args)<2:
            usage()
            sys.exit(1)
        for tid in args[1:]:
            close_task(tid)

    elif command == "postpone":
        if len(args)<3:
            usage()
            sys.exit(1)
        postpone(args[1], args[2])

    elif command == "show":
        if len(args)<2:
            usage()
            sys.exit(1)
        for tid in args[1:]:
            show_task(tid)

    elif command == "edit":
        if len(args)<2:
            usage()
            sys.exit(1)
        for tid in args[1:]:
            open_task_editor(tid)

    elif command == "browse":
        state = None
        if len(args)>1:
            state = args[1]
        toggle_browser_visibility(state)

    else:
        die("Unknown command '%s'\n" %(command))