roundup/cgi/templating.py

   1 """Implements the API used in the HTML templating for the web interface.
   2 """
   3 __docformat__ = 'restructuredtext'
   4
   5 from __future__ import nested_scopes
   6
   7 import sys, cgi, urllib, os, re, os.path, time, errno, mimetypes
   8
   9 from roundup import hyperdb, date, rcsv
  10 from roundup.i18n import _
  11
  12 try:
  13     import cPickle as pickle
  14 except ImportError:
  15     import pickle
  16 try:
  17     import cStringIO as StringIO
  18 except ImportError:
  19     import StringIO
  20 try:
  21     import StructuredText
  22 except ImportError:
  23     StructuredText = None
  24
  25 # bring in the templating support
  26 from roundup.cgi.PageTemplates import PageTemplate
  27 from roundup.cgi.PageTemplates.Expressions import getEngine
  28 from roundup.cgi.TAL.TALInterpreter import TALInterpreter
  29 from roundup.cgi import ZTUtils
  30
  31 class NoTemplate(Exception):
  32     pass
  33
  34 class Unauthorised(Exception):
  35     def __init__(self, action, klass):
  36         self.action = action
  37         self.klass = klass
  38     def __str__(self):
  39         return 'You are not allowed to %s items of class %s'%(self.action,
  40             self.klass)
  41
  42 def find_template(dir, name, extension):
  43     ''' Find a template in the nominated dir
  44     '''
  45     # find the source
  46     if extension:
  47         filename = '%s.%s'%(name, extension)
  48     else:
  49         filename = name
  50
  51     # try old-style
  52     src = os.path.join(dir, filename)
  53     if os.path.exists(src):
  54         return (src, filename)
  55
  56     # try with a .html extension (new-style)
  57     filename = filename + '.html'
  58     src = os.path.join(dir, filename)
  59     if os.path.exists(src):
  60         return (src, filename)
  61
  62     # no extension == no generic template is possible
  63     if not extension:
  64         raise NoTemplate, 'Template file "%s" doesn\'t exist'%name
  65
  66     # try for a _generic template
  67     generic = '_generic.%s'%extension
  68     src = os.path.join(dir, generic)
  69     if os.path.exists(src):
  70         return (src, generic)
  71
  72     # finally, try _generic.html
  73     generic = generic + '.html'
  74     src = os.path.join(dir, generic)
  75     if os.path.exists(src):
  76         return (src, generic)
  77
  78     raise NoTemplate, 'No template file exists for templating "%s" '\
  79         'with template "%s" (neither "%s" nor "%s")'%(name, extension,
  80         filename, generic)
  81
  82 class Templates:
  83     templates = {}
  84
  85     def __init__(self, dir):
  86         self.dir = dir
  87
  88     def precompileTemplates(self):
  89         ''' Go through a directory and precompile all the templates therein
  90         '''
  91         for filename in os.listdir(self.dir):
  92             if os.path.isdir(filename): continue
  93             if '.' in filename:
  94                 name, extension = filename.split('.')
  95                 self.get(name, extension)
  96             else:
  97                 self.get(filename, None)
  98
  99     def get(self, name, extension=None):
 100         ''' Interface to get a template, possibly loading a compiled template.
 101
 102             "name" and "extension" indicate the template we're after, which in
 103             most cases will be "name.extension". If "extension" is None, then
 104             we look for a template just called "name" with no extension.
 105
 106             If the file "name.extension" doesn't exist, we look for
 107             "_generic.extension" as a fallback.
 108         '''
 109         # default the name to "home"
 110         if name is None:
 111             name = 'home'
 112         elif extension is None and '.' in name:
 113             # split name
 114             name, extension = name.split('.')
 115
 116         # find the source
 117         src, filename = find_template(self.dir, name, extension)
 118
 119         # has it changed?
 120         try:
 121             stime = os.stat(src)[os.path.stat.ST_MTIME]
 122         except os.error, error:
 123             if error.errno != errno.ENOENT:
 124                 raise
 125
 126         if self.templates.has_key(src) and \
 127                 stime < self.templates[src].mtime:
 128             # compiled template is up to date
 129             return self.templates[src]
 130
 131         # compile the template
 132         self.templates[src] = pt = RoundupPageTemplate()
 133         # use pt_edit so we can pass the content_type guess too
 134         content_type = mimetypes.guess_type(filename)[0] or 'text/html'
 135         pt.pt_edit(open(src).read(), content_type)
 136         pt.id = filename
 137         pt.mtime = time.time()
 138         return pt
 139
 140     def __getitem__(self, name):
 141         name, extension = os.path.splitext(name)
 142         if extension:
 143             extension = extension[1:]
 144         try:
 145             return self.get(name, extension)
 146         except NoTemplate, message:
 147             raise KeyError, message
 148
 149 class RoundupPageTemplate(PageTemplate.PageTemplate):
 150     '''A Roundup-specific PageTemplate.
 151
 152     Interrogate the client to set up the various template variables to
 153     be available:
 154
 155     *context*
 156      this is one of three things:
 157
 158      1. None - we're viewing a "home" page
 159      2. The current class of item being displayed. This is an HTMLClass
 160         instance.
 161      3. The current item from the database, if we're viewing a specific
 162         item, as an HTMLItem instance.
 163     *request*
 164       Includes information about the current request, including:
 165
 166        - the url
 167        - the current index information (``filterspec``, ``filter`` args,
 168          ``properties``, etc) parsed out of the form.
 169        - methods for easy filterspec link generation
 170        - *user*, the current user node as an HTMLItem instance
 171        - *form*, the current CGI form information as a FieldStorage
 172     *config*
 173       The current tracker config.
 174     *db*
 175       The current database, used to access arbitrary database items.
 176     *utils*
 177       This is a special class that has its base in the TemplatingUtils
 178       class in this file. If the tracker interfaces module defines a
 179       TemplatingUtils class then it is mixed in, overriding the methods
 180       in the base class.
 181     '''
 182     def getContext(self, client, classname, request):
 183         # construct the TemplatingUtils class
 184         utils = TemplatingUtils
 185         if hasattr(client.instance.interfaces, 'TemplatingUtils'):
 186             class utils(client.instance.interfaces.TemplatingUtils, utils):
 187                 pass
 188
 189         c = {
 190              'options': {},
 191              'nothing': None,
 192              'request': request,
 193              'db': HTMLDatabase(client),
 194              'config': client.instance.config,
 195              'tracker': client.instance,
 196              'utils': utils(client),
 197              'templates': Templates(client.instance.config.TEMPLATES),
 198         }
 199         # add in the item if there is one
 200         if client.nodeid:
 201             if classname == 'user':
 202                 c['context'] = HTMLUser(client, classname, client.nodeid,
 203                     anonymous=1)
 204             else:
 205                 c['context'] = HTMLItem(client, classname, client.nodeid,
 206                     anonymous=1)
 207         elif client.db.classes.has_key(classname):
 208             if classname == 'user':
 209                 c['context'] = HTMLUserClass(client, classname, anonymous=1)
 210             else:
 211                 c['context'] = HTMLClass(client, classname, anonymous=1)
 212         return c
 213
 214     def render(self, client, classname, request, **options):
 215         """Render this Page Template"""
 216
 217         if not self._v_cooked:
 218             self._cook()
 219
 220         __traceback_supplement__ = (PageTemplate.PageTemplateTracebackSupplement, self)
 221
 222         if self._v_errors:
 223             raise PageTemplate.PTRuntimeError, \
 224                 'Page Template %s has errors.'%self.id
 225
 226         # figure the context
 227         classname = classname or client.classname
 228         request = request or HTMLRequest(client)
 229         c = self.getContext(client, classname, request)
 230         c.update({'options': options})
 231
 232         # and go
 233         output = StringIO.StringIO()
 234         TALInterpreter(self._v_program, self.macros,
 235             getEngine().getContext(c), output, tal=1, strictinsert=0)()
 236         return output.getvalue()
 237
 238     def __repr__(self):
 239         return '<Roundup PageTemplate %r>'%self.id
 240
 241 class HTMLDatabase:
 242     ''' Return HTMLClasses for valid class fetches
 243     '''
 244     def __init__(self, client):
 245         self._client = client
 246         self._db = client.db
 247
 248         # we want config to be exposed
 249         self.config = client.db.config
 250
 251     def __getitem__(self, item, desre=re.compile(r'(?P<cl>\w+)(?P<id>[-\d]+)')):
 252         # check to see if we're actually accessing an item
 253         m = desre.match(item)
 254         if m:
 255             self._client.db.getclass(m.group('cl'))
 256             return HTMLItem(self._client, m.group('cl'), m.group('id'))
 257         else:
 258             self._client.db.getclass(item)
 259             if item == 'user':
 260                 return HTMLUserClass(self._client, item)
 261             return HTMLClass(self._client, item)
 262
 263     def __getattr__(self, attr):
 264         try:
 265             return self[attr]
 266         except KeyError:
 267             raise AttributeError, attr
 268
 269     def classes(self):
 270         l = self._client.db.classes.keys()
 271         l.sort()
 272         m = []
 273         for item in l:
 274             if item == 'user':
 275                 m.append(HTMLUserClass(self._client, item))
 276             m.append(HTMLClass(self._client, item))
 277         return m
 278
 279 def lookupIds(db, prop, ids, fail_ok=0, num_re=re.compile('-?\d+')):
 280     ''' "fail_ok" should be specified if we wish to pass through bad values
 281         (most likely form values that we wish to represent back to the user)
 282     '''
 283     cl = db.getclass(prop.classname)
 284     l = []
 285     for entry in ids:
 286         if num_re.match(entry):
 287             l.append(entry)
 288         else:
 289             try:
 290                 l.append(cl.lookup(entry))
 291             except (TypeError, KeyError):
 292                 if fail_ok:
 293                     # pass through the bad value
 294                     l.append(entry)
 295     return l
 296
 297 def lookupKeys(linkcl, key, ids, num_re=re.compile('-?\d+')):
 298     ''' Look up the "key" values for "ids" list - though some may already
 299     be key values, not ids.
 300     '''
 301     l = []
 302     for entry in ids:
 303         if num_re.match(entry):
 304             l.append(linkcl.get(entry, key))
 305         else:
 306             l.append(entry)
 307     return l
 308
 309 class HTMLPermissions:
 310     ''' Helpers that provide answers to commonly asked Permission questions.
 311     '''
 312     def is_edit_ok(self):
 313         ''' Is the user allowed to Edit the current class?
 314         '''
 315         return self._db.security.hasPermission('Edit', self._client.userid,
 316             self._classname)
 317
 318     def is_view_ok(self):
 319         ''' Is the user allowed to View the current class?
 320         '''
 321         return self._db.security.hasPermission('View', self._client.userid,
 322             self._classname)
 323
 324     def is_only_view_ok(self):
 325         ''' Is the user only allowed to View (ie. not Edit) the current class?
 326         '''
 327         return self.is_view_ok() and not self.is_edit_ok()
 328
 329     def view_check(self):
 330         ''' Raise the Unauthorised exception if the user's not permitted to
 331             view this class.
 332         '''
 333         if not self.is_view_ok():
 334             raise Unauthorised("view", self._classname)
 335
 336     def edit_check(self):
 337         ''' Raise the Unauthorised exception if the user's not permitted to
 338             edit this class.
 339         '''
 340         if not self.is_edit_ok():
 341             raise Unauthorised("edit", self._classname)
 342
 343 def input_html4(**attrs):
 344     """Generate an 'input' (html4) element with given attributes"""
 345     return '<input %s>'%' '.join(['%s="%s"'%item for item in attrs.items()])
 346
 347 def input_xhtml(**attrs):
 348     """Generate an 'input' (xhtml) element with given attributes"""
 349     return '<input %s/>'%' '.join(['%s="%s"'%item for item in attrs.items()])
 350
 351 class HTMLInputMixin:
 352     ''' requires a _client property '''
 353     def __init__(self):
 354         html_version = 'html4'
 355         if hasattr(self._client.instance.config, 'HTML_VERSION'):
 356             html_version = self._client.instance.config.HTML_VERSION
 357         if html_version == 'xhtml':
 358             self.input = input_xhtml
 359         else:
 360             self.input = input_html4
 361
 362 class HTMLClass(HTMLInputMixin, HTMLPermissions):
 363     ''' Accesses through a class (either through *class* or *db.<classname>*)
 364     '''
 365     def __init__(self, client, classname, anonymous=0):
 366         self._client = client
 367         self._db = client.db
 368         self._anonymous = anonymous
 369
 370         # we want classname to be exposed, but _classname gives a
 371         # consistent API for extending Class/Item
 372         self._classname = self.classname = classname
 373         self._klass = self._db.getclass(self.classname)
 374         self._props = self._klass.getprops()
 375
 376         HTMLInputMixin.__init__(self)
 377
 378     def __repr__(self):
 379         return '<HTMLClass(0x%x) %s>'%(id(self), self.classname)
 380
 381     def __getitem__(self, item):
 382         ''' return an HTMLProperty instance
 383         '''
 384        #print 'HTMLClass.getitem', (self, item)
 385
 386         # we don't exist
 387         if item == 'id':
 388             return None
 389
 390         # get the property
 391         try:
 392             prop = self._props[item]
 393         except KeyError:
 394             raise KeyError, 'No such property "%s" on %s'%(item, self.classname)
 395
 396         # look up the correct HTMLProperty class
 397         form = self._client.form
 398         for klass, htmlklass in propclasses:
 399             if not isinstance(prop, klass):
 400                 continue
 401             if form.has_key(item):
 402                 if isinstance(prop, hyperdb.Multilink):
 403                     value = lookupIds(self._db, prop,
 404                         handleListCGIValue(form[item]), fail_ok=1)
 405                 elif isinstance(prop, hyperdb.Link):
 406                     value = form[item].value.strip()
 407                     if value:
 408                         value = lookupIds(self._db, prop, [value],
 409                             fail_ok=1)[0]
 410                     else:
 411                         value = None
 412                 else:
 413                     value = form[item].value.strip() or None
 414             else:
 415                 if isinstance(prop, hyperdb.Multilink):
 416                     value = []
 417                 else:
 418                     value = None
 419             return htmlklass(self._client, self._classname, '', prop, item,
 420                 value, self._anonymous)
 421
 422         # no good
 423         raise KeyError, item
 424
 425     def __getattr__(self, attr):
 426         ''' convenience access '''
 427         try:
 428             return self[attr]
 429         except KeyError:
 430             raise AttributeError, attr
 431
 432     def designator(self):
 433         ''' Return this class' designator (classname) '''
 434         return self._classname
 435
 436     def getItem(self, itemid, num_re=re.compile('-?\d+')):
 437         ''' Get an item of this class by its item id.
 438         '''
 439         # make sure we're looking at an itemid
 440         if not isinstance(itemid, type(1)) and not num_re.match(itemid):
 441             itemid = self._klass.lookup(itemid)
 442
 443         if self.classname == 'user':
 444             klass = HTMLUser
 445         else:
 446             klass = HTMLItem
 447
 448         return klass(self._client, self.classname, itemid)
 449
 450     def properties(self, sort=1):
 451         ''' Return HTMLProperty for all of this class' properties.
 452         '''
 453         l = []
 454         for name, prop in self._props.items():
 455             for klass, htmlklass in propclasses:
 456                 if isinstance(prop, hyperdb.Multilink):
 457                     value = []
 458                 else:
 459                     value = None
 460                 if isinstance(prop, klass):
 461                     l.append(htmlklass(self._client, self._classname, '',
 462                         prop, name, value, self._anonymous))
 463         if sort:
 464             l.sort(lambda a,b:cmp(a._name, b._name))
 465         return l
 466
 467     def list(self, sort_on=None):
 468         ''' List all items in this class.
 469         '''
 470         if self.classname == 'user':
 471             klass = HTMLUser
 472         else:
 473             klass = HTMLItem
 474
 475         # get the list and sort it nicely
 476         l = self._klass.list()
 477         sortfunc = make_sort_function(self._db, self.classname, sort_on)
 478         l.sort(sortfunc)
 479
 480         l = [klass(self._client, self.classname, x) for x in l]
 481         return l
 482
 483     def csv(self):
 484         ''' Return the items of this class as a chunk of CSV text.
 485         '''
 486         if rcsv.error:
 487             return rcsv.error
 488
 489         props = self.propnames()
 490         s = StringIO.StringIO()
 491         writer = rcsv.writer(s, rcsv.comma_separated)
 492         writer.writerow(props)
 493         for nodeid in self._klass.list():
 494             l = []
 495             for name in props:
 496                 value = self._klass.get(nodeid, name)
 497                 if value is None:
 498                     l.append('')
 499                 elif isinstance(value, type([])):
 500                     l.append(':'.join(map(str, value)))
 501                 else:
 502                     l.append(str(self._klass.get(nodeid, name)))
 503             writer.writerow(l)
 504         return s.getvalue()
 505
 506     def propnames(self):
 507         ''' Return the list of the names of the properties of this class.
 508         '''
 509         idlessprops = self._klass.getprops(protected=0).keys()
 510         idlessprops.sort()
 511         return ['id'] + idlessprops
 512
 513     def filter(self, request=None, filterspec={}, sort=(None,None),
 514             group=(None,None)):
 515         ''' Return a list of items from this class, filtered and sorted
 516             by the current requested filterspec/filter/sort/group args
 517
 518             "request" takes precedence over the other three arguments.
 519         '''
 520         if request is not None:
 521             filterspec = request.filterspec
 522             sort = request.sort
 523             group = request.group
 524         if self.classname == 'user':
 525             klass = HTMLUser
 526         else:
 527             klass = HTMLItem
 528         l = [klass(self._client, self.classname, x)
 529              for x in self._klass.filter(None, filterspec, sort, group)]
 530         return l
 531
 532     def classhelp(self, properties=None, label='(list)', width='500',
 533             height='400', property=''):
 534         ''' Pop up a javascript window with class help
 535
 536             This generates a link to a popup window which displays the
 537             properties indicated by "properties" of the class named by
 538             "classname". The "properties" should be a comma-separated list
 539             (eg. 'id,name,description'). Properties defaults to all the
 540             properties of a class (excluding id, creator, created and
 541             activity).
 542
 543             You may optionally override the label displayed, the width and
 544             height. The popup window will be resizable and scrollable.
 545
 546             If the "property" arg is given, it's passed through to the
 547             javascript help_window function.
 548         '''
 549         if properties is None:
 550             properties = self._klass.getprops(protected=0).keys()
 551             properties.sort()
 552             properties = ','.join(properties)
 553         if property:
 554             property = '&amp;property=%s'%property
 555         return '<a class="classhelp" href="javascript:help_window(\'%s?'\
 556             '@startwith=0&amp;@template=help&amp;properties=%s%s\', \'%s\', \
 557             \'%s\')">%s</a>'%(self.classname, properties, property, width,
 558             height, label)
 559
 560     def submit(self, label="Submit New Entry"):
 561         ''' Generate a submit button (and action hidden element)
 562         '''
 563         self.view_check()
 564         if self.is_edit_ok():
 565             return self.input(type="hidden",name="@action",value="new") + \
 566                    '\n' + self.input(type="submit",name="submit",value=label)
 567         return ''
 568
 569     def history(self):
 570         self.view_check()
 571         return 'New node - no history'
 572
 573     def renderWith(self, name, **kwargs):
 574         ''' Render this class with the given template.
 575         '''
 576         # create a new request and override the specified args
 577         req = HTMLRequest(self._client)
 578         req.classname = self.classname
 579         req.update(kwargs)
 580
 581         # new template, using the specified classname and request
 582         pt = Templates(self._db.config.TEMPLATES).get(self.classname, name)
 583
 584         # use our fabricated request
 585         args = {
 586             'ok_message': self._client.ok_message,
 587             'error_message': self._client.error_message
 588         }
 589         return pt.render(self._client, self.classname, req, **args)
 590
 591 class HTMLItem(HTMLInputMixin, HTMLPermissions):
 592     ''' Accesses through an *item*
 593     '''
 594     def __init__(self, client, classname, nodeid, anonymous=0):
 595         self._client = client
 596         self._db = client.db
 597         self._classname = classname
 598         self._nodeid = nodeid
 599         self._klass = self._db.getclass(classname)
 600         self._props = self._klass.getprops()
 601
 602         # do we prefix the form items with the item's identification?
 603         self._anonymous = anonymous
 604
 605         HTMLInputMixin.__init__(self)
 606
 607     def __repr__(self):
 608         return '<HTMLItem(0x%x) %s %s>'%(id(self), self._classname,
 609             self._nodeid)
 610
 611     def __getitem__(self, item):
 612         ''' return an HTMLProperty instance
 613         '''
 614         #print 'HTMLItem.getitem', (self, item)
 615         if item == 'id':
 616             return self._nodeid
 617
 618         # get the property
 619         prop = self._props[item]
 620
 621         # get the value, handling missing values
 622         value = None
 623         if int(self._nodeid) > 0:
 624             value = self._klass.get(self._nodeid, item, None)
 625         if value is None:
 626             if isinstance(self._props[item], hyperdb.Multilink):
 627                 value = []
 628
 629         # look up the correct HTMLProperty class
 630         for klass, htmlklass in propclasses:
 631             if isinstance(prop, klass):
 632                 return htmlklass(self._client, self._classname,
 633                     self._nodeid, prop, item, value, self._anonymous)
 634
 635         raise KeyError, item
 636
 637     def __getattr__(self, attr):
 638         ''' convenience access to properties '''
 639         try:
 640             return self[attr]
 641         except KeyError:
 642             raise AttributeError, attr
 643
 644     def designator(self):
 645         """Return this item's designator (classname + id)."""
 646         return '%s%s'%(self._classname, self._nodeid)
 647
 648     def submit(self, label="Submit Changes"):
 649         """Generate a submit button.
 650
 651         Also sneak in the lastactivity and action hidden elements.
 652         """
 653         return self.input(type="hidden", name="@lastactivity", value=date.Date('.')) + '\n' + \
 654                self.input(type="hidden", name="@action", value="edit") + '\n' + \
 655                self.input(type="submit", name="submit", value=label)
 656
 657     def journal(self, direction='descending'):
 658         ''' Return a list of HTMLJournalEntry instances.
 659         '''
 660         # XXX do this
 661         return []
 662
 663     def history(self, direction='descending', dre=re.compile('\d+')):
 664         self.view_check()
 665
 666         l = ['<table class="history">'
 667              '<tr><th colspan="4" class="header">',
 668              _('History'),
 669              '</th></tr><tr>',
 670              _('<th>Date</th>'),
 671              _('<th>User</th>'),
 672              _('<th>Action</th>'),
 673              _('<th>Args</th>'),
 674             '</tr>']
 675         current = {}
 676         comments = {}
 677         history = self._klass.history(self._nodeid)
 678         history.sort()
 679         timezone = self._db.getUserTimezone()
 680         if direction == 'descending':
 681             history.reverse()
 682             for prop_n in self._props.keys():
 683                 prop = self[prop_n]
 684                 if isinstance(prop, HTMLProperty):
 685                     current[prop_n] = prop.plain()
 686                     # make link if hrefable
 687                     if (self._props.has_key(prop_n) and
 688                             isinstance(self._props[prop_n], hyperdb.Link)):
 689                         classname = self._props[prop_n].classname
 690                         try:
 691                             template = find_template(self._db.config.TEMPLATES,
 692                                 classname, 'item')
 693                             if template[1].startswith('_generic'):
 694                                 raise NoTemplate, 'not really...'
 695                         except NoTemplate:
 696                             pass
 697                         else:
 698                             id = self._klass.get(self._nodeid, prop_n, None)
 699                             current[prop_n] = '<a href="%s%s">%s</a>'%(
 700                                 classname, id, current[prop_n])
 701
 702         for id, evt_date, user, action, args in history:
 703             date_s = str(evt_date.local(timezone)).replace("."," ")
 704             arg_s = ''
 705             if action == 'link' and type(args) == type(()):
 706                 if len(args) == 3:
 707                     linkcl, linkid, key = args
 708                     arg_s += '<a href="%s%s">%s%s %s</a>'%(linkcl, linkid,
 709                         linkcl, linkid, key)
 710                 else:
 711                     arg_s = str(args)
 712
 713             elif action == 'unlink' and type(args) == type(()):
 714                 if len(args) == 3:
 715                     linkcl, linkid, key = args
 716                     arg_s += '<a href="%s%s">%s%s %s</a>'%(linkcl, linkid,
 717                         linkcl, linkid, key)
 718                 else:
 719                     arg_s = str(args)
 720
 721             elif type(args) == type({}):
 722                 cell = []
 723                 for k in args.keys():
 724                     # try to get the relevant property and treat it
 725                     # specially
 726                     try:
 727                         prop = self._props[k]
 728                     except KeyError:
 729                         prop = None
 730                     if prop is None:
 731                         # property no longer exists
 732                         comments['no_exist'] = _('''<em>The indicated property
 733                             no longer exists</em>''')
 734                         cell.append('<em>%s: %s</em>\n'%(k, str(args[k])))
 735                         continue
 736
 737                     if args[k] and (isinstance(prop, hyperdb.Multilink) or
 738                             isinstance(prop, hyperdb.Link)):
 739                         # figure what the link class is
 740                         classname = prop.classname
 741                         try:
 742                             linkcl = self._db.getclass(classname)
 743                         except KeyError:
 744                             labelprop = None
 745                             comments[classname] = _('''The linked class
 746                                 %(classname)s no longer exists''')%locals()
 747                         labelprop = linkcl.labelprop(1)
 748                         try:
 749                             template = find_template(self._db.config.TEMPLATES,
 750                                 classname, 'item')
 751                             if template[1].startswith('_generic'):
 752                                 raise NoTemplate, 'not really...'
 753                             hrefable = 1
 754                         except NoTemplate:
 755                             hrefable = 0
 756
 757                     if isinstance(prop, hyperdb.Multilink) and args[k]:
 758                         ml = []
 759                         for linkid in args[k]:
 760                             if isinstance(linkid, type(())):
 761                                 sublabel = linkid[0] + ' '
 762                                 linkids = linkid[1]
 763                             else:
 764                                 sublabel = ''
 765                                 linkids = [linkid]
 766                             subml = []
 767                             for linkid in linkids:
 768                                 label = classname + linkid
 769                                 # if we have a label property, try to use it
 770                                 # TODO: test for node existence even when
 771                                 # there's no labelprop!
 772                                 try:
 773                                     if labelprop is not None and \
 774                                             labelprop != 'id':
 775                                         label = linkcl.get(linkid, labelprop)
 776                                 except IndexError:
 777                                     comments['no_link'] = _('''<strike>The
 778                                         linked node no longer
 779                                         exists</strike>''')
 780                                     subml.append('<strike>%s</strike>'%label)
 781                                 else:
 782                                     if hrefable:
 783                                         subml.append('<a href="%s%s">%s</a>'%(
 784                                             classname, linkid, label))
 785                                     else:
 786                                         subml.append(label)
 787                             ml.append(sublabel + ', '.join(subml))
 788                         cell.append('%s:\n  %s'%(k, ', '.join(ml)))
 789                     elif isinstance(prop, hyperdb.Link) and args[k]:
 790                         label = classname + args[k]
 791                         # if we have a label property, try to use it
 792                         # TODO: test for node existence even when
 793                         # there's no labelprop!
 794                         if labelprop is not None and labelprop != 'id':
 795                             try:
 796                                 label = linkcl.get(args[k], labelprop)
 797                             except IndexError:
 798                                 comments['no_link'] = _('''<strike>The
 799                                     linked node no longer
 800                                     exists</strike>''')
 801                                 cell.append(' <strike>%s</strike>,\n'%label)
 802                                 # "flag" this is done .... euwww
 803                                 label = None
 804                         if label is not None:
 805                             if hrefable:
 806                                 old = '<a href="%s%s">%s</a>'%(classname, args[k], label)
 807                             else:
 808                                 old = label;
 809                             cell.append('%s: %s' % (k,old))
 810                             if current.has_key(k):
 811                                 cell[-1] += ' -> %s'%current[k]
 812                                 current[k] = old
 813
 814                     elif isinstance(prop, hyperdb.Date) and args[k]:
 815                         d = date.Date(args[k]).local(timezone)
 816                         cell.append('%s: %s'%(k, str(d)))
 817                         if current.has_key(k):
 818                             cell[-1] += ' -> %s' % current[k]
 819                             current[k] = str(d)
 820
 821                     elif isinstance(prop, hyperdb.Interval) and args[k]:
 822                         d = date.Interval(args[k])
 823                         cell.append('%s: %s'%(k, str(d)))
 824                         if current.has_key(k):
 825                             cell[-1] += ' -> %s'%current[k]
 826                             current[k] = str(d)
 827
 828                     elif isinstance(prop, hyperdb.String) and args[k]:
 829                         cell.append('%s: %s'%(k, cgi.escape(args[k])))
 830                         if current.has_key(k):
 831                             cell[-1] += ' -> %s'%current[k]
 832                             current[k] = cgi.escape(args[k])
 833
 834                     elif not args[k]:
 835                         if current.has_key(k):
 836                             cell.append('%s: %s'%(k, current[k]))
 837                             current[k] = '(no value)'
 838                         else:
 839                             cell.append('%s: (no value)'%k)
 840
 841                     else:
 842                         cell.append('%s: %s'%(k, str(args[k])))
 843                         if current.has_key(k):
 844                             cell[-1] += ' -> %s'%current[k]
 845                             current[k] = str(args[k])
 846
 847                 arg_s = '<br />'.join(cell)
 848             else:
 849                 # unkown event!!
 850                 comments['unknown'] = _('''<strong><em>This event is not
 851                     handled by the history display!</em></strong>''')
 852                 arg_s = '<strong><em>' + str(args) + '</em></strong>'
 853             date_s = date_s.replace(' ', '&nbsp;')
 854             # if the user's an itemid, figure the username (older journals
 855             # have the username)
 856             if dre.match(user):
 857                 user = self._db.user.get(user, 'username')
 858             l.append('<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>'%(
 859                 date_s, user, action, arg_s))
 860         if comments:
 861             l.append(_('<tr><td colspan=4><strong>Note:</strong></td></tr>'))
 862         for entry in comments.values():
 863             l.append('<tr><td colspan=4>%s</td></tr>'%entry)
 864         l.append('</table>')
 865         return '\n'.join(l)
 866
 867     def renderQueryForm(self):
 868         ''' Render this item, which is a query, as a search form.
 869         '''
 870         # create a new request and override the specified args
 871         req = HTMLRequest(self._client)
 872         req.classname = self._klass.get(self._nodeid, 'klass')
 873         name = self._klass.get(self._nodeid, 'name')
 874         req.updateFromURL(self._klass.get(self._nodeid, 'url') +
 875             '&@queryname=%s'%urllib.quote(name))
 876
 877         # new template, using the specified classname and request
 878         pt = Templates(self._db.config.TEMPLATES).get(req.classname, 'search')
 879
 880         # use our fabricated request
 881         return pt.render(self._client, req.classname, req)
 882
 883 class HTMLUserPermission:
 884
 885     def is_edit_ok(self):
 886         ''' Is the user allowed to Edit the current class?
 887             Also check whether this is the current user's info.
 888         '''
 889         return self._user_perm_check('Edit')
 890
 891     def is_view_ok(self):
 892         ''' Is the user allowed to View the current class?
 893             Also check whether this is the current user's info.
 894         '''
 895         return self._user_perm_check('View')
 896
 897     def _user_perm_check(self, type):
 898         # some users may view / edit all users
 899         s = self._db.security
 900         userid = self._client.userid
 901         if s.hasPermission(type, userid, self._classname):
 902             return 1
 903
 904         # users may view their own info
 905         is_anonymous = self._db.user.get(userid, 'username') == 'anonymous'
 906         if getattr(self, '_nodeid', None) == userid and not is_anonymous:
 907             return 1
 908
 909         # may anonymous users register?
 910         if (is_anonymous and s.hasPermission('Web Registration', userid,
 911                 self._classname)):
 912             return 1
 913
 914         # nope, no access here
 915         return 0
 916
 917 class HTMLUserClass(HTMLUserPermission, HTMLClass):
 918     pass
 919
 920 class HTMLUser(HTMLUserPermission, HTMLItem):
 921     ''' Accesses through the *user* (a special case of item)
 922     '''
 923     def __init__(self, client, classname, nodeid, anonymous=0):
 924         HTMLItem.__init__(self, client, 'user', nodeid, anonymous)
 925         self._default_classname = client.classname
 926
 927         # used for security checks
 928         self._security = client.db.security
 929
 930     _marker = []
 931     def hasPermission(self, permission, classname=_marker):
 932         ''' Determine if the user has the Permission.
 933
 934             The class being tested defaults to the template's class, but may
 935             be overidden for this test by suppling an alternate classname.
 936         '''
 937         if classname is self._marker:
 938             classname = self._default_classname
 939         return self._security.hasPermission(permission, self._nodeid, classname)
 940
 941 class HTMLProperty(HTMLInputMixin, HTMLPermissions):
 942     ''' String, Number, Date, Interval HTMLProperty
 943
 944         Has useful attributes:
 945
 946          _name  the name of the property
 947          _value the value of the property if any
 948
 949         A wrapper object which may be stringified for the plain() behaviour.
 950     '''
 951     def __init__(self, client, classname, nodeid, prop, name, value,
 952             anonymous=0):
 953         self._client = client
 954         self._db = client.db
 955         self._classname = classname
 956         self._nodeid = nodeid
 957         self._prop = prop
 958         self._value = value
 959         self._anonymous = anonymous
 960         self._name = name
 961         if not anonymous:
 962             self._formname = '%s%s@%s'%(classname, nodeid, name)
 963         else:
 964             self._formname = name
 965
 966         HTMLInputMixin.__init__(self)
 967
 968     def __repr__(self):
 969         return '<HTMLProperty(0x%x) %s %r %r>'%(id(self), self._formname,
 970             self._prop, self._value)
 971     def __str__(self):
 972         return self.plain()
 973     def __cmp__(self, other):
 974         if isinstance(other, HTMLProperty):
 975             return cmp(self._value, other._value)
 976         return cmp(self._value, other)
 977
 978     def is_edit_ok(self):
 979         ''' Is the user allowed to Edit the current class?
 980         '''
 981         thing = HTMLDatabase(self._client)[self._classname]
 982         if self._nodeid:
 983             # this is a special-case for the User class where permission's
 984             # on a per-item basis :(
 985             thing = thing.getItem(self._nodeid)
 986         return thing.is_edit_ok()
 987
 988     def is_view_ok(self):
 989         ''' Is the user allowed to View the current class?
 990         '''
 991         thing = HTMLDatabase(self._client)[self._classname]
 992         if self._nodeid:
 993             # this is a special-case for the User class where permission's
 994             # on a per-item basis :(
 995             thing = thing.getItem(self._nodeid)
 996         return thing.is_view_ok()
 997
 998 class StringHTMLProperty(HTMLProperty):
 999     hyper_re = re.compile(r'((?P<url>\w{3,6}://\S+)|'
1000                           r'(?P<email>[-+=%/\w\.]+@[\w\.\-]+)|'
1001                           r'(?P<item>(?P<class>[a-z_]+)(?P<id>\d+)))')
1002     def _hyper_repl(self, match):
1003         if match.group('url'):
1004             s = match.group('url')
1005             return '<a href="%s">%s</a>'%(s, s)
1006         elif match.group('email'):
1007             s = match.group('email')
1008             return '<a href="mailto:%s">%s</a>'%(s, s)
1009         else:
1010             s = match.group('item')
1011             s1 = match.group('class')
1012             s2 = match.group('id')
1013             try:
1014                 # make sure s1 is a valid tracker classname
1015                 cl = self._db.getclass(s1)
1016                 if not cl.hasnode(s2):
1017                     raise KeyError, 'oops'
1018                 return '<a href="%s">%s%s</a>'%(s, s1, s2)
1019             except KeyError:
1020                 return '%s%s'%(s1, s2)
1021
1022     def hyperlinked(self):
1023         ''' Render a "hyperlinked" version of the text '''
1024         return self.plain(hyperlink=1)
1025
1026     def plain(self, escape=0, hyperlink=0):
1027         '''Render a "plain" representation of the property
1028
1029         - "escape" turns on/off HTML quoting
1030         - "hyperlink" turns on/off in-text hyperlinking of URLs, email
1031           addresses and designators
1032         '''
1033         self.view_check()
1034
1035         if self._value is None:
1036             return ''
1037         if escape:
1038             s = cgi.escape(str(self._value))
1039         else:
1040             s = str(self._value)
1041         if hyperlink:
1042             # no, we *must* escape this text
1043             if not escape:
1044                 s = cgi.escape(s)
1045             s = self.hyper_re.sub(self._hyper_repl, s)
1046         return s
1047
1048     def stext(self, escape=0):
1049         ''' Render the value of the property as StructuredText.
1050
1051             This requires the StructureText module to be installed separately.
1052         '''
1053         self.view_check()
1054
1055         s = self.plain(escape=escape)
1056         if not StructuredText:
1057             return s
1058         return StructuredText(s,level=1,header=0)
1059
1060     def field(self, size = 30):
1061         ''' Render the property as a field in HTML.
1062
1063             If not editable, just display the value via plain().
1064         '''
1065         self.view_check()
1066
1067         if self._value is None:
1068             value = ''
1069         else:
1070             value = cgi.escape(str(self._value))
1071
1072         if self.is_edit_ok():
1073             value = '&quot;'.join(value.split('"'))
1074             return self.input(name=self._formname,value=value,size=size)
1075
1076         return self.plain()
1077
1078     def multiline(self, escape=0, rows=5, cols=40):
1079         ''' Render a multiline form edit field for the property.
1080
1081             If not editable, just display the plain() value in a <pre> tag.
1082         '''
1083         self.view_check()
1084
1085         if self._value is None:
1086             value = ''
1087         else:
1088             value = cgi.escape(str(self._value))
1089
1090         if self.is_edit_ok():
1091             value = '&quot;'.join(value.split('"'))
1092             return '<textarea name="%s" rows="%s" cols="%s">%s</textarea>'%(
1093                 self._formname, rows, cols, value)
1094
1095         return '<pre>%s</pre>'%self.plain()
1096
1097     def email(self, escape=1):
1098         ''' Render the value of the property as an obscured email address
1099         '''
1100         self.view_check()
1101
1102         if self._value is None:
1103             value = ''
1104         else:
1105             value = str(self._value)
1106         if value.find('@') != -1:
1107             name, domain = value.split('@')
1108             domain = ' '.join(domain.split('.')[:-1])
1109             name = name.replace('.', ' ')
1110             value = '%s at %s ...'%(name, domain)
1111         else:
1112             value = value.replace('.', ' ')
1113         if escape:
1114             value = cgi.escape(value)
1115         return value
1116
1117 class PasswordHTMLProperty(HTMLProperty):
1118     def plain(self):
1119         ''' Render a "plain" representation of the property
1120         '''
1121         self.view_check()
1122
1123         if self._value is None:
1124             return ''
1125         return _('*encrypted*')
1126
1127     def field(self, size = 30):
1128         ''' Render a form edit field for the property.
1129
1130             If not editable, just display the value via plain().
1131         '''
1132         self.view_check()
1133
1134         if self.is_edit_ok():
1135             return self.input(type="password", name=self._formname, size=size)
1136
1137         return self.plain()
1138
1139     def confirm(self, size = 30):
1140         ''' Render a second form edit field for the property, used for
1141             confirmation that the user typed the password correctly. Generates
1142             a field with name "@confirm@name".
1143
1144             If not editable, display nothing.
1145         '''
1146         self.view_check()
1147
1148         if self.is_edit_ok():
1149             return self.input(type="password",
1150                 name="@confirm@%s"%self._formname, size=size)
1151
1152         return ''
1153
1154 class NumberHTMLProperty(HTMLProperty):
1155     def plain(self):
1156         ''' Render a "plain" representation of the property
1157         '''
1158         self.view_check()
1159
1160         return str(self._value)
1161
1162     def field(self, size = 30):
1163         ''' Render a form edit field for the property.
1164
1165             If not editable, just display the value via plain().
1166         '''
1167         self.view_check()
1168
1169         if self._value is None:
1170             value = ''
1171         else:
1172             value = cgi.escape(str(self._value))
1173
1174         if self.is_edit_ok():
1175             value = '&quot;'.join(value.split('"'))
1176             return self.input(name=self._formname,value=value,size=size)
1177
1178         return self.plain()
1179
1180     def __int__(self):
1181         ''' Return an int of me
1182         '''
1183         return int(self._value)
1184
1185     def __float__(self):
1186         ''' Return a float of me
1187         '''
1188         return float(self._value)
1189
1190
1191 class BooleanHTMLProperty(HTMLProperty):
1192     def plain(self):
1193         ''' Render a "plain" representation of the property
1194         '''
1195         self.view_check()
1196
1197         if self._value is None:
1198             return ''
1199         return self._value and "Yes" or "No"
1200
1201     def field(self):
1202         ''' Render a form edit field for the property
1203
1204             If not editable, just display the value via plain().
1205         '''
1206         self.view_check()
1207
1208         if not self.is_edit_ok():
1209             return self.plain()
1210
1211         checked = self._value and "checked" or ""
1212         if self._value:
1213             s = self.input(type="radio", name=self._formname, value="yes",
1214                 checked="checked")
1215             s += 'Yes'
1216             s +=self.input(type="radio", name=self._formname, value="no")
1217             s += 'No'
1218         else:
1219             s = self.input(type="radio", name=self._formname, value="yes")
1220             s += 'Yes'
1221             s +=self.input(type="radio", name=self._formname, value="no",
1222                 checked="checked")
1223             s += 'No'
1224         return s
1225
1226 class DateHTMLProperty(HTMLProperty):
1227     def plain(self):
1228         ''' Render a "plain" representation of the property
1229         '''
1230         self.view_check()
1231
1232         if self._value is None:
1233             return ''
1234         return str(self._value.local(self._db.getUserTimezone()))
1235
1236     def now(self):
1237         ''' Return the current time.
1238
1239             This is useful for defaulting a new value. Returns a
1240             DateHTMLProperty.
1241         '''
1242         self.view_check()
1243
1244         return DateHTMLProperty(self._client, self._classname, self._nodeid,
1245             self._prop, self._formname, date.Date('.'))
1246
1247     def field(self, size = 30):
1248         ''' Render a form edit field for the property
1249
1250             If not editable, just display the value via plain().
1251         '''
1252         self.view_check()
1253
1254         if self._value is None:
1255             value = ''
1256         else:
1257             tz = self._db.getUserTimezone()
1258             value = cgi.escape(str(self._value.local(tz)))
1259
1260         if is_edit_ok():
1261             value = '&quot;'.join(value.split('"'))
1262             return self.input(name=self._formname,value=value,size=size)
1263
1264         return self.plain()
1265
1266     def reldate(self, pretty=1):
1267         ''' Render the interval between the date and now.
1268
1269             If the "pretty" flag is true, then make the display pretty.
1270         '''
1271         self.view_check()
1272
1273         if not self._value:
1274             return ''
1275
1276         # figure the interval
1277         interval = self._value - date.Date('.')
1278         if pretty:
1279             return interval.pretty()
1280         return str(interval)
1281
1282     _marker = []
1283     def pretty(self, format=_marker):
1284         ''' Render the date in a pretty format (eg. month names, spaces).
1285
1286             The format string is a standard python strftime format string.
1287             Note that if the day is zero, and appears at the start of the
1288             string, then it'll be stripped from the output. This is handy
1289             for the situatin when a date only specifies a month and a year.
1290         '''
1291         self.view_check()
1292
1293         if format is not self._marker:
1294             return self._value.pretty(format)
1295         else:
1296             return self._value.pretty()
1297
1298     def local(self, offset):
1299         ''' Return the date/time as a local (timezone offset) date/time.
1300         '''
1301         self.view_check()
1302
1303         return DateHTMLProperty(self._client, self._classname, self._nodeid,
1304             self._prop, self._formname, self._value.local(offset))
1305
1306 class IntervalHTMLProperty(HTMLProperty):
1307     def plain(self):
1308         ''' Render a "plain" representation of the property
1309         '''
1310         self.view_check()
1311
1312         if self._value is None:
1313             return ''
1314         return str(self._value)
1315
1316     def pretty(self):
1317         ''' Render the interval in a pretty format (eg. "yesterday")
1318         '''
1319         self.view_check()
1320
1321         return self._value.pretty()
1322
1323     def field(self, size = 30):
1324         ''' Render a form edit field for the property
1325
1326             If not editable, just display the value via plain().
1327         '''
1328         self.view_check()
1329
1330         if self._value is None:
1331             value = ''
1332         else:
1333             value = cgi.escape(str(self._value))
1334
1335         if is_edit_ok():
1336             value = '&quot;'.join(value.split('"'))
1337             return self.input(name=self._formname,value=value,size=size)
1338
1339         return self.plain()
1340
1341 class LinkHTMLProperty(HTMLProperty):
1342     ''' Link HTMLProperty
1343         Include the above as well as being able to access the class
1344         information. Stringifying the object itself results in the value
1345         from the item being displayed. Accessing attributes of this object
1346         result in the appropriate entry from the class being queried for the
1347         property accessed (so item/assignedto/name would look up the user
1348         entry identified by the assignedto property on item, and then the
1349         name property of that user)
1350     '''
1351     def __init__(self, *args, **kw):
1352         HTMLProperty.__init__(self, *args, **kw)
1353         # if we're representing a form value, then the -1 from the form really
1354         # should be a None
1355         if str(self._value) == '-1':
1356             self._value = None
1357
1358     def __getattr__(self, attr):
1359         ''' return a new HTMLItem '''
1360        #print 'Link.getattr', (self, attr, self._value)
1361         if not self._value:
1362             raise AttributeError, "Can't access missing value"
1363         if self._prop.classname == 'user':
1364             klass = HTMLUser
1365         else:
1366             klass = HTMLItem
1367         i = klass(self._client, self._prop.classname, self._value)
1368         return getattr(i, attr)
1369
1370     def plain(self, escape=0):
1371         ''' Render a "plain" representation of the property
1372         '''
1373         self.view_check()
1374
1375         if self._value is None:
1376             return ''
1377         linkcl = self._db.classes[self._prop.classname]
1378         k = linkcl.labelprop(1)
1379         value = str(linkcl.get(self._value, k))
1380         if escape:
1381             value = cgi.escape(value)
1382         return value
1383
1384     def field(self, showid=0, size=None):
1385         ''' Render a form edit field for the property
1386
1387             If not editable, just display the value via plain().
1388         '''
1389         self.view_check()
1390
1391         if not self.is_edit_ok():
1392             return self.plain()
1393
1394         # edit field
1395         linkcl = self._db.getclass(self._prop.classname)
1396         if self._value is None:
1397             value = ''
1398         else:
1399             k = linkcl.getkey()
1400             if k:
1401                 value = linkcl.get(self._value, k)
1402             else:
1403                 value = self._value
1404             value = cgi.escape(str(value))
1405             value = '&quot;'.join(value.split('"'))
1406         return '<input name="%s" value="%s" size="%s">'%(self._formname,
1407             value, size)
1408
1409     def menu(self, size=None, height=None, showid=0, additional=[],
1410             sort_on=None, **conditions):
1411         ''' Render a form select list for this property
1412
1413             If not editable, just display the value via plain().
1414         '''
1415         self.view_check()
1416
1417         if not self.is_edit_ok():
1418             return self.plain()
1419
1420         value = self._value
1421
1422         linkcl = self._db.getclass(self._prop.classname)
1423         l = ['<select name="%s">'%self._formname]
1424         k = linkcl.labelprop(1)
1425         s = ''
1426         if value is None:
1427             s = 'selected="selected" '
1428         l.append(_('<option %svalue="-1">- no selection -</option>')%s)
1429         if linkcl.getprops().has_key('order'):
1430             sort_on = ('+', 'order')
1431         else:
1432             if sort_on is None:
1433                 sort_on = ('+', linkcl.labelprop())
1434             else:
1435                 sort_on = ('+', sort_on)
1436         options = linkcl.filter(None, conditions, sort_on, (None, None))
1437
1438         # make sure we list the current value if it's retired
1439         if self._value and self._value not in options:
1440             options.insert(0, self._value)
1441
1442         for optionid in options:
1443             # get the option value, and if it's None use an empty string
1444             option = linkcl.get(optionid, k) or ''
1445
1446             # figure if this option is selected
1447             s = ''
1448             if value in [optionid, option]:
1449                 s = 'selected="selected" '
1450
1451             # figure the label
1452             if showid:
1453                 lab = '%s%s: %s'%(self._prop.classname, optionid, option)
1454             else:
1455                 lab = option
1456
1457             # truncate if it's too long
1458             if size is not None and len(lab) > size:
1459                 lab = lab[:size-3] + '...'
1460             if additional:
1461                 m = []
1462                 for propname in additional:
1463                     m.append(linkcl.get(optionid, propname))
1464                 lab = lab + ' (%s)'%', '.join(map(str, m))
1465
1466             # and generate
1467             lab = cgi.escape(lab)
1468             l.append('<option %svalue="%s">%s</option>'%(s, optionid, lab))
1469         l.append('</select>')
1470         return '\n'.join(l)
1471 #    def checklist(self, ...)
1472
1473 class MultilinkHTMLProperty(HTMLProperty):
1474     ''' Multilink HTMLProperty
1475
1476         Also be iterable, returning a wrapper object like the Link case for
1477         each entry in the multilink.
1478     '''
1479     def __init__(self, *args, **kwargs):
1480         HTMLProperty.__init__(self, *args, **kwargs)
1481         if self._value:
1482             sortfun = make_sort_function(self._db, self._prop.classname)
1483             self._value.sort(sortfun)
1484
1485     def __len__(self):
1486         ''' length of the multilink '''
1487         return len(self._value)
1488
1489     def __getattr__(self, attr):
1490         ''' no extended attribute accesses make sense here '''
1491         raise AttributeError, attr
1492
1493     def __getitem__(self, num):
1494         ''' iterate and return a new HTMLItem
1495         '''
1496        #print 'Multi.getitem', (self, num)
1497         value = self._value[num]
1498         if self._prop.classname == 'user':
1499             klass = HTMLUser
1500         else:
1501             klass = HTMLItem
1502         return klass(self._client, self._prop.classname, value)
1503
1504     def __contains__(self, value):
1505         ''' Support the "in" operator. We have to make sure the passed-in
1506             value is a string first, not a HTMLProperty.
1507         '''
1508         return str(value) in self._value
1509
1510     def reverse(self):
1511         ''' return the list in reverse order
1512         '''
1513         l = self._value[:]
1514         l.reverse()
1515         if self._prop.classname == 'user':
1516             klass = HTMLUser
1517         else:
1518             klass = HTMLItem
1519         return [klass(self._client, self._prop.classname, value) for value in l]
1520
1521     def plain(self, escape=0):
1522         ''' Render a "plain" representation of the property
1523         '''
1524         self.view_check()
1525
1526         linkcl = self._db.classes[self._prop.classname]
1527         k = linkcl.labelprop(1)
1528         labels = []
1529         for v in self._value:
1530             labels.append(linkcl.get(v, k))
1531         value = ', '.join(labels)
1532         if escape:
1533             value = cgi.escape(value)
1534         return value
1535
1536     def field(self, size=30, showid=0):
1537         ''' Render a form edit field for the property
1538
1539             If not editable, just display the value via plain().
1540         '''
1541         self.view_check()
1542
1543         if not self.is_edit_ok():
1544             return self.plain()
1545
1546         linkcl = self._db.getclass(self._prop.classname)
1547         value = self._value[:]
1548         # map the id to the label property
1549         if not linkcl.getkey():
1550             showid=1
1551         if not showid:
1552             k = linkcl.labelprop(1)
1553             value = lookupKeys(linkcl, k, value)
1554         value = cgi.escape(','.join(value))
1555         return self.input(name=self._formname,size=size,value=value)
1556
1557     def menu(self, size=None, height=None, showid=0, additional=[],
1558             sort_on=None, **conditions):
1559         ''' Render a form select list for this property
1560
1561             If not editable, just display the value via plain().
1562         '''
1563         self.view_check()
1564
1565         if not self.is_edit_ok():
1566             return self.plain()
1567
1568         value = self._value
1569
1570         linkcl = self._db.getclass(self._prop.classname)
1571         if sort_on is None:
1572             sort_on = ('+', find_sort_key(linkcl))
1573         else:
1574             sort_on = ('+', sort_on)
1575         options = linkcl.filter(None, conditions, sort_on)
1576         height = height or min(len(options), 7)
1577         l = ['<select multiple name="%s" size="%s">'%(self._formname, height)]
1578         k = linkcl.labelprop(1)
1579
1580         # make sure we list the current values if they're retired
1581         for val in value:
1582             if val not in options:
1583                 options.insert(0, val)
1584
1585         for optionid in options:
1586             # get the option value, and if it's None use an empty string
1587             option = linkcl.get(optionid, k) or ''
1588
1589             # figure if this option is selected
1590             s = ''
1591             if optionid in value or option in value:
1592                 s = 'selected="selected" '
1593
1594             # figure the label
1595             if showid:
1596                 lab = '%s%s: %s'%(self._prop.classname, optionid, option)
1597             else:
1598                 lab = option
1599             # truncate if it's too long
1600             if size is not None and len(lab) > size:
1601                 lab = lab[:size-3] + '...'
1602             if additional:
1603                 m = []
1604                 for propname in additional:
1605                     m.append(linkcl.get(optionid, propname))
1606                 lab = lab + ' (%s)'%', '.join(m)
1607
1608             # and generate
1609             lab = cgi.escape(lab)
1610             l.append('<option %svalue="%s">%s</option>'%(s, optionid,
1611                 lab))
1612         l.append('</select>')
1613         return '\n'.join(l)
1614
1615 # set the propclasses for HTMLItem
1616 propclasses = (
1617     (hyperdb.String, StringHTMLProperty),
1618     (hyperdb.Number, NumberHTMLProperty),
1619     (hyperdb.Boolean, BooleanHTMLProperty),
1620     (hyperdb.Date, DateHTMLProperty),
1621     (hyperdb.Interval, IntervalHTMLProperty),
1622     (hyperdb.Password, PasswordHTMLProperty),
1623     (hyperdb.Link, LinkHTMLProperty),
1624     (hyperdb.Multilink, MultilinkHTMLProperty),
1625 )
1626
1627 def make_sort_function(db, classname, sort_on=None):
1628     '''Make a sort function for a given class
1629     '''
1630     linkcl = db.getclass(classname)
1631     if sort_on is None:
1632         sort_on = find_sort_key(linkcl)
1633     def sortfunc(a, b):
1634         return cmp(linkcl.get(a, sort_on), linkcl.get(b, sort_on))
1635     return sortfunc
1636
1637 def find_sort_key(linkcl):
1638     if linkcl.getprops().has_key('order'):
1639         return 'order'
1640     else:
1641         return linkcl.labelprop()
1642
1643 def handleListCGIValue(value):
1644     ''' Value is either a single item or a list of items. Each item has a
1645         .value that we're actually interested in.
1646     '''
1647     if isinstance(value, type([])):
1648         return [value.value for value in value]
1649     else:
1650         value = value.value.strip()
1651         if not value:
1652             return []
1653         return value.split(',')
1654
1655 class ShowDict:
1656     ''' A convenience access to the :columns index parameters
1657     '''
1658     def __init__(self, columns):
1659         self.columns = {}
1660         for col in columns:
1661             self.columns[col] = 1
1662     def __getitem__(self, name):
1663         return self.columns.has_key(name)
1664
1665 class HTMLRequest(HTMLInputMixin):
1666     '''The *request*, holding the CGI form and environment.
1667
1668     - "form" the CGI form as a cgi.FieldStorage
1669     - "env" the CGI environment variables
1670     - "base" the base URL for this instance
1671     - "user" a HTMLUser instance for this user
1672     - "classname" the current classname (possibly None)
1673     - "template" the current template (suffix, also possibly None)
1674
1675     Index args:
1676
1677     - "columns" dictionary of the columns to display in an index page
1678     - "show" a convenience access to columns - request/show/colname will
1679       be true if the columns should be displayed, false otherwise
1680     - "sort" index sort column (direction, column name)
1681     - "group" index grouping property (direction, column name)
1682     - "filter" properties to filter the index on
1683     - "filterspec" values to filter the index on
1684     - "search_text" text to perform a full-text search on for an index
1685     '''
1686     def __init__(self, client):
1687         # _client is needed by HTMLInputMixin
1688         self._client = self.client = client
1689
1690         # easier access vars
1691         self.form = client.form
1692         self.env = client.env
1693         self.base = client.base
1694         self.user = HTMLUser(client, 'user', client.userid)
1695
1696         # store the current class name and action
1697         self.classname = client.classname
1698         self.template = client.template
1699
1700         # the special char to use for special vars
1701         self.special_char = '@'
1702
1703         HTMLInputMixin.__init__(self)
1704
1705         self._post_init()
1706
1707     def _post_init(self):
1708         ''' Set attributes based on self.form
1709         '''
1710         # extract the index display information from the form
1711         self.columns = []
1712         for name in ':columns @columns'.split():
1713             if self.form.has_key(name):
1714                 self.special_char = name[0]
1715                 self.columns = handleListCGIValue(self.form[name])
1716                 break
1717         self.show = ShowDict(self.columns)
1718
1719         # sorting
1720         self.sort = (None, None)
1721         for name in ':sort @sort'.split():
1722             if self.form.has_key(name):
1723                 self.special_char = name[0]
1724                 sort = self.form[name].value
1725                 if sort.startswith('-'):
1726                     self.sort = ('-', sort[1:])
1727                 else:
1728                     self.sort = ('+', sort)
1729                 if self.form.has_key(self.special_char+'sortdir'):
1730                     self.sort = ('-', self.sort[1])
1731
1732         # grouping
1733         self.group = (None, None)
1734         for name in ':group @group'.split():
1735             if self.form.has_key(name):
1736                 self.special_char = name[0]
1737                 group = self.form[name].value
1738                 if group.startswith('-'):
1739                     self.group = ('-', group[1:])
1740                 else:
1741                     self.group = ('+', group)
1742                 if self.form.has_key(self.special_char+'groupdir'):
1743                     self.group = ('-', self.group[1])
1744
1745         # filtering
1746         self.filter = []
1747         for name in ':filter @filter'.split():
1748             if self.form.has_key(name):
1749                 self.special_char = name[0]
1750                 self.filter = handleListCGIValue(self.form[name])
1751
1752         self.filterspec = {}
1753         db = self.client.db
1754         if self.classname is not None:
1755             props = db.getclass(self.classname).getprops()
1756             for name in self.filter:
1757                 if not self.form.has_key(name):
1758                     continue
1759                 prop = props[name]
1760                 fv = self.form[name]
1761                 if (isinstance(prop, hyperdb.Link) or
1762                         isinstance(prop, hyperdb.Multilink)):
1763                     self.filterspec[name] = lookupIds(db, prop,
1764                         handleListCGIValue(fv))
1765                 else:
1766                     if isinstance(fv, type([])):
1767                         self.filterspec[name] = [v.value for v in fv]
1768                     else:
1769                         self.filterspec[name] = fv.value
1770
1771         # full-text search argument
1772         self.search_text = None
1773         for name in ':search_text @search_text'.split():
1774             if self.form.has_key(name):
1775                 self.special_char = name[0]
1776                 self.search_text = self.form[name].value
1777
1778         # pagination - size and start index
1779         # figure batch args
1780         self.pagesize = 50
1781         for name in ':pagesize @pagesize'.split():
1782             if self.form.has_key(name):
1783                 self.special_char = name[0]
1784                 self.pagesize = int(self.form[name].value)
1785
1786         self.startwith = 0
1787         for name in ':startwith @startwith'.split():
1788             if self.form.has_key(name):
1789                 self.special_char = name[0]
1790                 self.startwith = int(self.form[name].value)
1791
1792     def updateFromURL(self, url):
1793         ''' Parse the URL for query args, and update my attributes using the
1794             values.
1795         '''
1796         env = {'QUERY_STRING': url}
1797         self.form = cgi.FieldStorage(environ=env)
1798
1799         self._post_init()
1800
1801     def update(self, kwargs):
1802         ''' Update my attributes using the keyword args
1803         '''
1804         self.__dict__.update(kwargs)
1805         if kwargs.has_key('columns'):
1806             self.show = ShowDict(self.columns)
1807
1808     def description(self):
1809         ''' Return a description of the request - handle for the page title.
1810         '''
1811         s = [self.client.db.config.TRACKER_NAME]
1812         if self.classname:
1813             if self.client.nodeid:
1814                 s.append('- %s%s'%(self.classname, self.client.nodeid))
1815             else:
1816                 if self.template == 'item':
1817                     s.append('- new %s'%self.classname)
1818                 elif self.template == 'index':
1819                     s.append('- %s index'%self.classname)
1820                 else:
1821                     s.append('- %s %s'%(self.classname, self.template))
1822         else:
1823             s.append('- home')
1824         return ' '.join(s)
1825
1826     def __str__(self):
1827         d = {}
1828         d.update(self.__dict__)
1829         f = ''
1830         for k in self.form.keys():
1831             f += '\n      %r=%r'%(k,handleListCGIValue(self.form[k]))
1832         d['form'] = f
1833         e = ''
1834         for k,v in self.env.items():
1835             e += '\n     %r=%r'%(k, v)
1836         d['env'] = e
1837         return '''
1838 form: %(form)s
1839 base: %(base)r
1840 classname: %(classname)r
1841 template: %(template)r
1842 columns: %(columns)r
1843 sort: %(sort)r
1844 group: %(group)r
1845 filter: %(filter)r
1846 search_text: %(search_text)r
1847 pagesize: %(pagesize)r
1848 startwith: %(startwith)r
1849 env: %(env)s
1850 '''%d
1851
1852     def indexargs_form(self, columns=1, sort=1, group=1, filter=1,
1853             filterspec=1):
1854         ''' return the current index args as form elements '''
1855         l = []
1856         sc = self.special_char
1857         s = self.input(type="hidden",name="%s",value="%s")
1858         if columns and self.columns:
1859             l.append(s%(sc+'columns', ','.join(self.columns)))
1860         if sort and self.sort[1] is not None:
1861             if self.sort[0] == '-':
1862                 val = '-'+self.sort[1]
1863             else:
1864                 val = self.sort[1]
1865             l.append(s%(sc+'sort', val))
1866         if group and self.group[1] is not None:
1867             if self.group[0] == '-':
1868                 val = '-'+self.group[1]
1869             else:
1870                 val = self.group[1]
1871             l.append(s%(sc+'group', val))
1872         if filter and self.filter:
1873             l.append(s%(sc+'filter', ','.join(self.filter)))
1874         if filterspec:
1875             for k,v in self.filterspec.items():
1876                 if type(v) == type([]):
1877                     l.append(s%(k, ','.join(v)))
1878                 else:
1879                     l.append(s%(k, v))
1880         if self.search_text:
1881             l.append(s%(sc+'search_text', self.search_text))
1882         l.append(s%(sc+'pagesize', self.pagesize))
1883         l.append(s%(sc+'startwith', self.startwith))
1884         return '\n'.join(l)
1885
1886     def indexargs_url(self, url, args):
1887         ''' Embed the current index args in a URL
1888         '''
1889         sc = self.special_char
1890         l = ['%s=%s'%(k,v) for k,v in args.items()]
1891
1892         # pull out the special values (prefixed by @ or :)
1893         specials = {}
1894         for key in args.keys():
1895             if key[0] in '@:':
1896                 specials[key[1:]] = args[key]
1897
1898         # ok, now handle the specials we received in the request
1899         if self.columns and not specials.has_key('columns'):
1900             l.append(sc+'columns=%s'%(','.join(self.columns)))
1901         if self.sort[1] is not None and not specials.has_key('sort'):
1902             if self.sort[0] == '-':
1903                 val = '-'+self.sort[1]
1904             else:
1905                 val = self.sort[1]
1906             l.append(sc+'sort=%s'%val)
1907         if self.group[1] is not None and not specials.has_key('group'):
1908             if self.group[0] == '-':
1909                 val = '-'+self.group[1]
1910             else:
1911                 val = self.group[1]
1912             l.append(sc+'group=%s'%val)
1913         if self.filter and not specials.has_key('filter'):
1914             l.append(sc+'filter=%s'%(','.join(self.filter)))
1915         if self.search_text and not specials.has_key('search_text'):
1916             l.append(sc+'search_text=%s'%self.search_text)
1917         if not specials.has_key('pagesize'):
1918             l.append(sc+'pagesize=%s'%self.pagesize)
1919         if not specials.has_key('startwith'):
1920             l.append(sc+'startwith=%s'%self.startwith)
1921
1922         # finally, the remainder of the filter args in the request
1923         for k,v in self.filterspec.items():
1924             if not args.has_key(k):
1925                 if type(v) == type([]):
1926                     l.append('%s=%s'%(k, ','.join(v)))
1927                 else:
1928                     l.append('%s=%s'%(k, v))
1929         return '%s?%s'%(url, '&'.join(l))
1930     indexargs_href = indexargs_url
1931
1932     def base_javascript(self):
1933         return '''
1934 <script type="text/javascript">
1935 submitted = false;
1936 function submit_once() {
1937     if (submitted) {
1938         alert("Your request is being processed.\\nPlease be patient.");
1939         event.returnValue = 0;    // work-around for IE
1940         return 0;
1941     }
1942     submitted = true;
1943     return 1;
1944 }
1945
1946 function help_window(helpurl, width, height) {
1947     HelpWin = window.open('%s' + helpurl, 'RoundupHelpWindow', 'scrollbars=yes,resizable=yes,toolbar=no,height='+height+',width='+width);
1948 }
1949 </script>
1950 '''%self.base
1951
1952     def batch(self):
1953         ''' Return a batch object for results from the "current search"
1954         '''
1955         filterspec = self.filterspec
1956         sort = self.sort
1957         group = self.group
1958
1959         # get the list of ids we're batching over
1960         klass = self.client.db.getclass(self.classname)
1961         if self.search_text:
1962             matches = self.client.db.indexer.search(
1963                 re.findall(r'\b\w{2,25}\b', self.search_text), klass)
1964         else:
1965             matches = None
1966         l = klass.filter(matches, filterspec, sort, group)
1967
1968         # return the batch object, using IDs only
1969         return Batch(self.client, l, self.pagesize, self.startwith,
1970             classname=self.classname)
1971
1972 # extend the standard ZTUtils Batch object to remove dependency on
1973 # Acquisition and add a couple of useful methods
1974 class Batch(ZTUtils.Batch):
1975     ''' Use me to turn a list of items, or item ids of a given class, into a
1976         series of batches.
1977
1978         ========= ========================================================
1979         Parameter  Usage
1980         ========= ========================================================
1981         sequence  a list of HTMLItems or item ids
1982         classname if sequence is a list of ids, this is the class of item
1983         size      how big to make the sequence.
1984         start     where to start (0-indexed) in the sequence.
1985         end       where to end (0-indexed) in the sequence.
1986         orphan    if the next batch would contain less items than this
1987                   value, then it is combined with this batch
1988         overlap   the number of items shared between adjacent batches
1989         ========= ========================================================
1990
1991         Attributes: Note that the "start" attribute, unlike the
1992         argument, is a 1-based index (I know, lame).  "first" is the
1993         0-based index.  "length" is the actual number of elements in
1994         the batch.
1995
1996         "sequence_length" is the length of the original, unbatched, sequence.
1997     '''
1998     def __init__(self, client, sequence, size, start, end=0, orphan=0,
1999             overlap=0, classname=None):
2000         self.client = client
2001         self.last_index = self.last_item = None
2002         self.current_item = None
2003         self.classname = classname
2004         self.sequence_length = len(sequence)
2005         ZTUtils.Batch.__init__(self, sequence, size, start, end, orphan,
2006             overlap)
2007
2008     # overwrite so we can late-instantiate the HTMLItem instance
2009     def __getitem__(self, index):
2010         if index < 0:
2011             if index + self.end < self.first: raise IndexError, index
2012             return self._sequence[index + self.end]
2013
2014         if index >= self.length:
2015             raise IndexError, index
2016
2017         # move the last_item along - but only if the fetched index changes
2018         # (for some reason, index 0 is fetched twice)
2019         if index != self.last_index:
2020             self.last_item = self.current_item
2021             self.last_index = index
2022
2023         item = self._sequence[index + self.first]
2024         if self.classname:
2025             # map the item ids to instances
2026             if self.classname == 'user':
2027                 item = HTMLUser(self.client, self.classname, item)
2028             else:
2029                 item = HTMLItem(self.client, self.classname, item)
2030         self.current_item = item
2031         return item
2032
2033     def propchanged(self, property):
2034         ''' Detect if the property marked as being the group property
2035             changed in the last iteration fetch
2036         '''
2037         if (self.last_item is None or
2038                 self.last_item[property] != self.current_item[property]):
2039             return 1
2040         return 0
2041
2042     # override these 'cos we don't have access to acquisition
2043     def previous(self):
2044         if self.start == 1:
2045             return None
2046         return Batch(self.client, self._sequence, self._size,
2047             self.first - self._size + self.overlap, 0, self.orphan,
2048             self.overlap)
2049
2050     def next(self):
2051         try:
2052             self._sequence[self.end]
2053         except IndexError:
2054             return None
2055         return Batch(self.client, self._sequence, self._size,
2056             self.end - self.overlap, 0, self.orphan, self.overlap)
2057
2058 class TemplatingUtils:
2059     ''' Utilities for templating
2060     '''
2061     def __init__(self, client):
2062         self.client = client
2063     def Batch(self, sequence, size, start, end=0, orphan=0, overlap=0):
2064         return Batch(self.client, sequence, size, start, end, orphan,
2065             overlap)
2066