2d8ea77b64ca40273cc99cfa8316644057c3d6b1
1 from __future__ import nested_scopes
3 """Implements the API used in the HTML templating for the web interface.
4 """
6 todo = """
7 - Most methods should have a "default" arg to supply a value
8 when none appears in the hyperdb or request.
9 - Multilink property additions: change_note and new_upload
10 - Add class.find() too
11 - NumberHTMLProperty should support numeric operations
12 - LinkHTMLProperty should handle comparisons to strings (cf. linked name)
13 - HTMLRequest.default(self, sort, group, filter, columns, **filterspec):
14 '''Set the request's view arguments to the given values when no
15 values are found in the CGI environment.
16 '''
17 - have menu() methods accept filtering arguments
18 """
20 __docformat__ = 'restructuredtext'
23 import sys, cgi, urllib, os, re, os.path, time, errno, mimetypes, csv
24 import calendar, textwrap
26 from roundup import hyperdb, date, support
27 from roundup import i18n
28 from roundup.i18n import _
30 try:
31 import cPickle as pickle
32 except ImportError:
33 import pickle
34 try:
35 import cStringIO as StringIO
36 except ImportError:
37 import StringIO
38 try:
39 from StructuredText.StructuredText import HTML as StructuredText
40 except ImportError:
41 try: # older version
42 import StructuredText
43 except ImportError:
44 StructuredText = None
45 try:
46 from docutils.core import publish_parts as ReStructuredText
47 except ImportError:
48 ReStructuredText = None
50 # bring in the templating support
51 from roundup.cgi.PageTemplates import PageTemplate, GlobalTranslationService
52 from roundup.cgi.PageTemplates.Expressions import getEngine
53 from roundup.cgi.TAL import TALInterpreter
54 from roundup.cgi import TranslationService, ZTUtils
56 ### i18n services
57 # this global translation service is not thread-safe.
58 # it is left here for backward compatibility
59 # until all Web UI translations are done via client.translator object
60 translationService = TranslationService.get_translation()
61 GlobalTranslationService.setGlobalTranslationService(translationService)
63 ### templating
65 class NoTemplate(Exception):
66 pass
68 class Unauthorised(Exception):
69 def __init__(self, action, klass, translator=None):
70 self.action = action
71 self.klass = klass
72 if translator:
73 self._ = translator.gettext
74 else:
75 self._ = TranslationService.get_translation().gettext
76 def __str__(self):
77 return self._('You are not allowed to %(action)s '
78 'items of class %(class)s') % {
79 'action': self.action, 'class': self.klass}
81 def find_template(dir, name, view):
82 """ Find a template in the nominated dir
83 """
84 # find the source
85 if view:
86 filename = '%s.%s'%(name, view)
87 else:
88 filename = name
90 # try old-style
91 src = os.path.join(dir, filename)
92 if os.path.exists(src):
93 return (src, filename)
95 # try with a .html or .xml extension (new-style)
96 for extension in '.html', '.xml':
97 f = filename + extension
98 src = os.path.join(dir, f)
99 if os.path.exists(src):
100 return (src, f)
102 # no view == no generic template is possible
103 if not view:
104 raise NoTemplate, 'Template file "%s" doesn\'t exist'%name
106 # try for a _generic template
107 generic = '_generic.%s'%view
108 src = os.path.join(dir, generic)
109 if os.path.exists(src):
110 return (src, generic)
112 # finally, try _generic.html
113 generic = generic + '.html'
114 src = os.path.join(dir, generic)
115 if os.path.exists(src):
116 return (src, generic)
118 raise NoTemplate('No template file exists for templating "%s" '
119 'with template "%s" (neither "%s" nor "%s")'%(name, view,
120 filename, generic))
122 class Templates:
123 templates = {}
125 def __init__(self, dir):
126 self.dir = dir
128 def precompileTemplates(self):
129 """ Go through a directory and precompile all the templates therein
130 """
131 for filename in os.listdir(self.dir):
132 # skip subdirs
133 if os.path.isdir(filename):
134 continue
136 # skip files without ".html" or ".xml" extension - .css, .js etc.
137 for extension in '.html', '.xml':
138 if filename.endswith(extension):
139 break
140 else:
141 continue
143 # remove extension
144 filename = filename[:-len(extension)]
146 # load the template
147 if '.' in filename:
148 name, extension = filename.split('.', 1)
149 self.get(name, extension)
150 else:
151 self.get(filename, None)
153 def get(self, name, extension=None):
154 """ Interface to get a template, possibly loading a compiled template.
156 "name" and "extension" indicate the template we're after, which in
157 most cases will be "name.extension". If "extension" is None, then
158 we look for a template just called "name" with no extension.
160 If the file "name.extension" doesn't exist, we look for
161 "_generic.extension" as a fallback.
162 """
163 # default the name to "home"
164 if name is None:
165 name = 'home'
166 elif extension is None and '.' in name:
167 # split name
168 name, extension = name.split('.')
170 # find the source
171 src, filename = find_template(self.dir, name, extension)
173 # has it changed?
174 try:
175 stime = os.stat(src)[os.path.stat.ST_MTIME]
176 except os.error, error:
177 if error.errno != errno.ENOENT:
178 raise
180 if self.templates.has_key(src) and \
181 stime <= self.templates[src].mtime:
182 # compiled template is up to date
183 return self.templates[src]
185 # compile the template
186 pt = RoundupPageTemplate()
187 # use pt_edit so we can pass the content_type guess too
188 content_type = mimetypes.guess_type(filename)[0] or 'text/html'
189 pt.pt_edit(open(src).read(), content_type)
190 pt.id = filename
191 pt.mtime = stime
192 # Add it to the cache. We cannot do this until the template
193 # is fully initialized, as we could otherwise have a race
194 # condition when running with multiple threads:
195 #
196 # 1. Thread A notices the template is not in the cache,
197 # adds it, but has not yet set "mtime".
198 #
199 # 2. Thread B notices the template is in the cache, checks
200 # "mtime" (above) and crashes.
201 #
202 # Since Python dictionary access is atomic, as long as we
203 # insert "pt" only after it is fully initialized, we avoid
204 # this race condition. It's possible that two separate
205 # threads will both do the work of initializing the template,
206 # but the risk of wasted work is offset by avoiding a lock.
207 self.templates[src] = pt
208 return pt
210 def __getitem__(self, name):
211 name, extension = os.path.splitext(name)
212 if extension:
213 extension = extension[1:]
214 try:
215 return self.get(name, extension)
216 except NoTemplate, message:
217 raise KeyError, message
219 def context(client, template=None, classname=None, request=None):
220 """Return the rendering context dictionary
222 The dictionary includes following symbols:
224 *context*
225 this is one of three things:
227 1. None - we're viewing a "home" page
228 2. The current class of item being displayed. This is an HTMLClass
229 instance.
230 3. The current item from the database, if we're viewing a specific
231 item, as an HTMLItem instance.
233 *request*
234 Includes information about the current request, including:
236 - the url
237 - the current index information (``filterspec``, ``filter`` args,
238 ``properties``, etc) parsed out of the form.
239 - methods for easy filterspec link generation
240 - *user*, the current user node as an HTMLItem instance
241 - *form*, the current CGI form information as a FieldStorage
243 *config*
244 The current tracker config.
246 *db*
247 The current database, used to access arbitrary database items.
249 *utils*
250 This is a special class that has its base in the TemplatingUtils
251 class in this file. If the tracker interfaces module defines a
252 TemplatingUtils class then it is mixed in, overriding the methods
253 in the base class.
255 *templates*
256 Access to all the tracker templates by name.
257 Used mainly in *use-macro* commands.
259 *template*
260 Current rendering template.
262 *true*
263 Logical True value.
265 *false*
266 Logical False value.
268 *i18n*
269 Internationalization service, providing string translation
270 methods ``gettext`` and ``ngettext``.
272 """
273 # construct the TemplatingUtils class
274 utils = TemplatingUtils
275 if (hasattr(client.instance, 'interfaces') and
276 hasattr(client.instance.interfaces, 'TemplatingUtils')):
277 class utils(client.instance.interfaces.TemplatingUtils, utils):
278 pass
280 # if template, classname and/or request are not passed explicitely,
281 # compute form client
282 if template is None:
283 template = client.template
284 if classname is None:
285 classname = client.classname
286 if request is None:
287 request = HTMLRequest(client)
289 c = {
290 'context': None,
291 'options': {},
292 'nothing': None,
293 'request': request,
294 'db': HTMLDatabase(client),
295 'config': client.instance.config,
296 'tracker': client.instance,
297 'utils': utils(client),
298 'templates': client.instance.templates,
299 'template': template,
300 'true': 1,
301 'false': 0,
302 'i18n': client.translator
303 }
304 # add in the item if there is one
305 if client.nodeid:
306 c['context'] = HTMLItem(client, classname, client.nodeid,
307 anonymous=1)
308 elif client.db.classes.has_key(classname):
309 c['context'] = HTMLClass(client, classname, anonymous=1)
310 return c
312 class RoundupPageTemplate(PageTemplate.PageTemplate):
313 """A Roundup-specific PageTemplate.
315 Interrogate the client to set up Roundup-specific template variables
316 to be available. See 'context' function for the list of variables.
318 """
320 # 06-jun-2004 [als] i am not sure if this method is used yet
321 def getContext(self, client, classname, request):
322 return context(client, self, classname, request)
324 def render(self, client, classname, request, **options):
325 """Render this Page Template"""
327 if not self._v_cooked:
328 self._cook()
330 __traceback_supplement__ = (PageTemplate.PageTemplateTracebackSupplement, self)
332 if self._v_errors:
333 raise PageTemplate.PTRuntimeError, \
334 'Page Template %s has errors.'%self.id
336 # figure the context
337 c = context(client, self, classname, request)
338 c.update({'options': options})
340 # and go
341 output = StringIO.StringIO()
342 TALInterpreter.TALInterpreter(self._v_program, self.macros,
343 getEngine().getContext(c), output, tal=1, strictinsert=0)()
344 return output.getvalue()
346 def __repr__(self):
347 return '<Roundup PageTemplate %r>'%self.id
349 class HTMLDatabase:
350 """ Return HTMLClasses for valid class fetches
351 """
352 def __init__(self, client):
353 self._client = client
354 self._ = client._
355 self._db = client.db
357 # we want config to be exposed
358 self.config = client.db.config
360 def __getitem__(self, item, desre=re.compile(r'(?P<cl>[a-zA-Z_]+)(?P<id>[-\d]+)')):
361 # check to see if we're actually accessing an item
362 m = desre.match(item)
363 if m:
364 cl = m.group('cl')
365 self._client.db.getclass(cl)
366 return HTMLItem(self._client, cl, m.group('id'))
367 else:
368 self._client.db.getclass(item)
369 return HTMLClass(self._client, item)
371 def __getattr__(self, attr):
372 try:
373 return self[attr]
374 except KeyError:
375 raise AttributeError, attr
377 def classes(self):
378 l = self._client.db.classes.keys()
379 l.sort()
380 m = []
381 for item in l:
382 m.append(HTMLClass(self._client, item))
383 return m
385 num_re = re.compile('^-?\d+$')
387 def lookupIds(db, prop, ids, fail_ok=0, num_re=num_re, do_lookup=True):
388 """ "fail_ok" should be specified if we wish to pass through bad values
389 (most likely form values that we wish to represent back to the user)
390 "do_lookup" is there for preventing lookup by key-value (if we
391 know that the value passed *is* an id)
392 """
393 cl = db.getclass(prop.classname)
394 l = []
395 for entry in ids:
396 if do_lookup:
397 try:
398 item = cl.lookup(entry)
399 except (TypeError, KeyError):
400 pass
401 else:
402 l.append(item)
403 continue
404 # if fail_ok, ignore lookup error
405 # otherwise entry must be existing object id rather than key value
406 if fail_ok or num_re.match(entry):
407 l.append(entry)
408 return l
410 def lookupKeys(linkcl, key, ids, num_re=num_re):
411 """ Look up the "key" values for "ids" list - though some may already
412 be key values, not ids.
413 """
414 l = []
415 for entry in ids:
416 if num_re.match(entry):
417 label = linkcl.get(entry, key)
418 # fall back to designator if label is None
419 if label is None: label = '%s%s'%(linkcl.classname, entry)
420 l.append(label)
421 else:
422 l.append(entry)
423 return l
425 def _set_input_default_args(dic):
426 # 'text' is the default value anyway --
427 # but for CSS usage it should be present
428 dic.setdefault('type', 'text')
429 # useful e.g for HTML LABELs:
430 if not dic.has_key('id'):
431 try:
432 if dic['text'] in ('radio', 'checkbox'):
433 dic['id'] = '%(name)s-%(value)s' % dic
434 else:
435 dic['id'] = dic['name']
436 except KeyError:
437 pass
439 def cgi_escape_attrs(**attrs):
440 return ' '.join(['%s="%s"'%(k,cgi.escape(str(v), True))
441 for k,v in attrs.items()])
443 def input_html4(**attrs):
444 """Generate an 'input' (html4) element with given attributes"""
445 _set_input_default_args(attrs)
446 return '<input %s>'%cgi_escape_attrs(**attrs)
448 def input_xhtml(**attrs):
449 """Generate an 'input' (xhtml) element with given attributes"""
450 _set_input_default_args(attrs)
451 return '<input %s/>'%cgi_escape_attrs(**attrs)
453 class HTMLInputMixin:
454 """ requires a _client property """
455 def __init__(self):
456 html_version = 'html4'
457 if hasattr(self._client.instance.config, 'HTML_VERSION'):
458 html_version = self._client.instance.config.HTML_VERSION
459 if html_version == 'xhtml':
460 self.input = input_xhtml
461 else:
462 self.input = input_html4
463 # self._context is used for translations.
464 # will be initialized by the first call to .gettext()
465 self._context = None
467 def gettext(self, msgid):
468 """Return the localized translation of msgid"""
469 if self._context is None:
470 self._context = context(self._client)
471 return self._client.translator.translate(domain="roundup",
472 msgid=msgid, context=self._context)
474 _ = gettext
476 class HTMLPermissions:
478 def view_check(self):
479 """ Raise the Unauthorised exception if the user's not permitted to
480 view this class.
481 """
482 if not self.is_view_ok():
483 raise Unauthorised("view", self._classname,
484 translator=self._client.translator)
486 def edit_check(self):
487 """ Raise the Unauthorised exception if the user's not permitted to
488 edit items of this class.
489 """
490 if not self.is_edit_ok():
491 raise Unauthorised("edit", self._classname,
492 translator=self._client.translator)
494 def retire_check(self):
495 """ Raise the Unauthorised exception if the user's not permitted to
496 retire items of this class.
497 """
498 if not self.is_retire_ok():
499 raise Unauthorised("retire", self._classname,
500 translator=self._client.translator)
503 class HTMLClass(HTMLInputMixin, HTMLPermissions):
504 """ Accesses through a class (either through *class* or *db.<classname>*)
505 """
506 def __init__(self, client, classname, anonymous=0):
507 self._client = client
508 self._ = client._
509 self._db = client.db
510 self._anonymous = anonymous
512 # we want classname to be exposed, but _classname gives a
513 # consistent API for extending Class/Item
514 self._classname = self.classname = classname
515 self._klass = self._db.getclass(self.classname)
516 self._props = self._klass.getprops()
518 HTMLInputMixin.__init__(self)
520 def is_edit_ok(self):
521 """ Is the user allowed to Create the current class?
522 """
523 perm = self._db.security.hasPermission
524 return perm('Web Access', self._client.userid) and perm('Create',
525 self._client.userid, self._classname)
527 def is_retire_ok(self):
528 """ Is the user allowed to retire items of the current class?
529 """
530 perm = self._db.security.hasPermission
531 return perm('Web Access', self._client.userid) and perm('Retire',
532 self._client.userid, self._classname)
534 def is_view_ok(self):
535 """ Is the user allowed to View the current class?
536 """
537 perm = self._db.security.hasPermission
538 return perm('Web Access', self._client.userid) and perm('View',
539 self._client.userid, self._classname)
541 def is_only_view_ok(self):
542 """ Is the user only allowed to View (ie. not Create) the current class?
543 """
544 return self.is_view_ok() and not self.is_edit_ok()
546 def __repr__(self):
547 return '<HTMLClass(0x%x) %s>'%(id(self), self.classname)
549 def __getitem__(self, item):
550 """ return an HTMLProperty instance
551 """
553 # we don't exist
554 if item == 'id':
555 return None
557 # get the property
558 try:
559 prop = self._props[item]
560 except KeyError:
561 raise KeyError, 'No such property "%s" on %s'%(item, self.classname)
563 # look up the correct HTMLProperty class
564 form = self._client.form
565 for klass, htmlklass in propclasses:
566 if not isinstance(prop, klass):
567 continue
568 if isinstance(prop, hyperdb.Multilink):
569 value = []
570 else:
571 value = None
572 return htmlklass(self._client, self._classname, None, prop, item,
573 value, self._anonymous)
575 # no good
576 raise KeyError, item
578 def __getattr__(self, attr):
579 """ convenience access """
580 try:
581 return self[attr]
582 except KeyError:
583 raise AttributeError, attr
585 def designator(self):
586 """ Return this class' designator (classname) """
587 return self._classname
589 def getItem(self, itemid, num_re=num_re):
590 """ Get an item of this class by its item id.
591 """
592 # make sure we're looking at an itemid
593 if not isinstance(itemid, type(1)) and not num_re.match(itemid):
594 itemid = self._klass.lookup(itemid)
596 return HTMLItem(self._client, self.classname, itemid)
598 def properties(self, sort=1):
599 """ Return HTMLProperty for all of this class' properties.
600 """
601 l = []
602 for name, prop in self._props.items():
603 for klass, htmlklass in propclasses:
604 if isinstance(prop, hyperdb.Multilink):
605 value = []
606 else:
607 value = None
608 if isinstance(prop, klass):
609 l.append(htmlklass(self._client, self._classname, '',
610 prop, name, value, self._anonymous))
611 if sort:
612 l.sort(lambda a,b:cmp(a._name, b._name))
613 return l
615 def list(self, sort_on=None):
616 """ List all items in this class.
617 """
618 # get the list and sort it nicely
619 l = self._klass.list()
620 sortfunc = make_sort_function(self._db, self._classname, sort_on)
621 l.sort(sortfunc)
623 # check perms
624 check = self._client.db.security.hasPermission
625 userid = self._client.userid
626 if not check('Web Access', userid):
627 return []
629 l = [HTMLItem(self._client, self._classname, id) for id in l
630 if check('View', userid, self._classname, itemid=id)]
632 return l
634 def csv(self):
635 """ Return the items of this class as a chunk of CSV text.
636 """
637 props = self.propnames()
638 s = StringIO.StringIO()
639 writer = csv.writer(s)
640 writer.writerow(props)
641 check = self._client.db.security.hasPermission
642 userid = self._client.userid
643 if not check('Web Access', userid):
644 return ''
645 for nodeid in self._klass.list():
646 l = []
647 for name in props:
648 # check permission to view this property on this item
649 if not check('View', userid, itemid=nodeid,
650 classname=self._klass.classname, property=name):
651 raise Unauthorised('view', self._klass.classname,
652 translator=self._client.translator)
653 value = self._klass.get(nodeid, name)
654 if value is None:
655 l.append('')
656 elif isinstance(value, type([])):
657 l.append(':'.join(map(str, value)))
658 else:
659 l.append(str(self._klass.get(nodeid, name)))
660 writer.writerow(l)
661 return s.getvalue()
663 def propnames(self):
664 """ Return the list of the names of the properties of this class.
665 """
666 idlessprops = self._klass.getprops(protected=0).keys()
667 idlessprops.sort()
668 return ['id'] + idlessprops
670 def filter(self, request=None, filterspec={}, sort=[], group=[]):
671 """ Return a list of items from this class, filtered and sorted
672 by the current requested filterspec/filter/sort/group args
674 "request" takes precedence over the other three arguments.
675 """
676 if request is not None:
677 filterspec = request.filterspec
678 sort = request.sort
679 group = request.group
681 check = self._db.security.hasPermission
682 userid = self._client.userid
683 if not check('Web Access', userid):
684 return []
686 l = [HTMLItem(self._client, self.classname, id)
687 for id in self._klass.filter(None, filterspec, sort, group)
688 if check('View', userid, self.classname, itemid=id)]
689 return l
691 def classhelp(self, properties=None, label=''"(list)", width='500',
692 height='400', property='', form='itemSynopsis',
693 pagesize=50, inputtype="checkbox", sort=None, filter=None):
694 """Pop up a javascript window with class help
696 This generates a link to a popup window which displays the
697 properties indicated by "properties" of the class named by
698 "classname". The "properties" should be a comma-separated list
699 (eg. 'id,name,description'). Properties defaults to all the
700 properties of a class (excluding id, creator, created and
701 activity).
703 You may optionally override the label displayed, the width,
704 the height, the number of items per page and the field on which
705 the list is sorted (defaults to username if in the displayed
706 properties).
708 With the "filter" arg it is possible to specify a filter for
709 which items are supposed to be displayed. It has to be of
710 the format "<field>=<values>;<field>=<values>;...".
712 The popup window will be resizable and scrollable.
714 If the "property" arg is given, it's passed through to the
715 javascript help_window function.
717 You can use inputtype="radio" to display a radio box instead
718 of the default checkbox (useful for entering Link-properties)
720 If the "form" arg is given, it's passed through to the
721 javascript help_window function. - it's the name of the form
722 the "property" belongs to.
723 """
724 if properties is None:
725 properties = self._klass.getprops(protected=0).keys()
726 properties.sort()
727 properties = ','.join(properties)
728 if sort is None:
729 if 'username' in properties.split( ',' ):
730 sort = 'username'
731 else:
732 sort = self._klass.orderprop()
733 sort = '&@sort=' + sort
734 if property:
735 property = '&property=%s'%property
736 if form:
737 form = '&form=%s'%form
738 if inputtype:
739 type= '&type=%s'%inputtype
740 if filter:
741 filterprops = filter.split(';')
742 filtervalues = []
743 names = []
744 for x in filterprops:
745 (name, values) = x.split('=')
746 names.append(name)
747 filtervalues.append('&%s=%s' % (name, urllib.quote(values)))
748 filter = '&@filter=%s%s' % (','.join(names), ''.join(filtervalues))
749 else:
750 filter = ''
751 help_url = "%s?@startwith=0&@template=help&"\
752 "properties=%s%s%s%s%s&@pagesize=%s%s" % \
753 (self.classname, properties, property, form, type,
754 sort, pagesize, filter)
755 onclick = "javascript:help_window('%s', '%s', '%s');return false;" % \
756 (help_url, width, height)
757 return '<a class="classhelp" href="%s" onclick="%s">%s</a>' % \
758 (help_url, onclick, self._(label))
760 def submit(self, label=''"Submit New Entry", action="new"):
761 """ Generate a submit button (and action hidden element)
763 Generate nothing if we're not editable.
764 """
765 if not self.is_edit_ok():
766 return ''
768 return self.input(type="hidden", name="@action", value=action) + \
769 '\n' + \
770 self.input(type="submit", name="submit_button", value=self._(label))
772 def history(self):
773 if not self.is_view_ok():
774 return self._('[hidden]')
775 return self._('New node - no history')
777 def renderWith(self, name, **kwargs):
778 """ Render this class with the given template.
779 """
780 # create a new request and override the specified args
781 req = HTMLRequest(self._client)
782 req.classname = self.classname
783 req.update(kwargs)
785 # new template, using the specified classname and request
786 pt = self._client.instance.templates.get(self.classname, name)
788 # use our fabricated request
789 args = {
790 'ok_message': self._client.ok_message,
791 'error_message': self._client.error_message
792 }
793 return pt.render(self._client, self.classname, req, **args)
795 class _HTMLItem(HTMLInputMixin, HTMLPermissions):
796 """ Accesses through an *item*
797 """
798 def __init__(self, client, classname, nodeid, anonymous=0):
799 self._client = client
800 self._db = client.db
801 self._classname = classname
802 self._nodeid = nodeid
803 self._klass = self._db.getclass(classname)
804 self._props = self._klass.getprops()
806 # do we prefix the form items with the item's identification?
807 self._anonymous = anonymous
809 HTMLInputMixin.__init__(self)
811 def is_edit_ok(self):
812 """ Is the user allowed to Edit this item?
813 """
814 perm = self._db.security.hasPermission
815 return perm('Web Access', self._client.userid) and perm('Edit',
816 self._client.userid, self._classname, itemid=self._nodeid)
818 def is_retire_ok(self):
819 """ Is the user allowed to Reture this item?
820 """
821 perm = self._db.security.hasPermission
822 return perm('Web Access', self._client.userid) and perm('Retire',
823 self._client.userid, self._classname, itemid=self._nodeid)
825 def is_view_ok(self):
826 """ Is the user allowed to View this item?
827 """
828 perm = self._db.security.hasPermission
829 if perm('Web Access', self._client.userid) and perm('View',
830 self._client.userid, self._classname, itemid=self._nodeid):
831 return 1
832 return self.is_edit_ok()
834 def is_only_view_ok(self):
835 """ Is the user only allowed to View (ie. not Edit) this item?
836 """
837 return self.is_view_ok() and not self.is_edit_ok()
839 def __repr__(self):
840 return '<HTMLItem(0x%x) %s %s>'%(id(self), self._classname,
841 self._nodeid)
843 def __getitem__(self, item):
844 """ return an HTMLProperty instance
845 this now can handle transitive lookups where item is of the
846 form x.y.z
847 """
848 if item == 'id':
849 return self._nodeid
851 items = item.split('.', 1)
852 has_rest = len(items) > 1
854 # get the property
855 prop = self._props[items[0]]
857 if has_rest and not isinstance(prop, (hyperdb.Link, hyperdb.Multilink)):
858 raise KeyError, item
860 # get the value, handling missing values
861 value = None
862 if int(self._nodeid) > 0:
863 value = self._klass.get(self._nodeid, items[0], None)
864 if value is None:
865 if isinstance(prop, hyperdb.Multilink):
866 value = []
868 # look up the correct HTMLProperty class
869 htmlprop = None
870 for klass, htmlklass in propclasses:
871 if isinstance(prop, klass):
872 htmlprop = htmlklass(self._client, self._classname,
873 self._nodeid, prop, items[0], value, self._anonymous)
874 if htmlprop is not None:
875 if has_rest:
876 if isinstance(htmlprop, MultilinkHTMLProperty):
877 return [h[items[1]] for h in htmlprop]
878 return htmlprop[items[1]]
879 return htmlprop
881 raise KeyError, item
883 def __getattr__(self, attr):
884 """ convenience access to properties """
885 try:
886 return self[attr]
887 except KeyError:
888 raise AttributeError, attr
890 def designator(self):
891 """Return this item's designator (classname + id)."""
892 return '%s%s'%(self._classname, self._nodeid)
894 def is_retired(self):
895 """Is this item retired?"""
896 return self._klass.is_retired(self._nodeid)
898 def submit(self, label=''"Submit Changes", action="edit"):
899 """Generate a submit button.
901 Also sneak in the lastactivity and action hidden elements.
902 """
903 return self.input(type="hidden", name="@lastactivity",
904 value=self.activity.local(0)) + '\n' + \
905 self.input(type="hidden", name="@action", value=action) + '\n' + \
906 self.input(type="submit", name="submit_button", value=self._(label))
908 def journal(self, direction='descending'):
909 """ Return a list of HTMLJournalEntry instances.
910 """
911 # XXX do this
912 return []
914 def history(self, direction='descending', dre=re.compile('^\d+$'),
915 limit=None):
916 if not self.is_view_ok():
917 return self._('[hidden]')
919 # pre-load the history with the current state
920 current = {}
921 for prop_n in self._props.keys():
922 prop = self[prop_n]
923 if not isinstance(prop, HTMLProperty):
924 continue
925 current[prop_n] = prop.plain(escape=1)
926 # make link if hrefable
927 if (self._props.has_key(prop_n) and
928 isinstance(self._props[prop_n], hyperdb.Link)):
929 classname = self._props[prop_n].classname
930 try:
931 template = find_template(self._db.config.TEMPLATES,
932 classname, 'item')
933 if template[1].startswith('_generic'):
934 raise NoTemplate, 'not really...'
935 except NoTemplate:
936 pass
937 else:
938 id = self._klass.get(self._nodeid, prop_n, None)
939 current[prop_n] = '<a href="%s%s">%s</a>'%(
940 classname, id, current[prop_n])
942 # get the journal, sort and reverse
943 history = self._klass.history(self._nodeid)
944 history.sort()
945 history.reverse()
947 # restrict the volume
948 if limit:
949 history = history[:limit]
951 timezone = self._db.getUserTimezone()
952 l = []
953 comments = {}
954 for id, evt_date, user, action, args in history:
955 date_s = str(evt_date.local(timezone)).replace("."," ")
956 arg_s = ''
957 if action == 'link' and type(args) == type(()):
958 if len(args) == 3:
959 linkcl, linkid, key = args
960 arg_s += '<a href="%s%s">%s%s %s</a>'%(linkcl, linkid,
961 linkcl, linkid, key)
962 else:
963 arg_s = str(args)
965 elif action == 'unlink' and type(args) == type(()):
966 if len(args) == 3:
967 linkcl, linkid, key = args
968 arg_s += '<a href="%s%s">%s%s %s</a>'%(linkcl, linkid,
969 linkcl, linkid, key)
970 else:
971 arg_s = str(args)
973 elif type(args) == type({}):
974 cell = []
975 for k in args.keys():
976 # try to get the relevant property and treat it
977 # specially
978 try:
979 prop = self._props[k]
980 except KeyError:
981 prop = None
982 if prop is None:
983 # property no longer exists
984 comments['no_exist'] = self._(
985 "<em>The indicated property no longer exists</em>")
986 cell.append(self._('<em>%s: %s</em>\n')
987 % (self._(k), str(args[k])))
988 continue
990 if args[k] and (isinstance(prop, hyperdb.Multilink) or
991 isinstance(prop, hyperdb.Link)):
992 # figure what the link class is
993 classname = prop.classname
994 try:
995 linkcl = self._db.getclass(classname)
996 except KeyError:
997 labelprop = None
998 comments[classname] = self._(
999 "The linked class %(classname)s no longer exists"
1000 ) % locals()
1001 labelprop = linkcl.labelprop(1)
1002 try:
1003 template = find_template(self._db.config.TEMPLATES,
1004 classname, 'item')
1005 if template[1].startswith('_generic'):
1006 raise NoTemplate, 'not really...'
1007 hrefable = 1
1008 except NoTemplate:
1009 hrefable = 0
1011 if isinstance(prop, hyperdb.Multilink) and args[k]:
1012 ml = []
1013 for linkid in args[k]:
1014 if isinstance(linkid, type(())):
1015 sublabel = linkid[0] + ' '
1016 linkids = linkid[1]
1017 else:
1018 sublabel = ''
1019 linkids = [linkid]
1020 subml = []
1021 for linkid in linkids:
1022 label = classname + linkid
1023 # if we have a label property, try to use it
1024 # TODO: test for node existence even when
1025 # there's no labelprop!
1026 try:
1027 if labelprop is not None and \
1028 labelprop != 'id':
1029 label = linkcl.get(linkid, labelprop)
1030 label = cgi.escape(label)
1031 except IndexError:
1032 comments['no_link'] = self._(
1033 "<strike>The linked node"
1034 " no longer exists</strike>")
1035 subml.append('<strike>%s</strike>'%label)
1036 else:
1037 if hrefable:
1038 subml.append('<a href="%s%s">%s</a>'%(
1039 classname, linkid, label))
1040 elif label is None:
1041 subml.append('%s%s'%(classname,
1042 linkid))
1043 else:
1044 subml.append(label)
1045 ml.append(sublabel + ', '.join(subml))
1046 cell.append('%s:\n %s'%(self._(k), ', '.join(ml)))
1047 elif isinstance(prop, hyperdb.Link) and args[k]:
1048 label = classname + args[k]
1049 # if we have a label property, try to use it
1050 # TODO: test for node existence even when
1051 # there's no labelprop!
1052 if labelprop is not None and labelprop != 'id':
1053 try:
1054 label = cgi.escape(linkcl.get(args[k],
1055 labelprop))
1056 except IndexError:
1057 comments['no_link'] = self._(
1058 "<strike>The linked node"
1059 " no longer exists</strike>")
1060 cell.append(' <strike>%s</strike>,\n'%label)
1061 # "flag" this is done .... euwww
1062 label = None
1063 if label is not None:
1064 if hrefable:
1065 old = '<a href="%s%s">%s</a>'%(classname,
1066 args[k], label)
1067 else:
1068 old = label;
1069 cell.append('%s: %s' % (self._(k), old))
1070 if current.has_key(k):
1071 cell[-1] += ' -> %s'%current[k]
1072 current[k] = old
1074 elif isinstance(prop, hyperdb.Date) and args[k]:
1075 if args[k] is None:
1076 d = ''
1077 else:
1078 d = date.Date(args[k],
1079 translator=self._client).local(timezone)
1080 cell.append('%s: %s'%(self._(k), str(d)))
1081 if current.has_key(k):
1082 cell[-1] += ' -> %s' % current[k]
1083 current[k] = str(d)
1085 elif isinstance(prop, hyperdb.Interval) and args[k]:
1086 val = str(date.Interval(args[k],
1087 translator=self._client))
1088 cell.append('%s: %s'%(self._(k), val))
1089 if current.has_key(k):
1090 cell[-1] += ' -> %s'%current[k]
1091 current[k] = val
1093 elif isinstance(prop, hyperdb.String) and args[k]:
1094 val = cgi.escape(args[k])
1095 cell.append('%s: %s'%(self._(k), val))
1096 if current.has_key(k):
1097 cell[-1] += ' -> %s'%current[k]
1098 current[k] = val
1100 elif isinstance(prop, hyperdb.Boolean) and args[k] is not None:
1101 val = args[k] and ''"Yes" or ''"No"
1102 cell.append('%s: %s'%(self._(k), val))
1103 if current.has_key(k):
1104 cell[-1] += ' -> %s'%current[k]
1105 current[k] = val
1107 elif not args[k]:
1108 if current.has_key(k):
1109 cell.append('%s: %s'%(self._(k), current[k]))
1110 current[k] = '(no value)'
1111 else:
1112 cell.append(self._('%s: (no value)')%self._(k))
1114 else:
1115 cell.append('%s: %s'%(self._(k), str(args[k])))
1116 if current.has_key(k):
1117 cell[-1] += ' -> %s'%current[k]
1118 current[k] = str(args[k])
1120 arg_s = '<br />'.join(cell)
1121 else:
1122 # unkown event!!
1123 comments['unknown'] = self._(
1124 "<strong><em>This event is not handled"
1125 " by the history display!</em></strong>")
1126 arg_s = '<strong><em>' + str(args) + '</em></strong>'
1127 date_s = date_s.replace(' ', ' ')
1128 # if the user's an itemid, figure the username (older journals
1129 # have the username)
1130 if dre.match(user):
1131 user = self._db.user.get(user, 'username')
1132 l.append('<tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>'%(
1133 date_s, user, self._(action), arg_s))
1134 if comments:
1135 l.append(self._(
1136 '<tr><td colspan=4><strong>Note:</strong></td></tr>'))
1137 for entry in comments.values():
1138 l.append('<tr><td colspan=4>%s</td></tr>'%entry)
1140 if direction == 'ascending':
1141 l.reverse()
1143 l[0:0] = ['<table class="history">'
1144 '<tr><th colspan="4" class="header">',
1145 self._('History'),
1146 '</th></tr><tr>',
1147 self._('<th>Date</th>'),
1148 self._('<th>User</th>'),
1149 self._('<th>Action</th>'),
1150 self._('<th>Args</th>'),
1151 '</tr>']
1152 l.append('</table>')
1153 return '\n'.join(l)
1155 def renderQueryForm(self):
1156 """ Render this item, which is a query, as a search form.
1157 """
1158 # create a new request and override the specified args
1159 req = HTMLRequest(self._client)
1160 req.classname = self._klass.get(self._nodeid, 'klass')
1161 name = self._klass.get(self._nodeid, 'name')
1162 req.updateFromURL(self._klass.get(self._nodeid, 'url') +
1163 '&@queryname=%s'%urllib.quote(name))
1165 # new template, using the specified classname and request
1166 pt = self._client.instance.templates.get(req.classname, 'search')
1167 # The context for a search page should be the class, not any
1168 # node.
1169 self._client.nodeid = None
1171 # use our fabricated request
1172 return pt.render(self._client, req.classname, req)
1174 def download_url(self):
1175 """ Assume that this item is a FileClass and that it has a name
1176 and content. Construct a URL for the download of the content.
1177 """
1178 name = self._klass.get(self._nodeid, 'name')
1179 url = '%s%s/%s'%(self._classname, self._nodeid, name)
1180 return urllib.quote(url)
1182 def copy_url(self, exclude=("messages", "files")):
1183 """Construct a URL for creating a copy of this item
1185 "exclude" is an optional list of properties that should
1186 not be copied to the new object. By default, this list
1187 includes "messages" and "files" properties. Note that
1188 "id" property cannot be copied.
1190 """
1191 exclude = ("id", "activity", "actor", "creation", "creator") \
1192 + tuple(exclude)
1193 query = {
1194 "@template": "item",
1195 "@note": self._("Copy of %(class)s %(id)s") % {
1196 "class": self._(self._classname), "id": self._nodeid},
1197 }
1198 for name in self._props.keys():
1199 if name not in exclude:
1200 query[name] = self[name].plain()
1201 return self._classname + "?" + "&".join(
1202 ["%s=%s" % (key, urllib.quote(value))
1203 for key, value in query.items()])
1205 class _HTMLUser(_HTMLItem):
1206 """Add ability to check for permissions on users.
1207 """
1208 _marker = []
1209 def hasPermission(self, permission, classname=_marker,
1210 property=None, itemid=None):
1211 """Determine if the user has the Permission.
1213 The class being tested defaults to the template's class, but may
1214 be overidden for this test by suppling an alternate classname.
1215 """
1216 if classname is self._marker:
1217 classname = self._client.classname
1218 return self._db.security.hasPermission(permission,
1219 self._nodeid, classname, property, itemid)
1221 def hasRole(self, *rolenames):
1222 """Determine whether the user has any role in rolenames."""
1223 return self._db.user.has_role(self._nodeid, *rolenames)
1225 def HTMLItem(client, classname, nodeid, anonymous=0):
1226 if classname == 'user':
1227 return _HTMLUser(client, classname, nodeid, anonymous)
1228 else:
1229 return _HTMLItem(client, classname, nodeid, anonymous)
1231 class HTMLProperty(HTMLInputMixin, HTMLPermissions):
1232 """ String, Number, Date, Interval HTMLProperty
1234 Has useful attributes:
1236 _name the name of the property
1237 _value the value of the property if any
1239 A wrapper object which may be stringified for the plain() behaviour.
1240 """
1241 def __init__(self, client, classname, nodeid, prop, name, value,
1242 anonymous=0):
1243 self._client = client
1244 self._db = client.db
1245 self._ = client._
1246 self._classname = classname
1247 self._nodeid = nodeid
1248 self._prop = prop
1249 self._value = value
1250 self._anonymous = anonymous
1251 self._name = name
1252 if not anonymous:
1253 if nodeid:
1254 self._formname = '%s%s@%s'%(classname, nodeid, name)
1255 else:
1256 # This case occurs when creating a property for a
1257 # non-anonymous class.
1258 self._formname = '%s@%s'%(classname, name)
1259 else:
1260 self._formname = name
1262 # If no value is already present for this property, see if one
1263 # is specified in the current form.
1264 form = self._client.form
1265 if not self._value and form.has_key(self._formname):
1266 if isinstance(prop, hyperdb.Multilink):
1267 value = lookupIds(self._db, prop,
1268 handleListCGIValue(form[self._formname]),
1269 fail_ok=1)
1270 elif isinstance(prop, hyperdb.Link):
1271 value = form.getfirst(self._formname).strip()
1272 if value:
1273 value = lookupIds(self._db, prop, [value],
1274 fail_ok=1)[0]
1275 else:
1276 value = None
1277 else:
1278 value = form.getfirst(self._formname).strip() or None
1279 self._value = value
1281 HTMLInputMixin.__init__(self)
1283 def __repr__(self):
1284 return '<HTMLProperty(0x%x) %s %r %r>'%(id(self), self._formname,
1285 self._prop, self._value)
1286 def __str__(self):
1287 return self.plain()
1288 def __cmp__(self, other):
1289 if isinstance(other, HTMLProperty):
1290 return cmp(self._value, other._value)
1291 return cmp(self._value, other)
1293 def __nonzero__(self):
1294 return not not self._value
1296 def isset(self):
1297 """Is my _value not None?"""
1298 return self._value is not None
1300 def is_edit_ok(self):
1301 """Should the user be allowed to use an edit form field for this
1302 property. Check "Create" for new items, or "Edit" for existing
1303 ones.
1304 """
1305 perm = self._db.security.hasPermission
1306 userid = self._client.userid
1307 if self._nodeid:
1308 if not perm('Web Access', userid):
1309 return False
1310 return perm('Edit', userid, self._classname, self._name,
1311 self._nodeid)
1312 return perm('Create', userid, self._classname, self._name) or \
1313 perm('Register', userid, self._classname, self._name)
1315 def is_view_ok(self):
1316 """ Is the user allowed to View the current class?
1317 """
1318 perm = self._db.security.hasPermission
1319 if perm('Web Access', self._client.userid) and perm('View',
1320 self._client.userid, self._classname, self._name, self._nodeid):
1321 return 1
1322 return self.is_edit_ok()
1324 class StringHTMLProperty(HTMLProperty):
1325 hyper_re = re.compile(r'''(
1326 (?P<url>
1327 (
1328 (ht|f)tp(s?):// # protocol
1329 ([\w]+(:\w+)?@)? # username/password
1330 ([\w\-]+) # hostname
1331 ((\.[\w-]+)+)? # .domain.etc
1332 | # ... or ...
1333 ([\w]+(:\w+)?@)? # username/password
1334 www\. # "www."
1335 ([\w\-]+\.)+ # hostname
1336 [\w]{2,5} # TLD
1337 )
1338 (:[\d]{1,5})? # port
1339 (/[\w\-$.+!*(),;:@&=?/~\\#%]*)? # path etc.
1340 )|
1341 (?P<email>[-+=%/\w\.]+@[\w\.\-]+)|
1342 (?P<item>(?P<class>[A-Za-z_]+)(\s*)(?P<id>\d+))
1343 )''', re.X | re.I)
1344 protocol_re = re.compile('^(ht|f)tp(s?)://', re.I)
1348 def _hyper_repl(self, match):
1349 if match.group('url'):
1350 return self._hyper_repl_url(match, '<a href="%s">%s</a>%s')
1351 elif match.group('email'):
1352 return self._hyper_repl_email(match, '<a href="mailto:%s">%s</a>')
1353 elif len(match.group('id')) < 10:
1354 return self._hyper_repl_item(match,
1355 '<a href="%(cls)s%(id)s">%(item)s</a>')
1356 else:
1357 # just return the matched text
1358 return match.group(0)
1360 def _hyper_repl_url(self, match, replacement):
1361 u = s = match.group('url')
1362 if not self.protocol_re.search(s):
1363 u = 'http://' + s
1364 end = ''
1365 if '>' in s:
1366 # catch an escaped ">" in the URL
1367 pos = s.find('>')
1368 end = s[pos:]
1369 u = s = s[:pos]
1370 if ')' in s and s.count('(') != s.count(')'):
1371 # don't include extraneous ')' in the link
1372 pos = s.rfind(')')
1373 end = s[pos:] + end
1374 u = s = s[:pos]
1375 return replacement % (u, s, end)
1377 def _hyper_repl_email(self, match, replacement):
1378 s = match.group('email')
1379 return replacement % (s, s)
1381 def _hyper_repl_item(self, match, replacement):
1382 item = match.group('item')
1383 cls = match.group('class').lower()
1384 id = match.group('id')
1385 try:
1386 # make sure cls is a valid tracker classname
1387 cl = self._db.getclass(cls)
1388 if not cl.hasnode(id):
1389 return item
1390 return replacement % locals()
1391 except KeyError:
1392 return item
1395 def _hyper_repl_rst(self, match):
1396 if match.group('url'):
1397 s = match.group('url')
1398 return '`%s <%s>`_'%(s, s)
1399 elif match.group('email'):
1400 s = match.group('email')
1401 return '`%s <mailto:%s>`_'%(s, s)
1402 elif len(match.group('id')) < 10:
1403 return self._hyper_repl_item(match,'`%(item)s <%(cls)s%(id)s>`_')
1404 else:
1405 # just return the matched text
1406 return match.group(0)
1408 def hyperlinked(self):
1409 """ Render a "hyperlinked" version of the text """
1410 return self.plain(hyperlink=1)
1412 def plain(self, escape=0, hyperlink=0):
1413 """Render a "plain" representation of the property
1415 - "escape" turns on/off HTML quoting
1416 - "hyperlink" turns on/off in-text hyperlinking of URLs, email
1417 addresses and designators
1418 """
1419 if not self.is_view_ok():
1420 return self._('[hidden]')
1422 if self._value is None:
1423 return ''
1424 if escape:
1425 s = cgi.escape(str(self._value))
1426 else:
1427 s = str(self._value)
1428 if hyperlink:
1429 # no, we *must* escape this text
1430 if not escape:
1431 s = cgi.escape(s)
1432 s = self.hyper_re.sub(self._hyper_repl, s)
1433 return s
1435 def wrapped(self, escape=1, hyperlink=1):
1436 """Render a "wrapped" representation of the property.
1438 We wrap long lines at 80 columns on the nearest whitespace. Lines
1439 with no whitespace are not broken to force wrapping.
1441 Note that unlike plain() we default wrapped() to have the escaping
1442 and hyperlinking turned on since that's the most common usage.
1444 - "escape" turns on/off HTML quoting
1445 - "hyperlink" turns on/off in-text hyperlinking of URLs, email
1446 addresses and designators
1447 """
1448 if not self.is_view_ok():
1449 return self._('[hidden]')
1451 if self._value is None:
1452 return ''
1453 s = support.wrap(str(self._value), width=80)
1454 if escape:
1455 s = cgi.escape(s)
1456 if hyperlink:
1457 # no, we *must* escape this text
1458 if not escape:
1459 s = cgi.escape(s)
1460 s = self.hyper_re.sub(self._hyper_repl, s)
1461 return s
1463 def stext(self, escape=0, hyperlink=1):
1464 """ Render the value of the property as StructuredText.
1466 This requires the StructureText module to be installed separately.
1467 """
1468 if not self.is_view_ok():
1469 return self._('[hidden]')
1471 s = self.plain(escape=escape, hyperlink=hyperlink)
1472 if not StructuredText:
1473 return s
1474 return StructuredText(s,level=1,header=0)
1476 def rst(self, hyperlink=1):
1477 """ Render the value of the property as ReStructuredText.
1479 This requires docutils to be installed separately.
1480 """
1481 if not self.is_view_ok():
1482 return self._('[hidden]')
1484 if not ReStructuredText:
1485 return self.plain(escape=0, hyperlink=hyperlink)
1486 s = self.plain(escape=0, hyperlink=0)
1487 if hyperlink:
1488 s = self.hyper_re.sub(self._hyper_repl_rst, s)
1489 return ReStructuredText(s, writer_name="html")["html_body"].encode("utf-8",
1490 "replace")
1492 def field(self, **kwargs):
1493 """ Render the property as a field in HTML.
1495 If not editable, just display the value via plain().
1496 """
1497 if not self.is_edit_ok():
1498 return self.plain(escape=1)
1500 value = self._value
1501 if value is None:
1502 value = ''
1504 kwargs.setdefault("size", 30)
1505 kwargs.update({"name": self._formname, "value": value})
1506 return self.input(**kwargs)
1508 def multiline(self, escape=0, rows=5, cols=40, **kwargs):
1509 """ Render a multiline form edit field for the property.
1511 If not editable, just display the plain() value in a <pre> tag.
1512 """
1513 if not self.is_edit_ok():
1514 return '<pre>%s</pre>'%self.plain()
1516 if self._value is None:
1517 value = ''
1518 else:
1519 value = cgi.escape(str(self._value))
1521 value = '"'.join(value.split('"'))
1522 name = self._formname
1523 passthrough_args = cgi_escape_attrs(**kwargs)
1524 return ('<textarea %(passthrough_args)s name="%(name)s" id="%(name)s"'
1525 ' rows="%(rows)s" cols="%(cols)s">'
1526 '%(value)s</textarea>') % locals()
1528 def email(self, escape=1):
1529 """ Render the value of the property as an obscured email address
1530 """
1531 if not self.is_view_ok():
1532 return self._('[hidden]')
1534 if self._value is None:
1535 value = ''
1536 else:
1537 value = str(self._value)
1538 split = value.split('@')
1539 if len(split) == 2:
1540 name, domain = split
1541 domain = ' '.join(domain.split('.')[:-1])
1542 name = name.replace('.', ' ')
1543 value = '%s at %s ...'%(name, domain)
1544 else:
1545 value = value.replace('.', ' ')
1546 if escape:
1547 value = cgi.escape(value)
1548 return value
1550 class PasswordHTMLProperty(HTMLProperty):
1551 def plain(self, escape=0):
1552 """ Render a "plain" representation of the property
1553 """
1554 if not self.is_view_ok():
1555 return self._('[hidden]')
1557 if self._value is None:
1558 return ''
1559 return self._('*encrypted*')
1561 def field(self, size=30, **kwargs):
1562 """ Render a form edit field for the property.
1564 If not editable, just display the value via plain().
1565 """
1566 if not self.is_edit_ok():
1567 return self.plain(escape=1)
1569 return self.input(type="password", name=self._formname, size=size,
1570 **kwargs)
1572 def confirm(self, size=30):
1573 """ Render a second form edit field for the property, used for
1574 confirmation that the user typed the password correctly. Generates
1575 a field with name "@confirm@name".
1577 If not editable, display nothing.
1578 """
1579 if not self.is_edit_ok():
1580 return ''
1582 return self.input(type="password",
1583 name="@confirm@%s"%self._formname,
1584 id="%s-confirm"%self._formname,
1585 size=size)
1587 class NumberHTMLProperty(HTMLProperty):
1588 def plain(self, escape=0):
1589 """ Render a "plain" representation of the property
1590 """
1591 if not self.is_view_ok():
1592 return self._('[hidden]')
1594 if self._value is None:
1595 return ''
1597 return str(self._value)
1599 def field(self, size=30, **kwargs):
1600 """ Render a form edit field for the property.
1602 If not editable, just display the value via plain().
1603 """
1604 if not self.is_edit_ok():
1605 return self.plain(escape=1)
1607 value = self._value
1608 if value is None:
1609 value = ''
1611 return self.input(name=self._formname, value=value, size=size,
1612 **kwargs)
1614 def __int__(self):
1615 """ Return an int of me
1616 """
1617 return int(self._value)
1619 def __float__(self):
1620 """ Return a float of me
1621 """
1622 return float(self._value)
1625 class BooleanHTMLProperty(HTMLProperty):
1626 def plain(self, escape=0):
1627 """ Render a "plain" representation of the property
1628 """
1629 if not self.is_view_ok():
1630 return self._('[hidden]')
1632 if self._value is None:
1633 return ''
1634 return self._value and self._("Yes") or self._("No")
1636 def field(self, **kwargs):
1637 """ Render a form edit field for the property
1639 If not editable, just display the value via plain().
1640 """
1641 if not self.is_edit_ok():
1642 return self.plain(escape=1)
1644 value = self._value
1645 if isinstance(value, str) or isinstance(value, unicode):
1646 value = value.strip().lower() in ('checked', 'yes', 'true',
1647 'on', '1')
1649 checked = value and "checked" or ""
1650 if value:
1651 s = self.input(type="radio", name=self._formname, value="yes",
1652 checked="checked", **kwargs)
1653 s += self._('Yes')
1654 s +=self.input(type="radio", name=self._formname, value="no",
1655 **kwargs)
1656 s += self._('No')
1657 else:
1658 s = self.input(type="radio", name=self._formname, value="yes",
1659 **kwargs)
1660 s += self._('Yes')
1661 s +=self.input(type="radio", name=self._formname, value="no",
1662 checked="checked", **kwargs)
1663 s += self._('No')
1664 return s
1666 class DateHTMLProperty(HTMLProperty):
1668 _marker = []
1670 def __init__(self, client, classname, nodeid, prop, name, value,
1671 anonymous=0, offset=None):
1672 HTMLProperty.__init__(self, client, classname, nodeid, prop, name,
1673 value, anonymous=anonymous)
1674 if self._value and not (isinstance(self._value, str) or
1675 isinstance(self._value, unicode)):
1676 self._value.setTranslator(self._client.translator)
1677 self._offset = offset
1678 if self._offset is None :
1679 self._offset = self._prop.offset (self._db)
1681 def plain(self, escape=0):
1682 """ Render a "plain" representation of the property
1683 """
1684 if not self.is_view_ok():
1685 return self._('[hidden]')
1687 if self._value is None:
1688 return ''
1689 if self._offset is None:
1690 offset = self._db.getUserTimezone()
1691 else:
1692 offset = self._offset
1693 return str(self._value.local(offset))
1695 def now(self, str_interval=None):
1696 """ Return the current time.
1698 This is useful for defaulting a new value. Returns a
1699 DateHTMLProperty.
1700 """
1701 if not self.is_view_ok():
1702 return self._('[hidden]')
1704 ret = date.Date('.', translator=self._client)
1706 if isinstance(str_interval, basestring):
1707 sign = 1
1708 if str_interval[0] == '-':
1709 sign = -1
1710 str_interval = str_interval[1:]
1711 interval = date.Interval(str_interval, translator=self._client)
1712 if sign > 0:
1713 ret = ret + interval
1714 else:
1715 ret = ret - interval
1717 return DateHTMLProperty(self._client, self._classname, self._nodeid,
1718 self._prop, self._formname, ret)
1720 def field(self, size=30, default=None, format=_marker, popcal=True,
1721 **kwargs):
1722 """Render a form edit field for the property
1724 If not editable, just display the value via plain().
1726 If "popcal" then include the Javascript calendar editor.
1727 Default=yes.
1729 The format string is a standard python strftime format string.
1730 """
1731 if not self.is_edit_ok():
1732 if format is self._marker:
1733 return self.plain(escape=1)
1734 else:
1735 return self.pretty(format)
1737 value = self._value
1739 if value is None:
1740 if default is None:
1741 raw_value = None
1742 else:
1743 if isinstance(default, basestring):
1744 raw_value = date.Date(default, translator=self._client)
1745 elif isinstance(default, date.Date):
1746 raw_value = default
1747 elif isinstance(default, DateHTMLProperty):
1748 raw_value = default._value
1749 else:
1750 raise ValueError, self._('default value for '
1751 'DateHTMLProperty must be either DateHTMLProperty '
1752 'or string date representation.')
1753 elif isinstance(value, str) or isinstance(value, unicode):
1754 # most likely erroneous input to be passed back to user
1755 if isinstance(value, unicode): value = value.encode('utf8')
1756 return self.input(name=self._formname, value=value, size=size,
1757 **kwargs)
1758 else:
1759 raw_value = value
1761 if raw_value is None:
1762 value = ''
1763 elif isinstance(raw_value, str) or isinstance(raw_value, unicode):
1764 if format is self._marker:
1765 value = raw_value
1766 else:
1767 value = date.Date(raw_value).pretty(format)
1768 else:
1769 if self._offset is None :
1770 offset = self._db.getUserTimezone()
1771 else :
1772 offset = self._offset
1773 value = raw_value.local(offset)
1774 if format is not self._marker:
1775 value = value.pretty(format)
1777 s = self.input(name=self._formname, value=value, size=size,
1778 **kwargs)
1779 if popcal:
1780 s += self.popcal()
1781 return s
1783 def reldate(self, pretty=1):
1784 """ Render the interval between the date and now.
1786 If the "pretty" flag is true, then make the display pretty.
1787 """
1788 if not self.is_view_ok():
1789 return self._('[hidden]')
1791 if not self._value:
1792 return ''
1794 # figure the interval
1795 interval = self._value - date.Date('.', translator=self._client)
1796 if pretty:
1797 return interval.pretty()
1798 return str(interval)
1800 def pretty(self, format=_marker):
1801 """ Render the date in a pretty format (eg. month names, spaces).
1803 The format string is a standard python strftime format string.
1804 Note that if the day is zero, and appears at the start of the
1805 string, then it'll be stripped from the output. This is handy
1806 for the situation when a date only specifies a month and a year.
1807 """
1808 if not self.is_view_ok():
1809 return self._('[hidden]')
1811 if self._offset is None:
1812 offset = self._db.getUserTimezone()
1813 else:
1814 offset = self._offset
1816 if not self._value:
1817 return ''
1818 elif format is not self._marker:
1819 return self._value.local(offset).pretty(format)
1820 else:
1821 return self._value.local(offset).pretty()
1823 def local(self, offset):
1824 """ Return the date/time as a local (timezone offset) date/time.
1825 """
1826 if not self.is_view_ok():
1827 return self._('[hidden]')
1829 return DateHTMLProperty(self._client, self._classname, self._nodeid,
1830 self._prop, self._formname, self._value, offset=offset)
1832 def popcal(self, width=300, height=200, label="(cal)",
1833 form="itemSynopsis"):
1834 """Generate a link to a calendar pop-up window.
1836 item: HTMLProperty e.g.: context.deadline
1837 """
1838 if self.isset():
1839 date = "&date=%s"%self._value
1840 else :
1841 date = ""
1842 return ('<a class="classhelp" href="javascript:help_window('
1843 "'%s?@template=calendar&property=%s&form=%s%s', %d, %d)"
1844 '">%s</a>'%(self._classname, self._name, form, date, width,
1845 height, label))
1847 class IntervalHTMLProperty(HTMLProperty):
1848 def __init__(self, client, classname, nodeid, prop, name, value,
1849 anonymous=0):
1850 HTMLProperty.__init__(self, client, classname, nodeid, prop,
1851 name, value, anonymous)
1852 if self._value and not isinstance(self._value, (str, unicode)):
1853 self._value.setTranslator(self._client.translator)
1855 def plain(self, escape=0):
1856 """ Render a "plain" representation of the property
1857 """
1858 if not self.is_view_ok():
1859 return self._('[hidden]')
1861 if self._value is None:
1862 return ''
1863 return str(self._value)
1865 def pretty(self):
1866 """ Render the interval in a pretty format (eg. "yesterday")
1867 """
1868 if not self.is_view_ok():
1869 return self._('[hidden]')
1871 return self._value.pretty()
1873 def field(self, size=30, **kwargs):
1874 """ Render a form edit field for the property
1876 If not editable, just display the value via plain().
1877 """
1878 if not self.is_edit_ok():
1879 return self.plain(escape=1)
1881 value = self._value
1882 if value is None:
1883 value = ''
1885 return self.input(name=self._formname, value=value, size=size,
1886 **kwargs)
1888 class LinkHTMLProperty(HTMLProperty):
1889 """ Link HTMLProperty
1890 Include the above as well as being able to access the class
1891 information. Stringifying the object itself results in the value
1892 from the item being displayed. Accessing attributes of this object
1893 result in the appropriate entry from the class being queried for the
1894 property accessed (so item/assignedto/name would look up the user
1895 entry identified by the assignedto property on item, and then the
1896 name property of that user)
1897 """
1898 def __init__(self, *args, **kw):
1899 HTMLProperty.__init__(self, *args, **kw)
1900 # if we're representing a form value, then the -1 from the form really
1901 # should be a None
1902 if str(self._value) == '-1':
1903 self._value = None
1905 def __getattr__(self, attr):
1906 """ return a new HTMLItem """
1907 if not self._value:
1908 # handle a special page templates lookup
1909 if attr == '__render_with_namespace__':
1910 def nothing(*args, **kw):
1911 return ''
1912 return nothing
1913 msg = self._('Attempt to look up %(attr)s on a missing value')
1914 return MissingValue(msg%locals())
1915 i = HTMLItem(self._client, self._prop.classname, self._value)
1916 return getattr(i, attr)
1918 def plain(self, escape=0):
1919 """ Render a "plain" representation of the property
1920 """
1921 if not self.is_view_ok():
1922 return self._('[hidden]')
1924 if self._value is None:
1925 return ''
1926 linkcl = self._db.classes[self._prop.classname]
1927 k = linkcl.labelprop(1)
1928 if num_re.match(self._value):
1929 try:
1930 value = str(linkcl.get(self._value, k))
1931 except IndexError:
1932 value = self._value
1933 else :
1934 value = self._value
1935 if escape:
1936 value = cgi.escape(value)
1937 return value
1939 def field(self, showid=0, size=None, **kwargs):
1940 """ Render a form edit field for the property
1942 If not editable, just display the value via plain().
1943 """
1944 if not self.is_edit_ok():
1945 return self.plain(escape=1)
1947 # edit field
1948 linkcl = self._db.getclass(self._prop.classname)
1949 if self._value is None:
1950 value = ''
1951 else:
1952 k = linkcl.getkey()
1953 if k and num_re.match(self._value):
1954 value = linkcl.get(self._value, k)
1955 else:
1956 value = self._value
1957 return self.input(name=self._formname, value=value, size=size,
1958 **kwargs)
1960 def menu(self, size=None, height=None, showid=0, additional=[], value=None,
1961 sort_on=None, html_kwargs = {}, **conditions):
1962 """ Render a form select list for this property
1964 "size" is used to limit the length of the list labels
1965 "height" is used to set the <select> tag's "size" attribute
1966 "showid" includes the item ids in the list labels
1967 "value" specifies which item is pre-selected
1968 "additional" lists properties which should be included in the
1969 label
1970 "sort_on" indicates the property to sort the list on as
1971 (direction, property) where direction is '+' or '-'. A
1972 single string with the direction prepended may be used.
1973 For example: ('-', 'order'), '+name'.
1975 The remaining keyword arguments are used as conditions for
1976 filtering the items in the list - they're passed as the
1977 "filterspec" argument to a Class.filter() call.
1979 If not editable, just display the value via plain().
1980 """
1981 if not self.is_edit_ok():
1982 return self.plain(escape=1)
1984 # Since None indicates the default, we need another way to
1985 # indicate "no selection". We use -1 for this purpose, as
1986 # that is the value we use when submitting a form without the
1987 # value set.
1988 if value is None:
1989 value = self._value
1990 elif value == '-1':
1991 value = None
1993 linkcl = self._db.getclass(self._prop.classname)
1994 l = ['<select %s>'%cgi_escape_attrs(name = self._formname,
1995 **html_kwargs)]
1996 k = linkcl.labelprop(1)
1997 s = ''
1998 if value is None:
1999 s = 'selected="selected" '
2000 l.append(self._('<option %svalue="-1">- no selection -</option>')%s)
2002 if sort_on is not None:
2003 if not isinstance(sort_on, tuple):
2004 if sort_on[0] in '+-':
2005 sort_on = (sort_on[0], sort_on[1:])
2006 else:
2007 sort_on = ('+', sort_on)
2008 else:
2009 sort_on = ('+', linkcl.orderprop())
2011 options = [opt
2012 for opt in linkcl.filter(None, conditions, sort_on, (None, None))
2013 if self._db.security.hasPermission("View", self._client.userid,
2014 linkcl.classname, itemid=opt)]
2016 # make sure we list the current value if it's retired
2017 if value and value not in options:
2018 options.insert(0, value)
2020 if additional:
2021 additional_fns = []
2022 props = linkcl.getprops()
2023 for propname in additional:
2024 prop = props[propname]
2025 if isinstance(prop, hyperdb.Link):
2026 cl = self._db.getclass(prop.classname)
2027 labelprop = cl.labelprop()
2028 fn = lambda optionid: cl.get(linkcl.get(optionid,
2029 propname),
2030 labelprop)
2031 else:
2032 fn = lambda optionid: linkcl.get(optionid, propname)
2033 additional_fns.append(fn)
2035 for optionid in options:
2036 # get the option value, and if it's None use an empty string
2037 option = linkcl.get(optionid, k) or ''
2039 # figure if this option is selected
2040 s = ''
2041 if value in [optionid, option]:
2042 s = 'selected="selected" '
2044 # figure the label
2045 if showid:
2046 lab = '%s%s: %s'%(self._prop.classname, optionid, option)
2047 elif not option:
2048 lab = '%s%s'%(self._prop.classname, optionid)
2049 else:
2050 lab = option
2052 # truncate if it's too long
2053 if size is not None and len(lab) > size:
2054 lab = lab[:size-3] + '...'
2055 if additional:
2056 m = []
2057 for fn in additional_fns:
2058 m.append(str(fn(optionid)))
2059 lab = lab + ' (%s)'%', '.join(m)
2061 # and generate
2062 lab = cgi.escape(self._(lab))
2063 l.append('<option %svalue="%s">%s</option>'%(s, optionid, lab))
2064 l.append('</select>')
2065 return '\n'.join(l)
2066 # def checklist(self, ...)
2070 class MultilinkHTMLProperty(HTMLProperty):
2071 """ Multilink HTMLProperty
2073 Also be iterable, returning a wrapper object like the Link case for
2074 each entry in the multilink.
2075 """
2076 def __init__(self, *args, **kwargs):
2077 HTMLProperty.__init__(self, *args, **kwargs)
2078 if self._value:
2079 display_value = lookupIds(self._db, self._prop, self._value,
2080 fail_ok=1, do_lookup=False)
2081 sortfun = make_sort_function(self._db, self._prop.classname)
2082 # sorting fails if the value contains
2083 # items not yet stored in the database
2084 # ignore these errors to preserve user input
2085 try:
2086 display_value.sort(sortfun)
2087 except:
2088 pass
2089 self._value = display_value
2091 def __len__(self):
2092 """ length of the multilink """
2093 return len(self._value)
2095 def __getattr__(self, attr):
2096 """ no extended attribute accesses make sense here """
2097 raise AttributeError, attr
2099 def viewableGenerator(self, values):
2100 """Used to iterate over only the View'able items in a class."""
2101 check = self._db.security.hasPermission
2102 userid = self._client.userid
2103 classname = self._prop.classname
2104 if check('Web Access', userid):
2105 for value in values:
2106 if check('View', userid, classname, itemid=value):
2107 yield HTMLItem(self._client, classname, value)
2109 def __iter__(self):
2110 """ iterate and return a new HTMLItem
2111 """
2112 return self.viewableGenerator(self._value)
2114 def reverse(self):
2115 """ return the list in reverse order
2116 """
2117 l = self._value[:]
2118 l.reverse()
2119 return self.viewableGenerator(l)
2121 def sorted(self, property):
2122 """ Return this multilink sorted by the given property """
2123 value = list(self.__iter__())
2124 value.sort(lambda a,b:cmp(a[property], b[property]))
2125 return value
2127 def __contains__(self, value):
2128 """ Support the "in" operator. We have to make sure the passed-in
2129 value is a string first, not a HTMLProperty.
2130 """
2131 return str(value) in self._value
2133 def isset(self):
2134 """Is my _value not []?"""
2135 return self._value != []
2137 def plain(self, escape=0):
2138 """ Render a "plain" representation of the property
2139 """
2140 if not self.is_view_ok():
2141 return self._('[hidden]')
2143 linkcl = self._db.classes[self._prop.classname]
2144 k = linkcl.labelprop(1)
2145 labels = []
2146 for v in self._value:
2147 if num_re.match(v):
2148 try:
2149 label = linkcl.get(v, k)
2150 except IndexError:
2151 label = None
2152 # fall back to designator if label is None
2153 if label is None: label = '%s%s'%(self._prop.classname, k)
2154 else:
2155 label = v
2156 labels.append(label)
2157 value = ', '.join(labels)
2158 if escape:
2159 value = cgi.escape(value)
2160 return value
2162 def field(self, size=30, showid=0, **kwargs):
2163 """ Render a form edit field for the property
2165 If not editable, just display the value via plain().
2166 """
2167 if not self.is_edit_ok():
2168 return self.plain(escape=1)
2170 linkcl = self._db.getclass(self._prop.classname)
2172 if 'value' not in kwargs:
2173 value = self._value[:]
2174 # map the id to the label property
2175 if not linkcl.getkey():
2176 showid=1
2177 if not showid:
2178 k = linkcl.labelprop(1)
2179 value = lookupKeys(linkcl, k, value)
2180 value = ','.join(value)
2181 kwargs["value"] = value
2183 return self.input(name=self._formname, size=size, **kwargs)
2185 def menu(self, size=None, height=None, showid=0, additional=[],
2186 value=None, sort_on=None, html_kwargs = {}, **conditions):
2187 """ Render a form <select> list for this property.
2189 "size" is used to limit the length of the list labels
2190 "height" is used to set the <select> tag's "size" attribute
2191 "showid" includes the item ids in the list labels
2192 "additional" lists properties which should be included in the
2193 label
2194 "value" specifies which item is pre-selected
2195 "sort_on" indicates the property to sort the list on as
2196 (direction, property) where direction is '+' or '-'. A
2197 single string with the direction prepended may be used.
2198 For example: ('-', 'order'), '+name'.
2200 The remaining keyword arguments are used as conditions for
2201 filtering the items in the list - they're passed as the
2202 "filterspec" argument to a Class.filter() call.
2204 If not editable, just display the value via plain().
2205 """
2206 if not self.is_edit_ok():
2207 return self.plain(escape=1)
2209 if value is None:
2210 value = self._value
2212 linkcl = self._db.getclass(self._prop.classname)
2214 if sort_on is not None:
2215 if not isinstance(sort_on, tuple):
2216 if sort_on[0] in '+-':
2217 sort_on = (sort_on[0], sort_on[1:])
2218 else:
2219 sort_on = ('+', sort_on)
2220 else:
2221 sort_on = ('+', linkcl.orderprop())
2223 options = [opt
2224 for opt in linkcl.filter(None, conditions, sort_on)
2225 if self._db.security.hasPermission("View", self._client.userid,
2226 linkcl.classname, itemid=opt)]
2228 # make sure we list the current values if they're retired
2229 for val in value:
2230 if val not in options:
2231 options.insert(0, val)
2233 if not height:
2234 height = len(options)
2235 if value:
2236 # The "no selection" option.
2237 height += 1
2238 height = min(height, 7)
2239 l = ['<select multiple %s>'%cgi_escape_attrs(name = self._formname,
2240 size = height,
2241 **html_kwargs)]
2242 k = linkcl.labelprop(1)
2244 if value:
2245 l.append('<option value="%s">- no selection -</option>'
2246 % ','.join(['-' + v for v in value]))
2248 if additional:
2249 additional_fns = []
2250 props = linkcl.getprops()
2251 for propname in additional:
2252 prop = props[propname]
2253 if isinstance(prop, hyperdb.Link):
2254 cl = self._db.getclass(prop.classname)
2255 labelprop = cl.labelprop()
2256 fn = lambda optionid: cl.get(linkcl.get(optionid,
2257 propname),
2258 labelprop)
2259 else:
2260 fn = lambda optionid: linkcl.get(optionid, propname)
2261 additional_fns.append(fn)
2263 for optionid in options:
2264 # get the option value, and if it's None use an empty string
2265 option = linkcl.get(optionid, k) or ''
2267 # figure if this option is selected
2268 s = ''
2269 if optionid in value or option in value:
2270 s = 'selected="selected" '
2272 # figure the label
2273 if showid:
2274 lab = '%s%s: %s'%(self._prop.classname, optionid, option)
2275 else:
2276 lab = option
2277 # truncate if it's too long
2278 if size is not None and len(lab) > size:
2279 lab = lab[:size-3] + '...'
2280 if additional:
2281 m = []
2282 for fn in additional_fns:
2283 m.append(str(fn(optionid)))
2284 lab = lab + ' (%s)'%', '.join(m)
2286 # and generate
2287 lab = cgi.escape(self._(lab))
2288 l.append('<option %svalue="%s">%s</option>'%(s, optionid,
2289 lab))
2290 l.append('</select>')
2291 return '\n'.join(l)
2294 # set the propclasses for HTMLItem
2295 propclasses = [
2296 (hyperdb.String, StringHTMLProperty),
2297 (hyperdb.Number, NumberHTMLProperty),
2298 (hyperdb.Boolean, BooleanHTMLProperty),
2299 (hyperdb.Date, DateHTMLProperty),
2300 (hyperdb.Interval, IntervalHTMLProperty),
2301 (hyperdb.Password, PasswordHTMLProperty),
2302 (hyperdb.Link, LinkHTMLProperty),
2303 (hyperdb.Multilink, MultilinkHTMLProperty),
2304 ]
2306 def register_propclass(prop, cls):
2307 for index,propclass in enumerate(propclasses):
2308 p, c = propclass
2309 if prop == p:
2310 propclasses[index] = (prop, cls)
2311 break
2312 else:
2313 propclasses.append((prop, cls))
2316 def make_sort_function(db, classname, sort_on=None):
2317 """Make a sort function for a given class.
2319 The list being sorted may contain mixed ids and labels.
2320 """
2321 linkcl = db.getclass(classname)
2322 if sort_on is None:
2323 sort_on = linkcl.orderprop()
2324 def sortfunc(a, b):
2325 if num_re.match(a):
2326 a = linkcl.get(a, sort_on)
2327 if num_re.match(b):
2328 b = linkcl.get(b, sort_on)
2329 return cmp(a, b)
2330 return sortfunc
2332 def handleListCGIValue(value):
2333 """ Value is either a single item or a list of items. Each item has a
2334 .value that we're actually interested in.
2335 """
2336 if isinstance(value, type([])):
2337 return [value.value for value in value]
2338 else:
2339 value = value.value.strip()
2340 if not value:
2341 return []
2342 return [v.strip() for v in value.split(',')]
2344 class HTMLRequest(HTMLInputMixin):
2345 """The *request*, holding the CGI form and environment.
2347 - "form" the CGI form as a cgi.FieldStorage
2348 - "env" the CGI environment variables
2349 - "base" the base URL for this instance
2350 - "user" a HTMLItem instance for this user
2351 - "language" as determined by the browser or config
2352 - "classname" the current classname (possibly None)
2353 - "template" the current template (suffix, also possibly None)
2355 Index args:
2357 - "columns" dictionary of the columns to display in an index page
2358 - "show" a convenience access to columns - request/show/colname will
2359 be true if the columns should be displayed, false otherwise
2360 - "sort" index sort column (direction, column name)
2361 - "group" index grouping property (direction, column name)
2362 - "filter" properties to filter the index on
2363 - "filterspec" values to filter the index on
2364 - "search_text" text to perform a full-text search on for an index
2365 """
2366 def __repr__(self):
2367 return '<HTMLRequest %r>'%self.__dict__
2369 def __init__(self, client):
2370 # _client is needed by HTMLInputMixin
2371 self._client = self.client = client
2373 # easier access vars
2374 self.form = client.form
2375 self.env = client.env
2376 self.base = client.base
2377 self.user = HTMLItem(client, 'user', client.userid)
2378 self.language = client.language
2380 # store the current class name and action
2381 self.classname = client.classname
2382 self.nodeid = client.nodeid
2383 self.template = client.template
2385 # the special char to use for special vars
2386 self.special_char = '@'
2388 HTMLInputMixin.__init__(self)
2390 self._post_init()
2392 def current_url(self):
2393 url = self.base
2394 if self.classname:
2395 url += self.classname
2396 if self.nodeid:
2397 url += self.nodeid
2398 args = {}
2399 if self.template:
2400 args['@template'] = self.template
2401 return self.indexargs_url(url, args)
2403 def _parse_sort(self, var, name):
2404 """ Parse sort/group options. Append to var
2405 """
2406 fields = []
2407 dirs = []
2408 for special in '@:':
2409 idx = 0
2410 key = '%s%s%d'%(special, name, idx)
2411 while key in self.form:
2412 self.special_char = special
2413 fields.append(self.form.getfirst(key))
2414 dirkey = '%s%sdir%d'%(special, name, idx)
2415 if dirkey in self.form:
2416 dirs.append(self.form.getfirst(dirkey))
2417 else:
2418 dirs.append(None)
2419 idx += 1
2420 key = '%s%s%d'%(special, name, idx)
2421 # backward compatible (and query) URL format
2422 key = special + name
2423 dirkey = key + 'dir'
2424 if key in self.form and not fields:
2425 fields = handleListCGIValue(self.form[key])
2426 if dirkey in self.form:
2427 dirs.append(self.form.getfirst(dirkey))
2428 if fields: # only try other special char if nothing found
2429 break
2430 for f, d in map(None, fields, dirs):
2431 if f.startswith('-'):
2432 var.append(('-', f[1:]))
2433 elif d:
2434 var.append(('-', f))
2435 else:
2436 var.append(('+', f))
2438 def _post_init(self):
2439 """ Set attributes based on self.form
2440 """
2441 # extract the index display information from the form
2442 self.columns = []
2443 for name in ':columns @columns'.split():
2444 if self.form.has_key(name):
2445 self.special_char = name[0]
2446 self.columns = handleListCGIValue(self.form[name])
2447 break
2448 self.show = support.TruthDict(self.columns)
2450 # sorting and grouping
2451 self.sort = []
2452 self.group = []
2453 self._parse_sort(self.sort, 'sort')
2454 self._parse_sort(self.group, 'group')
2456 # filtering
2457 self.filter = []
2458 for name in ':filter @filter'.split():
2459 if self.form.has_key(name):
2460 self.special_char = name[0]
2461 self.filter = handleListCGIValue(self.form[name])
2463 self.filterspec = {}
2464 db = self.client.db
2465 if self.classname is not None:
2466 cls = db.getclass (self.classname)
2467 for name in self.filter:
2468 if not self.form.has_key(name):
2469 continue
2470 prop = cls.get_transitive_prop (name)
2471 fv = self.form[name]
2472 if (isinstance(prop, hyperdb.Link) or
2473 isinstance(prop, hyperdb.Multilink)):
2474 self.filterspec[name] = lookupIds(db, prop,
2475 handleListCGIValue(fv))
2476 else:
2477 if isinstance(fv, type([])):
2478 self.filterspec[name] = [v.value for v in fv]
2479 elif name == 'id':
2480 # special case "id" property
2481 self.filterspec[name] = handleListCGIValue(fv)
2482 else:
2483 self.filterspec[name] = fv.value
2485 # full-text search argument
2486 self.search_text = None
2487 for name in ':search_text @search_text'.split():
2488 if self.form.has_key(name):
2489 self.special_char = name[0]
2490 self.search_text = self.form.getfirst(name)
2492 # pagination - size and start index
2493 # figure batch args
2494 self.pagesize = 50
2495 for name in ':pagesize @pagesize'.split():
2496 if self.form.has_key(name):
2497 self.special_char = name[0]
2498 try:
2499 self.pagesize = int(self.form.getfirst(name))
2500 except ValueError:
2501 # not an integer - ignore
2502 pass
2504 self.startwith = 0
2505 for name in ':startwith @startwith'.split():
2506 if self.form.has_key(name):
2507 self.special_char = name[0]
2508 try:
2509 self.startwith = int(self.form.getfirst(name))
2510 except ValueError:
2511 # not an integer - ignore
2512 pass
2514 # dispname
2515 if self.form.has_key('@dispname'):
2516 self.dispname = self.form.getfirst('@dispname')
2517 else:
2518 self.dispname = None
2520 def updateFromURL(self, url):
2521 """ Parse the URL for query args, and update my attributes using the
2522 values.
2523 """
2524 env = {'QUERY_STRING': url}
2525 self.form = cgi.FieldStorage(environ=env)
2527 self._post_init()
2529 def update(self, kwargs):
2530 """ Update my attributes using the keyword args
2531 """
2532 self.__dict__.update(kwargs)
2533 if kwargs.has_key('columns'):
2534 self.show = support.TruthDict(self.columns)
2536 def description(self):
2537 """ Return a description of the request - handle for the page title.
2538 """
2539 s = [self.client.db.config.TRACKER_NAME]
2540 if self.classname:
2541 if self.client.nodeid:
2542 s.append('- %s%s'%(self.classname, self.client.nodeid))
2543 else:
2544 if self.template == 'item':
2545 s.append('- new %s'%self.classname)
2546 elif self.template == 'index':
2547 s.append('- %s index'%self.classname)
2548 else:
2549 s.append('- %s %s'%(self.classname, self.template))
2550 else:
2551 s.append('- home')
2552 return ' '.join(s)
2554 def __str__(self):
2555 d = {}
2556 d.update(self.__dict__)
2557 f = ''
2558 for k in self.form.keys():
2559 f += '\n %r=%r'%(k,handleListCGIValue(self.form[k]))
2560 d['form'] = f
2561 e = ''
2562 for k,v in self.env.items():
2563 e += '\n %r=%r'%(k, v)
2564 d['env'] = e
2565 return """
2566 form: %(form)s
2567 base: %(base)r
2568 classname: %(classname)r
2569 template: %(template)r
2570 columns: %(columns)r
2571 sort: %(sort)r
2572 group: %(group)r
2573 filter: %(filter)r
2574 search_text: %(search_text)r
2575 pagesize: %(pagesize)r
2576 startwith: %(startwith)r
2577 env: %(env)s
2578 """%d
2580 def indexargs_form(self, columns=1, sort=1, group=1, filter=1,
2581 filterspec=1, search_text=1):
2582 """ return the current index args as form elements """
2583 l = []
2584 sc = self.special_char
2585 def add(k, v):
2586 l.append(self.input(type="hidden", name=k, value=v))
2587 if columns and self.columns:
2588 add(sc+'columns', ','.join(self.columns))
2589 if sort:
2590 val = []
2591 for dir, attr in self.sort:
2592 if dir == '-':
2593 val.append('-'+attr)
2594 else:
2595 val.append(attr)
2596 add(sc+'sort', ','.join (val))
2597 if group:
2598 val = []
2599 for dir, attr in self.group:
2600 if dir == '-':
2601 val.append('-'+attr)
2602 else:
2603 val.append(attr)
2604 add(sc+'group', ','.join (val))
2605 if filter and self.filter:
2606 add(sc+'filter', ','.join(self.filter))
2607 if self.classname and filterspec:
2608 cls = self.client.db.getclass(self.classname)
2609 for k,v in self.filterspec.items():
2610 if type(v) == type([]):
2611 if isinstance(cls.get_transitive_prop(k), hyperdb.String):
2612 add(k, ' '.join(v))
2613 else:
2614 add(k, ','.join(v))
2615 else:
2616 add(k, v)
2617 if search_text and self.search_text:
2618 add(sc+'search_text', self.search_text)
2619 add(sc+'pagesize', self.pagesize)
2620 add(sc+'startwith', self.startwith)
2621 return '\n'.join(l)
2623 def indexargs_url(self, url, args):
2624 """ Embed the current index args in a URL
2625 """
2626 q = urllib.quote
2627 sc = self.special_char
2628 l = ['%s=%s'%(k,v) for k,v in args.items()]
2630 # pull out the special values (prefixed by @ or :)
2631 specials = {}
2632 for key in args.keys():
2633 if key[0] in '@:':
2634 specials[key[1:]] = args[key]
2636 # ok, now handle the specials we received in the request
2637 if self.columns and not specials.has_key('columns'):
2638 l.append(sc+'columns=%s'%(','.join(self.columns)))
2639 if self.sort and not specials.has_key('sort'):
2640 val = []
2641 for dir, attr in self.sort:
2642 if dir == '-':
2643 val.append('-'+attr)
2644 else:
2645 val.append(attr)
2646 l.append(sc+'sort=%s'%(','.join(val)))
2647 if self.group and not specials.has_key('group'):
2648 val = []
2649 for dir, attr in self.group:
2650 if dir == '-':
2651 val.append('-'+attr)
2652 else:
2653 val.append(attr)
2654 l.append(sc+'group=%s'%(','.join(val)))
2655 if self.filter and not specials.has_key('filter'):
2656 l.append(sc+'filter=%s'%(','.join(self.filter)))
2657 if self.search_text and not specials.has_key('search_text'):
2658 l.append(sc+'search_text=%s'%q(self.search_text))
2659 if not specials.has_key('pagesize'):
2660 l.append(sc+'pagesize=%s'%self.pagesize)
2661 if not specials.has_key('startwith'):
2662 l.append(sc+'startwith=%s'%self.startwith)
2664 # finally, the remainder of the filter args in the request
2665 if self.classname and self.filterspec:
2666 cls = self.client.db.getclass(self.classname)
2667 for k,v in self.filterspec.items():
2668 if not args.has_key(k):
2669 if type(v) == type([]):
2670 prop = cls.get_transitive_prop(k)
2671 if k != 'id' and isinstance(prop, hyperdb.String):
2672 l.append('%s=%s'%(k, '%20'.join([q(i) for i in v])))
2673 else:
2674 l.append('%s=%s'%(k, ','.join([q(i) for i in v])))
2675 else:
2676 l.append('%s=%s'%(k, q(v)))
2677 return '%s?%s'%(url, '&'.join(l))
2678 indexargs_href = indexargs_url
2680 def base_javascript(self):
2681 return """
2682 <script type="text/javascript">
2683 submitted = false;
2684 function submit_once() {
2685 if (submitted) {
2686 alert("Your request is being processed.\\nPlease be patient.");
2687 event.returnValue = 0; // work-around for IE
2688 return 0;
2689 }
2690 submitted = true;
2691 return 1;
2692 }
2694 function help_window(helpurl, width, height) {
2695 HelpWin = window.open('%s' + helpurl, 'RoundupHelpWindow', 'scrollbars=yes,resizable=yes,toolbar=no,height='+height+',width='+width);
2696 }
2697 </script>
2698 """%self.base
2700 def batch(self):
2701 """ Return a batch object for results from the "current search"
2702 """
2703 check = self._client.db.security.hasPermission
2704 userid = self._client.userid
2705 if not check('Web Access', userid):
2706 return Batch(self.client, [], self.pagesize, self.startwith,
2707 classname=self.classname)
2709 filterspec = self.filterspec
2710 sort = self.sort
2711 group = self.group
2713 # get the list of ids we're batching over
2714 klass = self.client.db.getclass(self.classname)
2715 if self.search_text:
2716 matches = self.client.db.indexer.search(
2717 [w.upper().encode("utf-8", "replace") for w in re.findall(
2718 r'(?u)\b\w{2,25}\b',
2719 unicode(self.search_text, "utf-8", "replace")
2720 )], klass)
2721 else:
2722 matches = None
2724 # filter for visibility
2725 l = [id for id in klass.filter(matches, filterspec, sort, group)
2726 if check('View', userid, self.classname, itemid=id)]
2728 # return the batch object, using IDs only
2729 return Batch(self.client, l, self.pagesize, self.startwith,
2730 classname=self.classname)
2732 # extend the standard ZTUtils Batch object to remove dependency on
2733 # Acquisition and add a couple of useful methods
2734 class Batch(ZTUtils.Batch):
2735 """ Use me to turn a list of items, or item ids of a given class, into a
2736 series of batches.
2738 ========= ========================================================
2739 Parameter Usage
2740 ========= ========================================================
2741 sequence a list of HTMLItems or item ids
2742 classname if sequence is a list of ids, this is the class of item
2743 size how big to make the sequence.
2744 start where to start (0-indexed) in the sequence.
2745 end where to end (0-indexed) in the sequence.
2746 orphan if the next batch would contain less items than this
2747 value, then it is combined with this batch
2748 overlap the number of items shared between adjacent batches
2749 ========= ========================================================
2751 Attributes: Note that the "start" attribute, unlike the
2752 argument, is a 1-based index (I know, lame). "first" is the
2753 0-based index. "length" is the actual number of elements in
2754 the batch.
2756 "sequence_length" is the length of the original, unbatched, sequence.
2757 """
2758 def __init__(self, client, sequence, size, start, end=0, orphan=0,
2759 overlap=0, classname=None):
2760 self.client = client
2761 self.last_index = self.last_item = None
2762 self.current_item = None
2763 self.classname = classname
2764 self.sequence_length = len(sequence)
2765 ZTUtils.Batch.__init__(self, sequence, size, start, end, orphan,
2766 overlap)
2768 # overwrite so we can late-instantiate the HTMLItem instance
2769 def __getitem__(self, index):
2770 if index < 0:
2771 if index + self.end < self.first: raise IndexError, index
2772 return self._sequence[index + self.end]
2774 if index >= self.length:
2775 raise IndexError, index
2777 # move the last_item along - but only if the fetched index changes
2778 # (for some reason, index 0 is fetched twice)
2779 if index != self.last_index:
2780 self.last_item = self.current_item
2781 self.last_index = index
2783 item = self._sequence[index + self.first]
2784 if self.classname:
2785 # map the item ids to instances
2786 item = HTMLItem(self.client, self.classname, item)
2787 self.current_item = item
2788 return item
2790 def propchanged(self, *properties):
2791 """ Detect if one of the properties marked as being a group
2792 property changed in the last iteration fetch
2793 """
2794 # we poke directly at the _value here since MissingValue can screw
2795 # us up and cause Nones to compare strangely
2796 if self.last_item is None:
2797 return 1
2798 for property in properties:
2799 if property == 'id' or isinstance (self.last_item[property], list):
2800 if (str(self.last_item[property]) !=
2801 str(self.current_item[property])):
2802 return 1
2803 else:
2804 if (self.last_item[property]._value !=
2805 self.current_item[property]._value):
2806 return 1
2807 return 0
2809 # override these 'cos we don't have access to acquisition
2810 def previous(self):
2811 if self.start == 1:
2812 return None
2813 return Batch(self.client, self._sequence, self._size,
2814 self.first - self._size + self.overlap, 0, self.orphan,
2815 self.overlap)
2817 def next(self):
2818 try:
2819 self._sequence[self.end]
2820 except IndexError:
2821 return None
2822 return Batch(self.client, self._sequence, self._size,
2823 self.end - self.overlap, 0, self.orphan, self.overlap)
2825 class TemplatingUtils:
2826 """ Utilities for templating
2827 """
2828 def __init__(self, client):
2829 self.client = client
2830 def Batch(self, sequence, size, start, end=0, orphan=0, overlap=0):
2831 return Batch(self.client, sequence, size, start, end, orphan,
2832 overlap)
2834 def url_quote(self, url):
2835 """URL-quote the supplied text."""
2836 return urllib.quote(url)
2838 def html_quote(self, html):
2839 """HTML-quote the supplied text."""
2840 return cgi.escape(html)
2842 def __getattr__(self, name):
2843 """Try the tracker's templating_utils."""
2844 if not hasattr(self.client.instance, 'templating_utils'):
2845 # backwards-compatibility
2846 raise AttributeError, name
2847 if not self.client.instance.templating_utils.has_key(name):
2848 raise AttributeError, name
2849 return self.client.instance.templating_utils[name]
2851 def html_calendar(self, request):
2852 """Generate a HTML calendar.
2854 `request` the roundup.request object
2855 - @template : name of the template
2856 - form : name of the form to store back the date
2857 - property : name of the property of the form to store
2858 back the date
2859 - date : current date
2860 - display : when browsing, specifies year and month
2862 html will simply be a table.
2863 """
2864 tz = request.client.db.getUserTimezone()
2865 current_date = date.Date(".").local(tz)
2866 date_str = request.form.getfirst("date", current_date)
2867 display = request.form.getfirst("display", date_str)
2868 template = request.form.getfirst("@template", "calendar")
2869 form = request.form.getfirst("form")
2870 property = request.form.getfirst("property")
2871 curr_date = date.Date(date_str) # to highlight
2872 display = date.Date(display) # to show
2873 day = display.day
2875 # for navigation
2876 date_prev_month = display + date.Interval("-1m")
2877 date_next_month = display + date.Interval("+1m")
2878 date_prev_year = display + date.Interval("-1y")
2879 date_next_year = display + date.Interval("+1y")
2881 res = []
2883 base_link = "%s?@template=%s&property=%s&form=%s&date=%s" % \
2884 (request.classname, template, property, form, curr_date)
2886 # navigation
2887 # month
2888 res.append('<table class="calendar"><tr><td>')
2889 res.append(' <table width="100%" class="calendar_nav"><tr>')
2890 link = "&display=%s"%date_prev_month
2891 res.append(' <td><a href="%s&display=%s"><</a></td>'%(base_link,
2892 date_prev_month))
2893 res.append(' <td>%s</td>'%calendar.month_name[display.month])
2894 res.append(' <td><a href="%s&display=%s">></a></td>'%(base_link,
2895 date_next_month))
2896 # spacer
2897 res.append(' <td width="100%"></td>')
2898 # year
2899 res.append(' <td><a href="%s&display=%s"><</a></td>'%(base_link,
2900 date_prev_year))
2901 res.append(' <td>%s</td>'%display.year)
2902 res.append(' <td><a href="%s&display=%s">></a></td>'%(base_link,
2903 date_next_year))
2904 res.append(' </tr></table>')
2905 res.append(' </td></tr>')
2907 # the calendar
2908 res.append(' <tr><td><table class="calendar_display">')
2909 res.append(' <tr class="weekdays">')
2910 for day in calendar.weekheader(3).split():
2911 res.append(' <td>%s</td>'%day)
2912 res.append(' </tr>')
2913 for week in calendar.monthcalendar(display.year, display.month):
2914 res.append(' <tr>')
2915 for day in week:
2916 link = "javascript:form[field].value = '%d-%02d-%02d'; " \
2917 "window.close ();"%(display.year, display.month, day)
2918 if (day == curr_date.day and display.month == curr_date.month
2919 and display.year == curr_date.year):
2920 # highlight
2921 style = "today"
2922 else :
2923 style = ""
2924 if day:
2925 res.append(' <td class="%s"><a href="%s">%s</a></td>'%(
2926 style, link, day))
2927 else :
2928 res.append(' <td></td>')
2929 res.append(' </tr>')
2930 res.append('</table></td></tr></table>')
2931 return "\n".join(res)
2933 class MissingValue:
2934 def __init__(self, description, **kwargs):
2935 self.__description = description
2936 for key, value in kwargs.items():
2937 self.__dict__[key] = value
2939 def __call__(self, *args, **kwargs): return MissingValue(self.__description)
2940 def __getattr__(self, name):
2941 # This allows assignments which assume all intermediate steps are Null
2942 # objects if they don't exist yet.
2943 #
2944 # For example (with just 'client' defined):
2945 #
2946 # client.db.config.TRACKER_WEB = 'BASE/'
2947 self.__dict__[name] = MissingValue(self.__description)
2948 return getattr(self, name)
2950 def __getitem__(self, key): return self
2951 def __nonzero__(self): return 0
2952 def __str__(self): return '[%s]'%self.__description
2953 def __repr__(self): return '<MissingValue 0x%x "%s">'%(id(self),
2954 self.__description)
2955 def gettext(self, str): return str
2956 _ = gettext
2958 # vim: set et sts=4 sw=4 :