roundup/cgi/templating.py

   1 import sys, cgi, urllib, os, re, os.path, time, errno
   2
   3 from roundup import hyperdb, date
   4 from roundup.i18n import _
   5
   6 try:
   7     import cPickle as pickle
   8 except ImportError:
   9     import pickle
  10 try:
  11     import cStringIO as StringIO
  12 except ImportError:
  13     import StringIO
  14 try:
  15     import StructuredText
  16 except ImportError:
  17     StructuredText = None
  18
  19 # bring in the templating support
  20 from roundup.cgi.PageTemplates import PageTemplate
  21 from roundup.cgi.PageTemplates.Expressions import getEngine
  22 from roundup.cgi.TAL.TALInterpreter import TALInterpreter
  23 from roundup.cgi import ZTUtils
  24
  25 class NoTemplate(Exception):
  26     pass
  27
  28 class Templates:
  29     templates = {}
  30
  31     def __init__(self, dir):
  32         self.dir = dir
  33
  34     def precompileTemplates(self):
  35         ''' Go through a directory and precompile all the templates therein
  36         '''
  37         for filename in os.listdir(self.dir):
  38             if os.path.isdir(filename): continue
  39             if '.' in filename:
  40                 name, extension = filename.split('.')
  41                 self.getTemplate(name, extension)
  42             else:
  43                 self.getTemplate(filename, None)
  44
  45     def get(self, name, extension):
  46         ''' Interface to get a template, possibly loading a compiled template.
  47
  48             "name" and "extension" indicate the template we're after, which in
  49             most cases will be "name.extension". If "extension" is None, then
  50             we look for a template just called "name" with no extension.
  51
  52             If the file "name.extension" doesn't exist, we look for
  53             "_generic.extension" as a fallback.
  54         '''
  55         # default the name to "home"
  56         if name is None:
  57             name = 'home'
  58
  59         # find the source, figure the time it was last modified
  60         if extension:
  61             filename = '%s.%s'%(name, extension)
  62         else:
  63             filename = name
  64         src = os.path.join(self.dir, filename)
  65         try:
  66             stime = os.stat(src)[os.path.stat.ST_MTIME]
  67         except os.error, error:
  68             if error.errno != errno.ENOENT:
  69                 raise
  70             if not extension:
  71                 raise NoTemplate, 'Template file "%s" doesn\'t exist'%name
  72
  73             # try for a generic template
  74             generic = '_generic.%s'%extension
  75             src = os.path.join(self.dir, generic)
  76             try:
  77                 stime = os.stat(src)[os.path.stat.ST_MTIME]
  78             except os.error, error:
  79                 if error.errno != errno.ENOENT:
  80                     raise
  81                 # nicer error
  82                 raise NoTemplate, 'No template file exists for templating '\
  83                     '"%s" with template "%s" (neither "%s" nor "%s")'%(name,
  84                     extension, filename, generic)
  85             filename = generic
  86
  87         if self.templates.has_key(filename) and \
  88                 stime < self.templates[filename].mtime:
  89             # compiled template is up to date
  90             return self.templates[filename]
  91
  92         # compile the template
  93         self.templates[filename] = pt = RoundupPageTemplate()
  94         pt.write(open(src).read())
  95         pt.id = filename
  96         pt.mtime = time.time()
  97         return pt
  98
  99     def __getitem__(self, name):
 100         name, extension = os.path.splitext(name)
 101         if extension:
 102             extension = extension[1:]
 103         try:
 104             return self.get(name, extension)
 105         except NoTemplate, message:
 106             raise KeyError, message
 107
 108 class RoundupPageTemplate(PageTemplate.PageTemplate):
 109     ''' A Roundup-specific PageTemplate.
 110
 111         Interrogate the client to set up the various template variables to
 112         be available:
 113
 114         *context*
 115          this is one of three things:
 116          1. None - we're viewing a "home" page
 117          2. The current class of item being displayed. This is an HTMLClass
 118             instance.
 119          3. The current item from the database, if we're viewing a specific
 120             item, as an HTMLItem instance.
 121         *request*
 122           Includes information about the current request, including:
 123            - the url
 124            - the current index information (``filterspec``, ``filter`` args,
 125              ``properties``, etc) parsed out of the form.
 126            - methods for easy filterspec link generation
 127            - *user*, the current user node as an HTMLItem instance
 128            - *form*, the current CGI form information as a FieldStorage
 129         *config*
 130           The current tracker config.
 131         *db*
 132           The current database, used to access arbitrary database items.
 133         *utils*
 134           This is a special class that has its base in the TemplatingUtils
 135           class in this file. If the tracker interfaces module defines a
 136           TemplatingUtils class then it is mixed in, overriding the methods
 137           in the base class.
 138     '''
 139     def getContext(self, client, classname, request):
 140         # construct the TemplatingUtils class
 141         utils = TemplatingUtils
 142         if hasattr(client.instance.interfaces, 'TemplatingUtils'):
 143             class utils(client.instance.interfaces.TemplatingUtils, utils):
 144                 pass
 145
 146         c = {
 147              'options': {},
 148              'nothing': None,
 149              'request': request,
 150              'db': HTMLDatabase(client),
 151              'config': client.instance.config,
 152              'tracker': client.instance,
 153              'utils': utils(client),
 154              'templates': Templates(client.instance.config.TEMPLATES),
 155         }
 156         # add in the item if there is one
 157         if client.nodeid:
 158             if classname == 'user':
 159                 c['context'] = HTMLUser(client, classname, client.nodeid)
 160             else:
 161                 c['context'] = HTMLItem(client, classname, client.nodeid)
 162         elif client.db.classes.has_key(classname):
 163             c['context'] = HTMLClass(client, classname)
 164         return c
 165
 166     def render(self, client, classname, request, **options):
 167         """Render this Page Template"""
 168
 169         if not self._v_cooked:
 170             self._cook()
 171
 172         __traceback_supplement__ = (PageTemplate.PageTemplateTracebackSupplement, self)
 173
 174         if self._v_errors:
 175             raise PageTemplate.PTRuntimeError, \
 176                 'Page Template %s has errors.'%self.id
 177
 178         # figure the context
 179         classname = classname or client.classname
 180         request = request or HTMLRequest(client)
 181         c = self.getContext(client, classname, request)
 182         c.update({'options': options})
 183
 184         # and go
 185         output = StringIO.StringIO()
 186         TALInterpreter(self._v_program, self.macros,
 187             getEngine().getContext(c), output, tal=1, strictinsert=0)()
 188         return output.getvalue()
 189
 190 class HTMLDatabase:
 191     ''' Return HTMLClasses for valid class fetches
 192     '''
 193     def __init__(self, client):
 194         self._client = client
 195
 196         # we want config to be exposed
 197         self.config = client.db.config
 198
 199     def __getitem__(self, item):
 200         self._client.db.getclass(item)
 201         return HTMLClass(self._client, item)
 202
 203     def __getattr__(self, attr):
 204         try:
 205             return self[attr]
 206         except KeyError:
 207             raise AttributeError, attr
 208
 209     def classes(self):
 210         l = self._client.db.classes.keys()
 211         l.sort()
 212         return [HTMLClass(self._client, cn) for cn in l]
 213
 214 def lookupIds(db, prop, ids, num_re=re.compile('-?\d+')):
 215     cl = db.getclass(prop.classname)
 216     l = []
 217     for entry in ids:
 218         if num_re.match(entry):
 219             l.append(entry)
 220         else:
 221             try:
 222                 l.append(cl.lookup(entry))
 223             except KeyError:
 224                 # ignore invalid keys
 225                 pass
 226     return l
 227
 228 class HTMLPermissions:
 229     ''' Helpers that provide answers to commonly asked Permission questions.
 230     '''
 231     def is_edit_ok(self):
 232         ''' Is the user allowed to Edit the current class?
 233         '''
 234         return self._db.security.hasPermission('Edit', self._client.userid,
 235             self._classname)
 236     def is_view_ok(self):
 237         ''' Is the user allowed to View the current class?
 238         '''
 239         return self._db.security.hasPermission('View', self._client.userid,
 240             self._classname)
 241     def is_only_view_ok(self):
 242         ''' Is the user only allowed to View (ie. not Edit) the current class?
 243         '''
 244         return self.is_view_ok() and not self.is_edit_ok()
 245
 246 class HTMLClass(HTMLPermissions):
 247     ''' Accesses through a class (either through *class* or *db.<classname>*)
 248     '''
 249     def __init__(self, client, classname):
 250         self._client = client
 251         self._db = client.db
 252
 253         # we want classname to be exposed, but _classname gives a
 254         # consistent API for extending Class/Item
 255         self._classname = self.classname = classname
 256         self._klass = self._db.getclass(self.classname)
 257         self._props = self._klass.getprops()
 258
 259     def __repr__(self):
 260         return '<HTMLClass(0x%x) %s>'%(id(self), self.classname)
 261
 262     def __getitem__(self, item):
 263         ''' return an HTMLProperty instance
 264         '''
 265        #print 'HTMLClass.getitem', (self, item)
 266
 267         # we don't exist
 268         if item == 'id':
 269             return None
 270
 271         # get the property
 272         prop = self._props[item]
 273
 274         # look up the correct HTMLProperty class
 275         form = self._client.form
 276         for klass, htmlklass in propclasses:
 277             if not isinstance(prop, klass):
 278                 continue
 279             if form.has_key(item):
 280                 if isinstance(prop, hyperdb.Multilink):
 281                     value = lookupIds(self._db, prop,
 282                         handleListCGIValue(form[item]))
 283                 elif isinstance(prop, hyperdb.Link):
 284                     value = form[item].value.strip()
 285                     if value:
 286                         value = lookupIds(self._db, prop, [value])[0]
 287                     else:
 288                         value = None
 289                 else:
 290                     value = form[item].value.strip() or None
 291             else:
 292                 if isinstance(prop, hyperdb.Multilink):
 293                     value = []
 294                 else:
 295                     value = None
 296             return htmlklass(self._client, '', prop, item, value)
 297
 298         # no good
 299         raise KeyError, item
 300
 301     def __getattr__(self, attr):
 302         ''' convenience access '''
 303         try:
 304             return self[attr]
 305         except KeyError:
 306             raise AttributeError, attr
 307
 308     def getItem(self, itemid, num_re=re.compile('\d+')):
 309         ''' Get an item of this class by its item id.
 310         '''
 311         # make sure we're looking at an itemid
 312         if not num_re.match(itemid):
 313             itemid = self._klass.lookup(itemid)
 314
 315         if self.classname == 'user':
 316             klass = HTMLUser
 317         else:
 318             klass = HTMLItem
 319
 320         return klass(self._client, self.classname, itemid)
 321
 322     def properties(self):
 323         ''' Return HTMLProperty for all of this class' properties.
 324         '''
 325         l = []
 326         for name, prop in self._props.items():
 327             for klass, htmlklass in propclasses:
 328                 if isinstance(prop, hyperdb.Multilink):
 329                     value = []
 330                 else:
 331                     value = None
 332                 if isinstance(prop, klass):
 333                     l.append(htmlklass(self._client, '', prop, name, value))
 334         return l
 335
 336     def list(self):
 337         ''' List all items in this class.
 338         '''
 339         if self.classname == 'user':
 340             klass = HTMLUser
 341         else:
 342             klass = HTMLItem
 343
 344         # get the list and sort it nicely
 345         l = self._klass.list()
 346         sortfunc = make_sort_function(self._db, self.classname)
 347         l.sort(sortfunc)
 348
 349         l = [klass(self._client, self.classname, x) for x in l]
 350         return l
 351
 352     def csv(self):
 353         ''' Return the items of this class as a chunk of CSV text.
 354         '''
 355         # get the CSV module
 356         try:
 357             import csv
 358         except ImportError:
 359             return 'Sorry, you need the csv module to use this function.\n'\
 360                 'Get it from: http://www.object-craft.com.au/projects/csv/'
 361
 362         props = self.propnames()
 363         p = csv.parser()
 364         s = StringIO.StringIO()
 365         s.write(p.join(props) + '\n')
 366         for nodeid in self._klass.list():
 367             l = []
 368             for name in props:
 369                 value = self._klass.get(nodeid, name)
 370                 if value is None:
 371                     l.append('')
 372                 elif isinstance(value, type([])):
 373                     l.append(':'.join(map(str, value)))
 374                 else:
 375                     l.append(str(self._klass.get(nodeid, name)))
 376             s.write(p.join(l) + '\n')
 377         return s.getvalue()
 378
 379     def propnames(self):
 380         ''' Return the list of the names of the properties of this class.
 381         '''
 382         idlessprops = self._klass.getprops(protected=0).keys()
 383         idlessprops.sort()
 384         return ['id'] + idlessprops
 385
 386     def filter(self, request=None):
 387         ''' Return a list of items from this class, filtered and sorted
 388             by the current requested filterspec/filter/sort/group args
 389         '''
 390         if request is not None:
 391             filterspec = request.filterspec
 392             sort = request.sort
 393             group = request.group
 394         if self.classname == 'user':
 395             klass = HTMLUser
 396         else:
 397             klass = HTMLItem
 398         l = [klass(self._client, self.classname, x)
 399              for x in self._klass.filter(None, filterspec, sort, group)]
 400         return l
 401
 402     def classhelp(self, properties=None, label='list', width='500',
 403             height='400'):
 404         ''' Pop up a javascript window with class help
 405
 406             This generates a link to a popup window which displays the
 407             properties indicated by "properties" of the class named by
 408             "classname". The "properties" should be a comma-separated list
 409             (eg. 'id,name,description'). Properties defaults to all the
 410             properties of a class (excluding id, creator, created and
 411             activity).
 412
 413             You may optionally override the label displayed, the width and
 414             height. The popup window will be resizable and scrollable.
 415         '''
 416         if properties is None:
 417             properties = self._klass.getprops(protected=0).keys()
 418             properties.sort()
 419             properties = ','.join(properties)
 420         return '<a href="javascript:help_window(\'%s?:template=help&' \
 421             'properties=%s\', \'%s\', \'%s\')"><b>(%s)</b></a>'%(
 422             self.classname, properties, width, height, label)
 423
 424     def submit(self, label="Submit New Entry"):
 425         ''' Generate a submit button (and action hidden element)
 426         '''
 427         return '  <input type="hidden" name=":action" value="new">\n'\
 428         '  <input type="submit" name="submit" value="%s">'%label
 429
 430     def history(self):
 431         return 'New node - no history'
 432
 433     def renderWith(self, name, **kwargs):
 434         ''' Render this class with the given template.
 435         '''
 436         # create a new request and override the specified args
 437         req = HTMLRequest(self._client)
 438         req.classname = self.classname
 439         req.update(kwargs)
 440
 441         # new template, using the specified classname and request
 442         pt = Templates(self._db.config.TEMPLATES).get(self.classname, name)
 443
 444         # use our fabricated request
 445         return pt.render(self._client, self.classname, req)
 446
 447 class HTMLItem(HTMLPermissions):
 448     ''' Accesses through an *item*
 449     '''
 450     def __init__(self, client, classname, nodeid):
 451         self._client = client
 452         self._db = client.db
 453         self._classname = classname
 454         self._nodeid = nodeid
 455         self._klass = self._db.getclass(classname)
 456         self._props = self._klass.getprops()
 457
 458     def __repr__(self):
 459         return '<HTMLItem(0x%x) %s %s>'%(id(self), self._classname,
 460             self._nodeid)
 461
 462     def __getitem__(self, item):
 463         ''' return an HTMLProperty instance
 464         '''
 465         #print 'HTMLItem.getitem', (self, item)
 466         if item == 'id':
 467             return self._nodeid
 468
 469         # get the property
 470         prop = self._props[item]
 471
 472         # get the value, handling missing values
 473         value = self._klass.get(self._nodeid, item, None)
 474         if value is None:
 475             if isinstance(self._props[item], hyperdb.Multilink):
 476                 value = []
 477
 478         # look up the correct HTMLProperty class
 479         for klass, htmlklass in propclasses:
 480             if isinstance(prop, klass):
 481                 return htmlklass(self._client, self._nodeid, prop, item, value)
 482
 483         raise KeyErorr, item
 484
 485     def __getattr__(self, attr):
 486         ''' convenience access to properties '''
 487         try:
 488             return self[attr]
 489         except KeyError:
 490             raise AttributeError, attr
 491
 492     def submit(self, label="Submit Changes"):
 493         ''' Generate a submit button (and action hidden element)
 494         '''
 495         return '  <input type="hidden" name=":action" value="edit">\n'\
 496         '  <input type="submit" name="submit" value="%s">'%label
 497
 498     def journal(self, direction='descending'):
 499         ''' Return a list of HTMLJournalEntry instances.
 500         '''
 501         # XXX do this
 502         return []
 503
 504     def history(self, direction='descending', dre=re.compile('\d+')):
 505         l = ['<table class="history">'
 506              '<tr><th colspan="4" class="header">',
 507              _('History'),
 508              '</th></tr><tr>',
 509              _('<th>Date</th>'),
 510              _('<th>User</th>'),
 511              _('<th>Action</th>'),
 512              _('<th>Args</th>'),
 513             '</tr>']
 514         comments = {}
 515         history = self._klass.history(self._nodeid)
 516         history.sort()
 517         if direction == 'descending':
 518             history.reverse()
 519         for id, evt_date, user, action, args in history:
 520             date_s = str(evt_date).replace("."," ")
 521             arg_s = ''
 522             if action == 'link' and type(args) == type(()):
 523                 if len(args) == 3:
 524                     linkcl, linkid, key = args
 525                     arg_s += '<a href="%s%s">%s%s %s</a>'%(linkcl, linkid,
 526                         linkcl, linkid, key)
 527                 else:
 528                     arg_s = str(args)
 529
 530             elif action == 'unlink' and type(args) == type(()):
 531                 if len(args) == 3:
 532                     linkcl, linkid, key = args
 533                     arg_s += '<a href="%s%s">%s%s %s</a>'%(linkcl, linkid,
 534                         linkcl, linkid, key)
 535                 else:
 536                     arg_s = str(args)
 537
 538             elif type(args) == type({}):
 539                 cell = []
 540                 for k in args.keys():
 541                     # try to get the relevant property and treat it
 542                     # specially
 543                     try:
 544                         prop = self._props[k]
 545                     except KeyError:
 546                         prop = None
 547                     if prop is not None:
 548                         if args[k] and (isinstance(prop, hyperdb.Multilink) or
 549                                 isinstance(prop, hyperdb.Link)):
 550                             # figure what the link class is
 551                             classname = prop.classname
 552                             try:
 553                                 linkcl = self._db.getclass(classname)
 554                             except KeyError:
 555                                 labelprop = None
 556                                 comments[classname] = _('''The linked class
 557                                     %(classname)s no longer exists''')%locals()
 558                             labelprop = linkcl.labelprop(1)
 559                             hrefable = os.path.exists(
 560                                 os.path.join(self._db.config.TEMPLATES,
 561                                 classname+'.item'))
 562
 563                         if isinstance(prop, hyperdb.Multilink) and \
 564                                 len(args[k]) > 0:
 565                             ml = []
 566                             for linkid in args[k]:
 567                                 if isinstance(linkid, type(())):
 568                                     sublabel = linkid[0] + ' '
 569                                     linkids = linkid[1]
 570                                 else:
 571                                     sublabel = ''
 572                                     linkids = [linkid]
 573                                 subml = []
 574                                 for linkid in linkids:
 575                                     label = classname + linkid
 576                                     # if we have a label property, try to use it
 577                                     # TODO: test for node existence even when
 578                                     # there's no labelprop!
 579                                     try:
 580                                         if labelprop is not None and \
 581                                                 labelprop != 'id':
 582                                             label = linkcl.get(linkid, labelprop)
 583                                     except IndexError:
 584                                         comments['no_link'] = _('''<strike>The
 585                                             linked node no longer
 586                                             exists</strike>''')
 587                                         subml.append('<strike>%s</strike>'%label)
 588                                     else:
 589                                         if hrefable:
 590                                             subml.append('<a href="%s%s">%s</a>'%(
 591                                                 classname, linkid, label))
 592                                         else:
 593                                             subml.append(label)
 594                                 ml.append(sublabel + ', '.join(subml))
 595                             cell.append('%s:\n  %s'%(k, ', '.join(ml)))
 596                         elif isinstance(prop, hyperdb.Link) and args[k]:
 597                             label = classname + args[k]
 598                             # if we have a label property, try to use it
 599                             # TODO: test for node existence even when
 600                             # there's no labelprop!
 601                             if labelprop is not None and labelprop != 'id':
 602                                 try:
 603                                     label = linkcl.get(args[k], labelprop)
 604                                 except IndexError:
 605                                     comments['no_link'] = _('''<strike>The
 606                                         linked node no longer
 607                                         exists</strike>''')
 608                                     cell.append(' <strike>%s</strike>,\n'%label)
 609                                     # "flag" this is done .... euwww
 610                                     label = None
 611                             if label is not None:
 612                                 if hrefable:
 613                                     cell.append('%s: <a href="%s%s">%s</a>\n'%(k,
 614                                         classname, args[k], label))
 615                                 else:
 616                                     cell.append('%s: %s' % (k,label))
 617
 618                         elif isinstance(prop, hyperdb.Date) and args[k]:
 619                             d = date.Date(args[k])
 620                             cell.append('%s: %s'%(k, str(d)))
 621
 622                         elif isinstance(prop, hyperdb.Interval) and args[k]:
 623                             d = date.Interval(args[k])
 624                             cell.append('%s: %s'%(k, str(d)))
 625
 626                         elif isinstance(prop, hyperdb.String) and args[k]:
 627                             cell.append('%s: %s'%(k, cgi.escape(args[k])))
 628
 629                         elif not args[k]:
 630                             cell.append('%s: (no value)\n'%k)
 631
 632                         else:
 633                             cell.append('%s: %s\n'%(k, str(args[k])))
 634                     else:
 635                         # property no longer exists
 636                         comments['no_exist'] = _('''<em>The indicated property
 637                             no longer exists</em>''')
 638                         cell.append('<em>%s: %s</em>\n'%(k, str(args[k])))
 639                 arg_s = '<br />'.join(cell)
 640             else:
 641                 # unkown event!!
 642                 comments['unknown'] = _('''<strong><em>This event is not
 643                     handled by the history display!</em></strong>''')
 644                 arg_s = '<strong><em>' + str(args) + '</em></strong>'
 645             date_s = date_s.replace(' ', '&nbsp;')
 646             # if the user's an itemid, figure the username (older journals
 647             # have the username)
 648             if dre.match(user):
 649                 user = self._db.user.get(user, 'username')
 650             l.append('<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>'%(
 651                 date_s, user, action, arg_s))
 652         if comments:
 653             l.append(_('<tr><td colspan=4><strong>Note:</strong></td></tr>'))
 654         for entry in comments.values():
 655             l.append('<tr><td colspan=4>%s</td></tr>'%entry)
 656         l.append('</table>')
 657         return '\n'.join(l)
 658
 659     def renderQueryForm(self):
 660         ''' Render this item, which is a query, as a search form.
 661         '''
 662         # create a new request and override the specified args
 663         req = HTMLRequest(self._client)
 664         req.classname = self._klass.get(self._nodeid, 'klass')
 665         name = self._klass.get(self._nodeid, 'name')
 666         req.updateFromURL(self._klass.get(self._nodeid, 'url') +
 667             '&:queryname=%s'%urllib.quote(name))
 668
 669         # new template, using the specified classname and request
 670         pt = Templates(self._db.config.TEMPLATES).get(req.classname, 'search')
 671
 672         # use our fabricated request
 673         return pt.render(self._client, req.classname, req)
 674
 675 class HTMLUser(HTMLItem):
 676     ''' Accesses through the *user* (a special case of item)
 677     '''
 678     def __init__(self, client, classname, nodeid):
 679         HTMLItem.__init__(self, client, 'user', nodeid)
 680         self._default_classname = client.classname
 681
 682         # used for security checks
 683         self._security = client.db.security
 684
 685     _marker = []
 686     def hasPermission(self, role, classname=_marker):
 687         ''' Determine if the user has the Role.
 688
 689             The class being tested defaults to the template's class, but may
 690             be overidden for this test by suppling an alternate classname.
 691         '''
 692         if classname is self._marker:
 693             classname = self._default_classname
 694         return self._security.hasPermission(role, self._nodeid, classname)
 695
 696     def is_edit_ok(self):
 697         ''' Is the user allowed to Edit the current class?
 698             Also check whether this is the current user's info.
 699         '''
 700         return self._db.security.hasPermission('Edit', self._client.userid,
 701             self._classname) or self._nodeid == self._client.userid
 702
 703     def is_view_ok(self):
 704         ''' Is the user allowed to View the current class?
 705             Also check whether this is the current user's info.
 706         '''
 707         return self._db.security.hasPermission('Edit', self._client.userid,
 708             self._classname) or self._nodeid == self._client.userid
 709
 710 class HTMLProperty:
 711     ''' String, Number, Date, Interval HTMLProperty
 712
 713         Has useful attributes:
 714
 715          _name  the name of the property
 716          _value the value of the property if any
 717
 718         A wrapper object which may be stringified for the plain() behaviour.
 719     '''
 720     def __init__(self, client, nodeid, prop, name, value):
 721         self._client = client
 722         self._db = client.db
 723         self._nodeid = nodeid
 724         self._prop = prop
 725         self._name = name
 726         self._value = value
 727     def __repr__(self):
 728         return '<HTMLProperty(0x%x) %s %r %r>'%(id(self), self._name, self._prop, self._value)
 729     def __str__(self):
 730         return self.plain()
 731     def __cmp__(self, other):
 732         if isinstance(other, HTMLProperty):
 733             return cmp(self._value, other._value)
 734         return cmp(self._value, other)
 735
 736 class StringHTMLProperty(HTMLProperty):
 737     def plain(self, escape=0):
 738         ''' Render a "plain" representation of the property
 739         '''
 740         if self._value is None:
 741             return ''
 742         if escape:
 743             return cgi.escape(str(self._value))
 744         return str(self._value)
 745
 746     def stext(self, escape=0):
 747         ''' Render the value of the property as StructuredText.
 748
 749             This requires the StructureText module to be installed separately.
 750         '''
 751         s = self.plain(escape=escape)
 752         if not StructuredText:
 753             return s
 754         return StructuredText(s,level=1,header=0)
 755
 756     def field(self, size = 30):
 757         ''' Render a form edit field for the property
 758         '''
 759         if self._value is None:
 760             value = ''
 761         else:
 762             value = cgi.escape(str(self._value))
 763             value = '&quot;'.join(value.split('"'))
 764         return '<input name="%s" value="%s" size="%s">'%(self._name, value, size)
 765
 766     def multiline(self, escape=0, rows=5, cols=40):
 767         ''' Render a multiline form edit field for the property
 768         '''
 769         if self._value is None:
 770             value = ''
 771         else:
 772             value = cgi.escape(str(self._value))
 773             value = '&quot;'.join(value.split('"'))
 774         return '<textarea name="%s" rows="%s" cols="%s">%s</textarea>'%(
 775             self._name, rows, cols, value)
 776
 777     def email(self, escape=1):
 778         ''' Render the value of the property as an obscured email address
 779         '''
 780         if self._value is None: value = ''
 781         else: value = str(self._value)
 782         if value.find('@') != -1:
 783             name, domain = value.split('@')
 784             domain = ' '.join(domain.split('.')[:-1])
 785             name = name.replace('.', ' ')
 786             value = '%s at %s ...'%(name, domain)
 787         else:
 788             value = value.replace('.', ' ')
 789         if escape:
 790             value = cgi.escape(value)
 791         return value
 792
 793 class PasswordHTMLProperty(HTMLProperty):
 794     def plain(self):
 795         ''' Render a "plain" representation of the property
 796         '''
 797         if self._value is None:
 798             return ''
 799         return _('*encrypted*')
 800
 801     def field(self, size = 30):
 802         ''' Render a form edit field for the property.
 803         '''
 804         return '<input type="password" name="%s" size="%s">'%(self._name, size)
 805
 806     def confirm(self, size = 30):
 807         ''' Render a second form edit field for the property, used for
 808             confirmation that the user typed the password correctly. Generates
 809             a field with name "name:confirm".
 810         '''
 811         return '<input type="password" name="%s:confirm" size="%s">'%(
 812             self._name, size)
 813
 814 class NumberHTMLProperty(HTMLProperty):
 815     def plain(self):
 816         ''' Render a "plain" representation of the property
 817         '''
 818         return str(self._value)
 819
 820     def field(self, size = 30):
 821         ''' Render a form edit field for the property
 822         '''
 823         if self._value is None:
 824             value = ''
 825         else:
 826             value = cgi.escape(str(self._value))
 827             value = '&quot;'.join(value.split('"'))
 828         return '<input name="%s" value="%s" size="%s">'%(self._name, value, size)
 829
 830 class BooleanHTMLProperty(HTMLProperty):
 831     def plain(self):
 832         ''' Render a "plain" representation of the property
 833         '''
 834         if self._value is None:
 835             return ''
 836         return self._value and "Yes" or "No"
 837
 838     def field(self):
 839         ''' Render a form edit field for the property
 840         '''
 841         checked = self._value and "checked" or ""
 842         s = '<input type="radio" name="%s" value="yes" %s>Yes'%(self._name,
 843             checked)
 844         if checked:
 845             checked = ""
 846         else:
 847             checked = "checked"
 848         s += '<input type="radio" name="%s" value="no" %s>No'%(self._name,
 849             checked)
 850         return s
 851
 852 class DateHTMLProperty(HTMLProperty):
 853     def plain(self):
 854         ''' Render a "plain" representation of the property
 855         '''
 856         if self._value is None:
 857             return ''
 858         return str(self._value)
 859
 860     def field(self, size = 30):
 861         ''' Render a form edit field for the property
 862         '''
 863         if self._value is None:
 864             value = ''
 865         else:
 866             value = cgi.escape(str(self._value))
 867             value = '&quot;'.join(value.split('"'))
 868         return '<input name="%s" value="%s" size="%s">'%(self._name, value, size)
 869
 870     def reldate(self, pretty=1):
 871         ''' Render the interval between the date and now.
 872
 873             If the "pretty" flag is true, then make the display pretty.
 874         '''
 875         if not self._value:
 876             return ''
 877
 878         # figure the interval
 879         interval = date.Date('.') - self._value
 880         if pretty:
 881             return interval.pretty()
 882         return str(interval)
 883
 884     def pretty(self, format='%d %B %Y'):
 885         ''' Render the date in a pretty format (eg. month names, spaces).
 886
 887             The format string is a standard python strftime format string.
 888             Note that if the day is zero, and appears at the start of the
 889             string, then it'll be stripped from the output. This is handy
 890             for the situatin when a date only specifies a month and a year.
 891         '''
 892         return self._value.pretty()
 893
 894     def local(self, offset):
 895         ''' Return the date/time as a local (timezone offset) date/time.
 896         '''
 897         return DateHTMLProperty(self._client, self._nodeid, self._prop,
 898             self._name, self._value.local())
 899
 900 class IntervalHTMLProperty(HTMLProperty):
 901     def plain(self):
 902         ''' Render a "plain" representation of the property
 903         '''
 904         if self._value is None:
 905             return ''
 906         return str(self._value)
 907
 908     def pretty(self):
 909         ''' Render the interval in a pretty format (eg. "yesterday")
 910         '''
 911         return self._value.pretty()
 912
 913     def field(self, size = 30):
 914         ''' Render a form edit field for the property
 915         '''
 916         if self._value is None:
 917             value = ''
 918         else:
 919             value = cgi.escape(str(self._value))
 920             value = '&quot;'.join(value.split('"'))
 921         return '<input name="%s" value="%s" size="%s">'%(self._name, value, size)
 922
 923 class LinkHTMLProperty(HTMLProperty):
 924     ''' Link HTMLProperty
 925         Include the above as well as being able to access the class
 926         information. Stringifying the object itself results in the value
 927         from the item being displayed. Accessing attributes of this object
 928         result in the appropriate entry from the class being queried for the
 929         property accessed (so item/assignedto/name would look up the user
 930         entry identified by the assignedto property on item, and then the
 931         name property of that user)
 932     '''
 933     def __init__(self, *args):
 934         HTMLProperty.__init__(self, *args)
 935         # if we're representing a form value, then the -1 from the form really
 936         # should be a None
 937         if str(self._value) == '-1':
 938             self._value = None
 939
 940     def __getattr__(self, attr):
 941         ''' return a new HTMLItem '''
 942        #print 'Link.getattr', (self, attr, self._value)
 943         if not self._value:
 944             raise AttributeError, "Can't access missing value"
 945         if self._prop.classname == 'user':
 946             klass = HTMLUser
 947         else:
 948             klass = HTMLItem
 949         i = klass(self._client, self._prop.classname, self._value)
 950         return getattr(i, attr)
 951
 952     def plain(self, escape=0):
 953         ''' Render a "plain" representation of the property
 954         '''
 955         if self._value is None:
 956             return ''
 957         linkcl = self._db.classes[self._prop.classname]
 958         k = linkcl.labelprop(1)
 959         value = str(linkcl.get(self._value, k))
 960         if escape:
 961             value = cgi.escape(value)
 962         return value
 963
 964     def field(self, showid=0, size=None):
 965         ''' Render a form edit field for the property
 966         '''
 967         linkcl = self._db.getclass(self._prop.classname)
 968         if linkcl.getprops().has_key('order'):
 969             sort_on = 'order'
 970         else:
 971             sort_on = linkcl.labelprop()
 972         options = linkcl.filter(None, {}, ('+', sort_on), (None, None))
 973         # TODO: make this a field display, not a menu one!
 974         l = ['<select name="%s">'%self._name]
 975         k = linkcl.labelprop(1)
 976         if self._value is None:
 977             s = 'selected '
 978         else:
 979             s = ''
 980         l.append(_('<option %svalue="-1">- no selection -</option>')%s)
 981
 982         # make sure we list the current value if it's retired
 983         if self._value and self._value not in options:
 984             options.insert(0, self._value)
 985
 986         for optionid in options:
 987             # get the option value, and if it's None use an empty string
 988             option = linkcl.get(optionid, k) or ''
 989
 990             # figure if this option is selected
 991             s = ''
 992             if optionid == self._value:
 993                 s = 'selected '
 994
 995             # figure the label
 996             if showid:
 997                 lab = '%s%s: %s'%(self._prop.classname, optionid, option)
 998             else:
 999                 lab = option
1000
1001             # truncate if it's too long
1002             if size is not None and len(lab) > size:
1003                 lab = lab[:size-3] + '...'
1004
1005             # and generate
1006             lab = cgi.escape(lab)
1007             l.append('<option %svalue="%s">%s</option>'%(s, optionid, lab))
1008         l.append('</select>')
1009         return '\n'.join(l)
1010
1011     def menu(self, size=None, height=None, showid=0, additional=[],
1012             **conditions):
1013         ''' Render a form select list for this property
1014         '''
1015         value = self._value
1016
1017         # sort function
1018         sortfunc = make_sort_function(self._db, self._prop.classname)
1019
1020         linkcl = self._db.getclass(self._prop.classname)
1021         l = ['<select name="%s">'%self._name]
1022         k = linkcl.labelprop(1)
1023         s = ''
1024         if value is None:
1025             s = 'selected '
1026         l.append(_('<option %svalue="-1">- no selection -</option>')%s)
1027         if linkcl.getprops().has_key('order'):
1028             sort_on = ('+', 'order')
1029         else:
1030             sort_on = ('+', linkcl.labelprop())
1031         options = linkcl.filter(None, conditions, sort_on, (None, None))
1032
1033         # make sure we list the current value if it's retired
1034         if self._value and self._value not in options:
1035             options.insert(0, self._value)
1036
1037         for optionid in options:
1038             # get the option value, and if it's None use an empty string
1039             option = linkcl.get(optionid, k) or ''
1040
1041             # figure if this option is selected
1042             s = ''
1043             if value in [optionid, option]:
1044                 s = 'selected '
1045
1046             # figure the label
1047             if showid:
1048                 lab = '%s%s: %s'%(self._prop.classname, optionid, option)
1049             else:
1050                 lab = option
1051
1052             # truncate if it's too long
1053             if size is not None and len(lab) > size:
1054                 lab = lab[:size-3] + '...'
1055             if additional:
1056                 m = []
1057                 for propname in additional:
1058                     m.append(linkcl.get(optionid, propname))
1059                 lab = lab + ' (%s)'%', '.join(map(str, m))
1060
1061             # and generate
1062             lab = cgi.escape(lab)
1063             l.append('<option %svalue="%s">%s</option>'%(s, optionid, lab))
1064         l.append('</select>')
1065         return '\n'.join(l)
1066 #    def checklist(self, ...)
1067
1068 class MultilinkHTMLProperty(HTMLProperty):
1069     ''' Multilink HTMLProperty
1070
1071         Also be iterable, returning a wrapper object like the Link case for
1072         each entry in the multilink.
1073     '''
1074     def __len__(self):
1075         ''' length of the multilink '''
1076         return len(self._value)
1077
1078     def __getattr__(self, attr):
1079         ''' no extended attribute accesses make sense here '''
1080         raise AttributeError, attr
1081
1082     def __getitem__(self, num):
1083         ''' iterate and return a new HTMLItem
1084         '''
1085        #print 'Multi.getitem', (self, num)
1086         value = self._value[num]
1087         if self._prop.classname == 'user':
1088             klass = HTMLUser
1089         else:
1090             klass = HTMLItem
1091         return klass(self._client, self._prop.classname, value)
1092
1093     def __contains__(self, value):
1094         ''' Support the "in" operator
1095         '''
1096         return value in self._value
1097
1098     def reverse(self):
1099         ''' return the list in reverse order
1100         '''
1101         l = self._value[:]
1102         l.reverse()
1103         if self._prop.classname == 'user':
1104             klass = HTMLUser
1105         else:
1106             klass = HTMLItem
1107         return [klass(self._client, self._prop.classname, value) for value in l]
1108
1109     def plain(self, escape=0):
1110         ''' Render a "plain" representation of the property
1111         '''
1112         linkcl = self._db.classes[self._prop.classname]
1113         k = linkcl.labelprop(1)
1114         labels = []
1115         for v in self._value:
1116             labels.append(linkcl.get(v, k))
1117         value = ', '.join(labels)
1118         if escape:
1119             value = cgi.escape(value)
1120         return value
1121
1122     def field(self, size=30, showid=0):
1123         ''' Render a form edit field for the property
1124         '''
1125         sortfunc = make_sort_function(self._db, self._prop.classname)
1126         linkcl = self._db.getclass(self._prop.classname)
1127         value = self._value[:]
1128         if value:
1129             value.sort(sortfunc)
1130         # map the id to the label property
1131         if not linkcl.getkey():
1132             showid=1
1133         if not showid:
1134             k = linkcl.labelprop(1)
1135             value = [linkcl.get(v, k) for v in value]
1136         value = cgi.escape(','.join(value))
1137         return '<input name="%s" size="%s" value="%s">'%(self._name, size, value)
1138
1139     def menu(self, size=None, height=None, showid=0, additional=[],
1140             **conditions):
1141         ''' Render a form select list for this property
1142         '''
1143         value = self._value
1144
1145         # sort function
1146         sortfunc = make_sort_function(self._db, self._prop.classname)
1147
1148         linkcl = self._db.getclass(self._prop.classname)
1149         if linkcl.getprops().has_key('order'):
1150             sort_on = ('+', 'order')
1151         else:
1152             sort_on = ('+', linkcl.labelprop())
1153         options = linkcl.filter(None, conditions, sort_on, (None,None))
1154         height = height or min(len(options), 7)
1155         l = ['<select multiple name="%s" size="%s">'%(self._name, height)]
1156         k = linkcl.labelprop(1)
1157
1158         # make sure we list the current values if they're retired
1159         for value in self._value:
1160             if value not in options:
1161                 options.insert(0, value)
1162
1163         for optionid in options:
1164             # get the option value, and if it's None use an empty string
1165             option = linkcl.get(optionid, k) or ''
1166
1167             # figure if this option is selected
1168             s = ''
1169             if optionid in value or option in value:
1170                 s = 'selected '
1171
1172             # figure the label
1173             if showid:
1174                 lab = '%s%s: %s'%(self._prop.classname, optionid, option)
1175             else:
1176                 lab = option
1177             # truncate if it's too long
1178             if size is not None and len(lab) > size:
1179                 lab = lab[:size-3] + '...'
1180             if additional:
1181                 m = []
1182                 for propname in additional:
1183                     m.append(linkcl.get(optionid, propname))
1184                 lab = lab + ' (%s)'%', '.join(m)
1185
1186             # and generate
1187             lab = cgi.escape(lab)
1188             l.append('<option %svalue="%s">%s</option>'%(s, optionid,
1189                 lab))
1190         l.append('</select>')
1191         return '\n'.join(l)
1192
1193 # set the propclasses for HTMLItem
1194 propclasses = (
1195     (hyperdb.String, StringHTMLProperty),
1196     (hyperdb.Number, NumberHTMLProperty),
1197     (hyperdb.Boolean, BooleanHTMLProperty),
1198     (hyperdb.Date, DateHTMLProperty),
1199     (hyperdb.Interval, IntervalHTMLProperty),
1200     (hyperdb.Password, PasswordHTMLProperty),
1201     (hyperdb.Link, LinkHTMLProperty),
1202     (hyperdb.Multilink, MultilinkHTMLProperty),
1203 )
1204
1205 def make_sort_function(db, classname):
1206     '''Make a sort function for a given class
1207     '''
1208     linkcl = db.getclass(classname)
1209     if linkcl.getprops().has_key('order'):
1210         sort_on = 'order'
1211     else:
1212         sort_on = linkcl.labelprop()
1213     def sortfunc(a, b, linkcl=linkcl, sort_on=sort_on):
1214         return cmp(linkcl.get(a, sort_on), linkcl.get(b, sort_on))
1215     return sortfunc
1216
1217 def handleListCGIValue(value):
1218     ''' Value is either a single item or a list of items. Each item has a
1219         .value that we're actually interested in.
1220     '''
1221     if isinstance(value, type([])):
1222         return [value.value for value in value]
1223     else:
1224         value = value.value.strip()
1225         if not value:
1226             return []
1227         return value.split(',')
1228
1229 class ShowDict:
1230     ''' A convenience access to the :columns index parameters
1231     '''
1232     def __init__(self, columns):
1233         self.columns = {}
1234         for col in columns:
1235             self.columns[col] = 1
1236     def __getitem__(self, name):
1237         return self.columns.has_key(name)
1238
1239 class HTMLRequest:
1240     ''' The *request*, holding the CGI form and environment.
1241
1242         "form" the CGI form as a cgi.FieldStorage
1243         "env" the CGI environment variables
1244         "base" the base URL for this instance
1245         "user" a HTMLUser instance for this user
1246         "classname" the current classname (possibly None)
1247         "template" the current template (suffix, also possibly None)
1248
1249         Index args:
1250         "columns" dictionary of the columns to display in an index page
1251         "show" a convenience access to columns - request/show/colname will
1252                be true if the columns should be displayed, false otherwise
1253         "sort" index sort column (direction, column name)
1254         "group" index grouping property (direction, column name)
1255         "filter" properties to filter the index on
1256         "filterspec" values to filter the index on
1257         "search_text" text to perform a full-text search on for an index
1258
1259     '''
1260     def __init__(self, client):
1261         self.client = client
1262
1263         # easier access vars
1264         self.form = client.form
1265         self.env = client.env
1266         self.base = client.base
1267         self.user = HTMLUser(client, 'user', client.userid)
1268
1269         # store the current class name and action
1270         self.classname = client.classname
1271         self.template = client.template
1272
1273         self._post_init()
1274
1275     def _post_init(self):
1276         ''' Set attributes based on self.form
1277         '''
1278         # extract the index display information from the form
1279         self.columns = []
1280         if self.form.has_key(':columns'):
1281             self.columns = handleListCGIValue(self.form[':columns'])
1282         self.show = ShowDict(self.columns)
1283
1284         # sorting
1285         self.sort = (None, None)
1286         if self.form.has_key(':sort'):
1287             sort = self.form[':sort'].value
1288             if sort.startswith('-'):
1289                 self.sort = ('-', sort[1:])
1290             else:
1291                 self.sort = ('+', sort)
1292         if self.form.has_key(':sortdir'):
1293             self.sort = ('-', self.sort[1])
1294
1295         # grouping
1296         self.group = (None, None)
1297         if self.form.has_key(':group'):
1298             group = self.form[':group'].value
1299             if group.startswith('-'):
1300                 self.group = ('-', group[1:])
1301             else:
1302                 self.group = ('+', group)
1303         if self.form.has_key(':groupdir'):
1304             self.group = ('-', self.group[1])
1305
1306         # filtering
1307         self.filter = []
1308         if self.form.has_key(':filter'):
1309             self.filter = handleListCGIValue(self.form[':filter'])
1310         self.filterspec = {}
1311         db = self.client.db
1312         if self.classname is not None:
1313             props = db.getclass(self.classname).getprops()
1314             for name in self.filter:
1315                 if self.form.has_key(name):
1316                     prop = props[name]
1317                     fv = self.form[name]
1318                     if (isinstance(prop, hyperdb.Link) or
1319                             isinstance(prop, hyperdb.Multilink)):
1320                         self.filterspec[name] = lookupIds(db, prop,
1321                             handleListCGIValue(fv))
1322                     else:
1323                         self.filterspec[name] = fv.value
1324
1325         # full-text search argument
1326         self.search_text = None
1327         if self.form.has_key(':search_text'):
1328             self.search_text = self.form[':search_text'].value
1329
1330         # pagination - size and start index
1331         # figure batch args
1332         if self.form.has_key(':pagesize'):
1333             self.pagesize = int(self.form[':pagesize'].value)
1334         else:
1335             self.pagesize = 50
1336         if self.form.has_key(':startwith'):
1337             self.startwith = int(self.form[':startwith'].value)
1338         else:
1339             self.startwith = 0
1340
1341     def updateFromURL(self, url):
1342         ''' Parse the URL for query args, and update my attributes using the
1343             values.
1344         '''
1345         self.form = {}
1346         for name, value in cgi.parse_qsl(url):
1347             if self.form.has_key(name):
1348                 if isinstance(self.form[name], type([])):
1349                     self.form[name].append(cgi.MiniFieldStorage(name, value))
1350                 else:
1351                     self.form[name] = [self.form[name],
1352                         cgi.MiniFieldStorage(name, value)]
1353             else:
1354                 self.form[name] = cgi.MiniFieldStorage(name, value)
1355         self._post_init()
1356
1357     def update(self, kwargs):
1358         ''' Update my attributes using the keyword args
1359         '''
1360         self.__dict__.update(kwargs)
1361         if kwargs.has_key('columns'):
1362             self.show = ShowDict(self.columns)
1363
1364     def description(self):
1365         ''' Return a description of the request - handle for the page title.
1366         '''
1367         s = [self.client.db.config.TRACKER_NAME]
1368         if self.classname:
1369             if self.client.nodeid:
1370                 s.append('- %s%s'%(self.classname, self.client.nodeid))
1371             else:
1372                 if self.template == 'item':
1373                     s.append('- new %s'%self.classname)
1374                 elif self.template == 'index':
1375                     s.append('- %s index'%self.classname)
1376                 else:
1377                     s.append('- %s %s'%(self.classname, self.template))
1378         else:
1379             s.append('- home')
1380         return ' '.join(s)
1381
1382     def __str__(self):
1383         d = {}
1384         d.update(self.__dict__)
1385         f = ''
1386         for k in self.form.keys():
1387             f += '\n      %r=%r'%(k,handleListCGIValue(self.form[k]))
1388         d['form'] = f
1389         e = ''
1390         for k,v in self.env.items():
1391             e += '\n     %r=%r'%(k, v)
1392         d['env'] = e
1393         return '''
1394 form: %(form)s
1395 base: %(base)r
1396 classname: %(classname)r
1397 template: %(template)r
1398 columns: %(columns)r
1399 sort: %(sort)r
1400 group: %(group)r
1401 filter: %(filter)r
1402 search_text: %(search_text)r
1403 pagesize: %(pagesize)r
1404 startwith: %(startwith)r
1405 env: %(env)s
1406 '''%d
1407
1408     def indexargs_form(self, columns=1, sort=1, group=1, filter=1,
1409             filterspec=1):
1410         ''' return the current index args as form elements '''
1411         l = []
1412         s = '<input type="hidden" name="%s" value="%s">'
1413         if columns and self.columns:
1414             l.append(s%(':columns', ','.join(self.columns)))
1415         if sort and self.sort[1] is not None:
1416             if self.sort[0] == '-':
1417                 val = '-'+self.sort[1]
1418             else:
1419                 val = self.sort[1]
1420             l.append(s%(':sort', val))
1421         if group and self.group[1] is not None:
1422             if self.group[0] == '-':
1423                 val = '-'+self.group[1]
1424             else:
1425                 val = self.group[1]
1426             l.append(s%(':group', val))
1427         if filter and self.filter:
1428             l.append(s%(':filter', ','.join(self.filter)))
1429         if filterspec:
1430             for k,v in self.filterspec.items():
1431                 l.append(s%(k, ','.join(v)))
1432         if self.search_text:
1433             l.append(s%(':search_text', self.search_text))
1434         l.append(s%(':pagesize', self.pagesize))
1435         l.append(s%(':startwith', self.startwith))
1436         return '\n'.join(l)
1437
1438     def indexargs_url(self, url, args):
1439         ''' embed the current index args in a URL '''
1440         l = ['%s=%s'%(k,v) for k,v in args.items()]
1441         if self.columns and not args.has_key(':columns'):
1442             l.append(':columns=%s'%(','.join(self.columns)))
1443         if self.sort[1] is not None and not args.has_key(':sort'):
1444             if self.sort[0] == '-':
1445                 val = '-'+self.sort[1]
1446             else:
1447                 val = self.sort[1]
1448             l.append(':sort=%s'%val)
1449         if self.group[1] is not None and not args.has_key(':group'):
1450             if self.group[0] == '-':
1451                 val = '-'+self.group[1]
1452             else:
1453                 val = self.group[1]
1454             l.append(':group=%s'%val)
1455         if self.filter and not args.has_key(':columns'):
1456             l.append(':filter=%s'%(','.join(self.filter)))
1457         for k,v in self.filterspec.items():
1458             if not args.has_key(k):
1459                 l.append('%s=%s'%(k, ','.join(v)))
1460         if self.search_text and not args.has_key(':search_text'):
1461             l.append(':search_text=%s'%self.search_text)
1462         if not args.has_key(':pagesize'):
1463             l.append(':pagesize=%s'%self.pagesize)
1464         if not args.has_key(':startwith'):
1465             l.append(':startwith=%s'%self.startwith)
1466         return '%s?%s'%(url, '&'.join(l))
1467     indexargs_href = indexargs_url
1468
1469     def base_javascript(self):
1470         return '''
1471 <script language="javascript">
1472 submitted = false;
1473 function submit_once() {
1474     if (submitted) {
1475         alert("Your request is being processed.\\nPlease be patient.");
1476         return 0;
1477     }
1478     submitted = true;
1479     return 1;
1480 }
1481
1482 function help_window(helpurl, width, height) {
1483     HelpWin = window.open('%s' + helpurl, 'RoundupHelpWindow', 'scrollbars=yes,resizable=yes,toolbar=no,height='+height+',width='+width);
1484 }
1485 </script>
1486 '''%self.base
1487
1488     def batch(self):
1489         ''' Return a batch object for results from the "current search"
1490         '''
1491         filterspec = self.filterspec
1492         sort = self.sort
1493         group = self.group
1494
1495         # get the list of ids we're batching over
1496         klass = self.client.db.getclass(self.classname)
1497         if self.search_text:
1498             matches = self.client.db.indexer.search(
1499                 re.findall(r'\b\w{2,25}\b', self.search_text), klass)
1500         else:
1501             matches = None
1502         l = klass.filter(matches, filterspec, sort, group)
1503
1504         # return the batch object, using IDs only
1505         return Batch(self.client, l, self.pagesize, self.startwith,
1506             classname=self.classname)
1507
1508 # extend the standard ZTUtils Batch object to remove dependency on
1509 # Acquisition and add a couple of useful methods
1510 class Batch(ZTUtils.Batch):
1511     ''' Use me to turn a list of items, or item ids of a given class, into a
1512         series of batches.
1513
1514         ========= ========================================================
1515         Parameter  Usage
1516         ========= ========================================================
1517         sequence  a list of HTMLItems or item ids
1518         classname if sequence is a list of ids, this is the class of item
1519         size      how big to make the sequence.
1520         start     where to start (0-indexed) in the sequence.
1521         end       where to end (0-indexed) in the sequence.
1522         orphan    if the next batch would contain less items than this
1523                   value, then it is combined with this batch
1524         overlap   the number of items shared between adjacent batches
1525         ========= ========================================================
1526
1527         Attributes: Note that the "start" attribute, unlike the
1528         argument, is a 1-based index (I know, lame).  "first" is the
1529         0-based index.  "length" is the actual number of elements in
1530         the batch.
1531
1532         "sequence_length" is the length of the original, unbatched, sequence.
1533     '''
1534     def __init__(self, client, sequence, size, start, end=0, orphan=0,
1535             overlap=0, classname=None):
1536         self.client = client
1537         self.last_index = self.last_item = None
1538         self.current_item = None
1539         self.classname = classname
1540         self.sequence_length = len(sequence)
1541         ZTUtils.Batch.__init__(self, sequence, size, start, end, orphan,
1542             overlap)
1543
1544     # overwrite so we can late-instantiate the HTMLItem instance
1545     def __getitem__(self, index):
1546         if index < 0:
1547             if index + self.end < self.first: raise IndexError, index
1548             return self._sequence[index + self.end]
1549
1550         if index >= self.length:
1551             raise IndexError, index
1552
1553         # move the last_item along - but only if the fetched index changes
1554         # (for some reason, index 0 is fetched twice)
1555         if index != self.last_index:
1556             self.last_item = self.current_item
1557             self.last_index = index
1558
1559         item = self._sequence[index + self.first]
1560         if self.classname:
1561             # map the item ids to instances
1562             if self.classname == 'user':
1563                 item = HTMLUser(self.client, self.classname, item)
1564             else:
1565                 item = HTMLItem(self.client, self.classname, item)
1566         self.current_item = item
1567         return item
1568
1569     def propchanged(self, property):
1570         ''' Detect if the property marked as being the group property
1571             changed in the last iteration fetch
1572         '''
1573         if (self.last_item is None or
1574                 self.last_item[property] != self.current_item[property]):
1575             return 1
1576         return 0
1577
1578     # override these 'cos we don't have access to acquisition
1579     def previous(self):
1580         if self.start == 1:
1581             return None
1582         return Batch(self.client, self._sequence, self._size,
1583             self.first - self._size + self.overlap, 0, self.orphan,
1584             self.overlap)
1585
1586     def next(self):
1587         try:
1588             self._sequence[self.end]
1589         except IndexError:
1590             return None
1591         return Batch(self.client, self._sequence, self._size,
1592             self.end - self.overlap, 0, self.orphan, self.overlap)
1593
1594 class TemplatingUtils:
1595     ''' Utilities for templating
1596     '''
1597     def __init__(self, client):
1598         self.client = client
1599     def Batch(self, sequence, size, start, end=0, orphan=0, overlap=0):
1600         return Batch(self.client, sequence, size, start, end, orphan,
1601             overlap)
1602