keithsalisbury-subtrac 0.1.1

data/lib/subtrac/trac-plugins/timingandestimationplugin/timingandestimationplugin/htdocs/linkifyer.js

@@ -0,0 +1,119 @@
+
+//var linkify = 
+//(function(){
+   String.prototype.trim = 
+      (function () {return this.replace(/^\s+/, "").replace(/\s+$/, "");});
+   var invalidDate = new Date("invalid").toString()
+   var billingfields= {}
+   var statusfields = []
+   function dateToUnixEpoch(date){
+      return Math.round(date.getTime()/1000) - (60 * date.getTimezoneOffset());
+   }
+   function addBillingField( name /*optional type defaults to "textbox", optional flag status*/ ){
+      var type = arguments.length >= 1 ? arguments[1] : "textbox";
+      var status = arguments.length >= 2 ? arguments[2] : false; 
+      var getSet = 
+	 (function(){
+	    var valueProp = "value";
+	    
+	    if(type == "date"){
+	       return function (/*optional value*/){
+		  if(arguments.length == 0){
+		     var d = new Date(this.$()[valueProp]);
+		     if(d.toString == invalidDate){
+			alert("You entered an invalid "+name);
+			return null;
+		     }
+		     return dateToUnixEpoch(d);
+		  }
+		  else{
+		     var val = new Date(arguments[0]);
+		     if(val.toString == invalidDate){
+			this.$()[valueProp] = null;
+			return null;
+		     }
+		     this.$()[valueProp] = val;
+		     return val;
+		  }
+	       }
+	    }
+	    //FOR EVERYTHING ELSE
+	    if(type == "checkbox"){
+	       valueProp = "checked";
+	    }
+	    return function (/*optional value*/){
+	       //alert(name+" : "+type+" "+valueProp);
+	       if(arguments.length == 0){
+		  var val = (this.$())[valueProp];
+		  
+		  if(typeof(val) == "string") val = val.trim();
+		  if(val)return val;
+		  return null;
+	       }
+	       else{
+		  var val = arguments[0];
+		  (this.$())[valueProp] = val;
+		  return val
+	       }
+	    }
+	 })()
+      billingfields[name] = {
+	 "$" : function(){
+	    return document.getElementById(name);
+	 },
+         getval : getSet,
+	 setval : getSet
+      };
+      if (status){
+	 statusfields.push({
+	      name:name,
+	      "$" : function(){
+		  return document.getElementById(name);
+	      },
+	      getval : getSet,
+	      setval : getSet
+	 });
+      }
+   }
+
+   addBillingField("billable", "checkbox");
+   addBillingField("unbillable", "checkbox");
+   addBillingField("startdate", "date");
+   addBillingField("startbilling", "dateselect");
+   addBillingField("enddate", "date");
+   addBillingField("endbilling", "dateselect");
+   
+
+   var linkify = function ( atag, basehref ){
+      var query = "";
+      var haveAdded = false;
+      function addToQuery(str){
+	 query += haveAdded ? "&" : "?";
+	 query += str;
+	 haveAdded = true;
+      }
+      //billable logic
+      addToQuery(billingfields["billable"].getval() || !(billingfields["unbillable"].getval())
+		 ? "BILLABLE=1" : "BILLABLE=0");
+      addToQuery(billingfields["unbillable"].getval() || !(billingfields["billable"].getval())
+		 ? "UNBILLABLE=0" : "UNBILLABLE=1");
+
+      for(var i=0, f = null ; f = statusfields[i] ; i++){
+	 val = f.name.toUpperCase().replace("_","", "g").replace(" ","","g")+"=";
+	 if(f.getval()){
+	    val += f.name
+	 }
+	 addToQuery(val);
+      }
+
+      //startdate the date in the text box or the date in the dropdown or the first time
+      startdate = billingfields["startdate"].getval() || billingfields["startbilling"].getval() || 0;
+      addToQuery("STARTDATE="+startdate);
+      //the date in the enddate text box or the date in the enddate billing box or real close to the end of integer unix epoch time
+      // this will need a patch to continue working  past this point
+      enddate = billingfields["enddate"].getval() || billingfields["endbilling"].getval() || 2000000000;
+      addToQuery("ENDDATE="+enddate);
+
+      atag.href = basehref+query;
+   }
+//})()

data/lib/subtrac/trac-plugins/timingandestimationplugin/timingandestimationplugin/htdocs/query.js

@@ -0,0 +1,73 @@
+(function(){
+   function AddEventListener( elem, evt, func, capture){
+      capture = capture || false;
+      if(elem.addEventListener) elem.addEventListener( evt, func, capture);
+      else elem.attachEvent('on'+evt, func);
+      return func;
+   };
+   var InitQuery = function(){
+      function createTableRow( numTds ){
+	 var tr = document.createElement('tr');
+	 var td = document.createElement('td');
+	 td.style.backgroundColor="#EEF";
+	 for(var i=0 ; i < numTds ; i++){
+	    tr.appendChild(td.cloneNode(true));
+	 }
+	 return tr;
+      }
+
+      var _tbls = document.getElementsByTagName('table');
+      var tbls = [], tbl, cell;
+      // filter so that we only get ticket listing tables
+      for(var i=0 ; tbl = _tbls[i] ; i++ ){
+	 if(tbl.className == 'listing tickets') tbls.push(tbl);
+      }
+
+      // find numerical columns
+      tbl = tbls[0];
+      
+      var cells = tbl.tBodies[0].rows[0].cells;
+      var cellIdxs = [], columnNames = {};
+      for(var i=0 ; cell = cells[i] ; i++ ){
+	 if(!isNaN(Number(cells[i].textContent))){
+	    cellIdxs.push(i);
+	    if(tbl && tbl.tHead.rows.length > 0)
+	       columnNames[i] = tbl.tHead.rows[0].cells[i].textContent;
+	 }
+      }
+
+      // total the numerical columns and add a total row to each table
+      var totals, total_totals =[], idx;
+      for(var i=0 ; tbl = tbls[i] ; i++ ){
+	 totals = [];
+	 for(var k=0 ; row = tbl.tBodies[0].rows[k] ; k++){
+	    for(var j=0 ; idx = cellIdxs[j] ; j++){
+	       if(totals[idx] == null) totals[idx] = 0;
+	       if(total_totals[idx] == null) total_totals[idx] = 0;
+	       if(!isNaN(Number(row.cells[idx].textContent)))
+		  var val = Number(row.cells[idx].textContent);
+		  total_totals[idx] += val
+                  totals[idx] += val;
+	    }
+	 }
+	 if(tbl.tBodies[0].rows.length > 0){
+	    var tr = createTableRow(tbl.tBodies[0].rows[0].cells.length);
+	    for(var j=0 ; idx = cellIdxs[j] ; j++){
+	       tr.cells[idx].appendChild(document.createTextNode(totals[idx])); 
+	    }
+	    tbl.tBodies[0].appendChild(tr);
+	 }
+      }
+      // If we are grouping by things, we are going to want to add a complete total to the bottom
+      if(tbls.length > 1){
+	 var totalHtml = document.createElement('div');
+	 totalHtml.style.backgroundColor="#EEF";
+	 for(var j=0 ; idx = cellIdxs[j] ; j++){
+	    totalHtml.appendChild(document.createTextNode("Total "+columnNames[idx]+": "+total_totals[idx])); 
+	    totalHtml.appendChild(document.createElement('br'));
+	 }
+	 tbls[0].parentNode.appendChild(totalHtml);
+      }
+   }
+   AddEventListener(window, 'load', InitQuery)
+})()

data/lib/subtrac/trac-plugins/timingandestimationplugin/timingandestimationplugin/htdocs/ticket.js

@@ -0,0 +1,165 @@
+(function(){
+   function teAddEventListener(elem, evt, func, capture)
+   {
+      capture = capture || false;
+      if (elem.addEventListener) elem.addEventListener(evt, func, capture);
+      else elem.attachEvent('on'+evt, func);
+      return func;
+   }
+   
+// Function from: http://www.robertnyman.com/index.php?p=256
+   function getElementsByClassName(className, tag, elm)
+   {
+      var testClass = new RegExp("(^|\\s)" + className + "(\\s|$)");
+      var tag = tag || "*";
+      var elm = elm || document;
+      var elements = (tag == "*" && elm.all)? elm.all : elm.getElementsByTagName(tag);
+      var returnElements = [];
+      var current;
+      var length = elements.length;
+      for (var i=0; i<length; i++)
+      {
+	 current = elements[i];
+	 if(testClass.test(current.className))
+	 {
+	    returnElements.push(current);
+	 }
+      }
+      return returnElements;
+   }
+   
+
+   function FloatToHoursMins(hours)
+   {
+      if (0 == hours) return hours;
+      var neg = false;
+      if(hours < 0){
+	 neg = true;
+	 hours *= -1;
+      }
+      mins = Math.floor((hours - Math.floor(hours)) * 60);
+      str = neg ? '-' : '';
+      if (hours) str += Math.floor(hours) + 'h';
+      if (mins)	 str += ' ' + mins + 'm';
+      return str;
+   }
+   
+   function IntToYesNo(boolflag)
+   {
+      if (boolflag == '1')
+	 return 'Yes';
+      
+      if (boolflag == '0')
+	 return 'No';
+      
+      return boolflag;
+   }
+   
+   
+   InitBilling = function(){
+      /*  // Convert totalhours field to non-editable
+      try
+      {
+	 var x = document.getElementById('totalhours');
+	 x = x || document.getElementById('field-totalhours');
+	 if (x)
+	 {
+	    var p = x.parentNode;
+	    var n = document.createElement('span')
+	       n.id = x.id;
+	    n.appendChild(document.createTextNode(x.value));
+	    p.removeChild(x);
+	    p.appendChild(n);
+	 }
+      }
+      catch (er) {}
+      */
+
+      // Display yes/no in the summary
+      // if we fail, then no harm done.
+      try
+      {
+	 var b = document.getElementById('h_billable');
+	 do{ b = b.nextSibling; }while(b.nodeName != "TD");
+	 b.innerHTML = IntToYesNo(b.innerHTML);
+      }
+      catch (er) {}
+  
+      /*
+      // Hide the Add Hours in the title table
+      // if we fail, then no harm done.
+      try
+      {
+	 var b = document.getElementById('h_hours');
+	 b.innerHTML = '';
+	 do{ b = b.nextSibling; }while(b.nodeName != "TD");
+	 b.innerHTML = '';
+      }
+      catch (er) {}
+      */
+      
+      // Convert hours from float to hours minutes seconds
+      // if we fail, then no harm done.
+      try
+      {
+	 fields = Array('estimatedhours', 'totalhours');
+	 for (var i=0; i < 2; ++i) 
+	 {
+	    var b = document.getElementById('h_' + fields[i]);
+	    while (b)
+	    {
+	       if (!b.nextSibling) break;
+	       b = b.nextSibling;
+	       if (b.nodeName == 'TD')
+	       {
+		  b.innerHTML = FloatToHoursMins(b.innerHTML);
+		  break;
+	       }
+	    }
+	 }
+      }
+      catch (er) {}
+      
+      // Convert all relevent ticket changes to hours/minutes
+      // if we fail, then no harm done.
+      try {
+	 changes = getElementsByClassName('changes', 'ul', document.getElementById('changelog'));
+	 var change, li;
+	 for (var i=0; change = changes[i]; i++) {
+	    for (var j=0, li = change.childNodes[j]; li = change.childNodes[j]; j++) {
+	       handleChangeRow(li); 
+	    }
+	 }
+      }
+      catch (er) {}
+   }
+
+   handleChangeRow = function(li){
+      var child, val, vals =[];
+      if (li.nodeName != 'LI') return;
+      // We look for a STRONG childNode
+      // We also need to find any em's following the STRONG
+      for(var i=0 ; child = li.childNodes[i] ; i++){
+	 if (child.nodeName == 'STRONG'){
+	    field = child.firstChild.nodeValue;
+	    if(!(field == 'hours'
+		 || field == 'estimatedhours'
+		 || field == 'totalhours'))
+	       return;
+	 }
+	 if (child.nodeName == 'EM'){
+	    vals.push([child, child.firstChild.nodeValue])
+	 } 
+      }
+      for(var i=0; val = vals[i] ; i++){
+	 out = FloatToHoursMins(Number(val[1]))
+	 //print(val[0]+'|'+ val[1] )
+	 //print("#"+ out)
+	 val[0].innerHTML = out
+      }
+      return vals;
+   }
+
+   teAddEventListener(window, 'load', InitBilling)
+})()
+

data/lib/subtrac/trac-plugins/timingandestimationplugin/timingandestimationplugin/query_webui.py

@@ -0,0 +1,28 @@
+import re
+from trac.log import logger_factory
+from trac.core import *
+from trac.web import IRequestHandler
+from trac.util import Markup
+from trac.web.chrome import add_stylesheet, add_script, \
+     INavigationContributor, ITemplateProvider
+from trac.web.href import Href
+
+class QueryWebUiAddon(Component):
+    implements(INavigationContributor)
+    
+    def __init__(self):
+        pass
+    
+     # INavigationContributor methods
+    def get_active_navigation_item(self, req):
+    
+        if re.search('query', req.path_info):
+            return "query-addon"
+        else:
+            return ""
+
+    def get_navigation_items(self, req):
+        src = req.href.chrome("Billing/query.js")
+        if re.search('query', req.path_info):
+            yield 'mainnav', "query-addon", \
+                  Markup("""<script language="javascript" type="text/javascript" src="%s"></script>"""%src)

data/lib/subtrac/trac-plugins/timingandestimationplugin/timingandestimationplugin/reportmanager.py

@@ -0,0 +1,221 @@
+from trac.core import *
+
+
+
+class CustomReportManager:
+  """A Class to manage custom reports"""
+  version = 1
+  name = "custom_report_manager_version"
+  env = None
+  log = None
+  TimingAndEstimationKey = "Timing and Estimation Plugin"
+  
+  def __init__(self, env, log):
+    self.env = env
+    self.log = log
+    self.upgrade()
+  
+  def upgrade(self):  
+    # Check to see what version we have
+    db = self.env.get_db_cnx()
+    cursor = db.cursor()
+    cursor.execute("SELECT value FROM system WHERE name=%s", (self.name,))
+    try:
+      version = int(cursor.fetchone()[0])
+    except:
+      version = 0
+      cursor.execute("INSERT INTO system (name,value) VALUES(%s,%s)",
+                     (self.name, version))
+        
+    if version > self.version:
+      raise TracError("Fatal Error: You appear to be running two plugins with conflicting versions "
+                      "of the CustomReportManager class. Please ensure that '%s' is updated to "
+                      "version %s of the file reportmanager.py (currently using version %s)."
+                      % (__name__, str(version), str(self.version)))
+    
+    # Do the staged updates
+    try:
+      if version < 1:
+        cursor.execute("CREATE TABLE custom_report ("
+                       "id         INTEGER,"
+                       "uuid       VARCHAR(64),"
+                       "maingroup  VARCHAR(255),"
+                       "subgroup   VARCHAR(255),"
+                       "version    INTEGER,"
+                       "ordering   INTEGER)")
+      
+      #if version < 2:
+      #  cursor.execute("...")
+    
+      # Updates complete, set the version
+      cursor.execute("UPDATE system SET value=%s WHERE name=%s", 
+                     (self.version, self.name))
+      db.commit()
+      db.close()
+    
+    except Exception, e:
+      self.log.error("CustomReportManager Exception: %s" % (e,));
+      db.rollback()
+
+  def get_report_id_and_version (self, uuid):
+    sql = "SELECT custom_report.id, custom_report.version FROM custom_report "\
+        "JOIN report ON report.id = custom_report.id " \
+        "WHERE uuid=%s"
+    tpl = self.get_first_row(sql, uuid)
+    return tpl or (None, 0)
+    
+  def get_new_report_id (self):
+    """find the next available report id """
+    rtn = self.get_scalar("SELECT MAX(id) FROM report")
+    return (rtn and rtn+1) or 1
+    
+  def get_max_ordering(self, maingroup, subgroup):
+    """ Find the maximum ordering value used for this group of the custom_report table"""
+    return self.get_scalar("SELECT MAX(ordering) FROM custom_report WHERE maingroup=%s AND subgroup=%s",
+                           0, maingroup, subgroup) or 0
+  
+  def _insert_report (self, next_id, title, author, description, query,
+                      uuid, maingroup, subgroup, version, ordering):
+    """ Adds a row the custom_report_table """
+    self.log.debug("Inserting new report '%s' with uuid '%s'" % (title,uuid))
+    self.execute_in_trans(("DELETE FROM custom_report WHERE uuid=%s", (uuid,)), 
+                          ("INSERT INTO report (id, title, author, description, query) " \
+                           "VALUES (%s, %s, %s, %s, %s)",
+                           (next_id, title, author, description, query)),
+                          ("INSERT INTO custom_report (id, uuid, maingroup, subgroup, version, ordering) " \
+                           "VALUES (%s, %s, %s, %s, %s, %s)",
+                           (next_id, uuid, maingroup, subgroup, version, ordering)))
+    self.log.debug("Attempting to increment sequence (only works in postgres)")
+    try:
+      self.execute_in_trans(("SELECT nextval('report_id_seq');",[]));
+      self.log.debug("Sequence updated");
+    except:
+      self.log.debug("Sequence failed to update, perhaps you are not running postgres?");
+
+  def _update_report (self, id, title, author, description, query,
+                      maingroup, subgroup, version):
+    """Updates a report and its row in the custom_report table """
+    self.log.debug("Updating report '%s' with to version %s" % (title, version))
+    self.execute_in_trans(("UPDATE report SET title=%s, author=%s, description=%s, query=%s " \
+                           "WHERE id=%s", (title, author, description, query, id)),
+                          ("UPDATE custom_report SET version=%s, maingroup=%s, subgroup=%s "
+                           "WHERE id=%s", (version, maingroup, subgroup, id)))
+    
+  def add_report(self, title, author, description, query, uuid, version,
+                 maingroup, subgroup="", force=False):
+    """
+    We add/update a report to the system. We will not overwrite unchanged versions
+    unless force is set.
+    """
+    # First check to see if we can load an existing version of this report
+    (id, currentversion) = self.get_report_id_and_version(uuid)
+    self.log.debug("add_report %s (ver:%s) | id: %s currentversion: %s" % (uuid , version, id, currentversion))
+    try:
+      if not id:
+        next_id = self.get_new_report_id()
+        ordering = self.get_max_ordering(maingroup, subgroup) + 1
+        self._insert_report(next_id, title, author, description, query,
+                      uuid, maingroup, subgroup, version, ordering)
+        return True
+      if currentversion < version or force:
+        self._update_report(id, title, author, description, query,
+                            maingroup, subgroup, version)
+        return True
+    except Exception, e:
+      self.log.error("CustomReportManager.add_report Exception: %s, %s" % (e,(title, author, uuid, version,
+                 maingroup, subgroup, force)));
+    self.log.debug("report %s not upgraded (a better version already exists)" % uuid)
+    return False
+  
+  def get_report_by_uuid(self, uuid):
+    sql = "SELECT report.id,report.title FROM custom_report "\
+          "LEFT JOIN report ON custom_report.id=report.id "\
+          "WHERE custom_report.uuid=%s"
+    return self.get_first_row(sql,uuid)
+
+  def get_reports_by_group(self, group):
+    """Gets all of the reports for a given group"""
+    db = self.env.get_db_cnx()
+    cursor = db.cursor()
+    rv = {}
+    try:
+      cursor.execute("SELECT custom_report.subgroup,report.id,report.title, custom_report.version, custom_report.uuid "
+                     "FROM custom_report "
+                     "LEFT JOIN report ON custom_report.id=report.id "
+                     "WHERE custom_report.maingroup=%s "
+                     "ORDER BY custom_report.subgroup,custom_report.ordering", (group,))
+      for subgroup, id, title, version, uuid in cursor:
+        if not rv.has_key(subgroup):
+          rv[subgroup] = { "title": subgroup,
+                           "reports": [] }
+        rv[subgroup]["reports"].append( { "id": int(id), "title": title, "version":version, "uuid":uuid } )
+    except:
+      pass
+    return rv
+  
+  def get_version_hash_by_group(self, group):
+    """Gets all of the reports for a given group as a uuid=>version hash"""
+    db = self.env.get_db_cnx()
+    cursor = db.cursor()
+    rv = {}
+    try:
+      cursor.execute("SELECT custom_report.subgroup,report.id,report.title, custom_report.version, custom_report.uuid "
+                     "FROM custom_report "
+                     "LEFT JOIN report ON custom_report.id=report.id "
+                     "WHERE custom_report.maingroup=%s "
+                     "ORDER BY custom_report.subgroup,custom_report.ordering", (group,))
+      for subgroup, id, title, version, uuid in cursor:
+        rv[uuid] = version
+    except:
+      pass
+    return rv
+
+  # similar functions are found in dbhelper, but this file should be fairly
+  # stand alone so that it can be copied and pasted around
+  def get_first_row(self, sql,*params):
+    """ Returns the first row of the query results as a tuple of values (or None)"""
+    db = self.env.get_db_cnx()
+    cur = db.cursor()
+    data = None;
+    try:
+      cur.execute(sql, params)
+      data = cur.fetchone();
+      db.commit();
+    except Exception, e:
+      self.log.error('There was a problem executing sql:%s \n \
+      with parameters:%s\nException:%s'%(sql, params, e));
+      db.rollback()
+    try:
+      db.close()
+    except:
+      pass
+    return data;
+
+  def get_scalar(self, sql, col=0, *params):
+    """ Gets a single value (in the specified column) from the result set of the query"""
+    data = self.get_first_row(sql, *params);
+    if data:
+      return data[col]
+    else:
+      return None;
+
+  def execute_in_trans(self, *args):
+    success = True
+    db = self.env.get_db_cnx()
+    cur = db.cursor()
+    try:
+      for sql, params in args:
+        cur.execute(sql, params)
+      db.commit()
+    except Exception, e:
+      self.log.error('There was a problem executing sql:%s \n \
+      with parameters:%s\nException:%s'%(sql, params, e));
+      db.rollback();
+      success = False
+    try:
+      db.close()
+    except:
+      pass
+    return success
+
+