keithsalisbury-subtrac 0.1.1

data/lib/subtrac/trac-plugins/estimationtoolsplugin/estimationtools/workloadchart.py

@@ -0,0 +1,86 @@
+from datetime import timedelta
+from estimationtools.utils import parse_options, execute_query, get_estimation_field, get_estimation_suffix, get_closed_states
+from trac.util.html import Markup
+from trac.wiki.macros import WikiMacroBase
+import copy
+
+DEFAULT_OPTIONS = {'width': '400', 'height': '100', 'color': 'ff9900'}
+
+class WorkloadChart(WikiMacroBase):
+    """Creates workload chart for the selected tickets.
+
+    This macro creates a pie chart that shows the remaining estimated workload per ticket owner,
+    and the remaining work days.
+    It has the following parameters:
+     * a comma-separated list of query parameters for the ticket selection, in the form "key=value" as specified in TracQuery#QueryLanguage.
+     * `width`: width of resulting diagram (defaults to 400)
+     * `height`: height of resulting diagram (defaults to 100)
+     * `color`: color specified as 6-letter string of hexadecimal values in the format `RRGGBB`.
+       Defaults to `ff9900`, a nice orange.
+
+    Examples:
+    {{{
+        [[WorkloadChart(milestone=Sprint 1)]]
+        [[WorkloadChart(milestone=Sprint 1, width=600, height=100, color=00ff00)]]
+    }}}
+    """
+
+    estimation_field = get_estimation_field()
+    estimation_suffix = get_estimation_suffix()
+    closed_states = get_closed_states()
+
+    def render_macro(self, req, name, content):
+        db = self.env.get_db_cnx()
+        # prepare options
+        options, query_args = parse_options(db, content, copy.copy(DEFAULT_OPTIONS))
+
+        query_args[self.estimation_field + "!"] = None
+        tickets = execute_query(self.env, req, query_args)
+
+        sum = 0.0
+        estimations = {}
+        for ticket in tickets:
+            if ticket['status'] in self.closed_states:
+                continue
+            try:
+                estimation = float(ticket[self.estimation_field])
+                owner = ticket['owner']
+                sum += estimation
+                if estimations.has_key(owner):
+                    estimations[owner] += estimation
+                else:
+                    estimations[owner] = estimation
+            except:
+                pass
+
+        estimations_string = []
+        labels = []
+        for owner, estimation in estimations.iteritems():
+            labels.append("%s %s%s" % (owner, str(int(estimation)), self.estimation_suffix))
+            estimations_string.append(str(int(estimation)))
+
+        # Title
+        title = 'Workload'
+
+        # calculate remaining work time
+        if options.get('today') and options.get('enddate'):
+            currentdate = options['today']
+            day = timedelta(days=1)
+            days_remaining = 0
+            while currentdate <= options['enddate']:
+                if currentdate.weekday() < 5:
+                    days_remaining += 1
+                currentdate += day
+            title += ' %s%s (%s workdays left)' % (int(sum), self.estimation_suffix, days_remaining)
+
+        return Markup("<img src=\"http://chart.apis.google.com/chart?"
+               "chs=%sx%s"
+               "&amp;chf=bg,s,00000000"
+               "&amp;chd=t:%s"
+               "&amp;cht=p3"
+               "&amp;chtt=%s"
+               "&amp;chl=%s"
+               "&amp;chco=%s\" "
+               "alt=\'Workload Chart\' />"
+               % (options['width'], options['height'], ",".join(estimations_string),
+                  title, "|".join(labels), options['color']))

data/lib/subtrac/trac-plugins/estimationtoolsplugin/setup.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: iso-8859-1 -*-
+
+from setuptools import setup
+
+setup(
+    name = 'EstimationTools',
+    author = 'Joachim Hoessler',
+    author_email = 'hoessler@gmail.com',
+    description = 'Trac plugin for visualizing and quick editing of effort estimations',
+    version = '0.4',
+    license='BSD',
+    packages=['estimationtools'],
+    package_data = { 'estimationtools': ['htdocs/*.js', 'templates/*.html'] },
+    entry_points = {
+        'trac.plugins': [
+            'estimationtools = estimationtools'
+        ]
+    }
+)

data/lib/subtrac/trac-plugins/timingandestimationplugin/scripts/SumRollups.js

@@ -0,0 +1,23 @@
+//javascript:(function(){var filter = function (fn, list, thisObj) { var arr = []; for (var i = 0; i < list.length; i++) { if (fn.call(thisObj, list[i])) { arr.push(list[i]);return arr;var sum = 0; var tds = filter(function(td){return td.innerHTML =='None';document.getElementsByTagName('td'),this); for(var i = 0; i < tds.length; i++){sum += parseFloat(tds[i].parentNode.childNodes[5].innerHTML);alert('Total hours: ' + sum);})();
+javascript:(
+   function(){
+      var filter = function (fn, list, thisObj) { 
+	 var arr = []; 
+	 for (var i = 0; i < list.length; i++) { 
+	    if (fn.call(thisObj, list[i])) { 
+	       arr.push(list[i]);
+	    }
+	 } 
+	 return arr;
+      }; 
+      var sum = 0; 
+      var tds = filter(function(td){
+			  return td.innerHTML =='None';
+		       },
+		       document.getElementsByTagName('td'),this); 
+      for(var i = 0; i < tds.length; i++){
+	 sum += parseFloat(tds[i].parentNode.childNodes[5].innerHTML);
+      } 
+      alert('Total hours: ' + sum);
+   }
+)();

data/lib/subtrac/trac-plugins/timingandestimationplugin/scripts/adw_tracdb.py

@@ -0,0 +1,128 @@
+from pysqlite2 import dbapi2 as sqlite
+from datetime import datetime, timedelta
+from time import mktime
+import os
+
+tracDir = '/var/trac'
+projectDBLocationFormat = '/var/trac/%s/db/trac.db'
+# all directories in the trac directory
+projects = [f for f in os.listdir(tracDir) if os.path.isdir('/'.join ([tracDir, f]))]
+
+def makeDb(proj):
+    return projectDBLocationFormat % proj
+
+def collectResultsFromAllTracs( sql ):
+    lst = []
+    for proj in projects:
+        try:
+            lst.extend([( proj , getResultSet( proj, sql ))])
+        except Exception, e:
+            print "collectResultsFromAllTracs: sql failed to execute on %s : %s " % (proj, e.args)
+            
+    return lst
+
+def executeAgainstAllTracs( sql ):
+    for proj in projects:
+        try:
+            executeNonQuery( proj, sql )
+        except:
+            print "executeAgainstAllTracs: sql failed to execute on %s" % proj
+    
+
+def executeNonQuery(proj, sql, *params):
+    """Executes the query on the given project"""
+    con = sqlite.connect(makeDb(proj))
+    cur = con.cursor()
+    try:
+        cur.execute(sql, params)
+        con.commit()
+    finally:
+        cur.close()
+        con.close()
+
+def getColumnAsList(db, sql, col=0, *params):
+    return [valueList[col] for valueList in get_all(db, sql, *params)[1]]
+
+def getScalar(proj , sql, col=0, *params):
+    db = sqlite.connect(makeDb(proj))
+    cur = db.cursor()
+    try:
+        cur.execute(sql, params)
+        data = cur.fetchone()
+    finally:
+        cur.close()
+    return data[col]
+
+
+def getVector(proj, sql, *params):
+    db = sqlite.connect(makeDb(proj))
+    cur = db.cursor()
+    try:
+        cur.execute(sql, params)
+        data = cur.fetchone()
+    finally:
+        cur.close()
+    return data
+
+def getAll(proj, sql, *params):
+    """Executes the query and returns the (description, data)"""
+    con = sqlite.connect(makeDb(proj)) 
+    cur = con.cursor()
+    try:
+        cur.execute(sql, params)
+        data = cur.fetchall()
+        desc = cur.description
+    finally:
+        cur.close()
+        con.close()
+    return (desc, data)
+       
+def getResultSet(proj, sql, *params):
+    """Executes the query and returns a Result Set"""
+    return ResultSet(getAll(proj, sql, *params))
+
+def _columnName( columnDescription ):
+    """ given a the columnHeader from the result set from getAll gives you the column Headers """
+    return columnDescription[0];
+
+class ResultSet:
+    """ the result of calling getResultSet """
+    def __init__ (self, (columnDescription, rows)):
+        self.columnDescription, self.rows = columnDescription, rows
+        self.columnNames = [_columnName(_) for _ in self.columnDescription]
+        self.columnMap = self.getColumnMap()
+
+    def getColumnMap ( self ):
+        """This function will take the result set from getAll and will
+        return a hash of the column names to their index """
+        h = {}
+        i = 0
+        if self.columnDescription:
+            for col in self.columnNames:
+                h[ col ] = i
+                i+=1
+        return h;
+    
+    def value(self, col, row ):
+        """ given a row(list or idx) and a column( name or idx ), retrieve the appropriate value"""
+        tcol = type(col)
+        trow = type(row)
+        if tcol == str:
+            if(trow == list or trow == tuple):
+                return row[self.columnMap[col]]
+            elif(trow == int):
+                return self.rows[row][self.columnMap[col]]
+            else:
+                print ("rs.value Type Failed col:%s  row:%s" % (type(col), type(row)))
+        elif tcol == int:
+            if(trow == list or trow == tuple):
+                return row[col]
+            elif(trow == int):
+                return self.rows[row][col]
+            else:
+                print ("rs.value Type Failed col:%s  row:%s" % (type(col), type(row)))
+        else:
+            print ("rs.value Type Failed col:%s  row:%s" % (type(col), type(row)))
+            
+
+

data/lib/subtrac/trac-plugins/timingandestimationplugin/scripts/git-post-receive

@@ -0,0 +1,40 @@
+#!/bin/sh
+#
+# An example hook script for the post-receive event
+#
+# This script is run after receive-pack has accepted a pack and the
+# repository has been updated.  It is passed arguments in through stdin
+# in the form
+#  <oldrev> <newrev> <refname>
+# For example:
+#  aa453216d1b3e49e7f6f98441fa56946ddcd6a20 68f7abf4e6f922807889f52bc043ecd31b79f814 refs/heads/master
+#
+# see contrib/hooks/ for an sample, or uncomment the next line (on debian)
+#
+
+
+TRAC_ENV="YOUR TRAC ENV HERE"
+LOG="/dev/null"
+echo "in git post commit: $TRAC_ENV" | cat >>$LOG
+
+while read oval nval ref ; do
+    if expr "$oval" : '0*$' >/dev/null
+    then
+        git-rev-list "$nval"
+    else
+        git-rev-list "$nval" "^$oval"
+    fi | while read com ; do
+	echo "posting a comment to trac" | cat >>$LOG
+	/usr/bin/python /usr/share/trac/contrib/trac-post-commit.py \
+	    -p "$TRAC_ENV" \
+	    -r "$com" \
+	    -u "$(git-rev-list -n 1 $com --pretty=format:%an | sed '1d')" \
+	    -m  "$(git-rev-list -n 1 $com --pretty=medium | sed '1,3d;s:^    ::')"
+	echo "DONE posting a comment to trac" | cat >>$LOG
+    done
+done
+
+echo "Done with trac commit hook: $TRAC_ENV" | cat >>$LOG
+
+git reset --hard 
+echo "resetting repo working copy" | cat >>$LOG

data/lib/subtrac/trac-plugins/timingandestimationplugin/scripts/trac-post-commit.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python
+
+# trac-post-commit-hook
+# ----------------------------------------------------------------------------
+# Copyright (c) 2004 Stephen Hansen 
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+#   The above copyright notice and this permission notice shall be included in
+#   all copies or substantial portions of the Software. 
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+# ----------------------------------------------------------------------------
+
+### Changes for the Timing and Estimation plugin
+#
+# This script is very similar to "trac-post-commit" included with trac
+# itself.  This section explains functional changes relative to that
+# script, and comments throughout the code explain other differences.
+#
+## Logging support for debugging this hook
+#
+## Support for specifying time spent in commit messages.
+#
+# "Blah refs #12 (1)" will add 1h to the spent time for issue #12
+# "Blah refs #12 (spent 1.5)" will add 1h to the spent time for issue #12
+#
+# As above it is possible to use complicated messages:
+#
+# "Changed blah and foo to do this or that. Fixes #10 (1) and #12 (2),
+# and refs #13 (0.5)."
+#
+# This will close #10 and #12, and add a note to #13 and also add 1h
+# spent time to #10, add 2h spent time to #12 and add 30m spent time
+# to #13.
+#
+# Note that:
+#     (spent 2), (sp 2) or simply (2) may be used for spent
+#     ' ', ',', '&' or 'and' may be used references
+
+# This Subversion post-commit hook script is meant to interface to the
+# Trac (http://www.edgewall.com/products/trac/) issue tracking/wiki/etc 
+# system.
+# 
+# It should be called from the 'post-commit' script in Subversion, such as
+# via:
+#
+# REPOS="$1"
+# REV="$2"
+# TRAC_ENV="/path/to/tracenv"
+#
+# /usr/bin/python /usr/local/src/trac/contrib/trac-post-commit-hook \
+#  -p "$TRAC_ENV" -r "$REV"
+#
+# (all the other arguments are now deprecated and not needed anymore)
+#
+# It searches commit messages for text in the form of:
+#   command #1
+#   command #1, #2
+#   command #1 & #2 
+#   command #1 and #2
+#
+# Instead of the short-hand syntax "#1", "ticket:1" can be used as well, e.g.:
+#   command ticket:1
+#   command ticket:1, ticket:2
+#   command ticket:1 & ticket:2 
+#   command ticket:1 and ticket:2
+#
+# In addition, the ':' character can be omitted and issue or bug can be used
+# instead of ticket.
+#
+# You can have more then one command in a message. The following commands
+# are supported. There is more then one spelling for each command, to make
+# this as user-friendly as possible.
+#
+#   close, closed, closes, fix, fixed, fixes
+#     The specified issue numbers are closed with the contents of this
+#     commit message being added to it. 
+#   references, refs, addresses, re, see 
+#     The specified issue numbers are left in their current status, but 
+#     the contents of this commit message are added to their notes. 
+#
+# A fairly complicated example of what you can do is with a commit message
+# of:
+#
+#    Changed blah and foo to do this or that. Fixes #10 and #12, and refs #12.
+#
+# This will close #10 and #12, and add a note to #12.
+
+import re
+import os
+import sys
+from datetime import datetime 
+from optparse import OptionParser
+
+parser = OptionParser()
+depr = '(not used anymore)'
+parser.add_option('-e', '--require-envelope', dest='envelope', default='',
+                  help="""
+Require commands to be enclosed in an envelope.
+If -e[], then commands must be in the form of [closes #4].
+Must be two characters.""")
+parser.add_option('-p', '--project', dest='project',
+                  help='Path to the Trac project.')
+parser.add_option('-r', '--revision', dest='rev',
+                  help='Repository revision number.')
+parser.add_option('-u', '--user', dest='user',
+                  help='The user who is responsible for this action '+depr)
+parser.add_option('-m', '--msg', dest='msg',
+                  help='The log message to search '+depr)
+parser.add_option('-c', '--encoding', dest='encoding',
+                  help='The encoding used by the log message '+depr)
+parser.add_option('-s', '--siteurl', dest='url',
+                  help=depr+' the base_url from trac.ini will always be used.')
+
+(options, args) = parser.parse_args(sys.argv[1:])
+
+if not 'PYTHON_EGG_CACHE' in os.environ:
+    os.environ['PYTHON_EGG_CACHE'] = os.path.join(options.project, '.egg-cache')
+
+from trac.env import open_environment
+from trac.ticket.notification import TicketNotifyEmail
+from trac.ticket import Ticket
+from trac.ticket.web_ui import TicketModule
+# TODO: move grouped_changelog_entries to model.py
+from trac.util.text import to_unicode
+from trac.util.datefmt import utc
+from trac.versioncontrol.api import NoSuchChangeset
+
+# Change logfile to point to someplace this script can write.
+logfile = "/var/trac/commithook.log"
+LOG = False
+
+if LOG:
+    f = open (logfile,"w")
+    f.write("Begin Log\n")
+    f.close()
+    def log (s, *params):
+        f = open (logfile,"a")
+        f.write(s % params)
+        f.write("\n")
+        f.close()
+else:
+    def log (s, *params):
+        pass
+
+# Relative to trac standard, this table is hoisted out of class
+# CommitHook so that it can be used in constructing a regexp that only
+# matches on supported commands.
+_supported_cmds = {'close':      '_cmdClose',
+                   'closed':     '_cmdClose',
+                   'closes':     '_cmdClose',
+                   'fix':        '_cmdClose',
+                   'fixed':      '_cmdClose',
+                   'fixes':      '_cmdClose',
+                   'addresses':  '_cmdRefs',
+                   're':         '_cmdRefs',
+                   'references': '_cmdRefs',
+                   'refs':       '_cmdRefs',
+                   'see':        '_cmdRefs'}
+
+# Regexps are extended to include "(1)" and "(spent 1)".
+ticket_prefix = '(?:#|(?:ticket|issue|bug)[: ]?)'
+time_pattern = r'[ ]?(?:\((?:(?:spent|sp)[ ]?)?(-?[0-9]*(?:\.[0-9]+)?)\))?'
+ticket_reference = ticket_prefix + '[0-9]+' + time_pattern
+support_cmds_pattern = '|'.join(_supported_cmds.keys())
+
+# Relative to upstream, only match command tokens (rather than
+# matching all words).
+ticket_command =  (r'(?P<action>(?:%s))[ ]*'
+                   '(?P<ticket>%s(?:(?:[, &]*|[ ]?and[ ]?)%s)*)' %
+                   (support_cmds_pattern, ticket_reference, ticket_reference))
+
+if options.envelope:
+    ticket_command = r'\%s%s\%s' % (options.envelope[0], ticket_command,
+                                    options.envelope[1])
+    
+# Because we build the regexp to recognize only supported commands,
+# ignore case here.
+command_re = re.compile(ticket_command, re.IGNORECASE)
+ticket_re = re.compile(ticket_prefix + '([0-9]+)' + time_pattern, re.IGNORECASE)
+
+class CommitHook:
+    def __init__(self, project=options.project, author=options.user,
+                 rev=options.rev, url=options.url):
+        self.env = open_environment(project)
+        repos = self.env.get_repository()
+        repos.sync()
+        
+        # Instead of bothering with the encoding, we'll use unicode data
+        # as provided by the Trac versioncontrol API (#1310).
+        try:
+            chgset = repos.get_changeset(rev)
+        except NoSuchChangeset:
+            return # out of scope changesets are not cached
+        self.author = chgset.author
+        self.rev = rev
+        self.msg = "(In [%s]) %s" % (rev, chgset.message)
+        self.now = datetime.now(utc)
+
+        cmd_groups = command_re.findall(self.msg)
+
+        log ("cmd_groups:%s", cmd_groups)
+        tickets = {}
+        # \todo Explain what xxx1 and xxx2 do; I can't see more params
+        # in command_re.
+        for cmd, tkts, xxx1, xxx2 in cmd_groups:
+            log ("cmd:%s, tkts%s ", cmd, tkts)
+            funcname = _supported_cmds.get(cmd.lower(), '')
+            if funcname:
+                for tkt_id, spent in ticket_re.findall(tkts):
+                    func = getattr(self, funcname)
+                    tickets.setdefault(tkt_id, []).append([func, spent])
+
+        for tkt_id, vals in tickets.iteritems():
+            log ("tkt_id:%s, vals%s ", tkt_id, vals)
+            spent_total = 0.0
+            try:
+                db = self.env.get_db_cnx()
+                
+                ticket = Ticket(self.env, int(tkt_id), db)
+                for (cmd, spent) in vals:
+                    cmd(ticket)
+                    if spent:
+                        spent_total += float(spent)
+
+                # determine sequence number... 
+                cnum = 0
+                tm = TicketModule(self.env)
+                for change in tm.grouped_changelog_entries(ticket, db):
+                    if change['permanent']:
+                        cnum += 1
+                
+                if spent_total:
+                    self._setTimeTrackerFields(ticket, spent_total)
+                ticket.save_changes(self.author, self.msg, self.now, db, cnum+1)
+                db.commit()
+                
+                tn = TicketNotifyEmail(self.env)
+                tn.notify(ticket, newticket=0, modtime=self.now)
+            except Exception, e:
+                # import traceback
+                # traceback.print_exc(file=sys.stderr)
+                log('Unexpected error while processing ticket ' \
+                                   'ID %s: %s' % (tkt_id, e))
+                print>>sys.stderr, 'Unexpected error while processing ticket ' \
+                                   'ID %s: %s' % (tkt_id, e)
+            
+
+    def _cmdClose(self, ticket):
+        ticket['status'] = 'closed'
+        ticket['resolution'] = 'fixed'
+
+    def _cmdRefs(self, ticket):
+        pass
+
+    def _setTimeTrackerFields(self, ticket, spent):
+        log ("Setting ticket:%s spent: %s", ticket, spent)
+        if (spent != ''):
+            spentTime = float(spent)
+            # \bug If the ticket has not been modified since
+            # TimingAndEstimation was installed, then it might not
+            # have hours.  It should still get hours applied because
+            # estimating and recording are separate.
+            if (ticket.values.has_key('hours')):
+                ticket['hours'] = str(spentTime)
+
+if __name__ == "__main__":
+    if len(sys.argv) < 5:
+        print "For usage: %s --help" % (sys.argv[0])
+        print
+        print "Note that the deprecated options will be removed in Trac 0.12."
+    else:
+        CommitHook()