Ticket #2288: 2288-time-queries-r7557.patch

trac/htdocs/css/report.css

@@ -38 +38 @@
 #filters td label { font-size: 11px }
 #filters td.mode { text-align: right }
 #filters td.filter { width: 100% }
-#filters td.filter label { padding-right: 1em }
 #filters td.actions { text-align: right; white-space: nowrap }
 
 #columns div label { 

trac/htdocs/js/query.js

@@ -225 +225 @@
         td.className = "filter";
         if (property.type == "select") {
           var element = createSelect(propertyName, property.options, true);
+          td.appendChild(element);
         } else if ((property.type == "text") || (property.type == "textarea")) {
           var element = document.createElement("input");
           element.type = "text";
           element.name = propertyName;
           element.size = 42;
+          td.appendChild(element);
+        } else if (property.type == "time") {
+          var element = document.createElement("input");
+          element.type = "text";
+          element.name = propertyName;
+          element.size = 14;
+          td.appendChild(element);
+          td.appendChild(document.createTextNode(" "));
+          td.appendChild(createLabel("and"));
+          td.appendChild(document.createTextNode(" "));
+          var element2 = document.createElement("input");
+          element2.type = "text";
+          element2.name = propertyName + "_end";
+          element2.size = 14;
+          td.appendChild(element2);
         }
-        td.appendChild(element);
         element.focus();
         tr.appendChild(td);
       }

trac/ticket/api.py

@@ -240 +240 @@
             field = {'name': name, 'type': 'text', 'label': name.title()}
             fields.append(field)
 
+        # Date/time fields
+        fields.append({'name': 'time', 'type': 'time',
+                       'label': _('Created')})
+        fields.append({'name': 'changetime', 'type': 'time',
+                       'label': _('Modified')})
+
         for field in self.get_custom_fields():
             if field['name'] in [f['name'] for f in fields]:
                 self.log.warning('Duplicate field name "%s" (ignoring)',
@@ -278 +284 @@
 
         fields.sort(lambda x, y: cmp(x['order'], y['order']))
         return fields
+
+    def get_field_synonyms(self):
+        """Return a mapping from field name synonyms to field names.
+        The synonyms are supposed to be more intuitive for custom queries."""
+        return {'created': 'time', 'modified': 'changetime'}
 
     # IPermissionRequestor methods
 

trac/ticket/model.py

@@ -40 +40 @@
     def id_is_valid(num):
         return 0 < int(num) <= 1L << 31
 
+    # 0.11 compatibility
+    time_created = property(lambda self: self.values.get('time'))
+    time_changed = property(lambda self: self.values.get('changetime'))
+    
     def __init__(self, env, tkt_id=None, db=None, version=None):
         self.env = env
         self.resource = Resource('ticket', tkt_id, version)
         self.fields = TicketSystem(self.env).get_ticket_fields()
+        self.time_fields = [f['name'] for f in self.fields
+                            if f['type'] == 'time']
         self.values = {}
         if tkt_id is not None:
             self._fetch_ticket(tkt_id, db)
         else:
             self._init_defaults(db)
-            self.id = self.time_created = self.time_changed = None
+            self.id = None
         self._old = {}
 
     def _get_db(self, db):
@@ -66 +72 @@
     def _init_defaults(self, db=None):
         for field in self.fields:
             default = None
-            if field['name'] in ['resolution', 'status']:
+            if field['name'] in ['resolution', 'status', 'time', 'changetime']:
                 # Ignore for new - only change through workflow
                 pass
             elif not field.get('custom'):
@@ -93 +99 @@
             # Fetch the standard ticket fields
             std_fields = [f['name'] for f in self.fields if not f.get('custom')]
             cursor = db.cursor()
-            cursor.execute("SELECT %s,time,changetime FROM ticket WHERE id=%%s"
+            cursor.execute("SELECT %s FROM ticket WHERE id=%%s"
                            % ','.join(std_fields), (tkt_id,))
             row = cursor.fetchone()
         if not row:
@@ -102 +108 @@
 
         self.id = tkt_id
         for i in range(len(std_fields)):
-            self.values[std_fields[i]] = row[i] or ''
-        self.time_created = datetime.fromtimestamp(row[len(std_fields)], utc)
-        self.time_changed = datetime.fromtimestamp(row[len(std_fields) + 1], utc)
+            field = std_fields[i]
+            if field in self.time_fields:
+                self.values[field] = datetime.fromtimestamp(row[i], utc)
+            else:
+                self.values[field] = row[i] or ''
 
         # Fetch custom fields if available
         custom_fields = [f['name'] for f in self.fields if f.get('custom')]
@@ -164 +172 @@
         # Add a timestamp
         if when is None:
             when = datetime.now(utc)
-        self.time_created = self.time_changed = when
+        self.values['time'] = self.values['changetime'] = when
 
         cursor = db.cursor()
 
@@ -178 +186 @@
                 # No such component exists
                 pass
 
+        # Perform type conversions
+        values = dict(self.values)
+        for field in self.time_fields:
+            if field in values:
+                values[field] = to_timestamp(values[field])
+        
         # Insert ticket record
-        created = to_timestamp(self.time_created)
-        changed = to_timestamp(self.time_changed)
         std_fields = []
         custom_fields = []
         for f in self.fields:
@@ -190 +202 @@
                     custom_fields.append(fname)
                 else:
                     std_fields.append(fname)
-        cursor.execute("INSERT INTO ticket (%s,time,changetime) VALUES (%s)"
+        cursor.execute("INSERT INTO ticket (%s) VALUES (%s)"
                        % (','.join(std_fields),
-                          ','.join(['%s'] * (len(std_fields) + 2))),
-                       [self[name] for name in std_fields] + [created, changed])
+                          ','.join(['%s'] * len(std_fields))),
+                       [values[name] for name in std_fields])
         tkt_id = db.get_last_id(cursor, 'ticket')
 
         # Insert custom fields
@@ -289 +301 @@
             db.commit()
         old_values = self._old
         self._old = {}
-        self.time_changed = when
+        self.values['changetime'] = when
 
         for listener in TicketSystem(self.env).change_listeners:
             listener.ticket_changed(self, comment, author, old_values)

trac/ticket/notification.py

@@ -149 +149 @@
 
     def format_props(self):
         tkt = self.ticket
-        fields = [f for f in tkt.fields if f['name'] not in ('summary', 'cc')]
+        fields = [f for f in tkt.fields 
+                  if f['name'] not in ('summary', 'cc', 'time', 'changetime')]
         width = [0, 0, 0, 0]
         i = 0
         for f in [f['name'] for f in fields if f['type'] != 'textarea']:

trac/ticket/query.py

@@ -31 +31 @@
 from trac.resource import Resource
 from trac.ticket.api import TicketSystem
 from trac.util import Ranges
-from trac.util.datefmt import to_timestamp, utc
+from trac.util.datefmt import format_datetime, parse_date, to_timestamp, utc
 from trac.util.presentation import Paginator
 from trac.util.text import shorten_line
 from trac.util.translation import _, tag_
@@ -56 +56 @@
         self.env = env
         self.id = report # if not None, it's the corresponding saved query
         self.constraints = constraints or {}
-        self.order = order
+        synonyms = TicketSystem(self.env).get_field_synonyms()
+        self.order = synonyms.get(order, order)     # 0.11 compatibility
         self.desc = desc
         self.group = group
         self.groupdesc = groupdesc
@@ -100 +101 @@
         if verbose and 'description' not in rows: # 0.10 compatibility
             rows.append('description')
         self.fields = TicketSystem(self.env).get_ticket_fields()
+        self.time_fields = [f['name'] for f in self.fields
+                            if f['type'] == 'time']
         field_names = [f['name'] for f in self.fields]
         self.cols = [c for c in cols or [] if c in field_names or 
-                     c in ('id', 'time', 'changetime')]
+                     c == 'id']
         self.rows = [c for c in rows if c in field_names]
         if self.order != 'id' and self.order not in field_names:
-            # TODO: fix after adding time/changetime to the api.py
-            if order == 'created':
-                order = 'time'
-            elif order == 'modified':
-                order = 'changetime'
-            if order in ('time', 'changetime'):
-                self.order = order
-            else:
-                self.order = 'priority'
+            self.order = 'priority'
 
         if self.group not in field_names:
             self.group = None
@@ -124 +119 @@
         kw_strs = ['order', 'group', 'page', 'max']
         kw_arys = ['rows']
         kw_bools = ['desc', 'groupdesc', 'verbose']
+        synonyms = TicketSystem(env).get_field_synonyms()
         constraints = {}
         cols = []
         for filter_ in filters:
@@ -131 +127 @@
             if len(filter_) != 2:
                 raise QuerySyntaxError(_('Query filter requires field and ' 
                                          'constraints separated by a "="'))
-            field,values = filter_
+            field, values = filter_
             if not field:
                 raise QuerySyntaxError(_('Query filter requires field name'))
             # from last char of `field`, get the mode of comparison
@@ -157 +153 @@
                 elif field in kw_bools:
                     kw[field] = True
                 elif field == 'col':
-                    cols.extend(processed_values)
+                    cols.extend(synonyms.get(value, value)
+                                for value in processed_values)
                 else:
-                    constraints[field] = processed_values
+                    constraints.setdefault(synonyms.get(field, field), 
+                                           []).extend(processed_values)
             except UnicodeError:
                 pass # field must be a str, see `get_href()`
         report = constraints.pop('report', None)
@@ -185 +183 @@
             if col in cols:
                 cols.remove(col)
                 cols.append(col)
-        # TODO: fix after adding time/changetime to the api.py
-        cols += ['time', 'changetime']
 
         # Semi-intelligently remove columns that are restricted to a single
         # value by a query constraint.
@@ -195 +191 @@
             constraint = self.constraints[col]
             if len(constraint) == 1 and constraint[0] \
                     and not constraint[0][0] in ('!', '~', '^', '$'):
-                if col in cols:
+                if col in cols and col not in self.time_fields:
                     cols.remove(col)
             if col == 'status' and not 'closed' in constraint \
                     and 'resolution' in cols:
@@ -299 +295 @@
                     result['href'] = req.href.ticket(val)
                 elif val is None:
                     val = '--'
-                elif name in ('changetime', 'time'):
+                elif name in self.time_fields:
                     val = datetime.fromtimestamp(int(val or 0), utc)
                 elif field and field['type'] == 'checkbox':
                     try:
@@ -425 +421 @@
 
         def get_constraint_sql(name, value, mode, neg):
             if name not in custom_fields:
-                name = 't.' + name
+                col = 't.' + name
             else:
-                name = name + '.value'
+                col = name + '.value'
             value = value[len(mode) + neg:]
 
+            if name in self.time_fields:
+                if ';' in value:
+                    (start, end) = [each.strip() for each in 
+                                    value.split(';', 1)]
+                else:
+                    (start, end) = (value.strip(), '')
+                col_cast = db.cast(col, 'int')
+                if start and end:
+                    start = to_timestamp(parse_date(start, req.tz))
+                    end = to_timestamp(parse_date(end, req.tz))
+                    return ("%s(%s>=%%s AND %s<%%s)" % (neg and 'NOT ' or '',
+                                                        col_cast, col_cast),
+                            (start, end))
+                elif start:
+                    start = to_timestamp(parse_date(start, req.tz))
+                    return ("%s%s>=%%s" % (neg and 'NOT ' or '', col_cast),
+                            (start, ))
+                elif end:
+                    end = to_timestamp(parse_date(end, req.tz))
+                    return ("%s%s<%%s" % (neg and 'NOT ' or '', col_cast),
+                            (end, ))
+                else:
+                    return None
+                
             if mode == '':
-                return ("COALESCE(%s,'')%s=%%s" % (name, neg and '!' or ''),
-                        value)
+                return ("COALESCE(%s,'')%s=%%s" % (col, neg and '!' or ''),
+                        (value, ))
+
             if not value:
                 return None
-            db = self.env.get_db_cnx()
             value = db.like_escape(value)
             if mode == '~':
                 value = '%' + value + '%'
@@ -443 +463 @@
                 value = value + '%'
             elif mode == '$':
                 value = '%' + value
-            return ("COALESCE(%s,'') %s%s" % (name, neg and 'NOT ' or '',
+            return ("COALESCE(%s,'') %s%s" % (col, neg and 'NOT ' or '',
                                               db.like()),
-                    value)
+                    (value, ))
 
+        db = self.env.get_db_cnx()
         clauses = []
         args = []
         for k, v in self.constraints.items():
@@ -480 +501 @@
                     clauses.append('%s(%s)' % (neg and 'NOT ' or '',
                                                ' OR '.join(id_clauses)))
             # Special case for exact matches on multiple values
-            elif not mode and len(v) > 1:
+            elif not mode and len(v) > 1 and k not in self.time_fields:
                 if k not in custom_fields:
                     col = 't.' + k
                 else:
@@ -501 +522 @@
                 else:
                     clauses.append("(" + " OR ".join(
                         [item[0] for item in constraint_sql]) + ")")
-                args += [item[1] for item in constraint_sql]
+                for item in constraint_sql:
+                    args.extend(item[1])
             elif len(v) == 1:
                 constraint_sql = get_constraint_sql(k, v[0], mode, neg)
                 if constraint_sql:
                     clauses.append(constraint_sql[0])
-                    args.append(constraint_sql[1])
+                    args.extend(constraint_sql[1])
 
         clauses = filter(None, clauses)
         if clauses:
@@ -530 +552 @@
             # FIXME: This is a somewhat ugly hack.  Can we also have the
             #        column type for this?  If it's an integer, we do first
             #        one, if text, we do 'else'
-            if name in ('id', 'time', 'changetime'):
+            if name == 'id' or name in self.time_fields:
                 sql.append("COALESCE(%s,0)=0%s," % (col, desc))
             else:
                 sql.append("COALESCE(%s,'')=''%s," % (col, desc))
@@ -575 +597 @@
         cols = self.get_columns()
         labels = dict([(f['name'], f['label']) for f in self.fields])
 
-        # TODO: remove after adding time/changetime to the api.py
-        labels['changetime'] = _('Modified')
-        labels['time'] = _('Created')
-
         headers = [{
             'name': col, 'label': labels.get(col, _('Ticket')),
             'href': self.get_href(context.href, order=col,
@@ -608 +626 @@
         modes['select'] = [
             {'name': _("is"), 'value': ""},
             {'name': _("is not"), 'value': "!"}
+        ]
+        modes['time'] = [
+            {'name': _("is between"), 'value': ""},
+            {'name': _("is not between"), 'value': "!"},
         ]
 
         groups = {}
@@ -826 +848 @@
 
     def _get_constraints(self, req):
         constraints = {}
-        ticket_fields = [f['name'] for f in
-                         TicketSystem(self.env).get_ticket_fields()]
+        fields = TicketSystem(self.env).get_ticket_fields()
+        synonyms = TicketSystem(self.env).get_field_synonyms()
+        ticket_fields = [f['name'] for f in fields]
         ticket_fields.append('id')
+        ticket_fields.extend(synonyms.iterkeys())
+        time_fields = [f['name'] for f in fields if f['type'] == 'time']
+        time_fields.extend([k for (k, v) in synonyms.iteritems() 
+                            if v in time_fields])
 
         # For clients without JavaScript, we remove constraints here if
         # requested
@@ -850 +877 @@
                 mode = req.args.get(field + '_mode')
                 if mode:
                     vals = [mode + x for x in vals]
+                if field in time_fields:
+                    ends = req.args.getlist(field + '_end')
+                    if ends:
+                        vals = [start + ';' + end 
+                                for (start, end) in zip(vals, ends)]
                 if field in remove_constraints:
                     idx = remove_constraints[field]
                     if idx >= 0:
@@ -858 +890 @@
                             continue
                     else:
                         continue
-                constraints[field] = vals
+                constraints.setdefault(synonyms.get(field, field), 
+                                       []).extend(vals)
 
         return constraints
 
@@ -954 +987 @@
                     if col in ('cc', 'reporter'):
                         value = Chrome(self.env).format_emails(context(ticket),
                                                                value)
+                    elif col in query.time_fields:
+                        value = format_datetime(value, tzinfo=req.tz)
                     values.append(unicode(value).encode('utf-8'))
                 writer.writerow(values)
         return (content.getvalue(), '%s;charset=utf-8' % mimetype)

trac/ticket/templates/query.html

@@ -43 +43 @@
             <py:for each="field_name in field_names" py:with="field = fields[field_name]">
               <py:for each="constraint_name, constraint in constraints.items()">
                 <tbody py:if="field_name == constraint_name"
-                  py:with="multiline = field.type in ('select', 'text', 'textarea')">
+                  py:with="multiline = field.type in ('select', 'text', 'textarea', 'time')">
                   <py:for each="constraint_idx, constraint_value in enumerate(constraint['values'])">
                     <tr class="${field_name}" py:if="multiline or constraint_idx == 0">
                       <py:choose test="constraint_idx">
@@ -95 +95 @@
 
                         <py:when test="field.type in ('text', 'textarea')">
                           <input type="text" name="${field_name}" value="$constraint_value" size="42" />
+                        </py:when>
+                        
+                        <py:when test="'time'" py:with="(start, end) = ';' in constraint_value 
+                                                        and constraint_value.split(';', 1)
+                                                        or (constraint_value, '')">
+                          <input type="text" name="${field_name}" value="$start" size="14" />
+                          <label>and</label>
+                          <input type="text" name="${field_name}_end" value="$end" size="14" />
                         </py:when>
 
                       </td>

trac/ticket/templates/ticket.html

@@ -125 +125 @@
         <div id="ticket" py:if="ticket.exists or preview_mode"
           class="${preview_mode and 'ticketdraft' or None}">
           <div class="date">
-            <p py:if="ticket.exists">Opened ${dateinfo(ticket.time_created)} ago</p>
-            <p py:if="ticket.time_changed != ticket.time_created">Last modified ${dateinfo(ticket.time_changed)} ago</p>
+            <p py:if="ticket.exists">Opened ${dateinfo(ticket.time)} ago</p>
+            <p py:if="ticket.changetime != ticket.time">Last modified ${dateinfo(ticket.changetime)} ago</p>
             <p py:if="not ticket.exists"><i>(ticket not yet created)</i></p>
           </div>
           <!-- use a placeholder if it's a new ticket -->

trac/ticket/tests/notification.py

@@ -605 +605 @@
                 # note project title / URL are not validated yet
 
         # ticket properties which are not expected in the banner
-        xlist = ['summary', 'description', 'link', 'comment', 'new']
+        xlist = ['summary', 'description', 'link', 'comment', 'new',
+                 'time', 'changetime']
         # check banner content (field exists, msg value matches ticket value)
         for p in [prop for prop in ticket.values.keys() if prop not in xlist]:
             self.failIf(not props.has_key(p))

trac/ticket/tests/query.py

@@ -2 +2 @@
 from trac.mimeview import Context
 from trac.test import Mock, EnvironmentStub, MockPerm
 from trac.ticket.query import Query, QueryModule
+from trac.util.datefmt import utc
 from trac.web.href import Href
 from trac.wiki.formatter import LinkFormatter
 from trac.db.sqlite_backend import sqlite_version
@@ -35 +36 @@
 
     def setUp(self):
         self.env = EnvironmentStub(default_data=True)
-        self.req = Mock(href=self.env.href, authname='anonymous')
+        self.req = Mock(href=self.env.href, authname='anonymous', tz=utc)
         
 
     def test_all_ordered_by_id(self):
@@ -336 +337 @@
         self.assertEqual([], args)
         tickets = query.execute(self.req)
 
+    def test_constrained_by_time_range(self):
+        query = Query.from_string(self.env, 'created=2008-08-01;2008-09-01', order='id')
+        sql, args = query.get_sql(self.req)
+        self.assertEqualSQL(sql,
+"""SELECT t.id AS id,t.summary AS summary,t.time AS time,t.owner AS owner,t.type AS type,t.status AS status,t.priority AS priority,t.changetime AS changetime,priority.value AS priority_value
+FROM ticket AS t
+  LEFT OUTER JOIN enum AS priority ON (priority.type='priority' AND priority.name=priority)
+WHERE (CAST(t.time AS int)>=%s AND CAST(t.time AS int)<%s)
+ORDER BY COALESCE(t.id,0)=0,t.id""")
+        self.assertEqual([1217548800, 1220227200], args)
+        tickets = query.execute(self.req)
+
+    def test_constrained_by_time_range_exclusion(self):
+        query = Query.from_string(self.env, 'created!=2008-08-01;2008-09-01', order='id')
+        sql, args = query.get_sql(self.req)
+        self.assertEqualSQL(sql,
+"""SELECT t.id AS id,t.summary AS summary,t.time AS time,t.owner AS owner,t.type AS type,t.status AS status,t.priority AS priority,t.changetime AS changetime,priority.value AS priority_value
+FROM ticket AS t
+  LEFT OUTER JOIN enum AS priority ON (priority.type='priority' AND priority.name=priority)
+WHERE NOT (CAST(t.time AS int)>=%s AND CAST(t.time AS int)<%s)
+ORDER BY COALESCE(t.id,0)=0,t.id""")
+        self.assertEqual([1217548800, 1220227200], args)
+        tickets = query.execute(self.req)
+
+    def test_constrained_by_time_range_open_right(self):
+        query = Query.from_string(self.env, 'created=2008-08-01;', order='id')
+        sql, args = query.get_sql(self.req)
+        self.assertEqualSQL(sql,
+"""SELECT t.id AS id,t.summary AS summary,t.time AS time,t.owner AS owner,t.type AS type,t.status AS status,t.priority AS priority,t.changetime AS changetime,priority.value AS priority_value
+FROM ticket AS t
+  LEFT OUTER JOIN enum AS priority ON (priority.type='priority' AND priority.name=priority)
+WHERE CAST(t.time AS int)>=%s
+ORDER BY COALESCE(t.id,0)=0,t.id""")
+        self.assertEqual([1217548800], args)
+        tickets = query.execute(self.req)
+
+    def test_constrained_by_time_range_open_left(self):
+        query = Query.from_string(self.env, 'created=;2008-09-01', order='id')
+        sql, args = query.get_sql(self.req)
+        self.assertEqualSQL(sql,
+"""SELECT t.id AS id,t.summary AS summary,t.time AS time,t.owner AS owner,t.type AS type,t.status AS status,t.priority AS priority,t.changetime AS changetime,priority.value AS priority_value
+FROM ticket AS t
+  LEFT OUTER JOIN enum AS priority ON (priority.type='priority' AND priority.name=priority)
+WHERE CAST(t.time AS int)<%s
+ORDER BY COALESCE(t.id,0)=0,t.id""")
+        self.assertEqual([1220227200], args)
+        tickets = query.execute(self.req)
+
+    def test_constrained_by_time_range_modified(self):
+        query = Query.from_string(self.env, 'modified=2008-08-01;2008-09-01', order='id')
+        sql, args = query.get_sql(self.req)
+        self.assertEqualSQL(sql,
+"""SELECT t.id AS id,t.summary AS summary,t.changetime AS changetime,t.owner AS owner,t.type AS type,t.status AS status,t.priority AS priority,t.time AS time,priority.value AS priority_value
+FROM ticket AS t
+  LEFT OUTER JOIN enum AS priority ON (priority.type='priority' AND priority.name=priority)
+WHERE (CAST(t.changetime AS int)>=%s AND CAST(t.changetime AS int)<%s)
+ORDER BY COALESCE(t.id,0)=0,t.id""")
+        self.assertEqu