keithsalisbury-subtrac 0.1.1

data/lib/subtrac/trac-plugins/estimationtoolsplugin/estimationtools/htdocs/jquery.jeditable.mini.js

@@ -0,0 +1,30 @@
+
+(function($){$.fn.editable=function(target,options){var settings={target:target,name:'value',id:'id',type:'text',width:'auto',height:'auto',event:'click',onblur:'cancel',loadtype:'GET',loadtext:'Loading...',placeholder:'Click to edit',loaddata:{},submitdata:{}};if(options){$.extend(settings,options);}
+var plugin=$.editable.types[settings.type].plugin||function(){};var submit=$.editable.types[settings.type].submit||function(){};var buttons=$.editable.types[settings.type].buttons||$.editable.types['defaults'].buttons;var content=$.editable.types[settings.type].content||$.editable.types['defaults'].content;var element=$.editable.types[settings.type].element||$.editable.types['defaults'].element;var reset=$.editable.types[settings.type].reset||$.editable.types['defaults'].reset;var callback=settings.callback||function(){};if(!$.isFunction($(this)[settings.event])){$.fn[settings.event]=function(fn){return fn?this.bind(settings.event,fn):this.trigger(settings.event);}}
+$(this).attr('title',settings.tooltip);settings.autowidth='auto'==settings.width;settings.autoheight='auto'==settings.height;return this.each(function(){var self=this;var savedwidth=$(self).width();var savedheight=$(self).height();if(!$.trim($(this).html())){$(this).html(settings.placeholder);}
+$(this)[settings.event](function(e){if(self.editing){return;}
+if(0==$(self).width()){settings.width=savedwidth;settings.height=savedheight;}else{if(settings.width!='none'){settings.width=settings.autowidth?$(self).width():settings.width;}
+if(settings.height!='none'){settings.height=settings.autoheight?$(self).height():settings.height;}}
+if($(this).html().toLowerCase().replace(/;/,'')==settings.placeholder.toLowerCase().replace(/;/,'')){$(this).html('');}
+self.editing=true;self.revert=$(self).html();$(self).html('');var form=$('<form/>');if(settings.cssclass){if('inherit'==settings.cssclass){form.attr('class',$(self).attr('class'));}else{form.attr('class',settings.cssclass);}}
+if(settings.style){if('inherit'==settings.style){form.attr('style',$(self).attr('style'));form.css('display',$(self).css('display'));}else{form.attr('style',settings.style);}}
+var input=element.apply(form,[settings,self]);var input_content;if(settings.loadurl){var t=setTimeout(function(){input.disabled=true;content.apply(form,[settings.loadtext,settings,self]);},100);var loaddata={};loaddata[settings.id]=self.id;if($.isFunction(settings.loaddata)){$.extend(loaddata,settings.loaddata.apply(self,[self.revert,settings]));}else{$.extend(loaddata,settings.loaddata);}
+$.ajax({type:settings.loadtype,url:settings.loadurl,data:loaddata,async:false,success:function(result){window.clearTimeout(t);input_content=result;input.disabled=false;}});}else if(settings.data){input_content=settings.data;if($.isFunction(settings.data)){input_content=settings.data.apply(self,[self.revert,settings]);}}else{input_content=self.revert;}
+content.apply(form,[input_content,settings,self]);input.attr('name',settings.name);buttons.apply(form,[settings,self]);$(self).append(form);plugin.apply(form,[settings,self]);$(':input:visible:enabled:first',form).focus();if(settings.select){input.select();}
+input.keydown(function(e){if(e.keyCode==27){e.preventDefault();reset.apply(form,[settings,self]);}});var t;if('cancel'==settings.onblur){input.blur(function(e){t=setTimeout(function(){reset.apply(form,[settings,self]);},500);});}else if('submit'==settings.onblur){input.blur(function(e){form.submit();});}else if($.isFunction(settings.onblur)){input.blur(function(e){settings.onblur.apply(self,[input.val(),settings]);});}else{input.blur(function(e){});}
+form.submit(function(e){if(t){clearTimeout(t);}
+e.preventDefault();if(false!==submit.apply(form,[settings,self])){if($.isFunction(settings.target)){var str=settings.target.apply(self,[input.val(),settings]);$(self).html(str);self.editing=false;callback.apply(self,[self.innerHTML,settings]);if(!$.trim($(self).html())){$(self).html(settings.placeholder);}}else{var submitdata={};submitdata[settings.name]=input.val();submitdata[settings.id]=self.id;if($.isFunction(settings.submitdata)){$.extend(submitdata,settings.submitdata.apply(self,[self.revert,settings]));}else{$.extend(submitdata,settings.submitdata);}
+if('PUT'==settings.method){submitdata['_method']='put';}
+$(self).html(settings.indicator);$.post(settings.target,submitdata,function(str){$(self).html(str);self.editing=false;callback.apply(self,[self.innerHTML,settings]);if(!$.trim($(self).html())){$(self).html(settings.placeholder);}});}}
+return false;});});this.reset=function(){$(self).html(self.revert);self.editing=false;if(!$.trim($(self).html())){$(self).html(settings.placeholder);}}});};$.editable={types:{defaults:{element:function(settings,original){var input=$('<input type="hidden">');$(this).append(input);return(input);},content:function(string,settings,original){$(':input:first',this).val(string);},reset:function(settings,original){original.reset();},buttons:function(settings,original){var form=this;if(settings.submit){if(settings.submit.match(/>$/)){var submit=$(settings.submit).click(function(){if(submit.attr("type")!="submit"){form.submit();}});}else{var submit=$('<button type="submit">');submit.html(settings.submit);}
+$(this).append(submit);}
+if(settings.cancel){if(settings.cancel.match(/>$/)){var cancel=$(settings.cancel);}else{var cancel=$('<button type="cancel">');cancel.html(settings.cancel);}
+$(this).append(cancel);$(cancel).click(function(event){if($.isFunction($.editable.types[settings.type].reset)){var reset=$.editable.types[settings.type].reset;}else{var reset=$.editable.types['defaults'].reset;}
+reset.apply(form,[settings,original]);return false;});}}},text:{element:function(settings,original){var input=$('<input>');if(settings.width!='none'){input.width(settings.width);}
+if(settings.height!='none'){input.height(settings.height);}
+input.attr('autocomplete','off');$(this).append(input);return(input);}},textarea:{element:function(settings,original){var textarea=$('<textarea>');if(settings.rows){textarea.attr('rows',settings.rows);}else{textarea.height(settings.height);}
+if(settings.cols){textarea.attr('cols',settings.cols);}else{textarea.width(settings.width);}
+$(this).append(textarea);return(textarea);}},select:{element:function(settings,original){var select=$('<select>');$(this).append(select);return(select);},content:function(string,settings,original){if(String==string.constructor){eval('var json = '+string);for(var key in json){if(!json.hasOwnProperty(key)){continue;}
+if('selected'==key){continue;}
+var option=$('<option>').val(key).append(json[key]);$('select',this).append(option);}}
+$('select',this).children().each(function(){if($(this).val()==json['selected']||$(this).text()==original.revert){$(this).attr('selected','selected');};});}}},addInputType:function(name,input){$.editable.types[name]=input;}};})(jQuery);

data/lib/subtrac/trac-plugins/estimationtoolsplugin/estimationtools/templates/edithours.html

@@ -0,0 +1,53 @@
+<script type="text/javascript" xmlns="http://www.w3.org/1999/xhtml"
+      xmlns:xi="http://www.w3.org/2001/XInclude"
+      xmlns:py="http://genshi.edgewall.org/" py:strip="">
+$(document).ready(function() {
+    var reportMethod = $('td.ticket'); //used in Trac reports
+    var queryMethod = $('td.id');      //used in custom queries
+    var xmlrpcPath = null;
+    var elements   = null;
+    if ( reportMethod.length != 0 ) {
+      elements   = reportMethod;
+      xmlrpcPath = '../xmlrpc';
+    } else if ( queryMethod.length != 0 ) {
+      elements   = queryMethod;
+      xmlrpcPath = 'xmlrpc';
+    }
+    if ( elements != null ) {
+      ids = elements.each(function(i) {
+        var id = jQuery.trim($(this).text()).substr(1);
+       	var estimationField = '$data.field';
+
+	   	var estimationCell = $('td.' + estimationField).eq(i);
+
+	   	estimationCell.editable(function(value, settings) {
+        var currentElement = this;
+        $.ajax({
+        	type: 'POST',
+        	url: xmlrpcPath,
+          	data: '<methodCall><methodName>ticket.update</methodName>' +
+       	 	'<params><param><value><int>' + id + '</int></value></param>' +
+       	   	'<param><value><string></string></value></param>' +
+       	   	'<param><value><struct><member><name>' + estimationField + '</name>' +
+       	   	'<value><string>' + value + '</string></value></member></struct></value></param>' +
+       	   	'</params></methodCall>',
+          	contentType: 'text/xml',
+          	success: function(){
+            	$(currentElement).text(value);
+          }
+         });
+         return('Saving...');
+       }, {
+    	 data : jQuery.trim(estimationCell.text()),
+         tooltip   : 'Click to edit...',
+         placeholder: '',
+         onblur : 'submit',
+         select : 'true',
+         style : 'inherit',
+         width     : 60
+       }); 
+    });
+    }
+ });
+ </script>
+ 

data/lib/subtrac/trac-plugins/estimationtoolsplugin/estimationtools/tests/burndownchart.py

@@ -0,0 +1,181 @@
+from decimal import Decimal
+from datetime import datetime, timedelta
+from estimationtools.burndownchart import BurndownChart
+from estimationtools.utils import parse_options
+from trac.test import EnvironmentStub, MockPerm, Mock
+from trac.ticket.model import Ticket
+from trac.util.datefmt import utc
+from trac.web.href import Href
+import unittest
+
+
+class BurndownChartTestCase(unittest.TestCase):
+    
+    def setUp(self):
+        self.env = EnvironmentStub(default_data = True)
+        self.env.config.set('ticket-custom', 'hours_remaining', 'text')
+        self.env.config.set('estimation-tools', 'estimation_field', 'hours_remaining')
+        self.req = Mock(href = Href('/'),
+                        abs_href = Href('http://www.example.com/'),
+                        perm = MockPerm(),
+                        authname='anonymous')
+        
+    def _insert_ticket(self, estimation):
+        ticket = Ticket(self.env)
+        ticket['summary'] = 'Test Ticket'
+        ticket['hours_remaining'] = estimation
+        ticket['milestone'] = 'milestone1'
+        return ticket.insert()
+
+    def _change_ticket_estimations(self, id, history):
+        ticket = Ticket(self.env, id)
+        keys = history.keys()
+        keys.sort()
+        for key in keys:
+            ticket['hours_remaining'] = history[key]
+            ticket.save_changes("me", "testing", datetime.combine(key, datetime.now(utc).timetz()))
+            
+    def _change_ticket_states(self, id, history):
+        ticket = Ticket(self.env, id)
+        keys = history.keys()
+        keys.sort()
+        for key in keys:
+            ticket['status'] = history[key]
+            ticket.save_changes("me", "testing", datetime.combine(key, datetime.now(utc).timetz()))       
+            
+    def test_parse_options(self):
+        db = self.env.get_db_cnx()
+        options, query_args = parse_options(db, "milestone=milestone1, startdate=2008-02-20, enddate=2008-02-28", {})
+        self.assertNotEqual(query_args['milestone'], None)
+        self.assertNotEqual(options['startdate'], None)
+        self.assertNotEqual(options['enddate'], None)
+        
+    def test_build_empty_chart(self):
+        chart = BurndownChart(self.env)
+        db = self.env.get_db_cnx()
+        options, query_args = parse_options(db, "milestone=milestone1, startdate=2008-02-20, enddate=2008-02-28", {})
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        xdata, ydata, maxhours = chart._scale_data(timetable, options)
+        self.assertEqual(xdata, ['0.00', '12.50', '25.00', '37.50', '50.00', '62.50', '75.00', '87.50', '100.00'])
+        self.assertEqual(ydata, ['0.00', '0.00', '0.00', '0.00', '0.00', '0.00', '0.00', '0.00', '0.00'])
+        self.assertEqual(maxhours, Decimal(100))
+        
+    def test_build_zero_day_chart(self):
+        chart = BurndownChart(self.env)
+        # shouldn't throw
+        chart.render_macro(self.req, "", "startdate=2008-01-01, enddate=2008-01-01")
+        
+    def test_calculate_timetable_simple(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        self._insert_ticket('10')
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(10), day3: Decimal(10)})
+        
+    def test_calculate_timetable_without_milestone(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        self._insert_ticket('10')
+        timetable = chart._calculate_timetable(options, {}, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(10), day3: Decimal(10)})
+        
+    def test_calculate_timetable_with_simple_changes(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        ticket1 = self._insert_ticket('10')
+        self._change_ticket_estimations(ticket1, {day2:'5', day3:'0'})
+     
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(5), day3: Decimal(0)})
+        
+    def test_calculate_timetable_with_closed_ticket(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        ticket1 = self._insert_ticket('10')
+        self._change_ticket_estimations(ticket1, {day2:'5'})
+        self._change_ticket_states(ticket1, {day3: 'closed'})
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(5), day3: Decimal(0)})
+
+    def test_calculate_timetable_with_closed_ticket2(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        ticket1 = self._insert_ticket('10')
+        self._change_ticket_states(ticket1, {day2: 'closed'})
+        self._change_ticket_estimations(ticket1, {day3:'5'})
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(0), day3: Decimal(0)})
+
+    def test_calculate_timetable_with_closed_and_reopened_ticket(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        day4 = day3 + timedelta(days=1)
+        options = {'today': day4, 'startdate': day1, 'enddate': day4, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        ticket1 = self._insert_ticket('10')
+        self._change_ticket_estimations(ticket1, {day3:'5'})
+        self._change_ticket_states(ticket1, {day2: 'closed', day4: 'new'})
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(0), day3: Decimal(0), day4: Decimal(5)})
+        
+    def test_calculate_timetable_with_simple_changes_2(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        ticket1 = self._insert_ticket('10')
+        self._change_ticket_estimations(ticket1, {day2:'5', day3:''})
+        ticket2 = self._insert_ticket('0')
+        self._change_ticket_estimations(ticket2, {day2:'1', day3:'2'})
+     
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(6), day3: Decimal(2)})
+
+    def test_calculate_timetable_with_recent_changes(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        day4 = day3 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        ticket1 = self._insert_ticket('10')
+        self._change_ticket_estimations(ticket1, {day2:'5', day4:''})
+     
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(5), day3: Decimal(5)})
+    
+    def test_calculate_timetable_with_gibberish_estimates(self):
+        chart = BurndownChart(self.env)
+        day1 = datetime.now(utc).date()
+        day2 = day1 + timedelta(days=1)
+        day3 = day2 + timedelta(days=1)
+        options = {'today': day3, 'startdate': day1, 'enddate': day3, 'closedstates': ['closed']}
+        query_args = {'milestone': "milestone1"}
+        ticket1 = self._insert_ticket('10')
+        self._change_ticket_estimations(ticket1, {day2: 'IGNOREME', day3:'5'})
+        timetable = chart._calculate_timetable(options, query_args, self.req)
+        self.assertEqual(timetable, {day1: Decimal(10), day2: Decimal(10), day3: Decimal(5)})

data/lib/subtrac/trac-plugins/estimationtoolsplugin/estimationtools/tests/hoursremaining.py

@@ -0,0 +1,66 @@
+from estimationtools.hoursremaining import HoursRemaining
+from trac.test import EnvironmentStub, Mock, MockPerm
+from trac.ticket.model import Ticket
+from trac.web.href import Href
+import unittest
+
+
+class HoursRemainingTestCase(unittest.TestCase):
+    
+    def setUp(self):
+        self.env = EnvironmentStub(default_data = True)
+        self.env.config.set('ticket-custom', 'hours_remaining', 'text')
+        self.env.config.set('estimation-tools', 'estimation_field', 'hours_remaining')
+        self.req = Mock(href = Href('/'),
+                        abs_href = Href('http://www.example.com/'),
+                        perm = MockPerm(),
+                        authname='anonymous')
+       
+    def _insert_ticket(self, estimation, status='open'):
+        ticket = Ticket(self.env)
+        ticket['summary'] = 'Test Ticket'
+        ticket['hours_remaining'] = estimation
+        ticket['milestone'] = 'milestone1'
+        ticket['status'] = status
+        return ticket.insert()
+
+    def test_basic(self):
+        hoursRemaining = HoursRemaining(self.env)
+        self._insert_ticket('10')
+        self._insert_ticket('20')
+        self._insert_ticket('30')
+        result = hoursRemaining.render_macro(self.req, "", "milestone=milestone1")
+        self.assertEqual(result, '60')
+
+    def test_real(self):
+        hoursRemaining = HoursRemaining(self.env)
+        self._insert_ticket('10')
+        self._insert_ticket('20.1')
+        self._insert_ticket('30')
+        result = hoursRemaining.render_macro(self.req, "", "milestone=milestone1")
+        self.assertEqual(result, '60')
+
+    def test_invalid(self):
+        hoursRemaining = HoursRemaining(self.env)
+        self._insert_ticket('10')
+        self._insert_ticket('20')
+        self._insert_ticket('30')
+        self._insert_ticket('xxx')
+        result = hoursRemaining.render_macro(self.req, "", "milestone=milestone1")
+        self.assertEqual(result, '60')
+
+    def test_closed_tickets(self):
+        hoursRemaining = HoursRemaining(self.env)
+        self._insert_ticket('10')
+        self._insert_ticket('20.1')
+        self._insert_ticket('30')
+        self._insert_ticket('30', status='closed')
+        result = hoursRemaining.render_macro(self.req, "", "status!=closed, milestone=milestone1")
+        self.assertEqual(result, '60')
+
+    def test_to_many_tickets(self):
+        hoursRemaining = HoursRemaining(self.env)
+        for _ in range(200):
+            self._insert_ticket('1')
+        result = hoursRemaining.render_macro(self.req, "", "milestone=milestone1")
+        self.assertEqual(result, '200')

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

@@ -0,0 +1,47 @@
+from estimationtools.workloadchart import WorkloadChart
+from trac.test import EnvironmentStub, Mock, MockPerm
+from trac.ticket.model import Ticket
+from trac.web.href import Href
+import unittest
+
+
+class WorkloadChartTestCase(unittest.TestCase):
+    
+    def setUp(self):
+        self.env = EnvironmentStub(default_data = True)
+        self.env.config.set('ticket-custom', 'hours_remaining', 'text')
+        self.env.config.set('estimation-tools', 'estimation_field', 'hours_remaining')
+        self.req = Mock(href = Href('/'),
+                        abs_href = Href('http://www.example.com/'),
+                        perm = MockPerm(),
+                        authname='anonymous')
+       
+    def _insert_ticket(self, estimation, owner):
+        ticket = Ticket(self.env)
+        ticket['summary'] = 'Test Ticket'
+        ticket['owner'] = owner
+        ticket['hours_remaining'] = estimation
+        ticket['milestone'] = 'milestone1'
+        return ticket.insert()
+
+    def test_basic(self):
+        workload_chart = WorkloadChart(self.env)
+        self._insert_ticket('10', 'A')
+        self._insert_ticket('20', 'B')
+        self._insert_ticket('30', 'C')
+        result = workload_chart.render_macro(self.req, "", "milestone=milestone1")
+        self.assertEqual(result, u'<img src="http://chart.apis.google.com/chart?chs=400x100&amp;'\
+                         'chf=bg,s,00000000&amp;chd=t:10,30,20&amp;cht=p3&amp;chtt=Workload 60h (1 workdays left)&amp;'\
+                         'chl=A 10h|C 30h|B 20h&amp;chco=ff9900" alt=\'Workload Chart\' />')
+
+    def test_invalid_value(self):
+        workload_chart = WorkloadChart(self.env)
+        self._insert_ticket('10', 'A')
+        self._insert_ticket('10', 'B')
+        self._insert_ticket('10', 'B')
+        self._insert_ticket('30', 'C')
+        self._insert_ticket('xxx', 'D')
+        result = workload_chart.render_macro(self.req, "", "milestone=milestone1")
+        self.assertEqual(result, u'<img src="http://chart.apis.google.com/chart?chs=400x100&amp;'\
+                         'chf=bg,s,00000000&amp;chd=t:10,30,20&amp;cht=p3&amp;chtt=Workload 60h (1 workdays left)&amp;'\
+                         'chl=A 10h|C 30h|B 20h&amp;chco=ff9900" alt=\'Workload Chart\' />' )

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

@@ -0,0 +1,93 @@
+from datetime import datetime
+from time import strptime
+from trac.config import Option, ListOption
+from trac.core import TracError
+from trac.wiki.api import parse_args
+from trac.ticket.query import Query
+
+AVAILABLE_OPTIONS = ['startdate', 'enddate', 'today', 'width', 'height', 
+                     'color', 'bgcolor', 'wecolor', 'weekends', 'gridlines',
+                     'expected', 'colorexpected']
+
+def get_estimation_field():
+    return Option('estimation-tools', 'estimation_field', 'estimatedhours',
+        doc="""Defines what custom field should be used to calculate estimation charts.
+        Defaults to 'estimatedhours'""")
+
+def get_closed_states():
+    return ListOption('estimation-tools', 'closed_states', 'closed',
+        doc="""Set to a comma separated list of workflow states that count as "closed",
+        where the effort will be treated as zero, e.g. closed_states=closed,another_state.
+        Defaults to closed.""")
+
+def get_estimation_suffix():
+    return Option('estimation-tools', 'estimation_suffix', 'h',
+        doc="""Suffix used for estimations. Defaults to 'h'""")
+
+def parse_options(db, content, options):
+    """Parses the parameters, makes some sanity checks, and creates default values
+    for missing parameters.
+    """
+    cursor = db.cursor()
+
+    # check arguments
+    _, parsed_options = parse_args(content, strict=False)
+
+    options.update(parsed_options)
+
+    startdatearg = options.get('startdate')
+    if startdatearg:
+        options['startdate'] = datetime(*strptime(startdatearg, "%Y-%m-%d")[0:5]).date()
+
+    enddatearg = options.get('enddate')
+    options['enddate'] = None
+    if enddatearg:
+        options['enddate'] = datetime(*strptime(enddatearg, "%Y-%m-%d")[0:5]).date()
+
+    if not options['enddate'] and options.get('milestone'):
+        # use first milestone
+        milestone = options['milestone'].split('|')[0]
+        # try to get end date from db
+        cursor.execute("SELECT completed, due FROM milestone WHERE name = %s", [milestone])
+        row = cursor.fetchone()
+        if not row:
+            raise TracError("Couldn't find milestone %s" % (milestone))
+        if row[0]:
+            options['enddate'] = datetime.fromtimestamp(row[0]).date()
+        elif row[1]:
+            options['enddate'] = datetime.fromtimestamp(row[1]).date()
+
+    if not options['enddate']:
+            options['enddate'] = datetime.now().date()
+    todayarg = options.get('today')
+    if not todayarg:
+        options['today'] = datetime.now().date()
+        
+    if options.get('weekends'):
+        options['weekends'] = parse_bool(options['weekends'] )
+
+    # all arguments that are no key should be treated as part of the query
+    query_args = {}
+    for key in options.keys():
+        if not key in AVAILABLE_OPTIONS:
+            query_args[key] = options[key]
+    return options, query_args
+
+def execute_query(env, req, query_args):
+    # set maximum number of returned tickets to 0 to get all tickets at once
+    query_args['max'] = 0
+    query_string = '&'.join(['%s=%s' % item for item in query_args.iteritems()])
+    query = Query.from_string(env, query_string)
+
+    tickets = query.execute(req)
+
+    tickets = [t for t in tickets
+               if ('TICKET_VIEW' or 'TICKET_VIEW_CC') in req.perm('ticket', t['id'])]
+
+    return tickets
+
+def parse_bool(s):
+    if s is True or s is False:
+        return s
+    s = str(s).strip().lower()
+    return not s in ['false','f','n','0','']