code-adcfdeac4e76/roundup/cgi/.cvsignore0000644000000000000000000000002407535310140016464 0ustar 00000000000000*.pyc *.pyo *.cover code-adcfdeac4e76/roundup/cgi/Acquisition.py0000644000000000000000000000016207535310140017331 0ustar 00000000000000class Explicit: pass def aq_base(obj): return obj aq_inner = aq_base def aq_parent(obj): return None code-adcfdeac4e76/roundup/cgi/ComputedAttribute.py0000644000000000000000000000053707535310140020513 0ustar 00000000000000class ComputedAttribute: def __init__(self, callable, level): self.callable = callable self.level = level def __of__(self, *args): if self.level > 0: return self.callable if isinstance(self.callable, type('')): return getattr(args[0], self.callable) return self.callable(*args) code-adcfdeac4e76/roundup/cgi/ExtensionClass.py0000644000000000000000000000002507535310140020001 0ustar 00000000000000class Base: pass code-adcfdeac4e76/roundup/cgi/MultiMapping.py0000644000000000000000000000132207535310140017446 0ustar 00000000000000import operator class MultiMapping: def __init__(self, *stores): self.stores = list(stores) def __getitem__(self, key): for store in self.stores: if store.has_key(key): return store[key] raise KeyError, key _marker = [] def get(self, key, default=_marker): for store in self.stores: if store.has_key(key): return store[key] if default is self._marker: raise KeyError, key return default def __len__(self): return reduce(operator.add, [len(x) for x in stores], 0) def push(self, store): self.stores.append(store) def pop(self): return self.stores.pop() code-adcfdeac4e76/roundup/cgi/__init__.py0000644000000000000000000000000007535310140016567 0ustar 00000000000000code-adcfdeac4e76/roundup/cgi/cgitb.py0000644000000000000000000001310307535310140016130 0ustar 00000000000000# # This module was written by Ka-Ping Yee, . # # $Id: cgitb.py,v 1.1 2002-08-30 08:28:44 richard Exp $ __doc__ = """ Extended CGI traceback handler by Ka-Ping Yee, . """ import sys, os, types, string, keyword, linecache, tokenize, inspect, pydoc from roundup.i18n import _ def breaker(): return ('' + ' > ' + '' * 5) def html(context=5): etype, evalue = sys.exc_type, sys.exc_value if type(etype) is types.ClassType: etype = etype.__name__ pyver = 'Python ' + string.split(sys.version)[0] + '
' + sys.executable head = pydoc.html.heading( '%s: %s'%(etype, evalue), '#ffffff', '#777777', pyver) head = head + (_('

A problem occurred while running a Python script. ' 'Here is the sequence of function calls leading up to ' 'the error, with the most recent (innermost) call first. ' 'The exception attributes are:')) indent = '%s ' % (' ' * 5) traceback = [] for frame, file, lnum, func, lines, index in inspect.trace(context): if file is None: link = '<file is None - probably inside eval or exec>' else: file = os.path.abspath(file) link = '%s' % (file, pydoc.html.escape(file)) args, varargs, varkw, locals = inspect.getargvalues(frame) if func == '?': call = '' else: call = 'in %s' % func + inspect.formatargvalues( args, varargs, varkw, locals, formatvalue=lambda value: '=' + pydoc.html.repr(value)) level = '''
%s %s
''' % (link, call) if index is None or file is None: traceback.append('

' + level) continue # do a fil inspection names = [] def tokeneater(type, token, start, end, line, names=names): if type == tokenize.NAME and token not in keyword.kwlist: if token not in names: names.append(token) if type == tokenize.NEWLINE: raise IndexError def linereader(file=file, lnum=[lnum]): line = linecache.getline(file, lnum[0]) lnum[0] = lnum[0] + 1 return line try: tokenize.tokenize(linereader, tokeneater) except IndexError: pass lvals = [] for name in names: if name in frame.f_code.co_varnames: if locals.has_key(name): value = pydoc.html.repr(locals[name]) else: value = _('undefined') name = '%s' % name else: if frame.f_globals.has_key(name): value = pydoc.html.repr(frame.f_globals[name]) else: value = _('undefined') name = 'global %s' % name lvals.append('%s = %s' % (name, value)) if lvals: lvals = string.join(lvals, ', ') lvals = indent + ''' %s
''' % lvals else: lvals = '' excerpt = [] i = lnum - index for line in lines: number = ' ' * (5-len(str(i))) + str(i) number = '%s' % number line = '%s %s' % (number, pydoc.html.preformat(line)) if i == lnum: line = '''
%s
''' % line excerpt.append('\n' + line) if i == lnum: excerpt.append(lvals) i = i + 1 traceback.append('

' + level + string.join(excerpt, '\n')) traceback.reverse() exception = '

%s: %s' % (str(etype), str(evalue)) attribs = [] if type(evalue) is types.InstanceType: for name in dir(evalue): value = pydoc.html.repr(getattr(evalue, name)) attribs.append('
%s%s = %s' % (indent, name, value)) return head + string.join(attribs) + string.join(traceback) + '

 

' def handler(): print breaker() print html() # # $Log: not supported by cvs2svn $ # Revision 1.10 2002/01/16 04:49:45 richard # Handle a special case that the CGI interface tickles. I need to check if # this needs fixing in python's core. # # Revision 1.9 2002/01/08 11:56:24 richard # missed an import _ # # Revision 1.8 2002/01/05 02:22:32 richard # i18n'ification # # Revision 1.7 2001/11/22 15:46:42 jhermann # Added module docstrings to all modules. # # Revision 1.6 2001/09/29 13:27:00 richard # CGI interfaces now spit up a top-level index of all the instances they can # serve. # # Revision 1.5 2001/08/07 00:24:42 richard # stupid typo # # Revision 1.4 2001/08/07 00:15:51 richard # Added the copyright/license notice to (nearly) all files at request of # Bizar Software. # # Revision 1.3 2001/07/29 07:01:39 richard # Added vim command to all source so that we don't get no steenkin' tabs :) # # Revision 1.2 2001/07/22 12:09:32 richard # Final commit of Grande Splite # # Revision 1.1 2001/07/22 11:58:35 richard # More Grande Splite # # # vim: set filetype=python ts=4 sw=4 et si code-adcfdeac4e76/roundup/cgi/client.py0000644000000000000000000011551107535310140016324 0ustar 00000000000000# $Id: client.py,v 1.11 2002-09-04 04:31:51 richard Exp $ __doc__ = """ WWW request handler (also used in the stand-alone server). """ import os, os.path, cgi, StringIO, urlparse, re, traceback, mimetypes, urllib import binascii, Cookie, time, random from roundup import roundupdb, date, hyperdb, password from roundup.i18n import _ from roundup.cgi.templating import getTemplate, HTMLRequest from roundup.cgi import cgitb from PageTemplates import PageTemplate class Unauthorised(ValueError): pass class NotFound(ValueError): pass class Redirect(Exception): pass class SendFile(Exception): ' Sent a file from the database ' class SendStaticFile(Exception): ' Send a static file from the instance html directory ' def initialiseSecurity(security): ''' Create some Permissions and Roles on the security object This function is directly invoked by security.Security.__init__() as a part of the Security object instantiation. ''' security.addPermission(name="Web Registration", description="User may register through the web") p = security.addPermission(name="Web Access", description="User may access the web interface") security.addPermissionToRole('Admin', p) # doing Role stuff through the web - make sure Admin can p = security.addPermission(name="Web Roles", description="User may manipulate user Roles through the web") security.addPermissionToRole('Admin', p) class Client: ''' A note about login ------------------ If the user has no login cookie, then they are anonymous. There are two levels of anonymous use. If there is no 'anonymous' user, there is no login at all and the database is opened in read-only mode. If the 'anonymous' user exists, the user is logged in using that user (though there is no cookie). This allows them to modify the database, and all modifications are attributed to the 'anonymous' user. Once a user logs in, they are assigned a session. The Client instance keeps the nodeid of the session as the "session" attribute. Client attributes: "url" is the current url path "path" is the PATH_INFO inside the instance "base" is the base URL for the instance ''' def __init__(self, instance, request, env, form=None): hyperdb.traceMark() self.instance = instance self.request = request self.env = env self.path = env['PATH_INFO'] self.split_path = self.path.split('/') self.instance_path_name = env['INSTANCE_NAME'] # this is the base URL for this instance url = self.env['SCRIPT_NAME'] + '/' + self.instance_path_name self.base = urlparse.urlunparse(('http', env['HTTP_HOST'], url, None, None, None)) # request.path is the full request path x, x, path, x, x, x = urlparse.urlparse(request.path) self.url = urlparse.urlunparse(('http', env['HTTP_HOST'], path, None, None, None)) if form is None: self.form = cgi.FieldStorage(environ=env) else: self.form = form self.headers_done = 0 try: self.debug = int(env.get("ROUNDUP_DEBUG", 0)) except ValueError: # someone gave us a non-int debug level, turn it off self.debug = 0 def main(self): ''' Wrap the request and handle unauthorised requests ''' self.content_action = None self.ok_message = [] self.error_message = [] try: # make sure we're identified (even anonymously) self.determine_user() # figure out the context and desired content template self.determine_context() # possibly handle a form submit action (may change self.message, # self.classname and self.template) self.handle_action() # now render the page self.write(self.renderTemplate('page', '', ok_message=self.ok_message, error_message=self.error_message)) except Redirect, url: # let's redirect - if the url isn't None, then we need to do # the headers, otherwise the headers have been set before the # exception was raised if url: self.header({'Location': url}, response=302) except SendFile, designator: self.serve_file(designator) except SendStaticFile, file: self.serve_static_file(str(file)) except Unauthorised, message: self.write(self.renderTemplate('page', '', error_message=message)) except: # everything else self.write(cgitb.html()) def determine_user(self): ''' Determine who the user is ''' # determine the uid to use self.opendb('admin') # make sure we have the session Class sessions = self.db.sessions # age sessions, remove when they haven't been used for a week # TODO: this shouldn't be done every access week = 60*60*24*7 now = time.time() for sessid in sessions.list(): interval = now - sessions.get(sessid, 'last_use') if interval > week: sessions.destroy(sessid) # look up the user session cookie cookie = Cookie.Cookie(self.env.get('HTTP_COOKIE', '')) user = 'anonymous' # bump the "revision" of the cookie since the format changed if (cookie.has_key('roundup_user_2') and cookie['roundup_user_2'].value != 'deleted'): # get the session key from the cookie self.session = cookie['roundup_user_2'].value # get the user from the session try: # update the lifetime datestamp sessions.set(self.session, last_use=time.time()) sessions.commit() user = sessions.get(self.session, 'user') except KeyError: user = 'anonymous' # sanity check on the user still being valid, getting the userid # at the same time try: self.userid = self.db.user.lookup(user) except (KeyError, TypeError): user = 'anonymous' # make sure the anonymous user is valid if we're using it if user == 'anonymous': self.make_user_anonymous() else: self.user = user # reopen the database as the correct user self.opendb(self.user) def determine_context(self, dre=re.compile(r'([^\d]+)(\d+)')): ''' Determine the context of this page: home (default if no url is given) classname designator (classname and nodeid) The desired template to be rendered is also determined There are two exceptional contexts: _file - serve up a static file path len > 1 - serve up a FileClass content (the additional path gives the browser a nicer filename to save as) The template used is specified by the :template CGI variable, which defaults to: only classname suplied: "index" full item designator supplied: "item" We set: self.classname - the class to display, can be None self.template - the template to render the current context with self.nodeid - the nodeid of the class we're displaying ''' # default the optional variables self.classname = None self.nodeid = None # determine the classname and possibly nodeid path = self.split_path if not path or path[0] in ('', 'home', 'index'): if self.form.has_key(':template'): self.template = self.form[':template'].value else: self.template = '' return elif path[0] == '_file': raise SendStaticFile, path[1] else: self.classname = path[0] if len(path) > 1: # send the file identified by the designator in path[0] raise SendFile, path[0] # see if we got a designator m = dre.match(self.classname) if m: self.classname = m.group(1) self.nodeid = m.group(2) # with a designator, we default to item view self.template = 'item' else: # with only a class, we default to index view self.template = 'index' # see if we have a template override if self.form.has_key(':template'): self.template = self.form[':template'].value # see if we were passed in a message if self.form.has_key(':ok_message'): self.ok_message.append(self.form[':ok_message'].value) if self.form.has_key(':error_message'): self.error_message.append(self.form[':error_message'].value) def serve_file(self, designator, dre=re.compile(r'([^\d]+)(\d+)')): ''' Serve the file from the content property of the designated item. ''' m = dre.match(str(designator)) if not m: raise NotFound, str(designator) classname, nodeid = m.group(1), m.group(2) if classname != 'file': raise NotFound, designator # we just want to serve up the file named file = self.db.file self.header({'Content-Type': file.get(nodeid, 'type')}) self.write(file.get(nodeid, 'content')) def serve_static_file(self, file): # we just want to serve up the file named mt = mimetypes.guess_type(str(file))[0] self.header({'Content-Type': mt}) self.write(open(os.path.join(self.instance.TEMPLATES, file)).read()) def renderTemplate(self, name, extension, **kwargs): ''' Return a PageTemplate for the named page ''' pt = getTemplate(self.instance.TEMPLATES, name, extension) # XXX handle PT rendering errors here more nicely try: # let the template render figure stuff out return pt.render(self, None, None, **kwargs) except PageTemplate.PTRuntimeError, message: return '%s
    %s
'%(message, '
  • '.join(pt._v_errors)) except: # everything else return cgitb.html() def content(self): ''' Callback used by the page template to render the content of the page. If we don't have a specific class to display, that is none was determined in determine_context(), then we display a "home" template. ''' # now render the page content using the template we determined in # determine_context if self.classname is None: name = 'home' else: name = self.classname return self.renderTemplate(self.classname, self.template) # these are the actions that are available actions = { 'edit': 'editItemAction', 'editCSV': 'editCSVAction', 'new': 'newItemAction', 'register': 'registerAction', 'login': 'login_action', 'logout': 'logout_action', 'search': 'searchAction', } def handle_action(self): ''' Determine whether there should be an _action called. The action is defined by the form variable :action which identifies the method on this object to call. The four basic actions are defined in the "actions" dictionary on this class: "edit" -> self.editItemAction "new" -> self.newItemAction "register" -> self.registerAction "login" -> self.login_action "logout" -> self.logout_action "search" -> self.searchAction ''' if not self.form.has_key(':action'): return None try: # get the action, validate it action = self.form[':action'].value if not self.actions.has_key(action): raise ValueError, 'No such action "%s"'%action # call the mapped action getattr(self, self.actions[action])() except Redirect: raise except: self.db.rollback() s = StringIO.StringIO() traceback.print_exc(None, s) self.error_message.append('
    %s
    '%cgi.escape(s.getvalue())) def write(self, content): if not self.headers_done: self.header() self.request.wfile.write(content) def header(self, headers=None, response=200): '''Put up the appropriate header. ''' if headers is None: headers = {'Content-Type':'text/html'} if not headers.has_key('Content-Type'): headers['Content-Type'] = 'text/html' self.request.send_response(response) for entry in headers.items(): self.request.send_header(*entry) self.request.end_headers() self.headers_done = 1 if self.debug: self.headers_sent = headers def set_cookie(self, user, password): # TODO generate a much, much stronger session key ;) self.session = binascii.b2a_base64(repr(time.time())).strip() # clean up the base64 if self.session[-1] == '=': if self.session[-2] == '=': self.session = self.session[:-2] else: self.session = self.session[:-1] # insert the session in the sessiondb self.db.sessions.set(self.session, user=user, last_use=time.time()) # and commit immediately self.db.sessions.commit() # expire us in a long, long time expire = Cookie._getdate(86400*365) # generate the cookie path - make sure it has a trailing '/' path = '/'.join((self.env['SCRIPT_NAME'], self.env['INSTANCE_NAME'], '')) self.header({'Set-Cookie': 'roundup_user_2=%s; expires=%s; Path=%s;'%( self.session, expire, path)}) def make_user_anonymous(self): ''' Make us anonymous This method used to handle non-existence of the 'anonymous' user, but that user is mandatory now. ''' self.userid = self.db.user.lookup('anonymous') self.user = 'anonymous' def logout(self): ''' Make us really anonymous - nuke the cookie too ''' self.make_user_anonymous() # construct the logout cookie now = Cookie._getdate() path = '/'.join((self.env['SCRIPT_NAME'], self.env['INSTANCE_NAME'], '')) self.header({'Set-Cookie': 'roundup_user_2=deleted; Max-Age=0; expires=%s; Path=%s;'%(now, path)}) self.login() def opendb(self, user): ''' Open the database. ''' # open the db if the user has changed if not hasattr(self, 'db') or user != self.db.journaltag: self.db = self.instance.open(user) # # Actions # def login_action(self): ''' Attempt to log a user in and set the cookie ''' # we need the username at a minimum if not self.form.has_key('__login_name'): self.error_message.append(_('Username required')) return self.user = self.form['__login_name'].value # re-open the database for real, using the user self.opendb(self.user) if self.form.has_key('__login_password'): password = self.form['__login_password'].value else: password = '' # make sure the user exists try: self.userid = self.db.user.lookup(self.user) except KeyError: name = self.user self.make_user_anonymous() self.error_message.append(_('No such user "%(name)s"')%locals()) return # and that the password is correct pw = self.db.user.get(self.userid, 'password') if password != pw: self.make_user_anonymous() self.error_message.append(_('Incorrect password')) return # set the session cookie self.set_cookie(self.user, password) def logout_action(self): ''' Make us really anonymous - nuke the cookie too ''' # log us out self.make_user_anonymous() # construct the logout cookie now = Cookie._getdate() path = '/'.join((self.env['SCRIPT_NAME'], self.env['INSTANCE_NAME'], '')) self.header(headers={'Set-Cookie': 'roundup_user_2=deleted; Max-Age=0; expires=%s; Path=%s;'%(now, path)}) # Let the user know what's going on self.ok_message.append(_('You are logged out')) def registerAction(self): '''Attempt to create a new user based on the contents of the form and then set the cookie. return 1 on successful login ''' # create the new user cl = self.db.user # parse the props from the form try: props = parsePropsFromForm(self.db, cl, self.form, self.nodeid) except (ValueError, KeyError), message: self.error_message.append(_('Error: ') + str(message)) return # make sure we're allowed to register if not self.registerPermission(props): raise Unauthorised, _("You do not have permission to register") # re-open the database as "admin" if self.user != 'admin': self.opendb('admin') # create the new user cl = self.db.user try: props = parsePropsFromForm(self.db, cl, self.form) props['roles'] = self.instance.NEW_WEB_USER_ROLES self.userid = cl.create(**props) self.db.commit() except ValueError, message: self.error_message.append(message) # log the new user in self.user = cl.get(self.userid, 'username') # re-open the database for real, using the user self.opendb(self.user) password = self.db.user.get(self.userid, 'password') self.set_cookie(self.user, password) # nice message self.ok_message.append(_('You are now registered, welcome!')) def registerPermission(self, props): ''' Determine whether the user has permission to register Base behaviour is to check the user has "Web Registration". ''' # registration isn't allowed to supply roles if props.has_key('roles'): return 0 if self.db.security.hasPermission('Web Registration', self.userid): return 1 return 0 def editItemAction(self): ''' Perform an edit of an item in the database. Some special form elements: :link=designator:property :multilink=designator:property The value specifies a node designator and the property on that node to add _this_ node to as a link or multilink. __note Create a message and attach it to the current node's "messages" property. __file Create a file and attach it to the current node's "files" property. Attach the file to the message created from the __note if it's supplied. ''' cl = self.db.classes[self.classname] # parse the props from the form try: props = parsePropsFromForm(self.db, cl, self.form, self.nodeid) except (ValueError, KeyError), message: self.error_message.append(_('Error: ') + str(message)) return # check permission if not self.editItemPermission(props): self.error_message.append( _('You do not have permission to edit %(classname)s'% self.__dict__)) return # perform the edit try: # make changes to the node props = self._changenode(props) # handle linked nodes self._post_editnode(self.nodeid) except (ValueError, KeyError), message: self.error_message.append(_('Error: ') + str(message)) return # commit now that all the tricky stuff is done self.db.commit() # and some nice feedback for the user if props: message = _('%(changes)s edited ok')%{'changes': ', '.join(props.keys())} elif self.form.has_key('__note') and self.form['__note'].value: message = _('note added') elif (self.form.has_key('__file') and self.form['__file'].filename): message = _('file added') else: message = _('nothing changed') # redirect to the item's edit page raise Redirect, '%s/%s%s?:ok_message=%s'%(self.base, self.classname, self.nodeid, urllib.quote(message)) def editItemPermission(self, props): ''' Determine whether the user has permission to edit this item. Base behaviour is to check the user can edit this class. If we're editing the "user" class, users are allowed to edit their own details. Unless it's the "roles" property, which requires the special Permission "Web Roles". ''' # if this is a user node and the user is editing their own node, then # we're OK has = self.db.security.hasPermission if self.classname == 'user': # reject if someone's trying to edit "roles" and doesn't have the # right permission. if props.has_key('roles') and not has('Web Roles', self.userid, 'user'): return 0 # if the item being edited is the current user, we're ok if self.nodeid == self.userid: return 1 if self.db.security.hasPermission('Edit', self.userid, self.classname): return 1 return 0 def newItemAction(self): ''' Add a new item to the database. This follows the same form as the editItemAction ''' cl = self.db.classes[self.classname] # parse the props from the form try: props = parsePropsFromForm(self.db, cl, self.form, self.nodeid) except (ValueError, KeyError), message: self.error_message.append(_('Error: ') + str(message)) return if not self.newItemPermission(props): self.error_message.append( _('You do not have permission to create %s' %self.classname)) # create a little extra message for anticipated :link / :multilink if self.form.has_key(':multilink'): link = self.form[':multilink'].value elif self.form.has_key(':link'): link = self.form[':multilink'].value else: link = None xtra = '' if link: designator, linkprop = link.split(':') xtra = ' for %s'%(designator, designator) try: # do the create nid = self._createnode(props) # handle linked nodes self._post_editnode(nid) # commit now that all the tricky stuff is done self.db.commit() # render the newly created item self.nodeid = nid # and some nice feedback for the user message = _('%(classname)s created ok')%self.__dict__ + xtra except (ValueError, KeyError), message: self.error_message.append(_('Error: ') + str(message)) return except: # oops self.db.rollback() s = StringIO.StringIO() traceback.print_exc(None, s) self.error_message.append('
    %s
    '%cgi.escape(s.getvalue())) return # redirect to the new item's page raise Redirect, '%s/%s%s?:ok_message=%s'%(self.base, self.classname, nid, urllib.quote(message)) def newItemPermission(self, props): ''' Determine whether the user has permission to create (edit) this item. Base behaviour is to check the user can edit this class. No additional property checks are made. Additionally, new user items may be created if the user has the "Web Registration" Permission. ''' has = self.db.security.hasPermission if self.classname == 'user' and has('Web Registration', self.userid, 'user'): return 1 if has('Edit', self.userid, self.classname): return 1 return 0 def editCSVAction(self): ''' Performs an edit of all of a class' items in one go. The "rows" CGI var defines the CSV-formatted entries for the class. New nodes are identified by the ID 'X' (or any other non-existent ID) and removed lines are retired. ''' # this is per-class only if not self.editCSVPermission(): self.error_message.append( _('You do not have permission to edit %s' %self.classname)) # get the CSV module try: import csv except ImportError: self.error_message.append(_( 'Sorry, you need the csv module to use this function.
    \n' 'Get it from: http://www.object-craft.com.au/projects/csv/')) return cl = self.db.classes[self.classname] idlessprops = cl.getprops(protected=0).keys() idlessprops.sort() props = ['id'] + idlessprops # do the edit rows = self.form['rows'].value.splitlines() p = csv.parser() found = {} line = 0 for row in rows[1:]: line += 1 values = p.parse(row) # not a complete row, keep going if not values: continue # skip property names header if values == props: continue # extract the nodeid nodeid, values = values[0], values[1:] found[nodeid] = 1 # confirm correct weight if len(idlessprops) != len(values): self.error_message.append( _('Not enough values on line %(line)s')%{'line':line}) return # extract the new values d = {} for name, value in zip(idlessprops, values): value = value.strip() # only add the property if it has a value if value: # if it's a multilink, split it if isinstance(cl.properties[name], hyperdb.Multilink): value = value.split(':') d[name] = value # perform the edit if cl.hasnode(nodeid): # edit existing cl.set(nodeid, **d) else: # new node found[cl.create(**d)] = 1 # retire the removed entries for nodeid in cl.list(): if not found.has_key(nodeid): cl.retire(nodeid) # all OK self.db.commit() self.ok_message.append(_('Items edited OK')) def editCSVPermission(self): ''' Determine whether the user has permission to edit this class. Base behaviour is to check the user can edit this class. ''' if not self.db.security.hasPermission('Edit', self.userid, self.classname): return 0 return 1 def searchAction(self): ''' Mangle some of the form variables. Set the form ":filter" variable based on the values of the filter variables - if they're set to anything other than "dontcare" then add them to :filter. Also handle the ":queryname" variable and save off the query to the user's query list. ''' # generic edit is per-class only if not self.searchPermission(): self.error_message.append( _('You do not have permission to search %s' %self.classname)) # add a faked :filter form variable for each filtering prop props = self.db.classes[self.classname].getprops() for key in self.form.keys(): if not props.has_key(key): continue if not self.form[key].value: continue self.form.value.append(cgi.MiniFieldStorage(':filter', key)) # handle saving the query params if self.form.has_key(':queryname'): queryname = self.form[':queryname'].value.strip() if queryname: # parse the environment and figure what the query _is_ req = HTMLRequest(self) url = req.indexargs_href('', {}) # handle editing an existing query try: qid = self.db.query.lookup(queryname) self.db.query.set(qid, klass=self.classname, url=url) except KeyError: # create a query qid = self.db.query.create(name=queryname, klass=self.classname, url=url) # and add it to the user's query multilink queries = self.db.user.get(self.userid, 'queries') queries.append(qid) self.db.user.set(self.userid, queries=queries) # commit the query change to the database self.db.commit() def searchPermission(self): ''' Determine whether the user has permission to search this class. Base behaviour is to check the user can view this class. ''' if not self.db.security.hasPermission('View', self.userid, self.classname): return 0 return 1 def XXXremove_action(self, dre=re.compile(r'([^\d]+)(\d+)')): # XXX I believe this could be handled by a regular edit action that # just sets the multilink... # XXX handle this ! target = self.index_arg(':target')[0] m = dre.match(target) if m: classname = m.group(1) nodeid = m.group(2) cl = self.db.getclass(classname) cl.retire(nodeid) # now take care of the reference parentref = self.index_arg(':multilink')[0] parent, prop = parentref.split(':') m = dre.match(parent) if m: self.classname = m.group(1) self.nodeid = m.group(2) cl = self.db.getclass(self.classname) value = cl.get(self.nodeid, prop) value.remove(nodeid) cl.set(self.nodeid, **{prop:value}) func = getattr(self, 'show%s'%self.classname) return func() else: raise NotFound, parent else: raise NotFound, target # # Utility methods for editing # def _changenode(self, props): ''' change the node based on the contents of the form ''' cl = self.db.classes[self.classname] # create the message message, files = self._handle_message() if message: props['messages'] = cl.get(self.nodeid, 'messages') + [message] if files: props['files'] = cl.get(self.nodeid, 'files') + files # make the changes return cl.set(self.nodeid, **props) def _createnode(self, props): ''' create a node based on the contents of the form ''' cl = self.db.classes[self.classname] # check for messages and files message, files = self._handle_message() if message: props['messages'] = [message] if files: props['files'] = files # create the node and return it's id return cl.create(**props) def _handle_message(self): ''' generate an edit message ''' # handle file attachments files = [] if self.form.has_key('__file'): file = self.form['__file'] if file.filename: filename = file.filename.split('\\')[-1] mime_type = mimetypes.guess_type(filename)[0] if not mime_type: mime_type = "application/octet-stream" # create the new file entry files.append(self.db.file.create(type=mime_type, name=filename, content=file.file.read())) # we don't want to do a message if none of the following is true... cn = self.classname cl = self.db.classes[self.classname] props = cl.getprops() note = None # in a nutshell, don't do anything if there's no note or there's no # NOSY if self.form.has_key('__note'): note = self.form['__note'].value.strip() if not note: return None, files if not props.has_key('messages'): return None, files if not isinstance(props['messages'], hyperdb.Multilink): return None, files if not props['messages'].classname == 'msg': return None, files if not (self.form.has_key('nosy') or note): return None, files # handle the note if '\n' in note: summary = re.split(r'\n\r?', note)[0] else: summary = note m = ['%s\n'%note] # handle the messageid # TODO: handle inreplyto messageid = "<%s.%s.%s@%s>"%(time.time(), random.random(), self.classname, self.instance.MAIL_DOMAIN) # now create the message, attaching the files content = '\n'.join(m) message_id = self.db.msg.create(author=self.userid, recipients=[], date=date.Date('.'), summary=summary, content=content, files=files, messageid=messageid) # update the messages property return message_id, files def _post_editnode(self, nid): '''Do the linking part of the node creation. If a form element has :link or :multilink appended to it, its value specifies a node designator and the property on that node to add _this_ node to as a link or multilink. This is typically used on, eg. the file upload page to indicated which issue to link the file to. TODO: I suspect that this and newfile will go away now that there's the ability to upload a file using the issue __file form element! ''' cn = self.classname cl = self.db.classes[cn] # link if necessary keys = self.form.keys() for key in keys: if key == ':multilink': value = self.form[key].value if type(value) != type([]): value = [value] for value in value: designator, property = value.split(':') link, nodeid = hyperdb.splitDesignator(designator) link = self.db.classes[link] # take a dupe of the list so we're not changing the cache value = link.get(nodeid, property)[:] value.append(nid) link.set(nodeid, **{property: value}) elif key == ':link': value = self.form[key].value if type(value) != type([]): value = [value] for value in value: designator, property = value.split(':') link, nodeid = hyperdb.splitDesignator(designator) link = self.db.classes[link] link.set(nodeid, **{property: nid}) def parsePropsFromForm(db, cl, form, nodeid=0, num_re=re.compile('^\d+$')): '''Pull properties for the given class out of the form. ''' props = {} keys = form.keys() for key in keys: if not cl.properties.has_key(key): continue proptype = cl.properties[key] if isinstance(proptype, hyperdb.String): value = form[key].value.strip() elif isinstance(proptype, hyperdb.Password): value = form[key].value.strip() if not value: # ignore empty password values continue value = password.Password(value) elif isinstance(proptype, hyperdb.Date): value = form[key].value.strip() if value: value = date.Date(form[key].value.strip()) else: value = None elif isinstance(proptype, hyperdb.Interval): value = form[key].value.strip() if value: value = date.Interval(form[key].value.strip()) else: value = None elif isinstance(proptype, hyperdb.Link): value = form[key].value.strip() # see if it's the "no selection" choice if value == '-1': value = None else: # handle key values link = cl.properties[key].classname if not num_re.match(value): try: value = db.classes[link].lookup(value) except KeyError: raise ValueError, _('property "%(propname)s": ' '%(value)s not a %(classname)s')%{'propname':key, 'value': value, 'classname': link} elif isinstance(proptype, hyperdb.Multilink): value = form[key] if not isinstance(value, type([])): value = [i.strip() for i in value.value.split(',')] else: value = [i.value.strip() for i in value] link = cl.properties[key].classname l = [] for entry in map(str, value): if entry == '': continue if not num_re.match(entry): try: entry = db.classes[link].lookup(entry) except KeyError: raise ValueError, _('property "%(propname)s": ' '"%(value)s" not an entry of %(classname)s')%{ 'propname':key, 'value': entry, 'classname': link} l.append(entry) l.sort() value = l elif isinstance(proptype, hyperdb.Boolean): value = form[key].value.strip() props[key] = value = value.lower() in ('yes', 'true', 'on', '1') elif isinstance(proptype, hyperdb.Number): value = form[key].value.strip() props[key] = value = int(value) # get the old value if nodeid: try: existing = cl.get(nodeid, key) except KeyError: # this might be a new property for which there is no existing # value if not cl.properties.has_key(key): raise # if changed, set it if value != existing: props[key] = value else: props[key] = value return props code-adcfdeac4e76/roundup/cgi/templating.py0000644000000000000000000013362307535310140017216 0ustar 00000000000000import sys, cgi, urllib, os, re, os.path, time, errno from roundup import hyperdb, date from roundup.i18n import _ try: import cPickle as pickle except ImportError: import pickle try: import cStringIO as StringIO except ImportError: import StringIO try: import StructuredText except ImportError: StructuredText = None # Make sure these modules are loaded # I need these to run PageTemplates outside of Zope :( # If we're running in a Zope environment, these modules will be loaded # already... if not sys.modules.has_key('zLOG'): import zLOG sys.modules['zLOG'] = zLOG if not sys.modules.has_key('MultiMapping'): import MultiMapping sys.modules['MultiMapping'] = MultiMapping if not sys.modules.has_key('ComputedAttribute'): import ComputedAttribute sys.modules['ComputedAttribute'] = ComputedAttribute if not sys.modules.has_key('ExtensionClass'): import ExtensionClass sys.modules['ExtensionClass'] = ExtensionClass if not sys.modules.has_key('Acquisition'): import Acquisition sys.modules['Acquisition'] = Acquisition # now it's safe to import PageTemplates, TAL and ZTUtils from PageTemplates import PageTemplate from PageTemplates.Expressions import getEngine from TAL.TALInterpreter import TALInterpreter import ZTUtils # XXX WAH pagetemplates aren't pickleable :( #def getTemplate(dir, name, classname=None, request=None): # ''' Interface to get a template, possibly loading a compiled template. # ''' # # source # src = os.path.join(dir, name) # # # see if we can get a compile from the template"c" directory (most # # likely is "htmlc" # split = list(os.path.split(dir)) # split[-1] = split[-1] + 'c' # cdir = os.path.join(*split) # split.append(name) # cpl = os.path.join(*split) # # # ok, now see if the source is newer than the compiled (or if the # # compiled even exists) # MTIME = os.path.stat.ST_MTIME # if (not os.path.exists(cpl) or os.stat(cpl)[MTIME] < os.stat(src)[MTIME]): # # nope, we need to compile # pt = RoundupPageTemplate() # pt.write(open(src).read()) # pt.id = name # # # save off the compiled template # if not os.path.exists(cdir): # os.makedirs(cdir) # f = open(cpl, 'wb') # pickle.dump(pt, f) # f.close() # else: # # yay, use the compiled template # f = open(cpl, 'rb') # pt = pickle.load(f) # return pt templates = {} def getTemplate(dir, name, extension, classname=None, request=None): ''' Interface to get a template, possibly loading a compiled template. "name" and "extension" indicate the template we're after, which in most cases will be "name.extension". If "extension" is None, then we look for a template just called "name" with no extension. If the file "name.extension" doesn't exist, we look for "_generic.extension" as a fallback. ''' # default the name to "home" if name is None: name = 'home' # find the source, figure the time it was last modified if extension: filename = '%s.%s'%(name, extension) else: filename = name src = os.path.join(dir, filename) try: stime = os.stat(src)[os.path.stat.ST_MTIME] except os.error, error: if error.errno != errno.ENOENT or not extension: raise # try for a generic template filename = '_generic.%s'%extension src = os.path.join(dir, filename) stime = os.stat(src)[os.path.stat.ST_MTIME] key = (dir, filename) if templates.has_key(key) and stime < templates[key].mtime: # compiled template is up to date return templates[key] # compile the template templates[key] = pt = RoundupPageTemplate() pt.write(open(src).read()) pt.id = name pt.mtime = time.time() return pt class RoundupPageTemplate(PageTemplate.PageTemplate): ''' A Roundup-specific PageTemplate. Interrogate the client to set up the various template variables to be available: *class* The current class of node being displayed as an HTMLClass instance. *item* The current node from the database, if we're viewing a specific node, as an HTMLItem instance. If it doesn't exist, then we're on a new item page. (*classname*) this is one of two things: 1. the *item* is also available under its classname, so a *user* node would also be available under the name *user*. This is also an HTMLItem instance. 2. if there's no *item* then the current class is available through this name, thus "user/name" and "user/name/menu" will still work - the latter will pull information from the form if it can. *form* The current CGI form information as a mapping of form argument name to value *request* Includes information about the current request, including: - the url - the current index information (``filterspec``, ``filter`` args, ``properties``, etc) parsed out of the form. - methods for easy filterspec link generation - *user*, the current user node as an HTMLItem instance *instance* The current instance *db* The current database, through which db.config may be reached. Maybe also: *modules* python modules made available (XXX: not sure what's actually in there tho) ''' def getContext(self, client, classname, request): c = { 'klass': HTMLClass(client, classname), 'options': {}, 'nothing': None, 'request': request, 'content': client.content, 'db': HTMLDatabase(client), 'instance': client.instance } # add in the item if there is one if client.nodeid: c['item'] = HTMLItem(client.db, classname, client.nodeid) c[classname] = c['item'] else: c[classname] = c['klass'] return c def render(self, client, classname, request, **options): """Render this Page Template""" if not self._v_cooked: self._cook() __traceback_supplement__ = (PageTemplate.PageTemplateTracebackSupplement, self) if self._v_errors: raise PTRuntimeError, 'Page Template %s has errors.' % self.id # figure the context classname = classname or client.classname request = request or HTMLRequest(client) c = self.getContext(client, classname, request) c.update({'options': options}) # and go output = StringIO.StringIO() TALInterpreter(self._v_program, self._v_macros, getEngine().getContext(c), output, tal=1, strictinsert=0)() return output.getvalue() class HTMLDatabase: ''' Return HTMLClasses for valid class fetches ''' def __init__(self, client): self.client = client self.config = client.db.config def __getattr__(self, attr): try: self.client.db.getclass(attr) except KeyError: raise AttributeError, attr return HTMLClass(self.client, attr) def classes(self): l = self.client.db.classes.keys() l.sort() return [HTMLClass(self.client, cn) for cn in l] class HTMLClass: ''' Accesses through a class (either through *class* or *db.*) ''' def __init__(self, client, classname): self.client = client self.db = client.db self.classname = classname if classname is not None: self.klass = self.db.getclass(self.classname) self.props = self.klass.getprops() def __repr__(self): return ''%(id(self), self.classname) def __getitem__(self, item): ''' return an HTMLItem instance''' #print 'getitem', (self, attr) if item == 'creator': return HTMLUser(self.client) if not self.props.has_key(item): raise KeyError, item prop = self.props[item] # look up the correct HTMLProperty class for klass, htmlklass in propclasses: if isinstance(prop, hyperdb.Multilink): value = [] else: value = None if isinstance(prop, klass): return htmlklass(self.db, '', prop, item, value) # no good raise KeyError, item def __getattr__(self, attr): ''' convenience access ''' try: return self[attr] except KeyError: raise AttributeError, attr def properties(self): ''' Return HTMLProperty for all props ''' l = [] for name, prop in self.props.items(): for klass, htmlklass in propclasses: if isinstance(prop, hyperdb.Multilink): value = [] else: value = None if isinstance(prop, klass): l.append(htmlklass(self.db, '', prop, name, value)) return l def list(self): l = [HTMLItem(self.db, self.classname, x) for x in self.klass.list()] return l def csv(self): ''' Return the items of this class as a chunk of CSV text. ''' # get the CSV module try: import csv except ImportError: return 'Sorry, you need the csv module to use this function.\n'\ 'Get it from: http://www.object-craft.com.au/projects/csv/' props = self.propnames() p = csv.parser() s = StringIO.StringIO() s.write(p.join(props) + '\n') for nodeid in self.klass.list(): l = [] for name in props: value = self.klass.get(nodeid, name) if value is None: l.append('') elif isinstance(value, type([])): l.append(':'.join(map(str, value))) else: l.append(str(self.klass.get(nodeid, name))) s.write(p.join(l) + '\n') return s.getvalue() def propnames(self): ''' Return the list of the names of the properties of this class. ''' idlessprops = self.klass.getprops(protected=0).keys() idlessprops.sort() return ['id'] + idlessprops def filter(self, request=None): ''' Return a list of items from this class, filtered and sorted by the current requested filterspec/filter/sort/group args ''' if request is not None: filterspec = request.filterspec sort = request.sort group = request.group l = [HTMLItem(self.db, self.classname, x) for x in self.klass.filter(None, filterspec, sort, group)] return l def classhelp(self, properties, label='?', width='400', height='400'): '''pop up a javascript window with class help This generates a link to a popup window which displays the properties indicated by "properties" of the class named by "classname". The "properties" should be a comma-separated list (eg. 'id,name,description'). You may optionally override the label displayed, the width and height. The popup window will be resizable and scrollable. ''' return '(%s)'%(self.classname, properties, width, height, label) def submit(self, label="Submit New Entry"): ''' Generate a submit button (and action hidden element) ''' return ' \n'\ ' '%label def history(self): return 'New node - no history' def renderWith(self, name, **kwargs): ''' Render this class with the given template. ''' # create a new request and override the specified args req = HTMLRequest(self.client) req.classname = self.classname req.update(kwargs) # new template, using the specified classname and request pt = getTemplate(self.db.config.TEMPLATES, self.classname, name) # XXX handle PT rendering errors here nicely try: # use our fabricated request return pt.render(self.client, self.classname, req) except PageTemplate.PTRuntimeError, message: return '%s
      %s
    '%(message, cgi.escape('
  • '.join(pt._v_errors))) class HTMLItem: ''' Accesses through an *item* ''' def __init__(self, db, classname, nodeid): self.db = db self.classname = classname self.nodeid = nodeid self.klass = self.db.getclass(classname) self.props = self.klass.getprops() def __repr__(self): return ''%(id(self), self.classname, self.nodeid) def __getitem__(self, item): ''' return an HTMLItem instance''' if item == 'id': return self.nodeid if not self.props.has_key(item): raise KeyError, item prop = self.props[item] # get the value, handling missing values 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.db, self.nodeid, prop, item, value) raise KeyErorr, item def __getattr__(self, attr): ''' convenience access to properties ''' try: return self[attr] except KeyError: raise AttributeError, attr def submit(self, label="Submit Changes"): ''' Generate a submit button (and action hidden element) ''' return ' \n'\ ' '%label # XXX this probably should just return the history items, not the HTML def history(self, direction='descending'): l = ['', '', _(''), _(''), _(''), _(''), ''] comments = {} history = self.klass.history(self.nodeid) history.sort() if direction == 'descending': history.reverse() for id, evt_date, user, action, args in history: date_s = str(evt_date).replace("."," ") arg_s = '' if action == 'link' and type(args) == type(()): if len(args) == 3: linkcl, linkid, key = args arg_s += '%s%s %s'%(linkcl, linkid, linkcl, linkid, key) else: arg_s = str(args) elif action == 'unlink' and type(args) == type(()): if len(args) == 3: linkcl, linkid, key = args arg_s += '%s%s %s'%(linkcl, linkid, linkcl, linkid, key) else: arg_s = str(args) elif type(args) == type({}): cell = [] for k in args.keys(): # try to get the relevant property and treat it # specially try: prop = self.props[k] except KeyError: prop = None if prop is not None: if args[k] and (isinstance(prop, hyperdb.Multilink) or isinstance(prop, hyperdb.Link)): # figure what the link class is classname = prop.classname try: linkcl = self.db.getclass(classname) except KeyError: labelprop = None comments[classname] = _('''The linked class %(classname)s no longer exists''')%locals() labelprop = linkcl.labelprop(1) hrefable = os.path.exists( os.path.join(self.db.config.TEMPLATES, classname+'.item')) if isinstance(prop, hyperdb.Multilink) and \ len(args[k]) > 0: ml = [] for linkid in args[k]: if isinstance(linkid, type(())): sublabel = linkid[0] + ' ' linkids = linkid[1] else: sublabel = '' linkids = [linkid] subml = [] for linkid in linkids: label = classname + linkid # if we have a label property, try to use it # TODO: test for node existence even when # there's no labelprop! try: if labelprop is not None: label = linkcl.get(linkid, labelprop) except IndexError: comments['no_link'] = _('''The linked node no longer exists''') subml.append('%s'%label) else: if hrefable: subml.append('%s'%( classname, linkid, label)) ml.append(sublabel + ', '.join(subml)) cell.append('%s:\n %s'%(k, ', '.join(ml))) elif isinstance(prop, hyperdb.Link) and args[k]: label = classname + args[k] # if we have a label property, try to use it # TODO: test for node existence even when # there's no labelprop! if labelprop is not None: try: label = linkcl.get(args[k], labelprop) except IndexError: comments['no_link'] = _('''The linked node no longer exists''') cell.append(' %s,\n'%label) # "flag" this is done .... euwww label = None if label is not None: if hrefable: cell.append('%s: %s\n'%(k, classname, args[k], label)) else: cell.append('%s: %s' % (k,label)) elif isinstance(prop, hyperdb.Date) and args[k]: d = date.Date(args[k]) cell.append('%s: %s'%(k, str(d))) elif isinstance(prop, hyperdb.Interval) and args[k]: d = date.Interval(args[k]) cell.append('%s: %s'%(k, str(d))) elif isinstance(prop, hyperdb.String) and args[k]: cell.append('%s: %s'%(k, cgi.escape(args[k]))) elif not args[k]: cell.append('%s: (no value)\n'%k) else: cell.append('%s: %s\n'%(k, str(args[k]))) else: # property no longer exists comments['no_exist'] = _('''The indicated property no longer exists''') cell.append('%s: %s\n'%(k, str(args[k]))) arg_s = '
    '.join(cell) else: # unkown event!! comments['unknown'] = _('''This event is not handled by the history display!''') arg_s = '' + str(args) + '' date_s = date_s.replace(' ', ' ') l.append('' ''%(date_s, user, action, arg_s)) if comments: l.append(_('')) for entry in comments.values(): l.append(''%entry) l.append('
    DateUserActionArgs
    %s%s%s%s
    Note:
    %s
    ') return '\n'.join(l) def remove(self): # XXX do what? return '' class HTMLUser(HTMLItem): ''' Accesses through the *user* (a special case of item) ''' def __init__(self, client): HTMLItem.__init__(self, client.db, 'user', client.userid) self.default_classname = client.classname self.userid = client.userid # used for security checks self.security = client.db.security _marker = [] def hasPermission(self, role, classname=_marker): ''' Determine if the user has the Role. 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.userid, classname) class HTMLProperty: ''' String, Number, Date, Interval HTMLProperty A wrapper object which may be stringified for the plain() behaviour. ''' def __init__(self, db, nodeid, prop, name, value): self.db = db self.nodeid = nodeid self.prop = prop self.name = name self.value = value def __repr__(self): return ''%(id(self), self.name, self.prop, self.value) def __str__(self): return self.plain() def __cmp__(self, other): if isinstance(other, HTMLProperty): return cmp(self.value, other.value) return cmp(self.value, other) class StringHTMLProperty(HTMLProperty): def plain(self, escape=0): if self.value is None: return '' if escape: return cgi.escape(str(self.value)) return str(self.value) def stext(self, escape=0): s = self.plain(escape=escape) if not StructuredText: return s return StructuredText(s,level=1,header=0) def field(self, size = 30): if self.value is None: value = '' else: value = cgi.escape(str(self.value)) value = '"'.join(value.split('"')) return ''%(self.name, value, size) def multiline(self, escape=0, rows=5, cols=40): if self.value is None: value = '' else: value = cgi.escape(str(self.value)) value = '"'.join(value.split('"')) return ''%( self.name, rows, cols, value) def email(self, escape=1): ''' fudge email ''' if self.value is None: value = '' else: value = str(self.value) value = value.replace('@', ' at ') value = value.replace('.', ' ') if escape: value = cgi.escape(value) return value class PasswordHTMLProperty(HTMLProperty): def plain(self): if self.value is None: return '' return _('*encrypted*') def field(self, size = 30): return ''%(self.name, size) class NumberHTMLProperty(HTMLProperty): def plain(self): return str(self.value) def field(self, size = 30): if self.value is None: value = '' else: value = cgi.escape(str(self.value)) value = '"'.join(value.split('"')) return ''%(self.name, value, size) class BooleanHTMLProperty(HTMLProperty): def plain(self): if self.value is None: return '' return self.value and "Yes" or "No" def field(self): checked = self.value and "checked" or "" s = 'Yes'%(self.name, checked) if checked: checked = "" else: checked = "checked" s += 'No'%(self.name, checked) return s class DateHTMLProperty(HTMLProperty): def plain(self): if self.value is None: return '' return str(self.value) def field(self, size = 30): if self.value is None: value = '' else: value = cgi.escape(str(self.value)) value = '"'.join(value.split('"')) return ''%(self.name, value, size) def reldate(self, pretty=1): if not self.value: return '' # figure the interval interval = date.Date('.') - self.value if pretty: return interval.pretty() return str(interval) class IntervalHTMLProperty(HTMLProperty): def plain(self): if self.value is None: return '' return str(self.value) def pretty(self): return self.value.pretty() def field(self, size = 30): if self.value is None: value = '' else: value = cgi.escape(str(self.value)) value = '"'.join(value.split('"')) return ''%(self.name, value, size) class LinkHTMLProperty(HTMLProperty): ''' Link HTMLProperty Include the above as well as being able to access the class information. Stringifying the object itself results in the value from the item being displayed. Accessing attributes of this object result in the appropriate entry from the class being queried for the property accessed (so item/assignedto/name would look up the user entry identified by the assignedto property on item, and then the name property of that user) ''' def __getattr__(self, attr): ''' return a new HTMLItem ''' #print 'getattr', (self, attr, self.value) if not self.value: raise AttributeError, "Can't access missing value" i = HTMLItem(self.db, self.prop.classname, self.value) return getattr(i, attr) def plain(self, escape=0): if self.value is None: return _('[unselected]') linkcl = self.db.classes[self.prop.classname] k = linkcl.labelprop(1) value = str(linkcl.get(self.value, k)) if escape: value = cgi.escape(value) return value # XXX most of the stuff from here down is of dubious utility - it's easy # enough to do in the template by hand (and in some cases, it's shorter # and clearer... def field(self): linkcl = self.db.getclass(self.prop.classname) if linkcl.getprops().has_key('order'): sort_on = 'order' else: sort_on = linkcl.labelprop() options = linkcl.filter(None, {}, [sort_on], []) # TODO: make this a field display, not a menu one! l = ['') return '\n'.join(l) def download(self, showid=0): linkname = self.prop.classname linkcl = self.db.getclass(linkname) k = linkcl.labelprop(1) linkvalue = cgi.escape(str(linkcl.get(self.value, k))) if showid: label = value title = ' title="%s"'%linkvalue # note ... this should be urllib.quote(linkcl.get(value, k)) else: label = linkvalue title = '' return '%s'%(linkname, self.value, linkvalue, title, label) def menu(self, size=None, height=None, showid=0, additional=[], **conditions): value = self.value # sort function sortfunc = make_sort_function(self.db, self.prop.classname) # force the value to be a single choice if isinstance(value, type('')): value = value[0] linkcl = self.db.getclass(self.prop.classname) l = ['') return '\n'.join(l) # def checklist(self, ...) class MultilinkHTMLProperty(HTMLProperty): ''' Multilink HTMLProperty Also be iterable, returning a wrapper object like the Link case for each entry in the multilink. ''' def __len__(self): ''' length of the multilink ''' return len(self.value) def __getattr__(self, attr): ''' no extended attribute accesses make sense here ''' raise AttributeError, attr def __getitem__(self, num): ''' iterate and return a new HTMLItem ''' #print 'getitem', (self, num) value = self.value[num] return HTMLItem(self.db, self.prop.classname, value) def reverse(self): ''' return the list in reverse order ''' l = self.value[:] l.reverse() return [HTMLItem(self.db, self.prop.classname, value) for value in l] def plain(self, escape=0): linkcl = self.db.classes[self.prop.classname] k = linkcl.labelprop(1) labels = [] for v in self.value: labels.append(linkcl.get(v, k)) value = ', '.join(labels) if escape: value = cgi.escape(value) return value # XXX most of the stuff from here down is of dubious utility - it's easy # enough to do in the template by hand (and in some cases, it's shorter # and clearer... def field(self, size=30, showid=0): sortfunc = make_sort_function(self.db, self.prop.classname) linkcl = self.db.getclass(self.prop.classname) value = self.value[:] if value: value.sort(sortfunc) # map the id to the label property if not showid: k = linkcl.labelprop(1) value = [linkcl.get(v, k) for v in value] value = cgi.escape(','.join(value)) return ''%(self.name, size, value) def menu(self, size=None, height=None, showid=0, additional=[], **conditions): value = self.value # sort function sortfunc = make_sort_function(self.db, self.prop.classname) linkcl = self.db.getclass(self.prop.classname) if linkcl.getprops().has_key('order'): sort_on = ('+', 'order') else: sort_on = ('+', linkcl.labelprop()) options = linkcl.filter(None, conditions, sort_on, (None,None)) height = height or min(len(options), 7) l = ['') return '\n'.join(l) # set the propclasses for HTMLItem propclasses = ( (hyperdb.String, StringHTMLProperty), (hyperdb.Number, NumberHTMLProperty), (hyperdb.Boolean, BooleanHTMLProperty), (hyperdb.Date, DateHTMLProperty), (hyperdb.Interval, IntervalHTMLProperty), (hyperdb.Password, PasswordHTMLProperty), (hyperdb.Link, LinkHTMLProperty), (hyperdb.Multilink, MultilinkHTMLProperty), ) def make_sort_function(db, classname): '''Make a sort function for a given class ''' linkcl = db.getclass(classname) if linkcl.getprops().has_key('order'): sort_on = 'order' else: sort_on = linkcl.labelprop() def sortfunc(a, b, linkcl=linkcl, sort_on=sort_on): return cmp(linkcl.get(a, sort_on), linkcl.get(b, sort_on)) return sortfunc def handleListCGIValue(value): ''' Value is either a single item or a list of items. Each item has a .value that we're actually interested in. ''' if isinstance(value, type([])): return [value.value for value in value] else: return value.value.split(',') class ShowDict: ''' A convenience access to the :columns index parameters ''' def __init__(self, columns): self.columns = {} for col in columns: self.columns[col] = 1 def __getitem__(self, name): return self.columns.has_key(name) class HTMLRequest: ''' The *request*, holding the CGI form and environment. "form" the CGI form as a cgi.FieldStorage "env" the CGI environment variables "url" the current URL path for this request "base" the base URL for this instance "user" a HTMLUser instance for this user "classname" the current classname (possibly None) "template" the current template (suffix, also possibly None) Index args: "columns" dictionary of the columns to display in an index page "show" a convenience access to columns - request/show/colname will be true if the columns should be displayed, false otherwise "sort" index sort column (direction, column name) "group" index grouping property (direction, column name) "filter" properties to filter the index on "filterspec" values to filter the index on "search_text" text to perform a full-text search on for an index ''' def __init__(self, client): self.client = client # easier access vars self.form = client.form self.env = client.env self.base = client.base self.url = client.url self.user = HTMLUser(client) # store the current class name and action self.classname = client.classname self.template = client.template # extract the index display information from the form self.columns = [] if self.form.has_key(':columns'): self.columns = handleListCGIValue(self.form[':columns']) 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]) # 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]) # filtering self.filter = [] if self.form.has_key(':filter'): self.filter = handleListCGIValue(self.form[':filter']) self.filterspec = {} if self.classname is not None: props = self.client.db.getclass(self.classname).getprops() for name in self.filter: if self.form.has_key(name): prop = props[name] fv = self.form[name] if (isinstance(prop, hyperdb.Link) or isinstance(prop, hyperdb.Multilink)): self.filterspec[name] = handleListCGIValue(fv) else: self.filterspec[name] = fv.value # full-text search argument self.search_text = None if self.form.has_key(':search_text'): self.search_text = self.form[':search_text'].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 def update(self, kwargs): self.__dict__.update(kwargs) if kwargs.has_key('columns'): self.show = ShowDict(self.columns) def __str__(self): d = {} d.update(self.__dict__) f = '' for k in self.form.keys(): f += '\n %r=%r'%(k,handleListCGIValue(self.form[k])) d['form'] = f e = '' for k,v in self.env.items(): e += '\n %r=%r'%(k, v) d['env'] = e return ''' form: %(form)s url: %(url)r base: %(base)r classname: %(classname)r template: %(template)r columns: %(columns)r sort: %(sort)r group: %(group)r filter: %(filter)r search_text: %(search_text)r pagesize: %(pagesize)r startwith: %(startwith)r env: %(env)s '''%d def indexargs_form(self, columns=1, sort=1, group=1, filter=1, filterspec=1): ''' return the current index args as form elements ''' l = [] s = '' if columns and self.columns: l.append(s%(':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)) 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)) if filter and self.filter: l.append(s%(':filter', ','.join(self.filter))) if filterspec: for k,v in self.filterspec.items(): l.append(s%(k, ','.join(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)) return '\n'.join(l) def indexargs_href(self, url, args): ''' embed the current index args in a URL ''' 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'): 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'): 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))) for k,v in self.filterspec.items(): if not args.has_key(k): l.append('%s=%s'%(k, ','.join(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)) def base_javascript(self): return ''' '''%self.base def batch(self): ''' Return a batch object for results from the "current search" ''' filterspec = self.filterspec sort = self.sort group = self.group # get the list of ids we're batching over klass = self.client.db.getclass(self.classname) if self.search_text: matches = self.client.db.indexer.search( re.findall(r'\b\w{2,25}\b', self.search_text), klass) else: matches = None l = klass.filter(matches, filterspec, sort, group) # return the batch object return Batch(self.client, self.classname, l, self.pagesize, self.startwith) # extend the standard ZTUtils Batch object to remove dependency on # Acquisition and add a couple of useful methods class Batch(ZTUtils.Batch): def __init__(self, client, classname, l, size, start, end=0, orphan=0, overlap=0): self.client = client self.classname = classname self.last_index = self.last_item = None self.current_item = None ZTUtils.Batch.__init__(self, l, size, start, end, orphan, overlap) # overwrite so we can late-instantiate the HTMLItem instance def __getitem__(self, index): if index < 0: if index + self.end < self.first: raise IndexError, index return self._sequence[index + self.end] if index >= self.length: raise IndexError, index # move the last_item along - but only if the fetched index changes # (for some reason, index 0 is fetched twice) if index != self.last_index: self.last_item = self.current_item self.last_index = index # wrap the return in an HTMLItem self.current_item = HTMLItem(self.client.db, self.classname, self._sequence[index+self.first]) return self.current_item def propchanged(self, property): ''' Detect if the property marked as being the group property changed in the last iteration fetch ''' if (self.last_item is None or self.last_item[property] != self.current_item[property]): return 1 return 0 # override these 'cos we don't have access to acquisition def previous(self): if self.start == 1: return None return Batch(self.client, self.classname, self._sequence, self._size, self.first - self._size + self.overlap, 0, self.orphan, self.overlap) def next(self): try: self._sequence[self.end] except IndexError: return None return Batch(self.client, self.classname, self._sequence, self._size, self.end - self.overlap, 0, self.orphan, self.overlap) def length(self): self.sequence_length = l = len(self._sequence) return l code-adcfdeac4e76/roundup/cgi/zLOG.py0000644000000000000000000000003707535310140015655 0ustar 00000000000000def LOG(*args, **kw): pass