![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index 709984626ee2df65ec240c629d24dd3e08807ad3..dff1bbcbe405b5cdb409b5e20ddc7d88918a0756 100644 (file)
else:
self.getTemplate(filename, None)
- def get(self, name, extension):
+ def get(self, name, extension=None):
''' Interface to get a template, possibly loading a compiled template.
"name" and "extension" indicate the template we're after, which in
# default the name to "home"
if name is None:
name = 'home'
+ elif extension is None and '.' in name:
+ # split name
+ name, extension = name.split('.')
# find the source, figure the time it was last modified
if extension:
filename = '%s.%s'%(name, extension)
else:
filename = name
+
src = os.path.join(self.dir, filename)
try:
stime = os.stat(src)[os.path.stat.ST_MTIME]
# add in the item if there is one
if client.nodeid:
if classname == 'user':
- c['context'] = HTMLUser(client, classname, client.nodeid)
+ c['context'] = HTMLUser(client, classname, client.nodeid,
+ anonymous=1)
else:
- c['context'] = HTMLItem(client, classname, client.nodeid)
+ c['context'] = HTMLItem(client, classname, client.nodeid,
+ anonymous=1)
elif client.db.classes.has_key(classname):
- c['context'] = HTMLClass(client, classname)
+ c['context'] = HTMLClass(client, classname, anonymous=1)
return c
def render(self, client, classname, request, **options):
# we want config to be exposed
self.config = client.db.config
- def __getitem__(self, item):
- self._client.db.getclass(item)
- return HTMLClass(self._client, item)
+ def __getitem__(self, item, desre=re.compile(r'(?P<cl>\w+)(?P<id>[-\d]+)')):
+ # check to see if we're actually accessing an item
+ m = desre.match(item)
+ if m:
+ self._client.db.getclass(m.group('cl'))
+ return HTMLItem(self._client, m.group('cl'), m.group('id'))
+ else:
+ self._client.db.getclass(item)
+ return HTMLClass(self._client, item)
def __getattr__(self, attr):
try:
class HTMLClass(HTMLPermissions):
''' Accesses through a class (either through *class* or *db.<classname>*)
'''
- def __init__(self, client, classname):
+ def __init__(self, client, classname, anonymous=0):
self._client = client
self._db = client.db
+ self._anonymous = anonymous
# we want classname to be exposed, but _classname gives a
# consistent API for extending Class/Item
value = []
else:
value = None
- return htmlklass(self._client, '', prop, item, value)
+ return htmlklass(self._client, self._classname, '', prop, item,
+ value, self._anonymous)
# no good
raise KeyError, item
else:
value = None
if isinstance(prop, klass):
- l.append(htmlklass(self._client, '', prop, name, value))
+ l.append(htmlklass(self._client, self._classname, '',
+ prop, name, value, self._anonymous))
return l
def list(self):
filterspec = request.filterspec
sort = request.sort
group = request.group
+ else:
+ filterspec = {}
+ sort = (None,None)
+ group = (None,None)
if self.classname == 'user':
klass = HTMLUser
else:
class HTMLItem(HTMLPermissions):
''' Accesses through an *item*
'''
- def __init__(self, client, classname, nodeid):
+ def __init__(self, client, classname, nodeid, anonymous=0):
self._client = client
self._db = client.db
self._classname = classname
self._klass = self._db.getclass(classname)
self._props = self._klass.getprops()
+ # do we prefix the form items with the item's identification?
+ self._anonymous = anonymous
+
def __repr__(self):
return '<HTMLItem(0x%x) %s %s>'%(id(self), self._classname,
self._nodeid)
prop = self._props[item]
# get the value, handling missing values
- value = self._klass.get(self._nodeid, item, None)
+ value = None
+ if int(self._nodeid) > 0:
+ value = self._klass.get(self._nodeid, item, None)
if value is None:
if isinstance(self._props[item], hyperdb.Multilink):
value = []
# look up the correct HTMLProperty class
for klass, htmlklass in propclasses:
if isinstance(prop, klass):
- return htmlklass(self._client, self._nodeid, prop, item, value)
+ return htmlklass(self._client, self._classname,
+ self._nodeid, prop, item, value, self._anonymous)
raise KeyError, item
comments = {}
history = self._klass.history(self._nodeid)
history.sort()
+ timezone = self._db.getUserTimezone()
if direction == 'descending':
history.reverse()
for prop_n in self._props.keys():
if isinstance(prop, HTMLProperty):
current[prop_n] = prop.plain()
# make link if hrefable
- if isinstance(self._props[prop_n], hyperdb.Link):
+ if (self._props.has_key(prop_n) and
+ isinstance(self._props[prop_n], hyperdb.Link)):
classname = self._props[prop_n].classname
if os.path.exists(os.path.join(self._db.config.TEMPLATES, classname + '.item')):
current[prop_n] = '<a href="%s%s">%s</a>'%(classname,
self._klass.get(self._nodeid, prop_n, None), current[prop_n])
for id, evt_date, user, action, args in history:
- date_s = str(evt_date).replace("."," ")
+ date_s = str(evt_date.local(timezone)).replace("."," ")
arg_s = ''
if action == 'link' and type(args) == type(()):
if len(args) == 3:
current[k] = old
elif isinstance(prop, hyperdb.Date) and args[k]:
- d = date.Date(args[k])
+ d = date.Date(args[k]).local(timezone)
cell.append('%s: %s'%(k, str(d)))
if current.has_key(k):
- cell[-1] += ' -> %s'%current[k]
+ cell[-1] += ' -> %s' % current[k]
current[k] = str(d)
elif isinstance(prop, hyperdb.Interval) and args[k]:
class HTMLUser(HTMLItem):
''' Accesses through the *user* (a special case of item)
'''
- def __init__(self, client, classname, nodeid):
- HTMLItem.__init__(self, client, 'user', nodeid)
+ def __init__(self, client, classname, nodeid, anonymous=0):
+ HTMLItem.__init__(self, client, 'user', nodeid, anonymous)
self._default_classname = client.classname
# used for security checks
self._security = client.db.security
_marker = []
- def hasPermission(self, role, classname=_marker):
- ''' Determine if the user has the Role.
+ def hasPermission(self, permission, classname=_marker):
+ ''' Determine if the user has the Permission.
The class being tested defaults to the template's class, but may
be overidden for this test by suppling an alternate classname.
'''
if classname is self._marker:
classname = self._default_classname
- return self._security.hasPermission(role, self._nodeid, classname)
+ return self._security.hasPermission(permission, self._nodeid, classname)
def is_edit_ok(self):
''' Is the user allowed to Edit the current class?
A wrapper object which may be stringified for the plain() behaviour.
'''
- def __init__(self, client, nodeid, prop, name, value):
+ def __init__(self, client, classname, nodeid, prop, name, value,
+ anonymous=0):
self._client = client
self._db = client.db
+ self._classname = classname
self._nodeid = nodeid
self._prop = prop
- self._name = name
self._value = value
+ self._anonymous = anonymous
+ if not anonymous:
+ self._name = '%s%s@%s'%(classname, nodeid, name)
+ else:
+ self._name = name
def __repr__(self):
- return '<HTMLProperty(0x%x) %s %r %r>'%(id(self), self._name, self._prop, self._value)
+ return '<HTMLProperty(0x%x) %s %r %r>'%(id(self), self._name,
+ self._prop, self._value)
def __str__(self):
return self.plain()
def __cmp__(self, other):
return cmp(self._value, other)
class StringHTMLProperty(HTMLProperty):
- url_re = re.compile(r'\w{3,6}://\S+')
- email_re = re.compile(r'[\w\.]+@[\w\.\-]+')
- designator_re = re.compile(r'([a-z_]+)(\d+)')
- def _url_repl(self, match):
- s = match.group(0)
- return '<a href="%s">%s</a>'%(s, s)
- def _email_repl(self, match):
- s = match.group(0)
- return '<a href="mailto:%s">%s</a>'%(s, s)
- def _designator_repl(self, match):
- s = match.group(0)
- s1 = match.group(1)
- s2 = match.group(2)
- try:
- # make sure s1 is a valid tracker classname
- self._db.getclass(s1)
- return '<a href="%s">%s %s</a>'%(s, s1, s2)
- except KeyError:
- return '%s%s'%(s1, s2)
+ hyper_re = re.compile(r'((?P<url>\w{3,6}://\S+)|'
+ r'(?P<email>[\w\.]+@[\w\.\-]+)|'
+ r'(?P<item>(?P<class>[a-z_]+)(?P<id>\d+)))')
+ def _hyper_repl(self, match):
+ if match.group('url'):
+ s = match.group('url')
+ return '<a href="%s">%s</a>'%(s, s)
+ elif match.group('email'):
+ s = match.group('email')
+ return '<a href="mailto:%s">%s</a>'%(s, s)
+ else:
+ s = match.group('item')
+ s1 = match.group('class')
+ s2 = match.group('id')
+ try:
+ # make sure s1 is a valid tracker classname
+ self._db.getclass(s1)
+ return '<a href="%s">%s %s</a>'%(s, s1, s2)
+ except KeyError:
+ return '%s%s'%(s1, s2)
- def plain(self, escape=0, hyperlink=1):
+ def plain(self, escape=0, hyperlink=0):
''' Render a "plain" representation of the property
"escape" turns on/off HTML quoting
if escape:
s = cgi.escape(str(self._value))
else:
- s = self._value
+ s = str(self._value)
if hyperlink:
- s = self.url_re.sub(self._url_repl, s)
- s = self.email_re.sub(self._email_repl, s)
- s = self.designator_re.sub(self._designator_repl, s)
+ if not escape:
+ s = cgi.escape(s)
+ s = self.hyper_re.sub(self._hyper_repl, s)
return s
def stext(self, escape=0):
def confirm(self, size = 30):
''' Render a second form edit field for the property, used for
confirmation that the user typed the password correctly. Generates
- a field with name "name:confirm".
+ a field with name ":confirm:name".
'''
- return '<input type="password" name="%s:confirm" size="%s">'%(
+ return '<input type="password" name=":confirm:%s" size="%s">'%(
self._name, size)
class NumberHTMLProperty(HTMLProperty):
'''
if self._value is None:
return ''
- return str(self._value)
+ return str(self._value.local(self._db.getUserTimezone()))
+
+ def now(self):
+ ''' Return the current time.
+
+ This is useful for defaulting a new value. Returns a
+ DateHTMLProperty.
+ '''
+ return DateHTMLProperty(self._client, self._nodeid, self._prop,
+ self._name, date.Date('.'))
def field(self, size = 30):
''' Render a form edit field for the property
if self._value is None:
value = ''
else:
- value = cgi.escape(str(self._value))
+ value = cgi.escape(str(self._value.local(self._db.getUserTimezone())))
value = '"'.join(value.split('"'))
return '<input name="%s" value="%s" size="%s">'%(self._name, value, size)
return interval.pretty()
return str(interval)
- def pretty(self, format='%d %B %Y'):
+ _marker = []
+ def pretty(self, format=_marker):
''' Render the date in a pretty format (eg. month names, spaces).
The format string is a standard python strftime format string.
string, then it'll be stripped from the output. This is handy
for the situatin when a date only specifies a month and a year.
'''
- return self._value.pretty()
+ if format is not self._marker:
+ return self._value.pretty(format)
+ else:
+ return self._value.pretty()
def local(self, offset):
''' Return the date/time as a local (timezone offset) date/time.
'''
return DateHTMLProperty(self._client, self._nodeid, self._prop,
- self._name, self._value.local())
+ self._name, self._value.local(offset))
class IntervalHTMLProperty(HTMLProperty):
def plain(self):
entry identified by the assignedto property on item, and then the
name property of that user)
'''
- def __init__(self, *args):
- HTMLProperty.__init__(self, *args)
+ def __init__(self, *args, **kw):
+ HTMLProperty.__init__(self, *args, **kw)
# if we're representing a form value, then the -1 from the form really
# should be a None
if str(self._value) == '-1':
self.classname = client.classname
self.template = client.template
+ # the special char to use for special vars
+ self.special_char = '@'
+
self._post_init()
def _post_init(self):
'''
# extract the index display information from the form
self.columns = []
- if self.form.has_key(':columns'):
- self.columns = handleListCGIValue(self.form[':columns'])
+ for name in ':columns @columns'.split():
+ if self.form.has_key(name):
+ self.special_char = name[0]
+ self.columns = handleListCGIValue(self.form[name])
+ break
self.show = ShowDict(self.columns)
# sorting
self.sort = (None, None)
- if self.form.has_key(':sort'):
- sort = self.form[':sort'].value
- if sort.startswith('-'):
- self.sort = ('-', sort[1:])
- else:
- self.sort = ('+', sort)
- if self.form.has_key(':sortdir'):
- self.sort = ('-', self.sort[1])
+ for name in ':sort @sort'.split():
+ if self.form.has_key(name):
+ self.special_char = name[0]
+ sort = self.form[name].value
+ if sort.startswith('-'):
+ self.sort = ('-', sort[1:])
+ else:
+ self.sort = ('+', sort)
+ if self.form.has_key(self.special_char+'sortdir'):
+ self.sort = ('-', self.sort[1])
# grouping
self.group = (None, None)
- if self.form.has_key(':group'):
- group = self.form[':group'].value
- if group.startswith('-'):
- self.group = ('-', group[1:])
- else:
- self.group = ('+', group)
- if self.form.has_key(':groupdir'):
- self.group = ('-', self.group[1])
+ for name in ':group @group'.split():
+ if self.form.has_key(name):
+ self.special_char = name[0]
+ group = self.form[name].value
+ if group.startswith('-'):
+ self.group = ('-', group[1:])
+ else:
+ self.group = ('+', group)
+ if self.form.has_key(self.special_char+'groupdir'):
+ self.group = ('-', self.group[1])
# filtering
self.filter = []
- if self.form.has_key(':filter'):
- self.filter = handleListCGIValue(self.form[':filter'])
+ for name in ':filter @filter'.split():
+ if self.form.has_key(name):
+ self.special_char = name[0]
+ self.filter = handleListCGIValue(self.form[name])
+
self.filterspec = {}
db = self.client.db
if self.classname is not None:
# full-text search argument
self.search_text = None
- if self.form.has_key(':search_text'):
- self.search_text = self.form[':search_text'].value
+ for name in ':search_text @search_text'.split():
+ if self.form.has_key(name):
+ self.special_char = name[0]
+ self.search_text = self.form[name].value
# pagination - size and start index
# figure batch args
- if self.form.has_key(':pagesize'):
- self.pagesize = int(self.form[':pagesize'].value)
- else:
- self.pagesize = 50
- if self.form.has_key(':startwith'):
- self.startwith = int(self.form[':startwith'].value)
- else:
- self.startwith = 0
+ self.pagesize = 50
+ for name in ':pagesize @pagesize'.split():
+ if self.form.has_key(name):
+ self.special_char = name[0]
+ self.pagesize = int(self.form[name].value)
+
+ self.startwith = 0
+ for name in ':startwith @startwith'.split():
+ if self.form.has_key(name):
+ self.special_char = name[0]
+ self.startwith = int(self.form[name].value)
def updateFromURL(self, url):
''' Parse the URL for query args, and update my attributes using the
filterspec=1):
''' return the current index args as form elements '''
l = []
+ sc = self.special_char
s = '<input type="hidden" name="%s" value="%s">'
if columns and self.columns:
- l.append(s%(':columns', ','.join(self.columns)))
+ l.append(s%(sc+'columns', ','.join(self.columns)))
if sort and self.sort[1] is not None:
if self.sort[0] == '-':
val = '-'+self.sort[1]
else:
val = self.sort[1]
- l.append(s%(':sort', val))
+ l.append(s%(sc+'sort', val))
if group and self.group[1] is not None:
if self.group[0] == '-':
val = '-'+self.group[1]
else:
val = self.group[1]
- l.append(s%(':group', val))
+ l.append(s%(sc+'group', val))
if filter and self.filter:
- l.append(s%(':filter', ','.join(self.filter)))
+ l.append(s%(sc+'filter', ','.join(self.filter)))
if filterspec:
for k,v in self.filterspec.items():
if type(v) == type([]):
else:
l.append(s%(k, v))
if self.search_text:
- l.append(s%(':search_text', self.search_text))
- l.append(s%(':pagesize', self.pagesize))
- l.append(s%(':startwith', self.startwith))
+ l.append(s%(sc+'search_text', self.search_text))
+ l.append(s%(sc+'pagesize', self.pagesize))
+ l.append(s%(sc+'startwith', self.startwith))
return '\n'.join(l)
def indexargs_url(self, url, args):
- ''' embed the current index args in a URL '''
+ ''' Embed the current index args in a URL
+ '''
+ sc = self.special_char
l = ['%s=%s'%(k,v) for k,v in args.items()]
- if self.columns and not args.has_key(':columns'):
- l.append(':columns=%s'%(','.join(self.columns)))
- if self.sort[1] is not None and not args.has_key(':sort'):
+
+ # pull out the special values (prefixed by @ or :)
+ specials = {}
+ for key in args.keys():
+ if key[0] in '@:':
+ specials[key[1:]] = args[key]
+
+ # ok, now handle the specials we received in the request
+ if self.columns and not specials.has_key('columns'):
+ l.append(sc+'columns=%s'%(','.join(self.columns)))
+ if self.sort[1] is not None and not specials.has_key('sort'):
if self.sort[0] == '-':
val = '-'+self.sort[1]
else:
val = self.sort[1]
- l.append(':sort=%s'%val)
- if self.group[1] is not None and not args.has_key(':group'):
+ l.append(sc+'sort=%s'%val)
+ if self.group[1] is not None and not specials.has_key('group'):
if self.group[0] == '-':
val = '-'+self.group[1]
else:
val = self.group[1]
- l.append(':group=%s'%val)
- if self.filter and not args.has_key(':columns'):
- l.append(':filter=%s'%(','.join(self.filter)))
+ l.append(sc+'group=%s'%val)
+ if self.filter and not specials.has_key('filter'):
+ l.append(sc+'filter=%s'%(','.join(self.filter)))
+ if self.search_text and not specials.has_key('search_text'):
+ l.append(sc+'search_text=%s'%self.search_text)
+ if not specials.has_key('pagesize'):
+ l.append(sc+'pagesize=%s'%self.pagesize)
+ if not specials.has_key('startwith'):
+ l.append(sc+'startwith=%s'%self.startwith)
+
+ # finally, the remainder of the filter args in the request
for k,v in self.filterspec.items():
if not args.has_key(k):
if type(v) == type([]):
l.append('%s=%s'%(k, ','.join(v)))
else:
l.append('%s=%s'%(k, v))
- if self.search_text and not args.has_key(':search_text'):
- l.append(':search_text=%s'%self.search_text)
- if not args.has_key(':pagesize'):
- l.append(':pagesize=%s'%self.pagesize)
- if not args.has_key(':startwith'):
- l.append(':startwith=%s'%self.startwith)
return '%s?%s'%(url, '&'.join(l))
indexargs_href = indexargs_url