| 1 | # -*- coding: utf-8 -*-
|
|---|
| 2 | #
|
|---|
| 3 | # Copyright (C) 2003-2023 Edgewall Software
|
|---|
| 4 | # Copyright (C) 2003-2006 Jonas Borgström <jonas@edgewall.com>
|
|---|
| 5 | # Copyright (C) 2005 Christopher Lenz <cmlenz@gmx.de>
|
|---|
| 6 | # Copyright (C) 2006 Christian Boos <cboos@edgewall.org>
|
|---|
| 7 | # All rights reserved.
|
|---|
| 8 | #
|
|---|
| 9 | # This software is licensed as described in the file COPYING, which
|
|---|
| 10 | # you should have received as part of this distribution. The terms
|
|---|
| 11 | # are also available at https://trac.edgewall.org/wiki/TracLicense.
|
|---|
| 12 | #
|
|---|
| 13 | # This software consists of voluntary contributions made by many
|
|---|
| 14 | # individuals. For the exact contribution history, see the revision
|
|---|
| 15 | # history and logs, available at https://trac.edgewall.org/log/.
|
|---|
| 16 | #
|
|---|
| 17 | # Author: Jonas Borgström <jonas@edgewall.com>
|
|---|
| 18 | # Christopher Lenz <cmlenz@gmx.de>
|
|---|
| 19 |
|
|---|
| 20 | import re
|
|---|
| 21 |
|
|---|
| 22 | from trac import core
|
|---|
| 23 | from trac.attachment import Attachment
|
|---|
| 24 | from trac.cache import cached
|
|---|
| 25 | from trac.core import TracError
|
|---|
| 26 | from trac.resource import Resource, ResourceExistsError, ResourceNotFound
|
|---|
| 27 | from trac.ticket.api import TicketSystem
|
|---|
| 28 | from trac.util import as_int, embedded_numbers, to_list
|
|---|
| 29 | from trac.util.datefmt import (datetime_now, from_utimestamp, parse_date,
|
|---|
| 30 | to_utimestamp, utc, utcmax)
|
|---|
| 31 | from trac.util.text import empty, stripws
|
|---|
| 32 | from trac.util.translation import _, N_, gettext
|
|---|
| 33 |
|
|---|
| 34 | __all__ = ['Ticket', 'Type', 'Status', 'Resolution', 'Priority', 'Severity',
|
|---|
| 35 | 'Component', 'Milestone', 'Version']
|
|---|
| 36 |
|
|---|
| 37 |
|
|---|
| 38 | def _fixup_cc_list(cc_value):
|
|---|
| 39 | """Fix up cc list separators and remove duplicates."""
|
|---|
| 40 | cclist = []
|
|---|
| 41 | for cc in to_list(cc_value, r'[;,\s]+'):
|
|---|
| 42 | if cc not in cclist:
|
|---|
| 43 | cclist.append(cc)
|
|---|
| 44 | return ', '.join(cclist)
|
|---|
| 45 |
|
|---|
| 46 |
|
|---|
| 47 | def _db_str_to_datetime(value):
|
|---|
| 48 | if value is None:
|
|---|
| 49 | return None
|
|---|
| 50 | try:
|
|---|
| 51 | return from_utimestamp(int(value))
|
|---|
| 52 | except ValueError:
|
|---|
| 53 | pass
|
|---|
| 54 | try:
|
|---|
| 55 | return parse_date(value.strip(), utc, 'datetime')
|
|---|
| 56 | except Exception:
|
|---|
| 57 | return None
|
|---|
| 58 |
|
|---|
| 59 |
|
|---|
| 60 | def _datetime_to_db_str(dt, is_custom_field):
|
|---|
| 61 | if not dt:
|
|---|
| 62 | return None
|
|---|
| 63 | ts = to_utimestamp(dt)
|
|---|
| 64 | if is_custom_field:
|
|---|
| 65 | # Padding with '0' would be easy to sort in report page for a user
|
|---|
| 66 | fmt = '%018d' if ts >= 0 else '%+017d'
|
|---|
| 67 | return fmt % ts
|
|---|
| 68 | else:
|
|---|
| 69 | return ts
|
|---|
| 70 |
|
|---|
| 71 |
|
|---|
| 72 | def _from_timestamp(time):
|
|---|
| 73 | return from_utimestamp(time) if time else None
|
|---|
| 74 |
|
|---|
| 75 |
|
|---|
| 76 | def _to_null(value):
|
|---|
| 77 | return value if value else None
|
|---|
| 78 |
|
|---|
| 79 |
|
|---|
| 80 | def _null_to_empty(value):
|
|---|
| 81 | return value if value else empty
|
|---|
| 82 |
|
|---|
| 83 |
|
|---|
| 84 | def simplify_whitespace(name):
|
|---|
| 85 | """Strip spaces and remove duplicate spaces within names"""
|
|---|
| 86 | if name:
|
|---|
| 87 | return ' '.join(name.split())
|
|---|
| 88 | return name
|
|---|
| 89 |
|
|---|
| 90 |
|
|---|
| 91 | def sort_tickets_by_priority(env, ids):
|
|---|
| 92 | with env.db_query as db:
|
|---|
| 93 | tickets = [int(id_) for id_ in ids]
|
|---|
| 94 | holders = ','.join(['%s'] * len(tickets))
|
|---|
| 95 | rows = db("""
|
|---|
| 96 | SELECT id FROM ticket AS t
|
|---|
| 97 | LEFT OUTER JOIN enum p
|
|---|
| 98 | ON p.type='priority' AND p.name=t.priority
|
|---|
| 99 | WHERE t.id IN (%s)
|
|---|
| 100 | ORDER BY COALESCE(p.value,'')='', %s, t.id
|
|---|
| 101 | """ % (holders, db.cast('p.value', 'int')), tickets)
|
|---|
| 102 | return [row[0] for row in rows]
|
|---|
| 103 |
|
|---|
| 104 |
|
|---|
| 105 | class Ticket(object):
|
|---|
| 106 |
|
|---|
| 107 | realm = 'ticket'
|
|---|
| 108 |
|
|---|
| 109 | # Fields that must not be modified directly by the user
|
|---|
| 110 | # 'owner' should eventually be a protected field (#2045)
|
|---|
| 111 | protected_fields = 'resolution', 'status', 'time', 'changetime'
|
|---|
| 112 |
|
|---|
| 113 | @staticmethod
|
|---|
| 114 | def id_is_valid(num):
|
|---|
| 115 | try:
|
|---|
| 116 | return 0 < int(num) <= 1 << 31
|
|---|
| 117 | except (ValueError, TypeError):
|
|---|
| 118 | return False
|
|---|
| 119 |
|
|---|
| 120 | @property
|
|---|
| 121 | def resource(self):
|
|---|
| 122 | return Resource(self.realm, self.id, self.version)
|
|---|
| 123 |
|
|---|
| 124 | def __init__(self, env, tkt_id=None, version=None):
|
|---|
| 125 | self.env = env
|
|---|
| 126 | self.fields = TicketSystem(self.env).get_ticket_fields()
|
|---|
| 127 | self.editable_fields = \
|
|---|
| 128 | {f['name'] for f in self.fields
|
|---|
| 129 | if f['name'] not in self.protected_fields}
|
|---|
| 130 | self.std_fields, self.custom_fields, self.time_fields = [], [], []
|
|---|
| 131 | for f in self.fields:
|
|---|
| 132 | if f.get('custom'):
|
|---|
| 133 | self.custom_fields.append(f['name'])
|
|---|
| 134 | else:
|
|---|
| 135 | self.std_fields.append(f['name'])
|
|---|
| 136 | if f['type'] == 'time':
|
|---|
| 137 | self.time_fields.append(f['name'])
|
|---|
| 138 | self.values = {}
|
|---|
| 139 | self._old = {}
|
|---|
| 140 | if tkt_id is not None:
|
|---|
| 141 | self._fetch_ticket(tkt_id)
|
|---|
| 142 | else:
|
|---|
| 143 | self._init_defaults()
|
|---|
| 144 | self.id = None
|
|---|
| 145 | self.version = version
|
|---|
| 146 |
|
|---|
| 147 | def __repr__(self):
|
|---|
| 148 | return '<%s %r>' % (self.__class__.__name__, self.id)
|
|---|
| 149 |
|
|---|
| 150 | exists = property(lambda self: self.id is not None)
|
|---|
| 151 |
|
|---|
| 152 | def _init_defaults(self):
|
|---|
| 153 | for field in self.fields:
|
|---|
| 154 | default = None
|
|---|
| 155 | if field['name'] in self.protected_fields:
|
|---|
| 156 | # Ignore for new - only change through workflow
|
|---|
| 157 | pass
|
|---|
| 158 | elif not field.get('custom'):
|
|---|
| 159 | default = self.env.config.get('ticket',
|
|---|
| 160 | 'default_' + field['name'])
|
|---|
| 161 | else:
|
|---|
| 162 | default = self._custom_field_default(field)
|
|---|
| 163 | if default:
|
|---|
| 164 | self.values.setdefault(field['name'], default)
|
|---|
| 165 |
|
|---|
| 166 | def _custom_field_default(self, field):
|
|---|
| 167 | default = field.get('value')
|
|---|
| 168 | options = field.get('options')
|
|---|
| 169 | if default and options and default not in options:
|
|---|
| 170 | try:
|
|---|
| 171 | default = options[int(default)]
|
|---|
| 172 | except (ValueError, IndexError):
|
|---|
| 173 | self.env.log.warning("Invalid default value '%s' "
|
|---|
| 174 | "for custom field '%s'",
|
|---|
| 175 | default, field['name'])
|
|---|
| 176 | if default and field.get('type') == 'time':
|
|---|
| 177 | try:
|
|---|
| 178 | default = parse_date(default,
|
|---|
| 179 | hint=field.get('format'))
|
|---|
| 180 | except TracError as e:
|
|---|
| 181 | self.env.log.warning("Invalid default value '%s' "
|
|---|
| 182 | "for custom field '%s': %s",
|
|---|
| 183 | default, field['name'], e)
|
|---|
| 184 | default = None
|
|---|
| 185 | return default
|
|---|
| 186 |
|
|---|
| 187 | def _fetch_ticket(self, tkt_id):
|
|---|
| 188 | row = None
|
|---|
| 189 | if self.id_is_valid(tkt_id):
|
|---|
| 190 | # Fetch the standard ticket fields
|
|---|
| 191 | tkt_id = int(tkt_id)
|
|---|
| 192 | for row in self.env.db_query("""
|
|---|
| 193 | SELECT %s FROM ticket WHERE id=%%s
|
|---|
| 194 | """ % ','.join(self.std_fields), (tkt_id,)):
|
|---|
| 195 | break
|
|---|
| 196 | if not row:
|
|---|
| 197 | raise ResourceNotFound(_("Ticket %(id)s does not exist.",
|
|---|
| 198 | id=tkt_id), _("Invalid ticket number"))
|
|---|
| 199 |
|
|---|
| 200 | self.id = tkt_id
|
|---|
| 201 | for i, field in enumerate(self.std_fields):
|
|---|
| 202 | value = row[i]
|
|---|
| 203 | if field in self.time_fields:
|
|---|
| 204 | self.values[field] = from_utimestamp(value)
|
|---|
| 205 | elif value is None:
|
|---|
| 206 | self.values[field] = empty
|
|---|
| 207 | else:
|
|---|
| 208 | self.values[field] = value
|
|---|
| 209 |
|
|---|
| 210 | # Fetch custom fields if available
|
|---|
| 211 | for name, value in self.env.db_query("""
|
|---|
| 212 | SELECT name, value FROM ticket_custom WHERE ticket=%s
|
|---|
| 213 | """, (tkt_id,)):
|
|---|
| 214 | if name in self.custom_fields:
|
|---|
| 215 | if name in self.time_fields:
|
|---|
| 216 | self.values[name] = _db_str_to_datetime(value)
|
|---|
| 217 | elif value is None:
|
|---|
| 218 | self.values[name] = empty
|
|---|
| 219 | else:
|
|---|
| 220 | self.values[name] = value
|
|---|
| 221 |
|
|---|
| 222 | # Set defaults for custom fields that haven't been fetched.
|
|---|
| 223 | for field in self.fields:
|
|---|
| 224 | name = field['name']
|
|---|
| 225 | if field.get('custom') and name not in self.values:
|
|---|
| 226 | default = self._custom_field_default(field)
|
|---|
| 227 | if default:
|
|---|
| 228 | self[name] = default
|
|---|
| 229 |
|
|---|
| 230 | def __getitem__(self, name):
|
|---|
| 231 | return self.values.get(name)
|
|---|
| 232 |
|
|---|
| 233 | def __setitem__(self, name, value):
|
|---|
| 234 | """Log ticket modifications so the table ticket_change can be updated
|
|---|
| 235 | """
|
|---|
| 236 | if value and name not in self.time_fields:
|
|---|
| 237 | if isinstance(value, list):
|
|---|
| 238 | raise TracError(_("Multi-values fields not supported yet"))
|
|---|
| 239 | if self.fields.by_name(name, {}).get('type') != 'textarea':
|
|---|
| 240 | value = value.strip()
|
|---|
| 241 | if name in self.values and self.values[name] == value:
|
|---|
| 242 | return
|
|---|
| 243 | if name not in self._old: # Changed field
|
|---|
| 244 | self._old[name] = self.values.get(name)
|
|---|
| 245 | elif self._old[name] == value: # Change of field reverted
|
|---|
| 246 | del self._old[name]
|
|---|
| 247 | self.values[name] = value
|
|---|
| 248 |
|
|---|
| 249 | def __contains__(self, item):
|
|---|
| 250 | return item in self.values
|
|---|
| 251 |
|
|---|
| 252 | def get_value_or_default(self, name):
|
|---|
| 253 | """Return the value of a field or the default value if it is undefined
|
|---|
| 254 | """
|
|---|
| 255 | try:
|
|---|
| 256 | value = self.values[name]
|
|---|
| 257 | return value if value is not empty else self.get_default(name)
|
|---|
| 258 | except KeyError:
|
|---|
| 259 | pass
|
|---|
| 260 |
|
|---|
| 261 | def get_default(self, name):
|
|---|
| 262 | """Return the default value of a field."""
|
|---|
| 263 | return self.fields.by_name(name, {}).get('value', '')
|
|---|
| 264 |
|
|---|
| 265 | def populate(self, values):
|
|---|
| 266 | """Populate the ticket with 'suitable' values from a dictionary"""
|
|---|
| 267 | field_names = [f['name'] for f in self.fields]
|
|---|
| 268 | for name in [name for name in values if name in field_names]:
|
|---|
| 269 | self[name] = values[name]
|
|---|
| 270 |
|
|---|
| 271 | # We have to do an extra trick to catch unchecked checkboxes
|
|---|
| 272 | for name in [name for name in values if name[9:] in field_names
|
|---|
| 273 | and name.startswith('checkbox_')]:
|
|---|
| 274 | if name[9:] not in values:
|
|---|
| 275 | self[name[9:]] = '0'
|
|---|
| 276 |
|
|---|
| 277 | def insert(self, when=None):
|
|---|
| 278 | """Add ticket to database.
|
|---|
| 279 | """
|
|---|
| 280 | assert not self.exists, 'Cannot insert an existing ticket'
|
|---|
| 281 |
|
|---|
| 282 | if 'cc' in self.values:
|
|---|
| 283 | self['cc'] = _fixup_cc_list(self.values['cc'])
|
|---|
| 284 |
|
|---|
| 285 | # Add a timestamp
|
|---|
| 286 | if when is None:
|
|---|
| 287 | when = datetime_now(utc)
|
|---|
| 288 | self.values['time'] = self.values['changetime'] = when
|
|---|
| 289 |
|
|---|
| 290 | # Perform type conversions
|
|---|
| 291 | db_values = self._to_db_types(self.values)
|
|---|
| 292 |
|
|---|
| 293 | # Insert ticket record
|
|---|
| 294 | std_fields = []
|
|---|
| 295 | custom_fields = []
|
|---|
| 296 | for f in self.fields:
|
|---|
| 297 | fname = f['name']
|
|---|
| 298 | if fname in self.values:
|
|---|
| 299 | if f.get('custom'):
|
|---|
| 300 | custom_fields.append(fname)
|
|---|
| 301 | else:
|
|---|
| 302 | std_fields.append(fname)
|
|---|
| 303 | with self.env.db_transaction as db:
|
|---|
| 304 | cursor = db.cursor()
|
|---|
| 305 | cursor.execute("INSERT INTO ticket (%s) VALUES (%s)"
|
|---|
| 306 | % (','.join(std_fields),
|
|---|
| 307 | ','.join(['%s'] * len(std_fields))),
|
|---|
| 308 | [db_values.get(name) for name in std_fields])
|
|---|
| 309 | tkt_id = db.get_last_id(cursor, 'ticket')
|
|---|
| 310 |
|
|---|
| 311 | # Insert custom fields
|
|---|
| 312 | if custom_fields:
|
|---|
| 313 | db.executemany(
|
|---|
| 314 | """INSERT INTO ticket_custom (ticket, name, value)
|
|---|
| 315 | VALUES (%s, %s, %s)
|
|---|
| 316 | """, [(tkt_id, c, db_values.get(c))
|
|---|
| 317 | for c in custom_fields])
|
|---|
| 318 |
|
|---|
| 319 | self.id = int(tkt_id)
|
|---|
| 320 | self._old = {}
|
|---|
| 321 |
|
|---|
| 322 | for listener in TicketSystem(self.env).change_listeners:
|
|---|
| 323 | listener.ticket_created(self)
|
|---|
| 324 |
|
|---|
| 325 | return self.id
|
|---|
| 326 |
|
|---|
| 327 | def get_comment_number(self, cdate):
|
|---|
| 328 | """Return a comment number by its date."""
|
|---|
| 329 | ts = to_utimestamp(cdate)
|
|---|
| 330 | for cnum, in self.env.db_query("""\
|
|---|
| 331 | SELECT oldvalue FROM ticket_change
|
|---|
| 332 | WHERE ticket=%s AND time=%s AND field='comment'
|
|---|
| 333 | """, (self.id, ts)):
|
|---|
| 334 | try:
|
|---|
| 335 | return int(cnum.rsplit('.', 1)[-1])
|
|---|
| 336 | except ValueError:
|
|---|
| 337 | break
|
|---|
| 338 |
|
|---|
| 339 | def save_changes(self, author=None, comment=None, when=None, replyto=None):
|
|---|
| 340 | """
|
|---|
| 341 | Store ticket changes in the database. The ticket must already exist in
|
|---|
| 342 | the database. Returns False if there were no changes to save, True
|
|---|
| 343 | otherwise.
|
|---|
| 344 | """
|
|---|
| 345 | assert self.exists, "Cannot update a new ticket"
|
|---|
| 346 |
|
|---|
| 347 | if 'cc' in self.values:
|
|---|
| 348 | self['cc'] = _fixup_cc_list(self.values['cc'])
|
|---|
| 349 |
|
|---|
| 350 | props_unchanged = all(self.values.get(k) == v
|
|---|
| 351 | for k, v in self._old.items())
|
|---|
| 352 | if (not comment or not stripws(comment)) and props_unchanged:
|
|---|
| 353 | return False # Not modified
|
|---|
| 354 |
|
|---|
| 355 | if when is None:
|
|---|
| 356 | when = datetime_now(utc)
|
|---|
| 357 | self.values['changetime'] = when
|
|---|
| 358 |
|
|---|
| 359 | # Perform type conversions
|
|---|
| 360 | db_values = self._to_db_types(self.values)
|
|---|
| 361 | old_db_values = self._to_db_types(self._old)
|
|---|
| 362 |
|
|---|
| 363 | with self.env.db_transaction as db:
|
|---|
| 364 | db("UPDATE ticket SET changetime=%s WHERE id=%s",
|
|---|
| 365 | (db_values['changetime'], self.id))
|
|---|
| 366 |
|
|---|
| 367 | num = 0
|
|---|
| 368 | for ts, old in db("""
|
|---|
| 369 | SELECT DISTINCT tc1.time, COALESCE(tc2.oldvalue,'')
|
|---|
| 370 | FROM ticket_change AS tc1
|
|---|
| 371 | LEFT OUTER JOIN ticket_change AS tc2
|
|---|
| 372 | ON tc2.ticket=%s AND tc2.time=tc1.time
|
|---|
| 373 | AND tc2.field='comment'
|
|---|
| 374 | WHERE tc1.ticket=%s ORDER BY tc1.time DESC
|
|---|
| 375 | """, (self.id, self.id)):
|
|---|
| 376 | # Use oldvalue if available, else count edits
|
|---|
| 377 | try:
|
|---|
| 378 | num += int(old.rsplit('.', 1)[-1])
|
|---|
| 379 | break
|
|---|
| 380 | except ValueError:
|
|---|
| 381 | num += 1
|
|---|
| 382 | cnum = str(num + 1)
|
|---|
| 383 | if replyto:
|
|---|
| 384 | cnum = '%s.%s' % (replyto, cnum)
|
|---|
| 385 |
|
|---|
| 386 | # store fields
|
|---|
| 387 | for name in self._old:
|
|---|
| 388 | db_val = db_values.get(name)
|
|---|
| 389 | old_db_val = old_db_values.get(name)
|
|---|
| 390 | if name in self.custom_fields:
|
|---|
| 391 | for row in db("""SELECT * FROM ticket_custom
|
|---|
| 392 | WHERE ticket=%s and name=%s
|
|---|
| 393 | """, (self.id, name)):
|
|---|
| 394 | db("""UPDATE ticket_custom SET value=%s
|
|---|
| 395 | WHERE ticket=%s AND name=%s
|
|---|
| 396 | """, (db_val, self.id, name))
|
|---|
| 397 | break
|
|---|
| 398 | else:
|
|---|
| 399 | db("""INSERT INTO ticket_custom (ticket,name,value)
|
|---|
| 400 | VALUES(%s,%s,%s)
|
|---|
| 401 | """, (self.id, name, db_val))
|
|---|
| 402 | # Don't add ticket change entry for custom field that
|
|---|
| 403 | # was added after ticket was created.
|
|---|
| 404 | if old_db_val is None:
|
|---|
| 405 | field = self.fields.by_name(name)
|
|---|
| 406 | default = self._custom_field_default(field)
|
|---|
| 407 | if self.values.get(name) == default:
|
|---|
| 408 | continue
|
|---|
| 409 | else:
|
|---|
| 410 | db("UPDATE ticket SET %s=%%s WHERE id=%%s"
|
|---|
| 411 | % name, (db_val, self.id))
|
|---|
| 412 | db("""INSERT INTO ticket_change
|
|---|
| 413 | (ticket,time,author,field,oldvalue,newvalue)
|
|---|
| 414 | VALUES (%s, %s, %s, %s, %s, %s)
|
|---|
| 415 | """, (self.id, db_values['changetime'], author, name,
|
|---|
| 416 | old_db_val, db_val))
|
|---|
| 417 |
|
|---|
| 418 | # always save comment, even if empty
|
|---|
| 419 | # (numbering support for timeline)
|
|---|
| 420 | db("""INSERT INTO ticket_change
|
|---|
| 421 | (ticket,time,author,field,oldvalue,newvalue)
|
|---|
| 422 | VALUES (%s,%s,%s,'comment',%s,%s)
|
|---|
| 423 | """, (self.id, db_values['changetime'], author, cnum,
|
|---|
| 424 | comment))
|
|---|
| 425 |
|
|---|
| 426 | old_values = self._old
|
|---|
| 427 | self._old = {}
|
|---|
| 428 |
|
|---|
| 429 | for listener in TicketSystem(self.env).change_listeners:
|
|---|
| 430 | listener.ticket_changed(self, comment, author, old_values)
|
|---|
| 431 | return int(cnum.rsplit('.', 1)[-1])
|
|---|
| 432 |
|
|---|
| 433 | def _to_db_types(self, values):
|
|---|
| 434 | values = values.copy()
|
|---|
| 435 | for field, value in values.items():
|
|---|
| 436 | if field in self.time_fields:
|
|---|
| 437 | is_custom_field = field in self.custom_fields
|
|---|
| 438 | values[field] = _datetime_to_db_str(value, is_custom_field)
|
|---|
| 439 | else:
|
|---|
| 440 | values[field] = _to_null(value)
|
|---|
| 441 | return values
|
|---|
| 442 |
|
|---|
| 443 | def get_changelog(self, when=None):
|
|---|
| 444 | """Return the changelog as a list of tuples of the form
|
|---|
| 445 | (time, author, field, oldvalue, newvalue, permanent).
|
|---|
| 446 |
|
|---|
| 447 | While the other tuple elements are quite self-explanatory,
|
|---|
| 448 | the `permanent` flag is used to distinguish collateral changes
|
|---|
| 449 | that are not yet immutable (like attachments, currently).
|
|---|
| 450 | """
|
|---|
| 451 | sid = str(self.id)
|
|---|
| 452 | when_ts = to_utimestamp(when)
|
|---|
| 453 | if when_ts:
|
|---|
| 454 | sql = """
|
|---|
| 455 | SELECT time, author, field, oldvalue, newvalue, 1 AS permanent
|
|---|
| 456 | FROM ticket_change WHERE ticket=%s AND time=%s
|
|---|
| 457 | UNION
|
|---|
| 458 | SELECT time, author, 'attachment', null, filename,
|
|---|
| 459 | 0 AS permanent
|
|---|
| 460 | FROM attachment WHERE type='ticket' AND id=%s AND time=%s
|
|---|
| 461 | UNION
|
|---|
| 462 | SELECT time, author, 'comment', null, description,
|
|---|
| 463 | 0 AS permanent
|
|---|
| 464 | FROM attachment WHERE type='ticket' AND id=%s AND time=%s
|
|---|
| 465 | ORDER BY time,permanent,author,field
|
|---|
| 466 | """
|
|---|
| 467 | args = (self.id, when_ts, sid, when_ts, sid, when_ts)
|
|---|
| 468 | else:
|
|---|
| 469 | sql = """
|
|---|
| 470 | SELECT time, author, field, oldvalue, newvalue, 1 AS permanent
|
|---|
| 471 | FROM ticket_change WHERE ticket=%s
|
|---|
| 472 | UNION
|
|---|
| 473 | SELECT time, author, 'attachment', null, filename,
|
|---|
| 474 | 0 AS permanent
|
|---|
| 475 | FROM attachment WHERE type='ticket' AND id=%s
|
|---|
| 476 | UNION
|
|---|
| 477 | SELECT time, author, 'comment', null, description,
|
|---|
| 478 | 0 AS permanent
|
|---|
| 479 | FROM attachment WHERE type='ticket' AND id=%s
|
|---|
| 480 | ORDER BY time,permanent,author,field
|
|---|
| 481 | """
|
|---|
| 482 | args = (self.id, sid, sid)
|
|---|
| 483 | log = []
|
|---|
| 484 | for t, author, field, oldvalue, newvalue, permanent \
|
|---|
| 485 | in self.env.db_query(sql, args):
|
|---|
| 486 | if field in self.time_fields:
|
|---|
| 487 | oldvalue = _db_str_to_datetime(oldvalue)
|
|---|
| 488 | newvalue = _db_str_to_datetime(newvalue)
|
|---|
| 489 | log.append((from_utimestamp(t), author, field,
|
|---|
| 490 | oldvalue or '', newvalue or '', permanent))
|
|---|
| 491 | return log
|
|---|
| 492 |
|
|---|
| 493 | def delete(self):
|
|---|
| 494 | """Delete the ticket.
|
|---|
| 495 | """
|
|---|
| 496 | with self.env.db_transaction as db:
|
|---|
| 497 | Attachment.delete_all(self.env, self.realm, self.id)
|
|---|
| 498 | db("DELETE FROM ticket WHERE id=%s", (self.id,))
|
|---|
| 499 | db("DELETE FROM ticket_change WHERE ticket=%s", (self.id,))
|
|---|
| 500 | db("DELETE FROM ticket_custom WHERE ticket=%s", (self.id,))
|
|---|
| 501 |
|
|---|
| 502 | for listener in TicketSystem(self.env).change_listeners:
|
|---|
| 503 | listener.ticket_deleted(self)
|
|---|
| 504 |
|
|---|
| 505 | def get_change(self, cnum=None, cdate=None):
|
|---|
| 506 | """Return a ticket change by its number or date.
|
|---|
| 507 | """
|
|---|
| 508 | if cdate is None:
|
|---|
| 509 | row = self._find_change(cnum)
|
|---|
| 510 | if not row:
|
|---|
| 511 | return
|
|---|
| 512 | cdate = from_utimestamp(row[0])
|
|---|
| 513 | ts = to_utimestamp(cdate)
|
|---|
| 514 | fields = {}
|
|---|
| 515 | change = {'date': cdate, 'fields': fields}
|
|---|
| 516 | for field, author, old, new in self.env.db_query("""
|
|---|
| 517 | SELECT field, author, oldvalue, newvalue
|
|---|
| 518 | FROM ticket_change WHERE ticket=%s AND time=%s
|
|---|
| 519 | """, (self.id, ts)):
|
|---|
| 520 | fields[field] = {'author': author, 'old': old, 'new': new}
|
|---|
| 521 | if field == 'comment':
|
|---|
| 522 | change['author'] = author
|
|---|
| 523 | elif not field.startswith('_'):
|
|---|
| 524 | change.setdefault('author', author)
|
|---|
| 525 | if fields:
|
|---|
| 526 | return change
|
|---|
| 527 |
|
|---|
| 528 | def delete_change(self, cnum=None, cdate=None, when=None):
|
|---|
| 529 | """Delete a ticket change identified by its number or date."""
|
|---|
| 530 | if cdate is None:
|
|---|
| 531 | row = self._find_change(cnum)
|
|---|
| 532 | if not row:
|
|---|
| 533 | return
|
|---|
| 534 | cdate = from_utimestamp(row[0])
|
|---|
| 535 | ts = to_utimestamp(cdate)
|
|---|
| 536 | if when is None:
|
|---|
| 537 | when = datetime_now(utc)
|
|---|
| 538 | when_ts = to_utimestamp(when)
|
|---|
| 539 |
|
|---|
| 540 | with self.env.db_transaction as db:
|
|---|
| 541 | # Find modified fields and their previous value
|
|---|
| 542 | fields = [(field, old, new)
|
|---|
| 543 | for field, old, new in db("""
|
|---|
| 544 | SELECT field, oldvalue, newvalue FROM ticket_change
|
|---|
| 545 | WHERE ticket=%s AND time=%s
|
|---|
| 546 | """, (self.id, ts))
|
|---|
| 547 | if field != 'comment' and not field.startswith('_')]
|
|---|
| 548 | for field, oldvalue, newvalue in fields:
|
|---|
| 549 | # Find the next change
|
|---|
| 550 | for next_ts, in db("""SELECT time FROM ticket_change
|
|---|
| 551 | WHERE ticket=%s AND time>%s AND field=%s
|
|---|
| 552 | LIMIT 1
|
|---|
| 553 | """, (self.id, ts, field)):
|
|---|
| 554 | # Modify the old value of the next change if it is equal
|
|---|
| 555 | # to the new value of the deleted change
|
|---|
| 556 | db("""UPDATE ticket_change SET oldvalue=%s
|
|---|
| 557 | WHERE ticket=%s AND time=%s AND field=%s
|
|---|
| 558 | AND oldvalue=%s
|
|---|
| 559 | """, (oldvalue, self.id, next_ts, field, newvalue))
|
|---|
| 560 | break
|
|---|
| 561 | else:
|
|---|
| 562 | # No next change, edit ticket field
|
|---|
| 563 | if field in self.std_fields:
|
|---|
| 564 | db("UPDATE ticket SET %s=%%s WHERE id=%%s"
|
|---|
| 565 | % field, (oldvalue, self.id))
|
|---|
| 566 | else:
|
|---|
| 567 | db("""UPDATE ticket_custom SET value=%s
|
|---|
| 568 | WHERE ticket=%s AND name=%s
|
|---|
| 569 | """, (oldvalue, self.id, field))
|
|---|
| 570 |
|
|---|
| 571 | # Delete the change
|
|---|
| 572 | db("DELETE FROM ticket_change WHERE ticket=%s AND time=%s",
|
|---|
| 573 | (self.id, ts))
|
|---|
| 574 |
|
|---|
| 575 | # Update last changed time
|
|---|
| 576 | db("UPDATE ticket SET changetime=%s WHERE id=%s",
|
|---|
| 577 | (when_ts, self.id))
|
|---|
| 578 |
|
|---|
| 579 | self._fetch_ticket(self.id)
|
|---|
| 580 |
|
|---|
| 581 | changes = {field: (oldvalue, newvalue)
|
|---|
| 582 | for field, oldvalue, newvalue in fields}
|
|---|
| 583 | for listener in TicketSystem(self.env).change_listeners:
|
|---|
| 584 | if hasattr(listener, 'ticket_change_deleted'):
|
|---|
| 585 | listener.ticket_change_deleted(self, cdate, changes)
|
|---|
| 586 |
|
|---|
| 587 | def modify_comment(self, cdate, author, comment, when=None):
|
|---|
| 588 | """Modify a ticket comment specified by its date, while keeping a
|
|---|
| 589 | history of edits.
|
|---|
| 590 | """
|
|---|
| 591 | ts = to_utimestamp(cdate)
|
|---|
| 592 | if when is None:
|
|---|
| 593 | when = datetime_now(utc)
|
|---|
| 594 | when_ts = to_utimestamp(when)
|
|---|
| 595 |
|
|---|
| 596 | old_comment = False
|
|---|
| 597 | with self.env.db_transaction as db:
|
|---|
| 598 | # Find the current value of the comment
|
|---|
| 599 | for old_comment, in db("""
|
|---|
| 600 | SELECT newvalue FROM ticket_change
|
|---|
| 601 | WHERE ticket=%s AND time=%s AND field='comment'
|
|---|
| 602 | """, (self.id, ts)):
|
|---|
| 603 | break
|
|---|
| 604 | if comment == (old_comment or ''):
|
|---|
| 605 | return
|
|---|
| 606 |
|
|---|
| 607 | # Comment history is stored in fields named "_comment%d"
|
|---|
| 608 | # Find the next edit number
|
|---|
| 609 | fields = db("""SELECT field FROM ticket_change
|
|---|
| 610 | WHERE ticket=%%s AND time=%%s AND field %s
|
|---|
| 611 | """ % db.prefix_match(),
|
|---|
| 612 | (self.id, ts, db.prefix_match_value('_comment')))
|
|---|
| 613 | rev = max(int(field[8:]) for field, in fields) + 1 \
|
|---|
| 614 | if fields else 0
|
|---|
| 615 | db("""INSERT INTO ticket_change
|
|---|
| 616 | (ticket,time,author,field,oldvalue,newvalue)
|
|---|
| 617 | VALUES (%s,%s,%s,%s,%s,%s)
|
|---|
| 618 | """, (self.id, ts, author, '_comment%d' % rev,
|
|---|
| 619 | old_comment or '', str(when_ts)))
|
|---|
| 620 | if old_comment is False:
|
|---|
| 621 | # There was no comment field, add one, find the
|
|---|
| 622 | # original author in one of the other changed fields
|
|---|
| 623 | for old_author, in db("""
|
|---|
| 624 | SELECT author FROM ticket_change
|
|---|
| 625 | WHERE ticket=%%s AND time=%%s AND NOT field %s LIMIT 1
|
|---|
| 626 | """ % db.prefix_match(),
|
|---|
| 627 | (self.id, ts, db.prefix_match_value('_'))):
|
|---|
| 628 | db("""INSERT INTO ticket_change
|
|---|
| 629 | (ticket,time,author,field,oldvalue,newvalue)
|
|---|
| 630 | VALUES (%s,%s,%s,'comment','',%s)
|
|---|
| 631 | """, (self.id, ts, old_author, comment))
|
|---|
| 632 | else:
|
|---|
| 633 | db("""UPDATE ticket_change SET newvalue=%s
|
|---|
| 634 | WHERE ticket=%s AND time=%s AND field='comment'
|
|---|
| 635 | """, (comment, self.id, ts))
|
|---|
| 636 |
|
|---|
| 637 | # Update last changed time
|
|---|
| 638 | db("UPDATE ticket SET changetime=%s WHERE id=%s",
|
|---|
| 639 | (when_ts, self.id))
|
|---|
| 640 |
|
|---|
| 641 | self.values['changetime'] = when
|
|---|
| 642 |
|
|---|
| 643 | old_comment = old_comment or ''
|
|---|
| 644 | for listener in TicketSystem(self.env).change_listeners:
|
|---|
| 645 | if hasattr(listener, 'ticket_comment_modified'):
|
|---|
| 646 | listener.ticket_comment_modified(self, cdate, author, comment,
|
|---|
| 647 | old_comment)
|
|---|
| 648 |
|
|---|
| 649 | def get_comment_history(self, cnum=None, cdate=None):
|
|---|
| 650 | """Retrieve the edit history of a comment identified by its number or
|
|---|
| 651 | date.
|
|---|
| 652 | """
|
|---|
| 653 | if cdate is None:
|
|---|
| 654 | row = self._find_change(cnum)
|
|---|
| 655 | if not row:
|
|---|
| 656 | return
|
|---|
| 657 | ts0, author0, last_comment = row
|
|---|
| 658 | else:
|
|---|
| 659 | ts0, author0, last_comment = to_utimestamp(cdate), None, None
|
|---|
| 660 | with self.env.db_query as db:
|
|---|
| 661 | # Get last comment and author if not available
|
|---|
| 662 | if last_comment is None:
|
|---|
| 663 | last_comment = ''
|
|---|
| 664 | for author0, last_comment in db("""
|
|---|
| 665 | SELECT author, newvalue FROM ticket_change
|
|---|
| 666 | WHERE ticket=%s AND time=%s AND field='comment'
|
|---|
| 667 | """, (self.id, ts0)):
|
|---|
| 668 | break
|
|---|
| 669 | if author0 is None:
|
|---|
| 670 | for author0, last_comment in db("""
|
|---|
| 671 | SELECT author, newvalue FROM ticket_change
|
|---|
| 672 | WHERE ticket=%%s AND time=%%s AND NOT field %s LIMIT 1
|
|---|
| 673 | """ % db.prefix_match(),
|
|---|
| 674 | (self.id, ts0, db.prefix_match_value('_'))):
|
|---|
| 675 | break
|
|---|
| 676 | else:
|
|---|
| 677 | return
|
|---|
| 678 |
|
|---|
| 679 | # Get all fields of the form "_comment%d"
|
|---|
| 680 | rows = db("""SELECT field, author, oldvalue, newvalue
|
|---|
| 681 | FROM ticket_change
|
|---|
| 682 | WHERE ticket=%%s AND time=%%s AND field %s
|
|---|
| 683 | """ % db.prefix_match(),
|
|---|
| 684 | (self.id, ts0, db.prefix_match_value('_comment')))
|
|---|
| 685 | rows = sorted((int(field[8:]), author, old, new)
|
|---|
| 686 | for field, author, old, new in rows)
|
|---|
| 687 | history = []
|
|---|
| 688 | for rev, author, comment, ts in rows:
|
|---|
| 689 | history.append((rev, from_utimestamp(int(ts0)), author0,
|
|---|
| 690 | comment))
|
|---|
| 691 | ts0, author0 = ts, author
|
|---|
| 692 | history.sort()
|
|---|
| 693 | rev = history[-1][0] + 1 if history else 0
|
|---|
| 694 | history.append((rev, from_utimestamp(int(ts0)), author0,
|
|---|
| 695 | last_comment))
|
|---|
| 696 | return history
|
|---|
| 697 |
|
|---|
| 698 | def _find_change(self, cnum):
|
|---|
| 699 | """Find a comment by its number."""
|
|---|
| 700 | scnum = str(cnum)
|
|---|
| 701 | with self.env.db_query as db:
|
|---|
| 702 | for row in db("""
|
|---|
| 703 | SELECT time, author, newvalue FROM ticket_change
|
|---|
| 704 | WHERE ticket=%%s AND field='comment'
|
|---|
| 705 | AND (oldvalue=%%s OR oldvalue %s)
|
|---|
| 706 | """ % db.like(),
|
|---|
| 707 | (self.id, scnum, '%' + db.like_escape('.' + scnum))):
|
|---|
| 708 | return row
|
|---|
| 709 |
|
|---|
| 710 | # Fallback when comment number is not available in oldvalue
|
|---|
| 711 | num = 0
|
|---|
| 712 | for ts, old, author, comment in db("""
|
|---|
| 713 | SELECT DISTINCT tc1.time, COALESCE(tc2.oldvalue,''),
|
|---|
| 714 | tc2.author, COALESCE(tc2.newvalue,'')
|
|---|
| 715 | FROM ticket_change AS tc1
|
|---|
| 716 | LEFT OUTER JOIN ticket_change AS tc2
|
|---|
| 717 | ON tc2.ticket=%s AND tc2.time=tc1.time
|
|---|
| 718 | AND tc2.field='comment'
|
|---|
| 719 | WHERE tc1.ticket=%s ORDER BY tc1.time
|
|---|
| 720 | """, (self.id, self.id)):
|
|---|
| 721 | # Use oldvalue if available, else count edits
|
|---|
| 722 | try:
|
|---|
| 723 | num = int(old.rsplit('.', 1)[-1])
|
|---|
| 724 | except ValueError:
|
|---|
| 725 | num += 1
|
|---|
| 726 | if num == cnum:
|
|---|
| 727 | break
|
|---|
| 728 | else:
|
|---|
| 729 | return
|
|---|
| 730 |
|
|---|
| 731 | # Find author if NULL
|
|---|
| 732 | if author is None:
|
|---|
| 733 | for author, in db("""
|
|---|
| 734 | SELECT author FROM ticket_change
|
|---|
| 735 | WHERE ticket=%%s AND time=%%s AND NOT field %s LIMIT 1
|
|---|
| 736 | """ % db.prefix_match(),
|
|---|
| 737 | (self.id, ts, db.prefix_match_value('_'))):
|
|---|
| 738 | break
|
|---|
| 739 | return ts, author, comment
|
|---|
| 740 |
|
|---|
| 741 |
|
|---|
| 742 | class AbstractEnum(object):
|
|---|
| 743 | type = None
|
|---|
| 744 | ticket_col = None
|
|---|
| 745 | label = None
|
|---|
| 746 |
|
|---|
| 747 | exists = property(lambda self: self._old_value is not None)
|
|---|
| 748 |
|
|---|
| 749 | def __init__(self, env, name=None):
|
|---|
| 750 | """Create a new `enum` instance. If `name` is specified and the
|
|---|
| 751 | enum with `name` exists, the enum will be retrieved from the
|
|---|
| 752 | database.
|
|---|
| 753 |
|
|---|
| 754 | :raises ResourceNotFound: if `name` is not `None` and an enum
|
|---|
| 755 | with `name` does not exist.
|
|---|
| 756 | """
|
|---|
| 757 | if not self.ticket_col:
|
|---|
| 758 | self.ticket_col = self.type
|
|---|
| 759 | self.env = env
|
|---|
| 760 | self.name = self._old_name = None
|
|---|
| 761 | self.value = self._old_value = None
|
|---|
| 762 | self.description = None
|
|---|
| 763 | if name:
|
|---|
| 764 | for value, description in self.env.db_query("""
|
|---|
| 765 | SELECT value, description FROM enum
|
|---|
| 766 | WHERE type=%s AND name=%s
|
|---|
| 767 | """, (self.type, name)):
|
|---|
| 768 | self.value = self._old_value = value
|
|---|
| 769 | self.description = _null_to_empty(description)
|
|---|
| 770 | self.name = self._old_name = name
|
|---|
| 771 | break
|
|---|
| 772 | else:
|
|---|
| 773 | raise ResourceNotFound(_("%(type)s %(name)s does not exist.",
|
|---|
| 774 | type=gettext(self.label[0]),
|
|---|
| 775 | name=name))
|
|---|
| 776 |
|
|---|
| 777 | def __repr__(self):
|
|---|
| 778 | return '<%s %r %r>' % (self.__class__.__name__, self.name, self.value)
|
|---|
| 779 |
|
|---|
| 780 | def delete(self):
|
|---|
| 781 | """Delete the enum.
|
|---|
| 782 |
|
|---|
| 783 | :raises TracError: if enum does not exist.
|
|---|
| 784 | """
|
|---|
| 785 | if not self.exists:
|
|---|
| 786 | raise TracError(_("Cannot delete non-existent %(type)s.",
|
|---|
| 787 | type=gettext(self.label[0])))
|
|---|
| 788 |
|
|---|
| 789 | self.env.log.info("Deleting %s '%s'", self.type, self.name)
|
|---|
| 790 | with self.env.db_transaction as db:
|
|---|
| 791 | db("DELETE FROM enum WHERE type=%s AND value=%s",
|
|---|
| 792 | (self.type, self._old_value))
|
|---|
| 793 | # Re-order any enums that have higher value than deleted
|
|---|
| 794 | # (close gap)
|
|---|
| 795 | for enum in self.select(self.env):
|
|---|
| 796 | try:
|
|---|
| 797 | if int(enum.value) > int(self._old_value):
|
|---|
| 798 | enum.value = str(int(enum.value) - 1)
|
|---|
| 799 | enum.update()
|
|---|
| 800 | except ValueError:
|
|---|
| 801 | pass # Ignore cast error for this non-essential operation
|
|---|
| 802 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 803 | self.value = self._old_value = None
|
|---|
| 804 | self.name = self._old_name = None
|
|---|
| 805 | self.description = None
|
|---|
| 806 |
|
|---|
| 807 | def insert(self):
|
|---|
| 808 | """Add a new enum.
|
|---|
| 809 |
|
|---|
| 810 | :raises TracError: if enum name is empty.
|
|---|
| 811 | :raises ResourceExistsError: if enum with name already exists.
|
|---|
| 812 | """
|
|---|
| 813 | if self.exists:
|
|---|
| 814 | raise ResourceExistsError(
|
|---|
| 815 | _('%(type)s value "%(name)s" already exists.',
|
|---|
| 816 | type=gettext(self.label[0]), name=self.name))
|
|---|
| 817 | self._check_and_coerce_fields()
|
|---|
| 818 |
|
|---|
| 819 | self.env.log.debug("Creating new %s '%s'", self.type, self.name)
|
|---|
| 820 | with self.env.db_transaction as db:
|
|---|
| 821 | try:
|
|---|
| 822 | if not self.value:
|
|---|
| 823 | row = db("""SELECT COALESCE(MAX(%s), 0) FROM enum
|
|---|
| 824 | WHERE type=%%s
|
|---|
| 825 | """ % db.cast('value', 'int'), (self.type,))
|
|---|
| 826 | self.value = int(float(row[0][0])) + 1 if row else 0
|
|---|
| 827 | db("""
|
|---|
| 828 | INSERT INTO enum (type, name, value, description)
|
|---|
| 829 | VALUES (%s, %s, %s, %s)
|
|---|
| 830 | """, (self.type, self.name, self.value,
|
|---|
| 831 | _to_null(self.description)))
|
|---|
| 832 | except self.env.db_exc.IntegrityError:
|
|---|
| 833 | raise ResourceExistsError(
|
|---|
| 834 | _('%(type)s value "%(name)s" already exists',
|
|---|
| 835 | type=gettext(self.label[0]), name=self.name))
|
|---|
| 836 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 837 | self._old_name = self.name
|
|---|
| 838 | self._old_value = self.value
|
|---|
| 839 |
|
|---|
| 840 | def update(self):
|
|---|
| 841 | """Update the enum.
|
|---|
| 842 |
|
|---|
| 843 | :raises TracError: if enum does not exist or enum name is empty.
|
|---|
| 844 | :raises ResourceExistsError: if renamed enum already exists.
|
|---|
| 845 | """
|
|---|
| 846 | if not self.exists:
|
|---|
| 847 | raise TracError(_("Cannot update non-existent enum."))
|
|---|
| 848 | self._check_and_coerce_fields()
|
|---|
| 849 |
|
|---|
| 850 | self.env.log.info("Updating %s '%s'", self.type, self.name)
|
|---|
| 851 | with self.env.db_transaction as db:
|
|---|
| 852 | try:
|
|---|
| 853 | db("""UPDATE enum SET name=%s,value=%s,description=%s
|
|---|
| 854 | WHERE type=%s AND name=%s
|
|---|
| 855 | """, (self.name, self.value,
|
|---|
| 856 | _to_null(self.description), self.type,
|
|---|
| 857 | self._old_name))
|
|---|
| 858 | except self.env.db_exc.IntegrityError:
|
|---|
| 859 | raise ResourceExistsError(
|
|---|
| 860 | _('%(type)s value "%(name)s" already exists',
|
|---|
| 861 | type=gettext(self.label[0]), name=self.name))
|
|---|
| 862 | self._old_value = self.value
|
|---|
| 863 | if self.name != self._old_name:
|
|---|
| 864 | # Update tickets
|
|---|
| 865 | db("UPDATE ticket SET %s=%%s WHERE %s=%%s"
|
|---|
| 866 | % (self.ticket_col, self.ticket_col),
|
|---|
| 867 | (self.name, self._old_name))
|
|---|
| 868 | self._old_name = self.name
|
|---|
| 869 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 870 |
|
|---|
| 871 | @classmethod
|
|---|
| 872 | def select(cls, env):
|
|---|
| 873 | with env.db_query as db:
|
|---|
| 874 | for name, value, description in db("""
|
|---|
| 875 | SELECT name, value, description FROM enum
|
|---|
| 876 | WHERE type=%s ORDER BY
|
|---|
| 877 | """ + db.cast('value', 'int'),
|
|---|
| 878 | (cls.type,)):
|
|---|
| 879 | obj = cls(env)
|
|---|
| 880 | obj.name = obj._old_name = name
|
|---|
| 881 | obj.value = obj._old_value = value
|
|---|
| 882 | obj.description = _null_to_empty(description)
|
|---|
| 883 | yield obj
|
|---|
| 884 |
|
|---|
| 885 | def _check_and_coerce_fields(self):
|
|---|
| 886 | self.name = simplify_whitespace(self.name)
|
|---|
| 887 | if not self.name:
|
|---|
| 888 | raise TracError(_("Invalid %(type)s name.",
|
|---|
| 889 | type=gettext(self.label[0])))
|
|---|
| 890 |
|
|---|
| 891 |
|
|---|
| 892 | class Type(AbstractEnum):
|
|---|
| 893 | type = 'ticket_type'
|
|---|
| 894 | ticket_col = 'type'
|
|---|
| 895 | label = N_("Ticket Type"), N_("Ticket Types")
|
|---|
| 896 |
|
|---|
| 897 |
|
|---|
| 898 | class Status(object):
|
|---|
| 899 | def __init__(self, env):
|
|---|
| 900 | self.env = env
|
|---|
| 901 |
|
|---|
| 902 | @classmethod
|
|---|
| 903 | def select(cls, env):
|
|---|
| 904 | for state in TicketSystem(env).get_all_status():
|
|---|
| 905 | status = cls(env)
|
|---|
| 906 | status.name = state
|
|---|
| 907 | yield status
|
|---|
| 908 |
|
|---|
| 909 | def __repr__(self):
|
|---|
| 910 | return '<%s %r>' % (self.__class__.__name__, self.name)
|
|---|
| 911 |
|
|---|
| 912 |
|
|---|
| 913 | class Resolution(AbstractEnum):
|
|---|
| 914 | type = 'resolution'
|
|---|
| 915 | label = N_("Resolution"), N_("Resolutions")
|
|---|
| 916 |
|
|---|
| 917 |
|
|---|
| 918 | class Priority(AbstractEnum):
|
|---|
| 919 | type = 'priority'
|
|---|
| 920 | label = N_("Priority"), N_("Priorities")
|
|---|
| 921 |
|
|---|
| 922 |
|
|---|
| 923 | class Severity(AbstractEnum):
|
|---|
| 924 | type = 'severity'
|
|---|
| 925 | label = N_("Severity"), N_("Severities")
|
|---|
| 926 |
|
|---|
| 927 |
|
|---|
| 928 | class Component(object):
|
|---|
| 929 |
|
|---|
| 930 | realm = 'component'
|
|---|
| 931 |
|
|---|
| 932 | exists = property(lambda self: self._old_name is not None)
|
|---|
| 933 |
|
|---|
| 934 | @property
|
|---|
| 935 | def resource(self):
|
|---|
| 936 | return Resource(self.realm, self.name)
|
|---|
| 937 |
|
|---|
| 938 | def __init__(self, env, name=None):
|
|---|
| 939 | """Create a new `Component` instance. If `name` is specified
|
|---|
| 940 | and the component with `name` exists, the component will be
|
|---|
| 941 | retrieved from the database.
|
|---|
| 942 |
|
|---|
| 943 | :raises ResourceNotFound: if `name` is not `None` and component
|
|---|
| 944 | with `name` does not exist.
|
|---|
| 945 | """
|
|---|
| 946 | self.env = env
|
|---|
| 947 | self.name = self._old_name = self.owner = self.description = None
|
|---|
| 948 | if name:
|
|---|
| 949 | for owner, description in self.env.db_query("""
|
|---|
| 950 | SELECT owner, description FROM component WHERE name=%s
|
|---|
| 951 | """, (name,)):
|
|---|
| 952 | self.name = self._old_name = name
|
|---|
| 953 | self.owner = _null_to_empty(owner)
|
|---|
| 954 | self.description = _null_to_empty(description)
|
|---|
| 955 | break
|
|---|
| 956 | else:
|
|---|
| 957 | raise ResourceNotFound(_("Component %(name)s does not exist.",
|
|---|
| 958 | name=name))
|
|---|
| 959 |
|
|---|
| 960 | def __repr__(self):
|
|---|
| 961 | return '<%s %r>' % (self.__class__.__name__, self.name)
|
|---|
| 962 |
|
|---|
| 963 | def delete(self):
|
|---|
| 964 | """Delete the component.
|
|---|
| 965 |
|
|---|
| 966 | :raises TracError: if component does not exist.
|
|---|
| 967 | """
|
|---|
| 968 | if not self.exists:
|
|---|
| 969 | raise TracError(_("Cannot delete non-existent component."))
|
|---|
| 970 |
|
|---|
| 971 | self.env.log.info("Deleting component '%s'", self.name)
|
|---|
| 972 | with self.env.db_transaction as db:
|
|---|
| 973 | db("DELETE FROM component WHERE name=%s", (self.name,))
|
|---|
| 974 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 975 | self.name = self._old_name = None
|
|---|
| 976 |
|
|---|
| 977 | def insert(self):
|
|---|
| 978 | """Insert a new component.
|
|---|
| 979 |
|
|---|
| 980 | :raises TracError: if component name is empty.
|
|---|
| 981 | :raises ResourceExistsError: if component with name already exists.
|
|---|
| 982 | """
|
|---|
| 983 | if self.exists:
|
|---|
| 984 | raise ResourceExistsError(
|
|---|
| 985 | _('Component "%(name)s" already exists.', name=self.name))
|
|---|
| 986 | self._check_and_coerce_fields()
|
|---|
| 987 |
|
|---|
| 988 | self.env.log.debug("Creating new component '%s'", self.name)
|
|---|
| 989 | with self.env.db_transaction as db:
|
|---|
| 990 | try:
|
|---|
| 991 | db("""
|
|---|
| 992 | INSERT INTO component (name,owner,description)
|
|---|
| 993 | VALUES (%s,%s,%s)
|
|---|
| 994 | """, (self.name, _to_null(self.owner),
|
|---|
| 995 | _to_null(self.description)))
|
|---|
| 996 | except self.env.db_exc.IntegrityError:
|
|---|
| 997 | raise ResourceExistsError(
|
|---|
| 998 | _('Component "%(name)s" already exists.', name=self.name))
|
|---|
| 999 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1000 | self._old_name = self.name
|
|---|
| 1001 |
|
|---|
| 1002 | def update(self):
|
|---|
| 1003 | """Update the component.
|
|---|
| 1004 |
|
|---|
| 1005 | :raises TracError: if component does not exist or component name
|
|---|
| 1006 | is empty.
|
|---|
| 1007 | :raises ResourceExistsError: if renamed component already exists.
|
|---|
| 1008 | """
|
|---|
| 1009 | if not self.exists:
|
|---|
| 1010 | raise TracError(_("Cannot update non-existent component."))
|
|---|
| 1011 | self._check_and_coerce_fields()
|
|---|
| 1012 |
|
|---|
| 1013 | self.env.log.info("Updating component '%s'", self.name)
|
|---|
| 1014 | with self.env.db_transaction as db:
|
|---|
| 1015 | try:
|
|---|
| 1016 | db("""UPDATE component SET name=%s,owner=%s, description=%s
|
|---|
| 1017 | WHERE name=%s
|
|---|
| 1018 | """, (self.name, _to_null(self.owner),
|
|---|
| 1019 | _to_null(self.description), self._old_name))
|
|---|
| 1020 | except self.env.db_exc.IntegrityError:
|
|---|
| 1021 | raise ResourceExistsError(
|
|---|
| 1022 | _('Component "%(name)s" already exists.', name=self.name))
|
|---|
| 1023 | if self.name != self._old_name:
|
|---|
| 1024 | # Update tickets
|
|---|
| 1025 | db("UPDATE ticket SET component=%s WHERE component=%s",
|
|---|
| 1026 | (self.name, self._old_name))
|
|---|
| 1027 | self._old_name = self.name
|
|---|
| 1028 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1029 |
|
|---|
| 1030 | @classmethod
|
|---|
| 1031 | def select(cls, env):
|
|---|
| 1032 | for name, owner, description in env.db_query("""
|
|---|
| 1033 | SELECT name, owner, description FROM component ORDER BY name
|
|---|
| 1034 | """):
|
|---|
| 1035 | component = cls(env)
|
|---|
| 1036 | component.name = component._old_name = name
|
|---|
| 1037 | component.owner = _null_to_empty(owner)
|
|---|
| 1038 | component.description = _null_to_empty(description)
|
|---|
| 1039 | yield component
|
|---|
| 1040 |
|
|---|
| 1041 | def _check_and_coerce_fields(self):
|
|---|
| 1042 | self.name = simplify_whitespace(self.name)
|
|---|
| 1043 | self.owner = simplify_whitespace(self.owner)
|
|---|
| 1044 | if not self.name:
|
|---|
| 1045 | raise TracError(_("Invalid component name."))
|
|---|
| 1046 |
|
|---|
| 1047 |
|
|---|
| 1048 | class MilestoneCache(core.Component):
|
|---|
| 1049 | """Cache for milestone data and factory for 'milestone' resources."""
|
|---|
| 1050 |
|
|---|
| 1051 | @cached
|
|---|
| 1052 | def milestones(self):
|
|---|
| 1053 | """Dictionary containing milestone data, indexed by name.
|
|---|
| 1054 |
|
|---|
| 1055 | Milestone data consist of a tuple containing the name, the
|
|---|
| 1056 | datetime objects for due and completed dates and the
|
|---|
| 1057 | description.
|
|---|
| 1058 | """
|
|---|
| 1059 | milestones = {}
|
|---|
| 1060 | for name, due, completed, description in self.env.db_query("""
|
|---|
| 1061 | SELECT name, due, completed, description FROM milestone
|
|---|
| 1062 | """):
|
|---|
| 1063 | milestones[name] = (
|
|---|
| 1064 | name,
|
|---|
| 1065 | _from_timestamp(due),
|
|---|
| 1066 | _from_timestamp(completed),
|
|---|
| 1067 | description or '')
|
|---|
| 1068 | return milestones
|
|---|
| 1069 |
|
|---|
| 1070 | def fetchone(self, name, milestone=None):
|
|---|
| 1071 | """Retrieve an existing milestone having the given `name`.
|
|---|
| 1072 |
|
|---|
| 1073 | If `milestone` is specified, fill that instance instead of creating
|
|---|
| 1074 | a fresh one.
|
|---|
| 1075 |
|
|---|
| 1076 | :return: `None` if no such milestone exists
|
|---|
| 1077 | """
|
|---|
| 1078 | data = self.milestones.get(name)
|
|---|
| 1079 | if data:
|
|---|
| 1080 | return self.factory(data, milestone)
|
|---|
| 1081 |
|
|---|
| 1082 | def fetchall(self):
|
|---|
| 1083 | """Iterator on all milestones."""
|
|---|
| 1084 | for data in self.milestones.values():
|
|---|
| 1085 | yield self.factory(data)
|
|---|
| 1086 |
|
|---|
| 1087 | def factory(self, values, milestone=None):
|
|---|
| 1088 | """Build a `Milestone` object from milestone data.
|
|---|
| 1089 |
|
|---|
| 1090 | That instance remains *private*, i.e. can't be retrieved by
|
|---|
| 1091 | name by other processes or even by other threads in the same
|
|---|
| 1092 | process, until its `~Milestone.insert` method gets called with
|
|---|
| 1093 | success.
|
|---|
| 1094 | """
|
|---|
| 1095 | name, due, completed, description = values
|
|---|
| 1096 | milestone = milestone or Milestone(self.env)
|
|---|
| 1097 | milestone.name = name
|
|---|
| 1098 | milestone.due = due
|
|---|
| 1099 | milestone.completed = completed
|
|---|
| 1100 | milestone.description = description
|
|---|
| 1101 | milestone.checkin(invalidate=False)
|
|---|
| 1102 | return milestone
|
|---|
| 1103 |
|
|---|
| 1104 |
|
|---|
| 1105 | class Milestone(object):
|
|---|
| 1106 |
|
|---|
| 1107 | realm = 'milestone'
|
|---|
| 1108 |
|
|---|
| 1109 | @property
|
|---|
| 1110 | def resource(self):
|
|---|
| 1111 | return Resource(self.realm, self.name) ### .version !!!
|
|---|
| 1112 |
|
|---|
| 1113 | def __init__(self, env, name=None):
|
|---|
| 1114 | """Create an undefined milestone or fetch one from the database,
|
|---|
| 1115 | if `name` is given.
|
|---|
| 1116 |
|
|---|
| 1117 | In the latter case however, raise `~trac.resource.ResourceNotFound`
|
|---|
| 1118 | if a milestone of that name doesn't exist yet.
|
|---|
| 1119 | """
|
|---|
| 1120 | self.env = env
|
|---|
| 1121 | self.name = self._old = None
|
|---|
| 1122 | if name:
|
|---|
| 1123 | if not self.cache.fetchone(name, self):
|
|---|
| 1124 | raise ResourceNotFound(
|
|---|
| 1125 | _("Milestone %(name)s does not exist.",
|
|---|
| 1126 | name=name), _("Invalid milestone name."))
|
|---|
| 1127 | else:
|
|---|
| 1128 | self.cache.factory((None, None, None, ''), self)
|
|---|
| 1129 |
|
|---|
| 1130 | def __repr__(self):
|
|---|
| 1131 | return '<%s %r>' % (self.__class__.__name__, self.name)
|
|---|
| 1132 |
|
|---|
| 1133 | @property
|
|---|
| 1134 | def cache(self):
|
|---|
| 1135 | return MilestoneCache(self.env)
|
|---|
| 1136 |
|
|---|
| 1137 | exists = property(lambda self: self._old['name'] is not None)
|
|---|
| 1138 | is_completed = property(lambda self: self.completed is not None)
|
|---|
| 1139 | is_late = property(lambda self: self.due and
|
|---|
| 1140 | self.due < datetime_now(utc))
|
|---|
| 1141 |
|
|---|
| 1142 | def checkin(self, invalidate=True):
|
|---|
| 1143 | self._old = {'name': self.name, 'due': self.due,
|
|---|
| 1144 | 'completed': self.completed,
|
|---|
| 1145 | 'description': self.description}
|
|---|
| 1146 | if invalidate:
|
|---|
| 1147 | del self.cache.milestones
|
|---|
| 1148 |
|
|---|
| 1149 | def delete(self):
|
|---|
| 1150 | """Delete the milestone."""
|
|---|
| 1151 | self.env.log.info("Deleting milestone '%s'", self.name)
|
|---|
| 1152 | with self.env.db_transaction as db:
|
|---|
| 1153 | db("DELETE FROM milestone WHERE name=%s", (self.name,))
|
|---|
| 1154 | Attachment.delete_all(self.env, self.realm, self.name)
|
|---|
| 1155 | del self.cache.milestones
|
|---|
| 1156 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1157 | self._old['name'] = None
|
|---|
| 1158 |
|
|---|
| 1159 | for listener in TicketSystem(self.env).milestone_change_listeners:
|
|---|
| 1160 | listener.milestone_deleted(self)
|
|---|
| 1161 |
|
|---|
| 1162 | def insert(self):
|
|---|
| 1163 | """Insert a new milestone.
|
|---|
| 1164 |
|
|---|
| 1165 | :raises TracError: if milestone name is empty.
|
|---|
| 1166 | :raises ResourceExistsError: if milestone with name already exists.
|
|---|
| 1167 | """
|
|---|
| 1168 | self.name = simplify_whitespace(self.name)
|
|---|
| 1169 | if not self.name:
|
|---|
| 1170 | raise TracError(_("Invalid milestone name."))
|
|---|
| 1171 |
|
|---|
| 1172 | self.env.log.debug("Creating new milestone '%s'", self.name)
|
|---|
| 1173 | with self.env.db_transaction as db:
|
|---|
| 1174 | try:
|
|---|
| 1175 | db("""
|
|---|
| 1176 | INSERT INTO milestone (name, due, completed, description)
|
|---|
| 1177 | VALUES (%s,%s,%s,%s)
|
|---|
| 1178 | """, (self.name, to_utimestamp(self.due),
|
|---|
| 1179 | to_utimestamp(self.completed), self.description))
|
|---|
| 1180 | except self.env.db_exc.IntegrityError:
|
|---|
| 1181 | raise ResourceExistsError(
|
|---|
| 1182 | _('Milestone "%(name)s" already exists.', name=self.name))
|
|---|
| 1183 | self.checkin()
|
|---|
| 1184 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1185 |
|
|---|
| 1186 | for listener in TicketSystem(self.env).milestone_change_listeners:
|
|---|
| 1187 | listener.milestone_created(self)
|
|---|
| 1188 |
|
|---|
| 1189 | def update(self, author=None):
|
|---|
| 1190 | """Update the milestone.
|
|---|
| 1191 |
|
|---|
| 1192 | :raises TracError: if milestone does not exist or milestone name
|
|---|
| 1193 | is empty.
|
|---|
| 1194 | :raises ResourceExistsError: if renamed milestone already exists.
|
|---|
| 1195 | """
|
|---|
| 1196 | self.name = simplify_whitespace(self.name)
|
|---|
| 1197 | if not self.name:
|
|---|
| 1198 | raise TracError(_("Invalid milestone name."))
|
|---|
| 1199 |
|
|---|
| 1200 | old = self._old.copy()
|
|---|
| 1201 | with self.env.db_transaction as db:
|
|---|
| 1202 | if self.name != old['name']:
|
|---|
| 1203 | # Update milestone field in tickets
|
|---|
| 1204 | self.move_tickets(self.name, author, "Milestone renamed")
|
|---|
| 1205 | # Reparent attachments
|
|---|
| 1206 | Attachment.reparent_all(self.env, self.realm, old['name'],
|
|---|
| 1207 | self.realm, self.name)
|
|---|
| 1208 |
|
|---|
| 1209 | self.env.log.info("Updating milestone '%s'", old['name'])
|
|---|
| 1210 | try:
|
|---|
| 1211 | db("""UPDATE milestone
|
|---|
| 1212 | SET name=%s, due=%s, completed=%s, description=%s
|
|---|
| 1213 | WHERE name=%s
|
|---|
| 1214 | """, (self.name, to_utimestamp(self.due),
|
|---|
| 1215 | to_utimestamp(self.completed),
|
|---|
| 1216 | self.description, old['name']))
|
|---|
| 1217 | except self.env.db_exc.IntegrityError:
|
|---|
| 1218 | raise ResourceExistsError(
|
|---|
| 1219 | _('Milestone "%(name)s" already exists.', name=self.name))
|
|---|
| 1220 | self.checkin()
|
|---|
| 1221 | # Fields need reset if renamed or completed/due changed
|
|---|
| 1222 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1223 |
|
|---|
| 1224 | old_values = {k: v for k, v in old.items()
|
|---|
| 1225 | if getattr(self, k) != v}
|
|---|
| 1226 | for listener in TicketSystem(self.env).milestone_change_listeners:
|
|---|
| 1227 | listener.milestone_changed(self, old_values)
|
|---|
| 1228 |
|
|---|
| 1229 | def move_tickets(self, new_milestone, author, comment=None,
|
|---|
| 1230 | exclude_closed=False):
|
|---|
| 1231 | """Move tickets associated with this milestone to another
|
|---|
| 1232 | milestone.
|
|---|
| 1233 |
|
|---|
| 1234 | :param new_milestone: milestone to which the tickets are moved
|
|---|
| 1235 | :param author: author of the change
|
|---|
| 1236 | :param comment: comment that is inserted into moved tickets. The
|
|---|
| 1237 | string should not be translated.
|
|---|
| 1238 | :param exclude_closed: whether tickets with status closed should be
|
|---|
| 1239 | excluded
|
|---|
| 1240 |
|
|---|
| 1241 | :return: a list of ids of tickets that were moved
|
|---|
| 1242 | """
|
|---|
| 1243 | # Check if milestone exists, but if the milestone is being renamed
|
|---|
| 1244 | # the new milestone won't exist in the cache yet so skip the test
|
|---|
| 1245 | if new_milestone and new_milestone != self.name:
|
|---|
| 1246 | if not self.cache.fetchone(new_milestone):
|
|---|
| 1247 | raise ResourceNotFound(
|
|---|
| 1248 | _("Milestone %(name)s does not exist.",
|
|---|
| 1249 | name=new_milestone), _("Invalid milestone name."))
|
|---|
| 1250 | now = datetime_now(utc)
|
|---|
| 1251 | sql = "SELECT id FROM ticket WHERE milestone=%s"
|
|---|
| 1252 | if exclude_closed:
|
|---|
| 1253 | sql += " AND status != 'closed'"
|
|---|
| 1254 | with self.env.db_transaction as db:
|
|---|
| 1255 | tkt_ids = [int(row[0]) for row in db(sql, (self._old['name'],))]
|
|---|
| 1256 | if tkt_ids:
|
|---|
| 1257 | self.env.log.info("Moving tickets associated with milestone "
|
|---|
| 1258 | "'%s' to milestone '%s'", self._old['name'],
|
|---|
| 1259 | new_milestone)
|
|---|
| 1260 | for tkt_id in tkt_ids:
|
|---|
| 1261 | ticket = Ticket(self.env, tkt_id)
|
|---|
| 1262 | ticket['milestone'] = new_milestone
|
|---|
| 1263 | ticket.save_changes(author, comment, now)
|
|---|
| 1264 | return tkt_ids
|
|---|
| 1265 |
|
|---|
| 1266 | @classmethod
|
|---|
| 1267 | def select(cls, env, include_completed=True):
|
|---|
| 1268 | milestones = MilestoneCache(env).fetchall()
|
|---|
| 1269 | if not include_completed:
|
|---|
| 1270 | milestones = [m for m in milestones if m.completed is None]
|
|---|
| 1271 | def milestone_order(m):
|
|---|
| 1272 | return (m.completed or utcmax,
|
|---|
| 1273 | m.due or utcmax,
|
|---|
| 1274 | embedded_numbers(m.name))
|
|---|
| 1275 | return sorted(milestones, key=milestone_order)
|
|---|
| 1276 |
|
|---|
| 1277 |
|
|---|
| 1278 | class Report(object):
|
|---|
| 1279 |
|
|---|
| 1280 | realm = 'report'
|
|---|
| 1281 |
|
|---|
| 1282 | @property
|
|---|
| 1283 | def exists(self):
|
|---|
| 1284 | return self.id is not None
|
|---|
| 1285 |
|
|---|
| 1286 | def __init__(self, env, id=None):
|
|---|
| 1287 | self.env = env
|
|---|
| 1288 | self.id = self.title = self.query = self.description = None
|
|---|
| 1289 | if id is not None:
|
|---|
| 1290 | id_as_int = as_int(id, None)
|
|---|
| 1291 | if id_as_int is not None:
|
|---|
| 1292 | for title, description, query in self.env.db_query("""
|
|---|
| 1293 | SELECT title, description, query FROM report
|
|---|
| 1294 | WHERE id=%s
|
|---|
| 1295 | """, (id_as_int,)):
|
|---|
| 1296 | self.id = id_as_int
|
|---|
| 1297 | self.title = _null_to_empty(title)
|
|---|
| 1298 | self.description = _null_to_empty(description)
|
|---|
| 1299 | self.query = _null_to_empty(query)
|
|---|
| 1300 | return
|
|---|
| 1301 | raise ResourceNotFound(_("Report {%(num)s} does not exist.",
|
|---|
| 1302 | num=id), _("Invalid Report Number"))
|
|---|
| 1303 |
|
|---|
| 1304 | def __repr__(self):
|
|---|
| 1305 | return '<%s %r>' % (self.__class__.__name__, self.id)
|
|---|
| 1306 |
|
|---|
| 1307 | def delete(self):
|
|---|
| 1308 | """Delete the report."""
|
|---|
| 1309 | assert self.exists, "Cannot delete non-existent report"
|
|---|
| 1310 | self.env.db_transaction("DELETE FROM report WHERE id=%s", (self.id,))
|
|---|
| 1311 | self.id = None
|
|---|
| 1312 |
|
|---|
| 1313 | def insert(self):
|
|---|
| 1314 | """Insert a new report.
|
|---|
| 1315 |
|
|---|
| 1316 | :raises TracError: if `query` is empty
|
|---|
| 1317 | """
|
|---|
| 1318 | assert not self.exists, "Cannot insert existing report"
|
|---|
| 1319 | if not self.query:
|
|---|
| 1320 | raise TracError(_("Query cannot be empty."))
|
|---|
| 1321 |
|
|---|
| 1322 | self.env.log.debug("Creating new report '%s'", self.id)
|
|---|
| 1323 | with self.env.db_transaction as db:
|
|---|
| 1324 | cursor = db.cursor()
|
|---|
| 1325 | cursor.execute("""
|
|---|
| 1326 | INSERT INTO report (title,query,description) VALUES (%s,%s,%s)
|
|---|
| 1327 | """, (_to_null(self.title), _to_null(self.query),
|
|---|
| 1328 | _to_null(self.description)))
|
|---|
| 1329 | self.id = db.get_last_id(cursor, 'report')
|
|---|
| 1330 |
|
|---|
| 1331 | def update(self):
|
|---|
| 1332 | """Update a report.
|
|---|
| 1333 |
|
|---|
| 1334 | :raises TracError: if `query` is empty
|
|---|
| 1335 | """
|
|---|
| 1336 | if not self.query:
|
|---|
| 1337 | raise TracError(_("Query cannot be empty."))
|
|---|
| 1338 | self.env.db_transaction("""
|
|---|
| 1339 | UPDATE report SET title=%s, query=%s, description=%s
|
|---|
| 1340 | WHERE id=%s
|
|---|
| 1341 | """, (_to_null(self.title), _to_null(self.query),
|
|---|
| 1342 | _to_null(self.description), self.id))
|
|---|
| 1343 |
|
|---|
| 1344 | @classmethod
|
|---|
| 1345 | def select(cls, env, sort='id', asc=True):
|
|---|
| 1346 | for id, title, description, query in env.db_query("""
|
|---|
| 1347 | SELECT id, title, description, query
|
|---|
| 1348 | FROM report ORDER BY %s %s
|
|---|
| 1349 | """ % ('title' if sort == 'title' else 'id',
|
|---|
| 1350 | '' if asc else 'DESC')):
|
|---|
| 1351 | report = cls(env)
|
|---|
| 1352 | report.id = id
|
|---|
| 1353 | report.title = _null_to_empty(title)
|
|---|
| 1354 | report.description = _null_to_empty(description)
|
|---|
| 1355 | report.query = _null_to_empty(query)
|
|---|
| 1356 | yield report
|
|---|
| 1357 |
|
|---|
| 1358 |
|
|---|
| 1359 | class Version(object):
|
|---|
| 1360 |
|
|---|
| 1361 | realm = 'version'
|
|---|
| 1362 |
|
|---|
| 1363 | exists = property(lambda self: self._old_name is not None)
|
|---|
| 1364 |
|
|---|
| 1365 | @property
|
|---|
| 1366 | def resource(self):
|
|---|
| 1367 | return Resource(self.realm, self.name)
|
|---|
| 1368 |
|
|---|
| 1369 | def __init__(self, env, name=None):
|
|---|
| 1370 | self.env = env
|
|---|
| 1371 | self.name = self._old_name = self.time = self.description = None
|
|---|
| 1372 | if name:
|
|---|
| 1373 | for time, description in self.env.db_query("""
|
|---|
| 1374 | SELECT time, description FROM version WHERE name=%s
|
|---|
| 1375 | """, (name,)):
|
|---|
| 1376 | self.name = self._old_name = name
|
|---|
| 1377 | self.time = _from_timestamp(time)
|
|---|
| 1378 | self.description = _null_to_empty(description)
|
|---|
| 1379 | break
|
|---|
| 1380 | else:
|
|---|
| 1381 | raise ResourceNotFound(_("Version %(name)s does not exist.",
|
|---|
| 1382 | name=name))
|
|---|
| 1383 |
|
|---|
| 1384 | def __repr__(self):
|
|---|
| 1385 | return '<%s %r>' % (self.__class__.__name__, self.name)
|
|---|
| 1386 |
|
|---|
| 1387 | def delete(self):
|
|---|
| 1388 | """Delete the version.
|
|---|
| 1389 |
|
|---|
| 1390 | :raises TracError: if version does not exist.
|
|---|
| 1391 | """
|
|---|
| 1392 | if not self.exists:
|
|---|
| 1393 | raise TracError(_("Cannot delete non-existent version."))
|
|---|
| 1394 |
|
|---|
| 1395 | self.env.log.info("Deleting version '%s'", self.name)
|
|---|
| 1396 | with self.env.db_transaction as db:
|
|---|
| 1397 | db("DELETE FROM version WHERE name=%s", (self.name,))
|
|---|
| 1398 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1399 | self.name = self._old_name = None
|
|---|
| 1400 |
|
|---|
| 1401 | def insert(self):
|
|---|
| 1402 | """Insert a new version.
|
|---|
| 1403 |
|
|---|
| 1404 | :raises TracError: if version name is empty.
|
|---|
| 1405 | :raises ResourceExistsError: if version with name already exists.
|
|---|
| 1406 | """
|
|---|
| 1407 | self._check_and_coerce_fields()
|
|---|
| 1408 |
|
|---|
| 1409 | self.env.log.debug("Creating new version '%s'", self.name)
|
|---|
| 1410 | with self.env.db_transaction as db:
|
|---|
| 1411 | try:
|
|---|
| 1412 | db("""
|
|---|
| 1413 | INSERT INTO version (name,time,description)
|
|---|
| 1414 | VALUES (%s,%s,%s)
|
|---|
| 1415 | """, (self.name, to_utimestamp(self.time),
|
|---|
| 1416 | _to_null(self.description)))
|
|---|
| 1417 | except self.env.db_exc.IntegrityError:
|
|---|
| 1418 | raise ResourceExistsError(
|
|---|
| 1419 | _('Version "%(name)s" already exists.', name=self.name))
|
|---|
| 1420 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1421 | self._old_name = self.name
|
|---|
| 1422 |
|
|---|
| 1423 | def update(self):
|
|---|
| 1424 | """Update the version.
|
|---|
| 1425 |
|
|---|
| 1426 | :raises TracError: if version does not exist or version name
|
|---|
| 1427 | is empty.
|
|---|
| 1428 | :raises ResourceExistsError: if renamed value already exists.
|
|---|
| 1429 | """
|
|---|
| 1430 | if not self.exists:
|
|---|
| 1431 | raise TracError(_("Cannot update non-existent version."))
|
|---|
| 1432 | self._check_and_coerce_fields()
|
|---|
| 1433 |
|
|---|
| 1434 | self.env.log.info("Updating version '%s'", self.name)
|
|---|
| 1435 | with self.env.db_transaction as db:
|
|---|
| 1436 | try:
|
|---|
| 1437 | db("""UPDATE version SET name=%s, time=%s, description=%s
|
|---|
| 1438 | WHERE name=%s
|
|---|
| 1439 | """, (self.name, to_utimestamp(self.time),
|
|---|
| 1440 | self.description, self._old_name))
|
|---|
| 1441 | except self.env.db_exc.IntegrityError:
|
|---|
| 1442 | raise ResourceExistsError(
|
|---|
| 1443 | _('Version "%(name)s" already exists.', name=self.name))
|
|---|
| 1444 | if self.name != self._old_name:
|
|---|
| 1445 | # Update tickets
|
|---|
| 1446 | db("UPDATE ticket SET version=%s WHERE version=%s",
|
|---|
| 1447 | (self.name, self._old_name))
|
|---|
| 1448 | self._old_name = self.name
|
|---|
| 1449 | # Fields need reset if renamed or if time is changed
|
|---|
| 1450 | TicketSystem(self.env).reset_ticket_fields()
|
|---|
| 1451 |
|
|---|
| 1452 | @classmethod
|
|---|
| 1453 | def select(cls, env):
|
|---|
| 1454 | versions = []
|
|---|
| 1455 | for name, time, description in env.db_query("""
|
|---|
| 1456 | SELECT name, time, description FROM version"""):
|
|---|
| 1457 | version = cls(env)
|
|---|
| 1458 | version.name = version._old_name = name
|
|---|
| 1459 | version.time = _from_timestamp(time)
|
|---|
| 1460 | version.description = _null_to_empty(description)
|
|---|
| 1461 | versions.append(version)
|
|---|
| 1462 | def version_order(v):
|
|---|
| 1463 | return v.time or utcmax, embedded_numbers(v.name)
|
|---|
| 1464 | return sorted(versions, key=version_order, reverse=True)
|
|---|
| 1465 |
|
|---|
| 1466 | def _check_and_coerce_fields(self):
|
|---|
| 1467 | self.name = simplify_whitespace(self.name)
|
|---|
| 1468 | if not self.name:
|
|---|
| 1469 | raise TracError(_("Invalid version name."))
|
|---|
