CPSSchemas-0.19.0/0040755000374200017510000000000010030542434012040 5ustar benzopeCPSSchemas-0.19.0/Extensions/0040755000374200017510000000000010030542433014176 5ustar benzopeCPSSchemas-0.19.0/Extensions/__init__.py0100444000374200017510000000007710030542431016304 0ustar benzope# Placeholder make this a python module. # This allows import. CPSSchemas-0.19.0/Extensions/convert_metadata.py0100444000374200017510000000411110030542431020056 0ustar benzope# (C) Copyright 2004 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: convert_metadata.py,v 1.1 2004/02/06 16:41:29 guillaum Exp $ """ Convert some metadata from old storage adapter to the new one. This does conversion of Coverage, Source and Relation. """ from zLOG import LOG, DEBUG from AccessControl import getSecurityManager from AccessControl import Unauthorized from Products.CMFCore.utils import getToolByName conversions = (('Coverage', 'coverage'), ('Source', 'source'), ('Relation', 'relation'), ) def convert_metadata(self): if not getSecurityManager().getUser().has_role('Manager'): raise Unauthorized('Must be a Manager') context = self repotool = getToolByName(self, 'portal_repository') log = [] for id, ob in repotool.objectItems(): # Unghostify object to have its dict loaded. ob.getId() done = [] for oldattr, newattr in conversions: if ob.__dict__.has_key(oldattr): v = getattr(ob, oldattr) delattr(ob, oldattr) setattr(ob, newattr, v) done.append(oldattr) if done: msg = '%s (%s): %s' % (id, ob.title_or_id(), ' '.join(done)) LOG('convert_metadata', DEBUG, msg) log.append(msg) return ('Done (%d conversions).\n%s' % (len(log), '\n'.join(log))) CPSSchemas-0.19.0/Extensions/install.py0100444000374200017510000001065710030542431016220 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: install.py,v 1.36 2004/03/16 15:35:00 regebro Exp $ import os from zLOG import LOG, INFO, DEBUG # XXX I think that as long as you don't run any CPSSpecific methods, # this should still work under pure CMF. This needs to be tested though. from Products.CPSInstaller.CPSInstaller import CPSInstaller class CPSSchemasInstaller(CPSInstaller): def installPortalTransforms(self): self.log("Verifying Portal Transforms tool") if self.portalHas('portal_transforms'): pt = self.portal.portal_transforms if pt.meta_type == 'Portal Transforms': self.logOK() else: self.portal.manage_delObjects(['portal_transforms']) if not self.portalHas('portal_transforms'): self.runExternalUpdater('portal_transforms_installer', 'Portal Transforms Installer', 'PortalTransforms', 'Install', 'install') self.log("Adding additional mime types") mimetypesRegistry = self.portal.mimetypes_registry for extension, mimetype in ( ('sxw', 'application/vnd.sun.xml.writer'), ('stw', 'application/vnd.sun.xml.writer.template'), ('sxg', 'application/vnd.sun.xml.writer.global'), ('sxc', 'application/vnd.sun.xml.calc'), ('stc', 'application/vnd.sun.xml.calc.template'), ('sxi', 'application/vnd.sun.xml.impress'), ('sti', 'application/vnd.sun.xml.impress.template'), ('sxd', 'application/vnd.sun.xml.draw'), ('std', 'application/vnd.sun.xml.draw.template'), ('sxm', 'application/vnd.sun.xml.math')): if not mimetypesRegistry.extensions.has_key(extension): mimetypesRegistry.manage_addMimeType(mimetype, [mimetype], [extension], '', 1) else: self.log("We already have a registration for " "extension '%s'" % extension) self.log(" done") def install(self): installer = CPSSchemasInstaller(self, 'CPSSchemas') installer.log("Starting CPSSchemas install") # skins skins = { 'cps_schemas': 'Products/CPSSchemas/skins/cps_schemas', 'cps_jscalendar': 'Products/CPSSchemas/skins/cps_jscalendar', } installer.verifySkins(skins) # Tools installer.verifyTool('portal_schemas', 'CPSSchemas', 'CPS Schemas Tool') installer.verifyTool('portal_widget_types', 'CPSSchemas', 'CPS Widget Types Tool') installer.verifyTool('portal_layouts', 'CPSSchemas', 'CPS Layouts Tool') installer.verifyTool('portal_vocabularies', 'CPSSchemas', 'CPS Vocabularies Tool') # portal_transforms installer.installPortalTransforms() # Old stuff (UPGRADES) if installer.portalHas('portal_widgets'): installer.portal.manage_delObjects('portal_widgets') installer.log(" Deleting old portal_widgets") # importing .po files # Non CPS installation may not have Localizer. if installer.portalHas('Localizer'): installer.setupTranslations() installer.log("") installer.log("### Epoz Installer") installer.runExternalUpdater('epoz_installer', 'Epoz Installer', 'Epoz','Install', 'install') installer.log("### End of Epoz install") installer.log("") installer.finalize() installer.log("End of specific CPSSchemas install") return installer.logResult() CPSSchemas-0.19.0/BasicFields.py0100444000374200017510000001675010030542431014563 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: BasicFields.py,v 1.42 2004/03/15 20:41:28 fermigier Exp $ """BasicFields Definition of standard field types. """ from zLOG import LOG, DEBUG from types import IntType, StringType, ListType, FloatType, LongType from Globals import InitializeClass from DateTime.DateTime import DateTime from OFS.Image import cookId, File, Image from Products.CMFCore.Expression import Expression from Products.CPSSchemas.Field import CPSField, FieldRegistry from Products.CPSSchemas.FileUtils import convertFileToHtml from Products.CPSSchemas.FileUtils import convertFileToText def _isinstance(ob, cls): try: return isinstance(ob, cls) except TypeError: # In python 2.1 isinstance() raises TypeError # instead of returning 0 for ExtensionClasses. return 0 class ValidationError(ValueError): pass class CPSIntField(CPSField): """Integer field.""" meta_type = "CPS Int Field" default_expr = 'python:0' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if isinstance(value, IntType): return value raise ValidationError('Not an integer: %s' % repr(value)) InitializeClass(CPSIntField) class CPSLongField(CPSField): """Long field.""" meta_type = "CPS Long Field" default_expr = 'python:0L' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if isinstance(value, LongType): return value raise ValidationError('Not an long integer: %s' % repr(value)) InitializeClass(CPSLongField) class CPSFloatField(CPSField): """Float field.""" meta_type = "CPS Float Field" default_expr = 'python:0.0' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if isinstance(value, FloatType): return value raise ValidationError('Not an real number: %s' % repr(value)) InitializeClass(CPSFloatField) class CPSStringField(CPSField): """String field.""" meta_type = "CPS String Field" default_expr = 'string:' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if isinstance(value, StringType): return value raise ValidationError('Not a string: %s' % repr(value)) InitializeClass(CPSStringField) class CPSPasswordField(CPSField): """Password field.""" meta_type = "CPS Password Field" default_expr = 'string:' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if isinstance(value, StringType): return value raise ValidationError('Not a string: %s' % repr(value)) InitializeClass(CPSPasswordField) class CPSStringListField(CPSField): """String List field.""" meta_type = "CPS String List Field" default_expr = 'python:[]' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if isinstance(value, ListType): ok = 1 for v in value: # XXX Deal with Unicode. if not isinstance(v, StringType): ok = 0 break if ok: return value raise ValidationError('Not a string list: %s' % repr(value)) InitializeClass(CPSStringListField) class CPSDateTimeField(CPSField): """DateTime field.""" meta_type = "CPS DateTime Field" default_expr = 'nothing' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if not value: return None if isinstance(value, DateTime): return value raise ValidationError('Not a datetime: %s' % repr(value)) InitializeClass(CPSDateTimeField) class CPSFileField(CPSField): """File field.""" meta_type = "CPS File Field" default_expr = 'nothing' default_expr_c = Expression(default_expr) _properties = CPSField._properties + ( {'id': 'suffix_text', 'type': 'string', 'mode': 'w', 'label': 'Suffix for field containing Text conversion'}, {'id': 'suffix_html', 'type': 'string', 'mode': 'w', 'label': 'Suffix for field containing HTML conversion'}, ) suffix_text = '' suffix_html = '' def _getDependantFieldId(self, schemas, suffix): """Get a dependant field id described by the suffix.""" if not suffix: return None id = self.getFieldId() + suffix for schema in schemas: if schema.has_key(id): return id return None def computeDependantFields(self, schemas, data, context=None): """Compute dependant fields.""" field_id = self.getFieldId() file = data[field_id] # May be None. text_field_id = self._getDependantFieldId(schemas, self.suffix_text) if text_field_id is not None: data[text_field_id] = convertFileToText(file, context=context) html_field_id = self._getDependantFieldId(schemas, self.suffix_html) if html_field_id is not None: html_string = convertFileToHtml(file, context=context) if html_string is not None: fileid = cookId('', '', file)[0] if '.' in fileid: fileid = fileid[:fileid.rfind('.')] if not fileid: fileid = 'document' fileid = fileid + '.html' html_file = File(fileid, '', html_string, content_type='text/html') else: html_file = None data[html_field_id] = html_file # XXX this is never called yet. def validate(self, value): if not value: return None if _isinstance(value, File): return value raise ValidationError('Not a file: %s' % repr(value)) InitializeClass(CPSFileField) class CPSImageField(CPSField): """Image field.""" meta_type = "CPS Image Field" default_expr = 'nothing' default_expr_c = Expression(default_expr) # XXX this is never called yet. def validate(self, value): if not value: return None if _isinstance(value, Image): return value raise ValidationError('Not an image: %s' % repr(value)) InitializeClass(CPSImageField) # Register field classes FieldRegistry.register(CPSStringField) FieldRegistry.register(CPSPasswordField) FieldRegistry.register(CPSStringListField) FieldRegistry.register(CPSIntField) FieldRegistry.register(CPSLongField) FieldRegistry.register(CPSFloatField) FieldRegistry.register(CPSDateTimeField) FieldRegistry.register(CPSFileField) FieldRegistry.register(CPSImageField) CPSSchemas-0.19.0/BasicWidgets.py0100444000374200017510000022552410030542431014764 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: BasicWidgets.py,v 1.153 2004/03/25 10:06:24 ben Exp $ """BasicWidgets Definition of standard widget types. """ from DateTime.DateTime import DateTime from Globals import InitializeClass from Acquisition import aq_parent, aq_inner from AccessControl import ClassSecurityInfo from types import ListType, TupleType, StringType from cgi import escape from re import compile, search from zLOG import LOG, DEBUG, PROBLEM try: import PIL.Image except ImportError: pass from ZPublisher.HTTPRequest import FileUpload from OFS.Image import cookId, File, Image from OFS.PropertyManager import PropertyManager from Products.PythonScripts.standard import structured_text, newline_to_br from Products.CMFCore.CMFCorePermissions import ManageProperties from Products.CMFCore.utils import getToolByName from Products.CPSSchemas.Widget import CPSWidget from Products.CPSSchemas.Widget import CPSWidgetType from Products.CPSSchemas.WidgetTypesTool import WidgetTypeRegistry def _isinstance(ob, cls): try: return isinstance(ob, cls) except TypeError: # In python 2.1 isinstance() raises TypeError # instead of returning 0 for ExtensionClasses. return 0 def renderHtmlTag(tagname, **kw): """Render an HTML tag.""" if kw.get('css_class'): kw['class'] = kw['css_class'] del kw['css_class'] if kw.has_key('contents'): contents = kw['contents'] del kw['contents'] else: contents = None attrs = [] for key, value in kw.items(): if value is None: value = key if key in ('value', ) or value != '': attrs.append('%s="%s"' % (key, escape(str(value)))) res = '<%s %s>' % (tagname, ' '.join(attrs)) if contents is not None: res += contents + '' % tagname return res ################################################## class CPSNoneWidget(CPSWidget): """None widget. Deprecated widget can inherit form this widget, they will disapear without breaking the rest of the document. """ meta_type = "CPS None Widget" def isHidden(self): return 1 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" pass def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" return 1 def render(self, mode, datastructure, **kw): return '' InitializeClass(CPSNoneWidget) ################################################## class CPSHtmlWidget(CPSWidget): """Html widget.""" meta_type = "CPS Html Widget" _properties = CPSWidget._properties + ( {'id': 'html_view', 'type': 'text', 'mode': 'w', 'label': 'Html for view'}, {'id': 'html_edit', 'type': 'text', 'mode': 'w', 'label': 'Html for edit'}, ) html_view = '' html_edit = '' def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" pass def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" if mode == 'view': return self.html_view elif mode == 'edit': return self.html_edit raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSHtmlWidget) class CPSHtmlWidgetType(CPSWidgetType): """Html widget type.""" meta_type = "CPS Html Widget Type" cls = CPSHtmlWidget InitializeClass(CPSHtmlWidgetType) ################################################## class CPSMethodWidget(CPSWidget): """Method widget.""" meta_type = "CPS Method Widget" _properties = CPSWidget._properties + ( {'id': 'render_method', 'type': 'text', 'mode': 'w', 'label': 'the zpt or py script method'},) render_method = '' def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" pass def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" meth = getattr(self, self.render_method, None) if meth is None: msg = "Unknown Render Method %s for widget type %s. " \ + "Please set or change the 'render_method' attribute on " \ + "your widget declaration." raise RuntimeError(msg % (self.render_method, self.getId())) return meth(mode=mode, datastructure=datastructure) InitializeClass(CPSMethodWidget) class CPSMethodWidgetType(CPSWidgetType): """Method widget type.""" meta_type = "CPS Method Widget Type" cls = CPSMethodWidget InitializeClass(CPSMethodWidgetType) ################################################## class CPSStringWidget(CPSWidget): """String widget.""" meta_type = "CPS String Widget" field_types = ('CPS String Field',) field_inits = ({'is_searchabletext': 1,},) display_width = 20 size_max = 0 _properties = CPSWidget._properties + ( {'id': 'display_width', 'type': 'int', 'mode': 'w', 'label': 'Display width'}, {'id': 'size_max', 'type': 'int', 'mode': 'w', 'label': 'Maximum input width'}, ) def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = str(datamodel[self.fields[0]]) def _extractValue(self, value): """Return err and new value.""" err = None if not value: v = '' else: v = value try: v = v.strip() except AttributeError: err = 'cpsschemas_err_string' else: if self.is_required and not v: err = 'cpsschemas_err_required' elif self.size_max and len(v) > self.size_max: err = 'cpsschemas_err_string_too_long' return err, v def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() err, v = self._extractValue(datastructure[widget_id]) if err: datastructure.setError(widget_id, err) datastructure[widget_id] = v else: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return not err def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure[self.getWidgetId()] if mode == 'view': return escape(value) elif mode == 'edit': # XXX TODO should use an other name than kw ! # XXX change this everywhere kw = {'type': 'text', 'id' : self.getHtmlWidgetId(), 'name': self.getHtmlWidgetId(), 'value': value, 'size': self.display_width, } if self.size_max: kw['maxlength'] = self.size_max return renderHtmlTag('input', **kw) raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSStringWidget) class CPSStringWidgetType(CPSWidgetType): """String widget type.""" meta_type = "CPS String Widget Type" cls = CPSStringWidget InitializeClass(CPSStringWidgetType) ################################################## class CPSURLWidget(CPSStringWidget): """URL widget.""" meta_type = "CPS URL Widget" _properties = CPSStringWidget._properties + ( {'id': 'target', 'type': 'string', 'mode': 'w', 'label': 'Target for the link'},) target = '' css_class = 'url' display_width = 72 size_max = 4096 # XXX should find a better one or check for invalid may be ? # see test_url_nok_5 url_pat = compile( r'^((http://)|/)?((\w|\~|\#|=|\.\.|\-)[\:\.\-\/\?\=\&\+%]?)+$') def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() err, v = self._extractValue(datastructure[widget_id]) if not err and v and not self.url_pat.match(v.lower()): err = 'cpsschemas_err_url' if err: datastructure.setError(widget_id, err) datastructure[widget_id] = v else: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return not err def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = escape(datastructure[self.getWidgetId()]) if mode == 'view': target = self.target if not target and value.lower().startswith('http'): target = 'CPS_Link' kw = {'href': value, 'contents': value, 'css_class': self.css_class, 'target': target} return renderHtmlTag('a', **kw ) return CPSStringWidget.render(self, mode, datastructure, **kw) InitializeClass(CPSURLWidget) class CPSURLWidgetType(CPSWidgetType): """URL widget type.""" meta_type = "CPS URL Widget Type" cls = CPSURLWidget InitializeClass(CPSURLWidgetType) ################################################## class CPSEmailWidget(CPSStringWidget): """Email widget.""" meta_type = "CPS Email Widget" css_class = "url" display_width = 72 size_max = 256 email_pat = compile(r"^([-\w_.+])+@(([-\w])+\.)+([\w]{2,4})$") def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() err, v = self._extractValue(datastructure[widget_id]) # no validation in search mode if not err and kw.get('layout_mode') != 'search' and \ v and not self.email_pat.match(v): err = 'cpsschemas_err_email' if err: datastructure.setError(widget_id, err) else: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return not err def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = escape(datastructure[self.getWidgetId()]) if mode == 'view': kw = {'href': 'mailto:' + value, 'contents': value} return renderHtmlTag('a', **kw) return CPSStringWidget.render(self, mode, datastructure, **kw) InitializeClass(CPSEmailWidget) class CPSEmailWidgetType(CPSWidgetType): """Email widget type.""" meta_type = "CPS Email Widget Type" cls = CPSEmailWidget InitializeClass(CPSEmailWidgetType) ################################################## class CPSIdentifierWidget(CPSStringWidget): """Identifier widget.""" meta_type = "CPS Identifier Widget" display_width = 30 size_max = 256 id_pat = compile(r"^[a-zA-Z][a-zA-Z0-9@\-\._]*$") def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() err, v = self._extractValue(datastructure[widget_id]) if not err and v and not self.id_pat.match(v.lower()): err = 'cpsschemas_err_identifier' if err: datastructure.setError(widget_id, err) datastructure[widget_id] = v else: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return not err InitializeClass(CPSIdentifierWidget) class CPSIdentifierWidgetType(CPSWidgetType): """Identifier widget type.""" meta_type = "CPS Identifier Widget Type" cls = CPSIdentifierWidget InitializeClass(CPSIdentifierWidgetType) ################################################## class CPSHeadingWidget(CPSStringWidget): """HTML Heading widget like H1 H2...""" meta_type = "CPS Heading Widget" display_width = 72 size_max = 128 _properties = CPSStringWidget._properties + ( {'id': 'level', 'type': 'selection', 'mode': 'w', 'select_variable': 'all_levels', 'label': 'There are six levels of headings in HTML'}, ) all_levels = ['1', '2', '3', '4', '5', '6'] level = all_levels[0] def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = escape(datastructure[self.getWidgetId()]) if mode == 'view': kw = {'contents': value} return renderHtmlTag('h%s' % self.level, **kw) return CPSStringWidget.render(self, mode, datastructure, **kw) InitializeClass(CPSHeadingWidget) class CPSHeadingWidgetType(CPSWidgetType): """CPS Heading widget type.""" meta_type = "CPS Heading Widget Type" cls = CPSHeadingWidget InitializeClass(CPSHeadingWidgetType) ################################################## class CPSPasswordWidget(CPSStringWidget): """Password widget. The password widget displays stars in view mode, and in edit mode it always starts with an empty string. When validating, it doesn't update data if the user entry is empty. """ meta_type = "CPS Password Widget" _properties = CPSStringWidget._properties + ( {'id': 'password_widget', 'type': 'string', 'mode': 'w', 'label': 'Password widget to compare with'}, {'id': 'check_lower', 'type': 'boolean', 'mode': 'w', 'label': 'Checking at least one lower case [a-z]'}, {'id': 'check_upper', 'type': 'boolean', 'mode': 'w', 'label': 'Checking at least one upper case [A-Z]'}, {'id': 'check_digit', 'type': 'boolean', 'mode': 'w', 'label': 'Checking at least one digit [0-9]'}, {'id': 'check_extra', 'type': 'boolean', 'mode': 'w', 'label': 'Checking at least one extra char other than [a-zA-Z0-9]'}, {'id': 'size_min', 'type': 'int', 'mode': 'w', 'label': 'Checking minimum size',} ) field_types = ('CPS Password Field',) password_widget = '' check_lower = 0 check_upper = 0 check_digit = 0 check_extra = 0 display_width = 8 size_min = 5 size_max = 8 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" # Never fetch the real password. datastructure[self.getWidgetId()] = '' def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure[self.getWidgetId()] if mode == 'view': return "********" elif mode == 'edit': kw = {'type': 'password', 'name': self.getHtmlWidgetId(), 'value': value, 'size': self.display_width, } if self.size_max: kw['maxlength'] = self.size_max return renderHtmlTag('input', **kw) raise RuntimeError('unknown mode %s' % mode) def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() value = datastructure[widget_id] err = 0 try: v = str(value).strip() except ValueError: err = 'cpsschemas_err_string' else: if self.password_widget: # here we only check that that our confirm match the pwd pwidget_id = self.password_widget pvalue = datastructure[pwidget_id] datastructure[widget_id] = '' datastructure[pwidget_id] = '' pv = str(pvalue).strip() if pv and v != pv: err = 'cpsschemas_err_password_mismatch' elif not v: if self.is_required: datamodel = datastructure.getDataModel() if not datamodel[self.fields[0]]: err = 'cpsschemas_err_required' else: # checking pw consistancy len_v = len(v) if not err and self.size_max and len_v > self.size_max: err = 'cpsschemas_err_string_too_long' if not err and self.size_min and len_v < self.size_min: err = 'cpsschemas_err_password_size_min' if not err and self.check_lower and not search(r'[a-z]', v): err = 'cpsschemas_err_password_lower' if not err and self.check_upper and not search(r'[A-Z]', v): err = 'cpsschemas_err_password_upper' if not err and self.check_digit and not search(r'[0-9]', v): err = 'cpsschemas_err_password_digit' if not err and self.check_extra and not search(r'[^a-zA-Z0-9]', v): err = 'cpsschemas_err_password_extra' if err: datastructure[widget_id] = '' datastructure.setError(widget_id, err) elif v: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return not err InitializeClass(CPSPasswordWidget) class CPSPasswordWidgetType(CPSStringWidgetType): """Password widget type.""" meta_type = "CPS Password Widget Type" cls = CPSPasswordWidget InitializeClass(CPSPasswordWidgetType) ################################################## class CPSCheckBoxWidget(CPSWidget): """CheckBox widget.""" meta_type = "CPS CheckBox Widget" field_types = ('CPS Int Field',) _properties = CPSWidget._properties + ( {'id': 'display_true', 'type': 'string', 'mode': 'w', 'label': 'Display for true'}, {'id': 'display_false', 'type': 'string', 'mode': 'w', 'label': 'Display for false'}, ) display_true = "Yes" display_false = "No" def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = not not datamodel[self.fields[0]] def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" value = datastructure[self.getWidgetId()] datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = not not value return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure[self.getWidgetId()] if mode == 'view': # XXX L10N Should expand view mode to be able to do i18n. if value: return self.display_true else: return self.display_false elif mode == 'edit': html_widget_id = self.getHtmlWidgetId() kw = {'type': 'checkbox', 'name': html_widget_id, } if value: kw['checked'] = None tag = renderHtmlTag('input', **kw) default_tag = renderHtmlTag('input', type='hidden', name=html_widget_id+':default', value='') return default_tag+tag raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSCheckBoxWidget) class CPSCheckBoxWidgetType(CPSStringWidgetType): """CheckBox widget type.""" meta_type = "CPS CheckBox Widget Type" cls = CPSCheckBoxWidget InitializeClass(CPSCheckBoxWidgetType) ################################################## # Warning textarea widget code is back to r1.75 # refactored textarea with position and format is now located in # ExtendWidgets and named CPSTextWidget class CPSTextAreaWidget(CPSWidget): """TextArea widget.""" meta_type = "CPS TextArea Widget" field_types = ('CPS String Field',) field_inits = ({'is_searchabletext': 1,},) _properties = CPSWidget._properties + ( {'id': 'width', 'type': 'int', 'mode': 'w', 'label': 'Width'}, {'id': 'height', 'type': 'int', 'mode': 'w', 'label': 'Height'}, {'id': 'render_format', 'type': 'selection', 'mode': 'w', 'select_variable': 'all_render_formats', 'label': 'Render format'}, ) all_render_formats = ['text', 'pre', 'stx', 'html'] width = 40 height = 5 render_format = all_render_formats[0] def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = str(datamodel[self.fields[0]]) def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() value = datastructure[widget_id] try: v = str(value).strip() except ValueError: datastructure.setError(widget_id, "cpsschemas_err_textarea") return 0 if self.is_required and not v: datastructure[widget_id] = '' datastructure.setError(widget_id, "cpsschemas_err_required") return 0 datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure[self.getWidgetId()] if mode == 'edit': ret = renderHtmlTag('textarea', name=self.getHtmlWidgetId(), cols=self.width, rows=self.height, contents=value) elif mode == 'view': rformat = self.render_format if rformat == 'pre': ret = '
'+escape(value)+'
' elif rformat == 'stx': ret = structured_text(value) elif rformat == 'text': ret = newline_to_br(value) elif rformat == 'html': ret = value else: raise RuntimeError("unknown render_format '%s' for '%s'" % (render_format, self.getId())) else: raise RuntimeError('unknown mode %s' % mode) return ret InitializeClass(CPSTextAreaWidget) class CPSTextAreaWidgetType(CPSWidgetType): """TextArea widget type.""" meta_type = "CPS TextArea Widget Type" cls = CPSTextAreaWidget InitializeClass(CPSTextAreaWidgetType) ################################################## class CPSLinesWidget(CPSWidget): """Lines widget.""" meta_type = "CPS Lines Widget" field_types = ('CPS String List Field',) field_inits = ({'is_searchabletext': 1,},) width = 40 height = 5 format_empty = '' _properties = CPSWidget._properties + ( {'id': 'width', 'type': 'int', 'mode': 'w', 'label': 'Width'}, {'id': 'height', 'type': 'int', 'mode': 'w', 'label': 'Height'}, {'id': 'format_empty', 'type': 'string', 'mode': 'w', 'label': 'Format for empty list'}, ) def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() value = datamodel[self.fields[0]] if value == '': # Buggy Zope :lines prop may give us '' instead of [] for default. value = [] # XXX make a copy of the list ? datastructure[self.getWidgetId()] = value def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() value = datastructure[widget_id] if value == ['']: # Buggy Zope :lines prop may give us [''] instead of [] value = [] v = value # Zope handle :lines automagically if self.is_required and not v: datastructure[widget_id] = '' datastructure.setError(widget_id, "cpsschemas_err_required") return 0 datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure[self.getWidgetId()] if mode == 'view': if not value: # XXX L10N empty format may be subject to i18n. return self.format_empty # XXX customize view mode, lots of displays are possible return ', '.join([escape(i) for i in value]) elif mode == 'edit': return renderHtmlTag('textarea', id=self.getHtmlWidgetId(), name=self.getHtmlWidgetId()+":lines", cols=self.width, rows=self.height, contents='\n'.join(value)) raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSLinesWidget) class CPSLinesWidgetType(CPSWidgetType): """Lines widget type.""" meta_type = "CPS Lines Widget Type" cls = CPSLinesWidget InitializeClass(CPSLinesWidgetType) ################################################## class CPSListWidget(CPSLinesWidget): """Abstract list widget""" meta_type = "CPS List Widget" display = None def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" if not self.display: raise NotImplementedError value = datastructure[self.getWidgetId()] meth = getattr(self, 'widget_list_render', None) if meth is None: raise RuntimeError( "Unknown Render Method widget_list_render for widget type %s" % self.getId()) return meth(mode=mode, value=value) InitializeClass(CPSListWidget) class CPSListWidgetType(CPSLinesWidgetType): """Abstract list widget type.""" meta_type = "CPS List Widget Type" cls = CPSListWidget InitializeClass(CPSListWidgetType) ################################################## class CPSOrderedListWidget(CPSListWidget): """Ordered list widget""" meta_type = "CPS Ordered List Widget" display = 'ordered' InitializeClass(CPSOrderedListWidget) class CPSOrderedListWidgetType(CPSListWidgetType): """Ordered list widget type""" meta_type = "CPS Ordered List Widget Type" cls = CPSOrderedListWidget InitializeClass(CPSOrderedListWidgetType) ################################################## class CPSUnorderedListWidget(CPSListWidget): """Unordered list widget""" meta_type = "CPS Unordered List Widget" display = 'unordered' InitializeClass(CPSOrderedListWidget) class CPSUnorderedListWidgetType(CPSListWidgetType): """Unordered list widget type""" meta_type = "CPS Unordered List Widget Type" cls = CPSUnorderedListWidget InitializeClass(CPSUnorderedListWidgetType) ################################################## class CPSSelectWidget(CPSWidget): """Select widget.""" meta_type = "CPS Select Widget" field_types = ('CPS String Field',) field_inits = ({'is_searchabletext': 1,},) vocabulary = '' _properties = CPSWidget._properties + ( {'id': 'vocabulary', 'type': 'string', 'mode': 'w', 'label': 'Vocabulary'}, ) # XXX make a menu for the vocabulary. def _getVocabulary(self, datastructure=None): """Get the vocabulary object for this widget.""" vtool = getToolByName(self, 'portal_vocabularies') try: vocabulary = getattr(vtool, self.vocabulary) except AttributeError: raise ValueError("Missing vocabulary '%s' for widget '%s'" % (self.vocabulary, self.getWidgetId())) return vocabulary def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = datamodel[self.fields[0]] def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() value = datastructure[widget_id] try: v = str(value) except ValueError: datastructure.setError(widget_id, "cpsschemas_err_select") return 0 vocabulary = self._getVocabulary(datastructure) if not vocabulary.has_key(value): datastructure.setError(widget_id, "cpsschemas_err_select") return 0 datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure[self.getWidgetId()] vocabulary = self._getVocabulary(datastructure) if mode == 'view': return escape(vocabulary.get(value, value)) elif mode == 'edit': res = renderHtmlTag('select', name=self.getHtmlWidgetId()) in_selection = 0 for k, v in vocabulary.items(): kw = {'value': k, 'contents': v} if value == k: kw['selected'] = None in_selection = 1 res += renderHtmlTag('option', **kw) if value and not in_selection: kw = {'value': value, 'contents': 'invalid: '+value, 'selected': None} res += renderHtmlTag('option', **kw) res += '' return res raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSSelectWidget) class CPSSelectWidgetType(CPSWidgetType): """Select widget type.""" meta_type = "CPS Select Widget Type" cls = CPSSelectWidget InitializeClass(CPSSelectWidgetType) ################################################## class CPSMultiSelectWidget(CPSWidget): """MultiSelect widget.""" meta_type = "CPS MultiSelect Widget" field_types = ('CPS String List Field',) field_inits = ({'is_searchabletext': 1,},) _properties = CPSWidget._properties + ( {'id': 'vocabulary', 'type': 'string', 'mode': 'w', 'label': 'Vocabulary'}, {'id': 'size', 'type': 'int', 'mode': 'w', 'label': 'Size'}, {'id': 'format_empty', 'type': 'string', 'mode': 'w', 'label': 'Format for empty list'}, ) # XXX make a menu for the vocabulary. vocabulary = '' size = 0 format_empty = '' def _getVocabulary(self, datastructure=None): """Get the vocabulary object for this widget.""" vtool = getToolByName(self, 'portal_vocabularies') try: vocabulary = getattr(vtool, self.vocabulary) except AttributeError: raise ValueError("Missing vocabulary '%s' for widget '%s'" % (self.vocabulary, self.getWidgetId())) return vocabulary def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() value = datamodel[self.fields[0]] if value == '': # Buggy Zope :lines prop may give us '' instead of [] for default. value = [] # XXX make a copy of the list ? datastructure[self.getWidgetId()] = value def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() value = datastructure[widget_id] if (not _isinstance(value, ListType) and not _isinstance(value, TupleType)): datastructure.setError(widget_id, "cpsschemas_err_multiselect") return 0 vocabulary = self._getVocabulary(datastructure) v = [] for i in value: try: i = str(i) except ValueError: datastructure.setError(widget_id, "cpsschemas_err_multiselect") return 0 if not vocabulary.has_key(i): datastructure.setError(widget_id, "cpsschemas_err_multiselect") return 0 v.append(i) if self.is_required and not len(v): datastructure.setError(widget_id, "cpsschemas_err_required") return 0 datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure[self.getWidgetId()] vocabulary = self._getVocabulary(datastructure) if mode == 'view': if not value: # XXX L10N empty format may be subject to i18n. return self.format_empty # XXX customize view mode, lots of displays are possible return ', '.join([escape(vocabulary.get(i, i)) for i in value]) elif mode == 'edit': html_widget_id = self.getHtmlWidgetId() kw = {'name': html_widget_id+':list', 'multiple': None, } if self.size: kw['size'] = self.size res = renderHtmlTag('select', **kw) for k, v in vocabulary.items(): kw = {'value': k, 'contents': v} if k in value: kw['selected'] = None res += renderHtmlTag('option', **kw) res += '' default_tag = renderHtmlTag('input', type='hidden', name=html_widget_id+':tokens:default', value='') return default_tag+res raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSMultiSelectWidget) class CPSMultiSelectWidgetType(CPSWidgetType): """MultiSelect widget type.""" meta_type = "CPS MultiSelect Widget Type" cls = CPSMultiSelectWidget InitializeClass(CPSMultiSelectWidgetType) ################################################## class CPSBooleanWidget(CPSWidget): """Boolean widget.""" meta_type = "CPS Boolean Widget" field_types = ('CPS Int Field',) # XXX should extend with a property to choose rendering # between checkbox, select or radio button (and replace chekbox widget) _properties = CPSWidget._properties + ( {'id': 'label_false', 'type': 'string', 'mode': 'w', 'label': 'False label'}, {'id': 'label_true', 'type': 'string', 'mode': 'w', 'label': 'True label'}, ) label_false = 'cpsschemas_label_false' label_true = 'cpsschemas_label_true' def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = str(datamodel[self.fields[0]]) def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" value = datastructure[self.getWidgetId()] try: v = int(value) except (ValueError, TypeError): datastructure.setError(self.getWidgetId(), "cpsschemas_err_boolean") return 0 if v not in (0, 1): datastructure.setError(self.getWidgetId(), "cpsschemas_err_boolean") return 0 datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = datastructure.getDataModel()[self.getWidgetId()] if value and str(value) != '0': label_value = self.label_true else: label_value = self.label_false render_method = 'widget_boolean_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) return meth(mode=mode, value=value, label_value=label_value) InitializeClass(CPSBooleanWidget) class CPSBooleanWidgetType(CPSWidgetType): """Boolean widget type.""" meta_type = "CPS Boolean Widget Type" cls = CPSBooleanWidget InitializeClass(CPSBooleanWidgetType) ################################################## class CPSIntWidget(CPSWidget): """Integer widget.""" meta_type = "CPS Int Widget" field_types = ('CPS Int Field',) _properties = CPSWidget._properties + ( {'id': 'is_limited', 'type': 'boolean', 'mode': 'w', 'label': 'Value must be in range'}, {'id': 'min_value', 'type': 'float', 'mode': 'w', 'label': 'Range minimum value'}, {'id': 'max_value', 'type': 'float', 'mode': 'w', 'label': 'Range maximum value'}, {'id': 'thousands_separator', 'type': 'string', 'mode': 'w', 'label': 'Thousands separator'}, ) is_limited = 0 min_value = 0 max_value = 0 thousands_separator = '' def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = str(datamodel[self.fields[0]]) def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" value = datastructure[self.getWidgetId()] #put value back in a python-parsable state as thousands #separator might not be std representations understood by python if self.thousands_separator: value = value.replace(self.thousands_separator,'') try: v = int(value) except (ValueError, TypeError): datastructure.setError(self.getWidgetId(), "cpsschemas_err_int") return 0 if self.is_limited: if (v < self.min_value) or (v > self.max_value): datastructure.setError(self.getWidgetId(), "cpsschemas_err_int_range") return 0 datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = str(datastructure.getDataModel()[self.getWidgetId()]) #format number according to widget prefs if self.thousands_separator: thousands = [] while value: thousands.insert(0, value[-3:]) value = value[:-3] value = self.thousands_separator.join(thousands) if mode == 'view': return escape(value) elif mode == 'edit': return renderHtmlTag('input', type='text', name=self.getHtmlWidgetId(), value=value) raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSIntWidget) class CPSIntWidgetType(CPSWidgetType): """Int widget type.""" meta_type = "CPS Int Widget Type" cls = CPSIntWidget InitializeClass(CPSIntWidgetType) ####################################################### class CPSLongWidget(CPSWidget): """Long Widget with limits""" meta_type = "CPS Long Widget" field_types = ('CPS Long Field',) _properties = CPSWidget._properties + ( {'id': 'is_limited', 'type': 'boolean', 'mode': 'w', 'label': 'Value must be in range'}, {'id': 'min_value', 'type': 'int', 'mode': 'w', 'label': 'Range minimum value'}, {'id': 'max_value', 'type': 'int', 'mode': 'w', 'label': 'Range maximum value'}, {'id': 'thousands_separator', 'type': 'string', 'mode': 'w', 'label': 'Thousands separator'}, ) is_limited = 0 min_value = 0 max_value = 0 thousands_separator = '' def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = str(datamodel[self.fields[0]]) def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" datamodel = datastructure.getDataModel() widget_id = self.getWidgetId() value = datastructure[widget_id] #put value back in a python-parsable state as thousands #separator might not be std representations understood by python if self.thousands_separator: value = value.replace(self.thousands_separator,'') if not value and self.is_required: datastructure[widget_id] = 0 datastructure.setError(widget_id, "cpsschemas_err_required") return 0 try: v = long(value) except (ValueError, TypeError): datastructure.setError(widget_id, "cpsschemas_err_int") ok = 0 else: if self.is_limited and (v < self.min_value or v > self.max_value): datastructure.setError(widget_id, "cpsschemas_err_long_range") ok = 0 else: datamodel[self.fields[0]] = v ok = 1 return ok def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = str(datastructure.getDataModel()[self.getWidgetId()]) #format number according to widget prefs if self.thousands_separator: thousands = [] while value: thousands.insert(0, value[-3:]) value = value[:-3] value = self.thousands_separator.join(thousands) if mode == 'view': return escape(value) elif mode == 'edit': return renderHtmlTag('input', type='text', name=self.getHtmlWidgetId(), value=value) raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSLongWidget) class CPSLongWidgetType(CPSWidgetType): """Long with limits widget type.""" meta_type = "CPS Long Widget Type" cls = CPSLongWidget InitializeClass(CPSLongWidgetType) ################################################## class CPSFloatWidget(CPSWidget): """Float number widget.""" meta_type = "CPS Float Widget" field_types = ('CPS Float Field',) _properties = CPSWidget._properties + ( {'id': 'is_limited', 'type': 'boolean', 'mode': 'w', 'label': 'Value must be in range'}, {'id': 'min_value', 'type': 'float', 'mode': 'w', 'label': 'Range minimum value'}, {'id': 'max_value', 'type': 'float', 'mode': 'w', 'label': 'Range maximum value'}, {'id': 'thousands_separator', 'type': 'string', 'mode': 'w', 'label': 'Thousands separator'}, {'id': 'decimals_separator', 'type': 'string', 'mode': 'w', 'label': 'Decimal separator'}, {'id': 'decimals_number', 'type': 'int', 'mode': 'w', 'label': 'Number of decimals'}, ) is_limited = 0 min_value = 0.0 max_value = 0.0 thousands_separator = '' decimals_separator = ',' decimals_number = 0 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = str(datamodel[self.fields[0]]) def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" value = datastructure[self.getWidgetId()] #put value back in a python-parsable state as decimal/thousands #separators might not be std representations understood by python if self.thousands_separator: value = value.replace(self.thousands_separator,'') if self.decimals_separator: value = value.replace(self.decimals_separator,'.') try: v = float(value) except (ValueError, TypeError): datastructure.setError(self.getWidgetId(), "cpsschemas_err_float") return 0 if self.is_limited: if (v < self.min_value) or (v > self.max_value): datastructure.setError(self.getWidgetId(), "cpsschemas_err_float_range") return 0 datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" value = str(datastructure.getDataModel()[self.getWidgetId()]) #format number according to widget prefs if self.decimals_number: v = float(value) value = ("%0." + str(self.decimals_number) + "f") % v if self.thousands_separator: intpart, decpart = value.split('.') thousands = [] while intpart: thousands.insert(0, intpart[-3:]) intpart = intpart[:-3] value = self.thousands_separator.join(thousands) value = ''.join([value, '.', decpart]) if self.decimals_separator: value = value.replace('.', self.decimals_separator) if mode == 'view': return escape(value) elif mode == 'edit': return renderHtmlTag('input', type='text', name=self.getHtmlWidgetId(), value=value) raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSFloatWidget) class CPSFloatWidgetType(CPSWidgetType): """Float widget type.""" meta_type = "CPS Float Widget Type" cls = CPSFloatWidget InitializeClass(CPSFloatWidgetType) ################################################## # Warning Date widget code is back to r1.49 # refactored date widget is now located in # ExtendWidgets and named CPSDateTimeWidget class CPSDateWidget(CPSWidget): """Date widget.""" meta_type = "CPS Date Widget" field_types = ('CPS DateTime Field',) _properties = CPSWidget._properties + ( {'id': 'view_format', 'type': 'string', 'mode': 'w', 'label': 'View format'}, {'id': 'view_format_none', 'type': 'string', 'mode': 'w', 'label': 'View format empty'}, {'id': 'use_javascript', 'type': 'boolean', 'mode': 'w', 'label': 'Use Javascript'}, ) view_format = "%d/%m/%Y" # XXX unused for now view_format_none = "-" use_javascript = 0 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() v = datamodel[self.fields[0]] widget_id = self.getWidgetId() if v is not None: d = str(v.day()) m = str(v.month()) y = str(v.year()) else: d = m = y = '' datastructure[widget_id+'_d'] = d datastructure[widget_id+'_m'] = m datastructure[widget_id+'_y'] = y def validate(self, datastructure, **kw): """Update datamodel from user data in datastructure.""" datamodel = datastructure.getDataModel() field_id = self.fields[0] widget_id = self.getWidgetId() d = datastructure[widget_id+'_d'].strip() m = datastructure[widget_id+'_m'].strip() y = datastructure[widget_id+'_y'].strip() if not (d+m+y): if self.is_required: datastructure[widget_id] = '' datastructure.setError(widget_id, "cpsschemas_err_required") return 0 else: datamodel[field_id] = None return 1 try: v = DateTime(int(y), int(m), int(d)) except (ValueError, TypeError, DateTime.DateTimeError, DateTime.SyntaxError, DateTime.DateError): datastructure.setError(widget_id, 'cpsschemas_err_date') return 0 else: datamodel[field_id] = v return 1 def render(self, mode, datastructure, **kw): """Render this widget from the datastructure or datamodel.""" if self.use_javascript: js_onKeyPress = """if (navigator.appName == 'Netscape') { var key = event.which } else { var key = event.keyCode }; if ( key < 32 ) { return true; } if ( key < 48 || key > 57 ) { return false; }""" js_onKeyUp = """if (navigator.appName == 'Netscape') { var key = event.which } else { var key = event.keyCode }; if ( key < 32 ) { return true; } if ( this.value > %(max_value)s ) { return false}; if ( this.value >= %(low_trigger)s || this.value.length >= %(max_size)s ) { form.%(next_widget)s.focus() } """ else: js_onKeyPress = "" js_onKeyUp = "" widget_id = self.getWidgetId() d = datastructure[widget_id+'_d'] m = datastructure[widget_id+'_m'] y = datastructure[widget_id+'_y'] if mode == 'view': if not (d+m+y): return escape(self.view_format_none) else: # XXX customize format return escape(d+'/'+m+'/'+y) elif mode == 'edit': html_widget_id = self.getHtmlWidgetId() dtag = renderHtmlTag('input', type='text', name=html_widget_id+'_d', value=d, size=2, maxlength=2, onKeyPress=js_onKeyPress, onKeyUp=js_onKeyUp % { 'max_value': '31', 'max_size': '2', 'low_trigger': '4', 'next_widget': html_widget_id+'_m', }) mtag = renderHtmlTag('input', type='text', name=html_widget_id+'_m', value=m, size=2, maxlength=2, onKeyPress=js_onKeyPress, onKeyUp=js_onKeyUp % { 'max_value': '12', 'max_size': '2', 'low_trigger': '2', 'next_widget': html_widget_id+'_y', }) ytag = renderHtmlTag('input', type='text', name=html_widget_id+'_y', value=y, size=6, maxlength=6, onKeyPress=js_onKeyPress, ) # XXX customize format return dtag + '/' + mtag + '/' + ytag raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSDateWidget) class CPSDateWidgetType(CPSWidgetType): """Date widget type.""" meta_type = "CPS Date Widget Type" cls = CPSDateWidget InitializeClass(CPSDateWidgetType) ################################################## # Warning File widget code is back to r1.47 # refactored file widget with html preview and text extraction is in # ExtendWidgets and named CPSAttachedFileWidget ################################################## class CPSFileWidget(CPSWidget): """File widget.""" meta_type = "CPS File Widget" field_types = ('CPS File Field',) _properties = CPSWidget._properties + ( {'id': 'deletable', 'type': 'boolean', 'mode': 'w', 'label': 'Deletable'}, {'id': 'size_max', 'type': 'int', 'mode': 'w', 'label': 'Maximum file size'}, ) deletable = 1 size_max = 4*1024*1024 def getFileInfo(self, datastructure): """Get the file info from the datastructure.""" file = datastructure[self.getWidgetId()] size = 0 last_modified = '' if file: if _isinstance(file, File): current_name = file.getId() size = file.get_size() last_modified = str(file._p_mtime) else: current_name = self.getWidgetId() empty_file = 0 else: current_name = '' empty_file = 1 # The attached file current name should not contain spaces otherwise it # causes problem when used by the ExternalEditor. current_name = current_name.replace(' ', '_') # XXX This is a total mess, it needs refactoring. dm = datastructure.getDataModel() field_id = self.fields[0] for adapter in dm._adapters: if adapter.getSchema().has_key(field_id): break # Note: 'adapter' is still the right one ob = dm.getProxy() if ob is None: # Not stored in the ZODB. # StorageAdapters that do not store the object in # ZODB takes the entry_id instead of object. # Get the entry_id from the datamodel context(typically # a directory). id_field = getattr(dm.getContext(), 'id_field', None) if id_field: entry_id = datastructure[id_field] else: # No object passed, and no id_field entry_id = None if entry_id: content_url = adapter._getContentUrl(entry_id, field_id) else: content_url = None else: content_url = adapter._getContentUrl(ob, field_id, current_name) registry = getToolByName(self, 'mimetypes_registry') mimetype = registry.lookupExtension(current_name.lower()) return {'empty_file': empty_file, 'content_url': content_url, 'current_name': current_name, 'mimetype': mimetype, 'size': size, 'last_modified': last_modified, } def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() widget_id = self.getWidgetId() datastructure[widget_id] = datamodel[self.fields[0]] # make update from request work datastructure[widget_id + '_choice'] = '' def validate(self, datastructure, **kw): """Update datamodel from user data in datastructure.""" datamodel = datastructure.getDataModel() field_id = self.fields[0] widget_id = self.getWidgetId() choice = datastructure[widget_id+'_choice'] err = 0 if choice == 'delete': datamodel[field_id] = None elif choice == 'change' and datastructure.get(widget_id): file = datastructure[widget_id] if not _isinstance(file, FileUpload): err = 'cpsschemas_err_file' else: ms = self.size_max if file.read(1) == '': err = 'cpsschemas_err_file_empty' elif ms and len(file.read(ms)) == ms: err = 'cpsschemas_err_file_too_big' else: file.seek(0) fileid = cookId('', '', file)[0] file = File(fileid, fileid, file) LOG('CPSFileWidget', DEBUG, 'validate change set %s' % `file`) datamodel[field_id] = file if err: datastructure.setError(widget_id, err) LOG('CPSFileWidget', DEBUG, 'error %s on %s' % (err, `file`)) else: self.prepare(datastructure) return not err def render(self, mode, datastructure, **kw): """Render this widget from the datastructure or datamodel.""" render_method = 'widget_file_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) if kw['layout_mode'] == 'create': file_info = {'empty_file': 1, 'content_url': '', 'current_name': '-', 'mimetype': '', 'last_modified': '', } else: file_info = self.getFileInfo(datastructure) return meth(mode=mode, datastructure=datastructure, **file_info) InitializeClass(CPSFileWidget) class CPSFileWidgetType(CPSWidgetType): """File widget type.""" meta_type = "CPS File Widget Type" cls = CPSFileWidget InitializeClass(CPSFileWidgetType) ################################################## class CPSImageWidget(CPSFileWidget): """Image widget.""" meta_type = "CPS Image Widget" field_types = ('CPS Image Field',) _properties = CPSWidget._properties + ( {'id': 'deletable', 'type': 'boolean', 'mode': 'w', 'label': 'Deletable'}, {'id': 'size_max', 'type': 'int', 'mode': 'w', 'label': 'maximum image size'}, {'id': 'display_width', 'type': 'int', 'mode': 'w', 'label': 'Display width'}, {'id': 'display_height', 'type': 'int', 'mode': 'w', 'label': 'Display height'}, {'id': 'allow_resize', 'type': 'boolean', 'mode': 'w', 'label': 'Enable to resize img to lower size'}, ) deletable = 1 size_max = 2*1024*1024 display_height = 0 display_width = 0 allow_resize = 0 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() widget_id = self.getWidgetId() datastructure[widget_id] = datamodel[self.fields[0]] # make update from request work datastructure[widget_id + '_choice'] = '' if self.allow_resize: datastructure[widget_id + '_resize'] = '' def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" datamodel = datastructure.getDataModel() field_id = self.fields[0] widget_id = self.getWidgetId() choice = datastructure[widget_id+'_choice'] err = None if choice == 'delete': datamodel[field_id] = None elif choice == 'change' and datastructure.get(widget_id): file = datastructure[widget_id] if type(file) is StringType: file = Image('-', '', file) elif not _isinstance(file, FileUpload): err = 'cpsschemas_err_file' else: ms = self.size_max if file.read(1) == '': err = 'cpsschemas_err_file_empty' elif ms and len(file.read(ms)) == ms: err = 'cpsschemas_err_file_too_big' else: file.seek(0) fileid = cookId('', '', file)[0] registry = getToolByName(self, 'mimetypes_registry') mimetype = registry.lookupExtension(fileid.lower()) if (not mimetype or not mimetype.normalized().startswith('image')): err = 'cpsschemas_err_image' else: size = (self.display_width, self.display_height) if self.allow_resize: resize_op = datastructure[widget_id + '_resize'] resize = None for s in self.getImgSizes(): if s['id'] == resize_op: resize = s['size'] if resize and resize < size: size = resize if size[0] and size[1]: try: img = PIL.Image.open(file) img.thumbnail(size, resample=PIL.Image.ANTIALIAS) file.seek(0) img.save(file, format=img.format) except (NameError, IOError, ValueError): LOG('CPSImageWidget', PROBLEM, "Failed to resize file %s keep original" \ % fileid) file = Image(fileid, fileid, file) LOG('CPSImageWidget', DEBUG, 'validate change set %s' % `file`) datamodel[field_id] = file if err: datastructure.setError(widget_id, err) LOG('CPSImageWidget', DEBUG, 'error %s on %s' % (err, `file`)) # reset datastructure datastructure[widget_id] = datamodel[self.fields[0]] datastructure[widget_id + '_choice'] = '' if self.allow_resize: datastructure[widget_id + '_resize'] = '' return not err def getImageInfo(self, datastructure): """Get the image info from the datastructure.""" image_info = self.getFileInfo(datastructure) image = datastructure[self.getWidgetId()] if image: if not _isinstance(image, Image): image = Image(self.getWidgetId(), '', image) if image_info['empty_file']: tag = '' else: height = int(getattr(image, 'height', 0)) width = int(getattr(image,'width', 0)) if self.allow_resize: z_w = z_h = 1 h = int(self.display_height) w = int(self.display_width) if w and h: if w < width: z_w = w / float(width) if h < height: z_h = h / float(height) zoom = min(z_w, z_h) width = int(zoom * width) height = int(zoom * height) title = getattr(image, 'title', None) tag = renderHtmlTag('img', src=image_info['content_url'], width=str(width), height=str(height), border='0', alt=title, title=title) image_info['image_tag'] = tag return image_info def render(self, mode, datastructure, **kw): render_method = 'widget_image_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) if kw['layout_mode'] == 'create': img_info = {'empty_file': 1, 'content_url': '', 'image_tag': '', 'current_name': '-', 'mimetype': '', 'last_modified': '', } else: img_info = self.getImageInfo(datastructure) return meth(mode=mode, datastructure=datastructure, **img_info) InitializeClass(CPSImageWidget) class CPSImageWidgetType(CPSWidgetType): """Image widget type.""" meta_type = "CPS Image Widget Type" cls = CPSImageWidget # XXX: TBD InitializeClass(CPSImageWidgetType) ################################################## class CPSCustomizableWidget(CPSWidget): """Widget with customizable logic and presentation.""" meta_type = "CPS Customizable Widget" security = ClassSecurityInfo() _properties = CPSWidget._properties + ( {'id': 'widget_type', 'type': 'string', 'mode': 'w', 'label': 'Widget type'}, ) widget_type = '' security.declarePrivate('_getType') def _getType(self): """Get the type object for this widget.""" wtool = getToolByName(self, 'portal_widget_types') return getattr(wtool, self.widget_type) security.declarePrivate('getFieldTypes') def getFieldTypes(self): return self._getType().field_types def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" return self._getType().prepare(self, datastructure) def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" return self._getType().validate(self, datastructure) def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" return self._getType().render(self, mode, datastructure) InitializeClass(CPSCustomizableWidget) class CPSCustomizableWidgetType(CPSWidgetType): """Customizable widget type.""" meta_type = "CPS Customizable Widget Type" cls = CPSCustomizableWidget security = ClassSecurityInfo() _properties = CPSWidgetType._properties + ( {'id': 'field_types', 'type': 'lines', 'mode': 'w', 'label': 'Field types'}, {'id': 'prepare_validate_method', 'type': 'string', 'mode': 'w', 'label': 'Prepare & Validate Method'}, {'id': 'render_method', 'type': 'string', 'mode': 'w', 'label': 'Render Method'}, ) field_types = [] prepare_validate_method = '' render_method = '' _class_props = [p['id'] for p in _properties] # Make properties editable. def manage_propertiesForm(self, REQUEST, *args, **kw): """Override to make the properties editable.""" return PropertyManager.manage_propertiesForm( self, self, REQUEST, *args, **kw) security.declareProtected(ManageProperties, 'manage_addProperty') security.declareProtected(ManageProperties, 'manage_delProperties') # API security.declarePrivate('makeInstance') def makeInstance(self, id, **kw): """Create an instance of this widget type.""" ob = CPSWidgetType.makeInstance(self, id, **kw) # Copy user-added properties to the instance. for prop in self._properties: id = prop['id'] if id in self._class_props: continue t = prop['type'] ob.manage_addProperty(id, '', t) return ob security.declarePrivate('prepare') def prepare(self, widget, datastructure): """Prepare datastructure from datamodel.""" if not self.prepare_validate_method: raise RuntimeError("Missing Prepare Method in widget type %s" % self.getId()) meth = getattr(widget, self.prepare_validate_method, None) if meth is None: raise RuntimeError("Unknown Prepare Method %s for widget type %s" % (self.prepare_validate_method, self.getId())) return meth('prepare', datastructure) security.declarePrivate('validate') def validate(self, widget, datastructure): """Validate datastructure and update datamodel.""" if not self.prepare_validate_method: raise RuntimeError("Missing Validate Method in widget type %s" % self.getId()) meth = getattr(widget, self.prepare_validate_method, None) if meth is None: raise RuntimeError("Unknown Validate Method %s for widget type %s" % (self.prepare_validate_method, self.getId())) return meth('validate', datastructure) security.declarePrivate('render') def render(self, widget, mode, datastructure): """Render a widget from the datastructure or datamodel.""" if not self.render_method: raise RuntimeError("Missing Render Method in widget type %s" % self.getId()) meth = getattr(widget, self.render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (self.render_method, self.getId())) return meth(mode=mode, datastructure=datastructure) InitializeClass(CPSCustomizableWidgetType) ################################################## class CPSCompoundWidget(CPSWidget): """Widget aggregating several widgets.""" meta_type = "CPS Compound Widget" security = ClassSecurityInfo() _properties = ( CPSWidget._properties[:2] + ( {'id': 'widget_ids', 'type': 'tokens', 'mode': 'w', 'label': 'Widget ids'}, {'id': 'widget_type', 'type': 'string', 'mode': 'w', 'label': 'Widget type'}, ) + CPSWidget._properties[2:] ) widget_ids = [] widget_type = '' security.declarePrivate('_getType') def _getType(self): """Get the type object for this widget.""" wtool = getToolByName(self, 'portal_widget_types') return getattr(wtool, self.widget_type) security.declarePrivate('_getRenderMethod') def _getRenderMethod(self): """Get the render method.""" wtool = getToolByName(self, 'portal_widget_types') wt = getattr(wtool, self.widget_type) return wt.getRenderMethod(self) security.declarePrivate('getFieldTypes') def getFieldTypes(self): """Get field types from the underlying widgets.""" return [] security.declarePrivate('getFieldInits') def getFieldInits(self): """Get field inits from the underlying widgets.""" return [] def prepare(self, datastructure, **kw): """Prepare the underlying widgets.""" layout = aq_parent(aq_inner(self)) for widget_id in self.widget_ids: widget = layout[widget_id] widget.prepare(datastructure, **kw) self._getType().prepare(self, datastructure) def validate(self, datastructure, **kw): """Validate the underlying widgets.""" layout = aq_parent(aq_inner(self)) ret = 1 self._getType().validate(self, datastructure, post_validate=0) for widget_id in self.widget_ids: widget = layout[widget_id] ret = widget.validate(datastructure, **kw) and ret return ret and self._getType().validate(self, datastructure) def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" layout = aq_parent(aq_inner(self)) widget_infos = kw['widget_infos'] render = self._getRenderMethod() cells = [] for widget_id in self.widget_ids: cell = {} cell.update(widget_infos[widget_id]) # widget, widget_mode widget = layout[widget_id] widget_mode = cell['widget_mode'] rendered = widget.render(widget_mode, datastructure, **kw) rendered = rendered.strip() cell['widget_rendered'] = rendered cells.append(cell) return render(mode=mode, datastructure=datastructure, cells=cells) InitializeClass(CPSCompoundWidget) class CPSCompoundWidgetType(CPSWidgetType): """Compound widget type.""" meta_type = "CPS Compound Widget Type" cls = CPSCompoundWidget security = ClassSecurityInfo() _properties = CPSWidgetType._properties + ( {'id': 'render_method', 'type': 'string', 'mode': 'w', 'label': 'Render Method'}, {'id': 'prepare_validate_method', 'type': 'string', 'mode': 'w', 'label': 'Prepare & Validate Method'}, ) render_method = '' prepare_validate_method = None # API security.declarePrivate('getRenderMethod') def getRenderMethod(self, widget): """Get the render method.""" if not self.render_method: raise RuntimeError("Missing Render Method in widget type %s" % self.getId()) meth = getattr(widget, self.render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (self.render_method, self.getId())) return meth def prepare(self, widget, datastructure): if not self.prepare_validate_method: return meth = getattr(widget, self.prepare_validate_method, None) if meth: return meth('prepare', datastructure) raise RuntimeError("Unknown Validate Method %s for widget type %s" % (self.prepare_validate_method, self.getId())) def validate(self, widget, datastructure, post_validate=1): if not self.prepare_validate_method: return 1 meth = getattr(widget, self.prepare_validate_method, None) if meth: return meth('validate', datastructure, post_validate) raise RuntimeError("Unknown Validate Method %s for widget type %s" % (self.prepare_validate_method, self.getId())) InitializeClass(CPSCompoundWidgetType) ################################################## # # Register widget types. # WidgetTypeRegistry.register(CPSCustomizableWidgetType, CPSCustomizableWidget) WidgetTypeRegistry.register(CPSCompoundWidgetType, CPSCompoundWidget) WidgetTypeRegistry.register(CPSStringWidgetType, CPSStringWidget) WidgetTypeRegistry.register(CPSURLWidgetType, CPSURLWidget) WidgetTypeRegistry.register(CPSEmailWidgetType, CPSEmailWidget) WidgetTypeRegistry.register(CPSIdentifierWidgetType, CPSIdentifierWidget) WidgetTypeRegistry.register(CPSHeadingWidgetType, CPSHeadingWidget) WidgetTypeRegistry.register(CPSPasswordWidgetType, CPSPasswordWidget) WidgetTypeRegistry.register(CPSCheckBoxWidgetType, CPSCheckBoxWidget) WidgetTypeRegistry.register(CPSTextAreaWidgetType, CPSTextAreaWidget) WidgetTypeRegistry.register(CPSLinesWidgetType, CPSLinesWidget) WidgetTypeRegistry.register(CPSBooleanWidgetType, CPSBooleanWidget) WidgetTypeRegistry.register(CPSIntWidgetType, CPSIntWidget) WidgetTypeRegistry.register(CPSLongWidgetType, CPSLongWidget) WidgetTypeRegistry.register(CPSFloatWidgetType, CPSFloatWidget) WidgetTypeRegistry.register(CPSDateWidgetType, CPSDateWidget) WidgetTypeRegistry.register(CPSFileWidgetType, CPSFileWidget) WidgetTypeRegistry.register(CPSImageWidgetType, CPSImageWidget) WidgetTypeRegistry.register(CPSHtmlWidgetType, CPSHtmlWidget) WidgetTypeRegistry.register(CPSMethodWidgetType, CPSMethodWidget) WidgetTypeRegistry.register(CPSSelectWidgetType, CPSSelectWidget) WidgetTypeRegistry.register(CPSMultiSelectWidgetType, CPSMultiSelectWidget) WidgetTypeRegistry.register(CPSOrderedListWidgetType, CPSOrderedListWidget) WidgetTypeRegistry.register(CPSUnorderedListWidgetType, CPSUnorderedListWidget) CPSSchemas-0.19.0/CREDITS.txt0100444000374200017510000000024610030542431013670 0ustar benzopeCredits for the CPSSchemas product The link_popup.gif and search_popup.gif icons are from the default Gnome theme. Many thanks to their authors for their work. CPSSchemas-0.19.0/DataModel.py0100444000374200017510000002327410030542431014244 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: DataModel.py,v 1.47 2004/03/23 06:24:03 fermigier Exp $ """DataModel The DataModel is a transient object that holds information about a particular document's data structure, including the underlying schemas and the storage options. It is *not* a storage, it isn't persistent at all. Its purpose is: - being one single point of access for information on the structure of the document, as well as a single point of access for the document data, no matter with which schema and in which storage the data is located, - validating data before storage, - acting as a cache (read and write) for data. This is only really useful for data that is not stored in the ZODB, but for simplicity *all* data is cached. (NOTIMPLEMENTED). The storage itself is done through a storage adapter. """ from zLOG import LOG, DEBUG, WARNING from Acquisition import aq_base from UserDict import UserDict from cgi import escape from Globals import InitializeClass from AccessControl import ClassSecurityInfo, Unauthorized from AccessControl import getSecurityManager from Products.CMFCore.utils import _checkPermission from Products.CMFCore.CMFCorePermissions import ModifyPortalContent from Products.CPSSchemas.Field import ReadAccessError class ValidationError(Exception): """Validation error during field storage.""" pass class DataModel(UserDict): """An abstraction for the data stored in an object. """ security = ClassSecurityInfo() security.setDefaultAccess('allow') def __init__(self, ob, adapters=(), proxy=None, context=None, add_roles=()): """Constructor. Proxy must be passed, if different than the object, so that an editable content can be created at commit time. Context must be passed if the widgets or fields have some placeful computations to do. Be careful that the context may not be the proxy but its container during creation. The context is also the one used for acl checks. """ UserDict.__init__(self) # self.data initialized by UserDict self._ob = ob self._adapters = adapters self._proxy = proxy if context is None: if proxy is not None: context = proxy else: context = ob self._context = context fields = {} schemas = [] for adapter in adapters: schema = adapter.getSchema() for fieldid, field in schema.items(): if fields.has_key(fieldid): LOG('DataModel.__init__', WARNING, "Two schemas have field id '%s', ignoring schema '%s'" % (fieldid, schema.getId())) continue fields[fieldid] = field schemas.append(schema) self._schemas = tuple(schemas) self._fields = fields # Precomputed things used for validation user = getSecurityManager().getUser() self._acl_cache_user = user self._setAddRoles(add_roles) self._check_acls = 1 def _setAddRoles(self, add_roles): user = self._acl_cache_user user_roles = (tuple(user.getRolesInContext(self._context)) + tuple(add_roles)) self._acl_cache_user_roles = user_roles self._acl_cache_permissions = {} # dict with perm: hasit/not # # Restricted accessors # def checkReadAccess(self, key): if self._check_acls: self._fields[key].checkReadAccess(self, self._context) def checkWriteAccess(self, key): if self._check_acls: self._fields[key].checkWriteAccess(self, self._context) def __getitem__(self, key): self.checkReadAccess(key) return self.data[key] def get(self, key, failobj=None): try: self.checkReadAccess(key) except (ReadAccessError, KeyError): return failobj return self.data.get(key, failobj) def items(self): for key in self.data.keys(): self.checkReadAccess(key) return self.data.items() def values(self): for key in self.data.keys(): self.checkReadAccess(key) return self.data.values() def popitem(self): key, item = self.data.popitem() self.checkReadAccess(key) return key, item def pop(self, key): # python2.3 self.checkReadAccess(key) return self.data.pop(key) def __setitem__(self, key, item): self.checkWriteAccess(key) self.data[key] = item # Expose setter as method for restricted code. def set(self, key, item): self.checkWriteAccess(key) self.data[key] = item def update(self, dict): for key in dict.keys(): self.checkWriteAccess(key) UserDict.update(self, dict) def setdefault(self, key, failobj=None): self.checkReadAccess(key) self.checkWriteAccess(key) return UserDict.setdefault(self, key, failobj=failobj) # XXX python2.2 iterators not done. # # DataModel accessors # def getObject(self): """Get the object this DataModel is about.""" # XXX used by what ??? return self._ob def getProxy(self): """Get the proxy of the object for this DataModel.""" return self._proxy def getContext(self): """Get the context for this DataModel.""" return self._context # # Fetch and commit # def _fetch(self): """Fetch the data into local dict for user access.""" for adapter in self._adapters: self.data.update(adapter.getData()) def _setEditable(self): """Set the editable object for this DataModel. Uses the proxy passed to the constructor. Future uses of the DataModel will refer to the editable object. Needed by CPS because getEditableContent may have to be called on the proxy before the object is ready for modification (CPS uses this to provide "freezing", a lazy unsharing of objects). """ proxy = self._proxy if proxy is None: return if not hasattr(aq_base(proxy), 'getEditableContent'): return ob = old_ob = self._ob if ob is None: return # Get the language from the doc to be sure we have the correct one. if hasattr(aq_base(ob), 'Language'): lang = ob.Language() else: lang = None ob = proxy.getEditableContent(lang=lang) if ob is not old_ob: self._setObject(ob, proxy=proxy) def _setObject(self, ob, proxy=None): """Set the object (and proxy) this datamodel is about. Used when a datamodel is switched to a new editable content, or to a newly created object. """ self._ob = ob self._proxy = proxy for adapter in self._adapters: adapter.setContextObject(ob) def _commit(self, check_perms=1): """Commit modified data into object. Returns the resulting object. Try to re-get an editable version of the object before modifying it. This is needed by CPS for frozen objects. """ self._setEditable() ob = self._ob # Check permission on the object. # This is global and in addition to field-level checks. # XXX This should somehow be checked by the adapters. if (ob is not None and check_perms and not _checkPermission(ModifyPortalContent, ob)): LOG("_commit", DEBUG, "Unauthorized to modify object %s" % (ob,)) raise Unauthorized("Cannot modify object") # Compute dependant fields. data = self.data for schema in self._schemas: for field_id, field in schema.items(): field.computeDependantFields(self._schemas, data, context=self._context) # Call the adapters to store the data. for adapter in self._adapters: adapter.setData(data) # XXX temporary until we have a better API for this if hasattr(aq_base(ob), 'postCommitHook'): ob.postCommitHook(datamodel=self) return ob # # Import/export # def _exportAsXML(self): """Export the datamodel as XML string.""" res = [] data = self.data for schema in self._schemas: for field_id, field in schema.items(): value = data[field_id] svalue, info = field._exportValue(value) s = ' ' res.append(s) return '\n'.join(res) def __repr__(self): return '' % (self.data,) InitializeClass(DataModel) CPSSchemas-0.19.0/DataStructure.py0100444000374200017510000001056010030542431015176 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Authors: Lennart Regebro # Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: DataStructure.py,v 1.15 2003/12/14 16:20:45 fermigier Exp $ """DataStructure A DataStructure holds the form-related data before display or after validation returned an error, for redisplay. """ from UserDict import UserDict from Globals import InitializeClass from AccessControl import ClassSecurityInfo from Products.CPSSchemas.Widget import widgetname class DataStructure(UserDict): """An abstraction for the data entered by the user or displayed. It also stores error messages if the data cannot be validated. It also stores the datamodel backing this datastructure. It's basically two dictionaries, one for data and one for errors. The data dictionary is exposed through the standard dictionary interface, while the error dictionary is exposed through specific methods. """ # Bugs/features: # - __setitem__ only updates the data, the errors will stay # unchanged. security = ClassSecurityInfo() security.setDefaultAccess('allow') def __init__(self, data={}, errors={}, datamodel=None): self.data = {} self.data.update(data) self.errors = {} self.errors.update(errors) self.datamodel = datamodel # Override standard dictionary stuff: def clear(self): self.data.clear() self.errors.clear() def __delitem__(self, key): del self.data[key] if self.errors.has_key(key): del self.errors[key] def copy(self): if self.__class__ is DataStructure: return DataStructure(self.data, self.errors) # Some kind of subclass. Just return a dict with data. # If more is needed, override copy() in the subclass. return self.data.copy() def popitem(self): key, val = self.data.popitem() if self.errors.has_key(key): del self.errors[key] return key, val def update(self, dict): if isinstance(dict, UserDict): self.data.update(dict.data) elif isinstance(dict, type(self.data)): self.data.update(dict) # XXX do same for errors else: for k, v in dict.items(): self.data[k] = v def updateFromMapping(self, mapping): """Updates and validates field data from a mapping. This method (unlike the standard update method) will only update existing fields. It is used to set the data from request (or indeed any other object with a mapping-interface). No validation is done. XXX: explain why is used instead of . """ for key in self.keys(): if mapping.has_key(widgetname(key)): self[key] = mapping[widgetname(key)] # Expose setter as method for restricted code. def set(self, key, value): self.__setitem__(key, value) # Expose the errors dictionary. def getError(self, key): return self.errors.get(key) def hasError(self, key): return self.errors.has_key(key) def setError(self, key, message): self.errors[key] = message # XXX: Not used, seemingly def delError(self, key): """Removes an error""" if self.errors.has_key(key): del self.errors[key] # XXX: Not used, seemingly def getErrorsFields(self): return self.errors.keys() # XXX: Not used, seemingly def getErrors(self): return self.errors # XXX Should it return the original or a copy? def getDataModel(self): """Return the datamodel associated with this datastructure.""" return self.datamodel InitializeClass(DataStructure) CPSSchemas-0.19.0/EpozPatch.py0100444000374200017510000000213010030542431014273 0ustar benzope# (C) Copyright 2004 Nuxeo SARL # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: EpozPatch.py,v 1.1 2004/02/19 11:29:43 ben Exp $ from Products import Epoz from Products.PageTemplates.PageTemplateFile import PageTemplateFile from zLOG import LOG, INFO LOG('EpozPatch', INFO, 'Patching epoz_blank_iframe.html') # override to load all css Epoz.methods.update({'epoz_blank_iframe.html': PageTemplateFile( 'skins/cps_schemas/epoz_blank_iframe.html.pt', globals())}) CPSSchemas-0.19.0/ExtendedWidgets.py0100444000374200017510000006123010030542431015473 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: ExtendedWidgets.py,v 1.32 2004/03/15 20:41:28 fermigier Exp $ """Extended widget types. Definition of extended widget types. """ from zLOG import LOG, DEBUG from cgi import escape from re import match from Globals import InitializeClass from Acquisition import aq_base from types import StringType from DateTime.DateTime import DateTime from ZPublisher.HTTPRequest import FileUpload from OFS.Image import cookId, File from Products.PythonScripts.standard import structured_text, newline_to_br from Products.CMFCore.utils import getToolByName from Products.CPSSchemas.WidgetTypesTool import WidgetTypeRegistry from Products.CPSSchemas.Widget import CPSWidget, CPSWidgetType from Products.CPSSchemas.BasicWidgets import CPSSelectWidget, \ _isinstance, CPSStringWidget, CPSImageWidget, CPSNoneWidget, CPSFileWidget ################################################## # previously named CPSTextAreaWidget in BasicWidget r1.78 class CPSTextWidget(CPSStringWidget): """Text widget.""" meta_type = "CPS Text Widget" # Warning if configurable the widget require field[1] and field[2] field_types = ('CPS String Field', # text value 'CPS String Field', # render_position if configurable 'CPS String Field') # render_format if configurable field_inits = ({'is_searchabletext': 1,}, {}, {}) _properties = CPSWidget._properties + ( {'id': 'width', 'type': 'int', 'mode': 'w', 'label': 'Width'}, {'id': 'height', 'type': 'int', 'mode': 'w', 'label': 'Height'}, {'id': 'size_max', 'type': 'int', 'mode': 'w', 'label': 'Max Size'}, {'id': 'render_position', 'type': 'selection', 'mode': 'w', 'select_variable': 'all_render_positions', 'label': 'Render position'}, {'id': 'render_format', 'type': 'selection', 'mode': 'w', 'select_variable': 'all_render_formats', 'label': 'Render format'}, {'id': 'configurable', 'type': 'selection', 'mode': 'w', 'select_variable': 'all_configurable', 'label': 'What is user configurable, require extra fields'}, ) all_configurable = ['nothing', 'position', 'format', 'position and format'] all_render_positions = ['normal', 'col_left', 'col_right'] all_render_formats = ['text', 'stx', 'html'] # remove 'pre' as we do the # same using text width = 40 height = 5 size_max = 0 render_position = all_render_positions[0] render_format = all_render_formats[0] configurable = 'nothing' def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() widget_id = self.getWidgetId() datastructure[widget_id] = str(datamodel[self.fields[0]]) rposition = self.render_position rformat = self.render_format if self.configurable != 'nothing': if len(self.fields) > 1: v = datamodel[self.fields[1]] if v in self.all_render_positions: rposition = v if len(self.fields) > 2: v = datamodel[self.fields[2]] if v in self.all_render_formats: rformat = v datastructure[widget_id + '_rposition'] = rposition datastructure[widget_id + '_rformat'] = rformat def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() err, v = self._extractValue(datastructure[widget_id]) if err: datastructure.setError(widget_id, err) datastructure[widget_id] = v else: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v if self.configurable != 'nothing': if len(self.fields) > 1: rposition = datastructure[widget_id + '_rposition'] if rposition and rposition in self.all_render_positions: datamodel[self.fields[1]] = rposition if len(self.fields) > 2: rformat = datastructure[widget_id + '_rformat'] if rformat and rformat in self.all_render_formats: datamodel[self.fields[2]] = rformat return not err def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" render_method = 'widget_text_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) widget_id = self.getWidgetId() value = datastructure[widget_id] rposition = datastructure[widget_id + '_rposition'] rformat = datastructure[widget_id + '_rformat'] if mode == 'view': if rformat == 'pre': value = '
'+escape(value)+'
' elif rformat == 'stx': value = structured_text(value) elif rformat == 'text': value = newline_to_br(value) elif rformat == 'html': pass else: RuntimeError("unknown render_format '%s' for '%s'" % (rformat, self.getId())) return meth(mode=mode, datastructure=datastructure, value=value, render_position=rposition, render_format=rformat, configurable=str(self.configurable)) InitializeClass(CPSTextWidget) class CPSTextWidgetType(CPSWidgetType): """Text widget type.""" meta_type = "CPS Text Widget Type" cls = CPSTextWidget InitializeClass(CPSTextWidgetType) ################################################## # previously named CPSDateWidget in BasicWidget r1.78 class CPSDateTimeWidget(CPSWidget): """DateTime widget.""" meta_type = "CPS DateTime Widget" field_types = ('CPS DateTime Field',) _properties = CPSWidget._properties + ( {'id': 'view_format', 'type': 'string', 'mode': 'w', 'label': 'View format (short, medium or long)'}, {'id': 'time_setting', 'type': 'boolean', 'mode': 'w', 'label': 'Enabling the setting of time of the day'}, ) view_format = 'medium' time_setting = 1 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() v = datamodel[self.fields[0]] if not v and self.is_required: v = DateTime() widget_id = self.getWidgetId() date = '' hour = minute = '' if v == 'None': v = None if v: if type(v) is StringType: v = DateTime(v) d = str(v.day()) m = str(v.month()) y = str(v.year()) locale = self.Localizer.get_selected_language() if locale in ('en', 'hu', ): date = m+'/'+d+'/'+y else: date = d+'/'+m+'/'+y hour = str(v.h_24()) minute = str(v.minute()) datastructure[widget_id] = v datastructure[widget_id+'_date'] = date datastructure[widget_id+'_hour'] = hour or '12' datastructure[widget_id+'_minute'] = minute or '00' def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" datamodel = datastructure.getDataModel() field_id = self.fields[0] widget_id = self.getWidgetId() date = datastructure[widget_id+'_date'].strip() hour = datastructure[widget_id+'_hour'].strip() or '12' minute = datastructure[widget_id+'_minute'].strip() or '00' if not (date): if self.is_required: datastructure[widget_id] = '' datastructure.setError(widget_id, "cpsschemas_err_required") return 0 else: datamodel[field_id] = None return 1 if not match(r'^[0-9]?[0-9]/[0-9]?[0-9]/[0-9]{2,4}$', date): datastructure.setError(widget_id, 'cpsschemas_err_date') return 0 locale = self.Localizer.get_selected_language() if locale in ('en', 'hu', ): m, d, y = date.split('/') else: d, m, y = date.split('/') try: v = DateTime(int(y), int(m), int(d), int(hour), int(minute)) except (ValueError, TypeError, DateTime.DateTimeError, DateTime.SyntaxError, DateTime.DateError): datastructure.setError(widget_id, 'cpsschemas_err_date') return 0 else: datastructure[widget_id] = v datamodel[field_id] = v return 1 def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" render_method = 'widget_datetime_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) return meth(mode=mode, datastructure=datastructure) InitializeClass(CPSDateTimeWidget) class CPSDateTimeWidgetType(CPSWidgetType): """DateTime widget type.""" meta_type = "CPS DateTime Widget Type" cls = CPSDateTimeWidget InitializeClass(CPSDateTimeWidgetType) ################################################## class CPSAttachedFileWidget(CPSFileWidget): """AttachedFile widget.""" meta_type = "CPS AttachedFile Widget" # XXX The second and third fields are actually optional... field_types = ('CPS File Field', 'CPS String Field', 'CPS File Field') field_inits = ({'is_searchabletext': 0, 'suffix_text': '_f1', # _f# are autocomputed field ext 'suffix_html': '_f2', }, {'is_searchabletext': 1, }, {'is_searchabletext': 0, }, ) _properties = CPSWidget._properties + ( {'id': 'deletable', 'type': 'boolean', 'mode': 'w', 'label': 'Deletable'}, {'id': 'size_max', 'type': 'int', 'mode': 'w', 'label': 'Maximum file size'}, ) deletable = 1 size_max = 4*1024*1024 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() widget_id = self.getWidgetId() datastructure[widget_id] = datamodel[self.fields[0]] # Compute preview info for widget. if len(self.fields) > 2 and datamodel.get(self.fields[2]) is not None: preview_id = self.fields[2] else: preview_id = None datastructure[widget_id + '_preview'] = preview_id # make update from request work datastructure[widget_id + '_choice'] = '' def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" datamodel = datastructure.getDataModel() field_id = self.fields[0] widget_id = self.getWidgetId() choice = datastructure[widget_id+'_choice'] err = 0 if choice == 'delete': datamodel[field_id] = None elif choice == 'change' and datastructure.get(widget_id): file = datastructure[widget_id] if not _isinstance(file, FileUpload): err = 'cpsschemas_err_file' else: ms = self.size_max if file.read(1) == '': err = 'cpsschemas_err_file_empty' elif ms and len(file.read(ms)) == ms: err = 'cpsschemas_err_file_too_big' else: file.seek(0) fileid = cookId('', '', file)[0] file = File(fileid, fileid, file) registry = getToolByName(self, 'mimetypes_registry') mimetype = registry.lookupExtension(fileid.lower()) if mimetype and file.content_type != mimetype.normalized(): LOG('CPSAttachedFileWidget', DEBUG, 'Fixing mimetype from %s to %s' % ( file.content_type, mimetype.normalized())) file.manage_changeProperties( content_type=mimetype.normalized()) LOG('CPSAttachedFileWidget', DEBUG, 'validate change set %s' % `file`) datamodel[field_id] = file if err: datastructure.setError(widget_id, err) LOG('CPSAttachedFileWidget', DEBUG, 'error %s on %s' % (err, `file`)) else: self.prepare(datastructure) return not err def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" render_method = 'widget_attachedfile_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) if mode == 'create': file_info = {'empty_file': 1, 'content_url': '', 'current_name': '-', 'mimetype': '', 'last_modified': '', } else: file_info = self.getFileInfo(datastructure) return meth(mode=mode, datastructure=datastructure, **file_info) InitializeClass(CPSAttachedFileWidget) class CPSAttachedFileWidgetType(CPSWidgetType): """AttachedFile widget type.""" meta_type = "CPS AttachedFile Widget Type" cls = CPSAttachedFileWidget InitializeClass(CPSAttachedFileWidgetType) ################################################# class CPSRichTextEditorWidget(CPSWidget): """Rich Text Editor widget.""" meta_type = "CPS Rich Text Editor Widget" field_types = ('CPS String Field',) field_inits = ({'is_searchabletext': 1,},) width = 40 height = 5 _properties = CPSWidget._properties + ( {'id': 'width', 'type': 'int', 'mode': 'w', 'label': 'Width'}, {'id': 'height', 'type': 'int', 'mode': 'w', 'label': 'Height'}, ) def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = datamodel[self.fields[0]] def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" value = datastructure[self.getWidgetId()] try: v = str(value) except ValueError: datastructure.setError(self.getWidgetId(), "cpsschemas_err_textarea") ok = 0 else: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v ok = 1 return ok def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" # XXXX # Not finished !! Just for tests value = datastructure[self.getWidgetId()] if mode == 'view': # To change return structured_text(value) elif mode == 'edit': render_method = 'widget_rte_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) value = datastructure[self.getWidgetId()] if hasattr(aq_base(value), 'getId'): current_name = value.getId() else: current_name = '-' return meth(mode=mode, datastructure=datastructure, current_name=current_name) raise RuntimeError("unknown mode %s" % mode) InitializeClass(CPSRichTextEditorWidget) class CPSRichTextEditorWidgetType(CPSWidgetType): """RTE widget type""" meta_type = "CPS Rich Text Editor Widget Type" cls = CPSRichTextEditorWidget InitializeClass(CPSRichTextEditorWidgetType) ########################################## class CPSExtendedSelectWidget(CPSSelectWidget): """Extended Select widget.""" meta_type = "CPS ExtendedSelect Widget" def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" if mode == 'view': return CPSSelectWidget.render(self, mode, datastructure) elif mode == 'edit': render_method = 'widget_extendedselect_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) return meth(mode=mode, datastructure=datastructure, vocabulary=self._getVocabulary(datastructure)) else: raise RuntimeError('unknown mode %s' % mode) InitializeClass(CPSExtendedSelectWidget) class CPSExtendedSelectWidgetType(CPSWidgetType): """Extended Select widget type.""" meta_type = "CPS ExtendedSelect Widget Type" cls = CPSExtendedSelectWidget InitializeClass(CPSExtendedSelectWidgetType) ########################################## class CPSInternalLinksWidget(CPSWidget): """Internal Links widget.""" meta_type = "CPS InternalLinks Widget" field_types = ('CPS String List Field',) field_inits = ({'is_searchabletext': 1,},) _properties = CPSWidget._properties + ( {'id': 'new_window', 'type': 'boolean', 'mode': 'w', 'label': 'Display in a new window'}, {'id': 'size', 'type': 'int', 'mode': 'w', 'label': 'Links displayed'}, ) new_window = 0 size = 0 def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() datastructure[self.getWidgetId()] = datamodel[self.fields[0]] def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" widget_id = self.getWidgetId() value = datastructure[widget_id] err = 0 if self.is_required and (value == [] or value == ['']): err = 'cpsschemas_err_required' v = [] for line in value: if line.strip() != '': v.append(line) if err: datastructure.setError(widget_id, err) else: datamodel = datastructure.getDataModel() datamodel[self.fields[0]] = v return not err def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" if mode not in ('view', 'edit'): raise RuntimeError('unknown mode %s' % mode) render_method = 'widget_internallinks_render' meth = getattr(self, render_method, None) return meth(mode=mode, datastructure=datastructure) InitializeClass(CPSInternalLinksWidget) class CPSInternalLinksWidgetType(CPSWidgetType): """Internal links widget type.""" meta_type = "CPS InternalLinks Widget Type" cls = CPSInternalLinksWidget InitializeClass(CPSInternalLinksWidgetType) ################################################## class CPSPhotoWidget(CPSImageWidget): """Photo widget.""" meta_type = "CPS Photo Widget" field_types = ('CPS Image Field', # Image 'CPS String Field', # Sub title 'CPS String Field',) # render_position if configurable field_inits = ({}, {'is_searchabletext': 1,}, {}) _properties = CPSImageWidget._properties + ( {'id': 'render_position', 'type': 'selection', 'mode': 'w', 'select_variable': 'all_render_positions', 'label': 'Render position'}, {'id': 'configurable', 'type': 'selection', 'mode': 'w', 'select_variable': 'all_configurable', 'label': 'What is user configurable, require extra fields'}, ) all_configurable = ['nothing', 'position'] all_render_positions = ['left', 'center', 'right'] allow_resize = 1 configurable = all_configurable[0] render_position = all_render_positions[0] def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" datamodel = datastructure.getDataModel() widget_id = self.getWidgetId() datastructure[widget_id] = datamodel[self.fields[0]] datastructure[widget_id + '_subtitle'] = datamodel[self.fields[1]] rposition = self.render_position if self.configurable != 'nothing': if len(self.fields) > 2: v = datamodel[self.fields[2]] if v in self.all_render_positions: rposition = v datastructure[widget_id + '_rposition'] = rposition # make update from request work datastructure[widget_id + '_choice'] = '' if self.allow_resize: datastructure[widget_id + '_resize'] = '' def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" datamodel = datastructure.getDataModel() field_id = self.fields[0] widget_id = self.getWidgetId() ret = CPSImageWidget.validate(self, datastructure, **kw) if ret and datamodel[field_id]: datamodel[self.fields[1]] = datastructure[widget_id + '_subtitle'] if self.configurable != 'nothing': if len(self.fields) > 2: rposition = datastructure[widget_id + '_rposition'] if rposition and rposition in self.all_render_positions: datamodel[self.fields[2]] = rposition return ret def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" render_method = 'widget_photo_render' meth = getattr(self, render_method, None) if meth is None: raise RuntimeError("Unknown Render Method %s for widget type %s" % (render_method, self.getId())) widget_id = self.getWidgetId() rposition = datastructure[widget_id + '_rposition'] subtitle = datastructure[widget_id + '_subtitle'] if kw['layout_mode'] == 'create': img_info = {'empty_file': 1, 'content_url': '', 'image_tag': '', 'current_name': '-', 'mimetype': '', 'last_modified': '', } else: img_info = self.getImageInfo(datastructure) return meth(mode=mode, datastructure=datastructure, subtitle=subtitle, render_position=rposition, configurable=str(self.configurable), **img_info) InitializeClass(CPSPhotoWidget) class CPSPhotoWidgetType(CPSWidgetType): """Photo widget type.""" meta_type = "CPS Photo Widget Type" cls = CPSPhotoWidget # XXX: TBD InitializeClass(CPSPhotoWidgetType) ################################################## class CPSLinkWidget(CPSNoneWidget): """Deprecated Link Widget now using compound widget.""" meta_type = "CPS Link Widget" InitializeClass(CPSLinkWidget) ################################################## # # Register widget types. # WidgetTypeRegistry.register(CPSTextWidgetType, CPSTextWidget) WidgetTypeRegistry.register(CPSDateTimeWidgetType, CPSDateTimeWidget) WidgetTypeRegistry.register(CPSAttachedFileWidgetType, CPSAttachedFileWidget) WidgetTypeRegistry.register(CPSRichTextEditorWidgetType, CPSRichTextEditorWidget) WidgetTypeRegistry.register(CPSExtendedSelectWidgetType, CPSExtendedSelectWidget) WidgetTypeRegistry.register(CPSInternalLinksWidgetType, CPSInternalLinksWidget) WidgetTypeRegistry.register(CPSPhotoWidgetType, CPSPhotoWidget) CPSSchemas-0.19.0/Field.py0100444000374200017510000003330710030542431013433 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: Field.py,v 1.28 2004/03/23 12:43:11 fermigier Exp $ """Field Base classes for fields, the individual parts of a schema. """ from zLOG import LOG, DEBUG from copy import deepcopy from ComputedAttribute import ComputedAttribute from Globals import InitializeClass, DTMLFile from DateTime.DateTime import DateTime from AccessControl import ClassSecurityInfo from AccessControl import getSecurityManager from AccessControl.PermissionRole import rolesForPermissionOn from Products.CMFCore.Expression import Expression from Products.CMFCore.Expression import getEngine from Products.CMFCore.CMFCorePermissions import View from Products.CMFCore.utils import SimpleItemWithProperties from Products.CMFCore.utils import getToolByName from Products.CPSSchemas.PropertiesPostProcessor import PropertiesPostProcessor class AccessError(ValueError): """Raised by a field when access is denied.""" def __init__(self, field, message=''): self.field = field self.message = message def __str__(self): s = "%s access to %s denied" % (self.type, self.field) if self.message: s += " ("+self.message+") " return s class ReadAccessError(AccessError): type = "Read" class WriteAccessError(AccessError): type = "Write" class ValidationError(ValueError): """Raised by a widget or a field when user input is incorrect.""" pass class Field(PropertiesPostProcessor, SimpleItemWithProperties): """Basic Field. A field is part of a schema and describes a type of data that can be stored. A field does not describe graphical rendering, it only hints at what is the preferred method for rendering. """ security = ClassSecurityInfo() _propertiesBaseClass = SimpleItemWithProperties _properties = ( {'id': 'getFieldIdProperty', 'type': 'string', 'mode': '', 'label': "Id"}, {'id': 'default_expr', 'type': 'string', 'mode': 'w', 'label': "Default value expression"}, {'id': 'is_searchabletext', 'type': 'boolean', 'mode': 'w', 'label': "Indexed by SearchableText"}, {'id': 'acl_read_permissions', 'type': 'string', 'mode': 'w', 'label': "ACL: read permissions"}, {'id': 'acl_read_roles', 'type': 'string', 'mode': 'w', 'label': "ACL: read roles"}, {'id': 'acl_read_expr', 'type': 'string', 'mode': 'w', 'label': "ACL: read expression"}, {'id': 'acl_write_permissions', 'type': 'string', 'mode': 'w', 'label': "ACL: write permission"}, {'id': 'acl_write_roles', 'type': 'string', 'mode': 'w', 'label': "ACL: write roles"}, {'id': 'acl_write_expr', 'type': 'string', 'mode': 'w', 'label': "ACL: write expression"}, #{'id': 'is_subschema', 'type': 'boolean', 'mode': 'w', # 'label': 'Is Subschema'}, #{'id': 'is_multi_valued', 'type': 'boolean', 'mode': 'w', # 'label': 'Is Multi-Valued'}, #{'id': 'vocabulary', 'type': 'string', 'mode': 'w', # 'label': 'Vocabulary'}, {'id': 'read_ignore_storage', 'type': 'boolean', 'mode': 'w', 'label': "Read: ignore storage"}, {'id': 'read_process_expr', 'type': 'string', 'mode': 'w', 'label': "Read: expression"}, {'id': 'read_process_dependent_fields', 'type': 'tokens', 'mode': 'w', 'label': "Read: expression dependent fields"}, {'id': 'write_ignore_storage', 'type': 'boolean', 'mode': 'w', 'label': "Write: ignore storage"}, {'id': 'write_process_expr', 'type': 'string', 'mode': 'w', 'label': "Write: expression"}, ) default_expr = 'string:' is_searchabletext = 0 acl_read_permissions = '' acl_read_roles = '' acl_read_expr = '' acl_write_permissions = '' acl_write_roles = '' acl_write_expr = '' #is_subschema = 0 #is_multi_valued = 0 #vocabulary = None read_ignore_storage = 0 read_process_expr = '' read_process_dependent_fields = [] write_ignore_storage = 0 write_process_expr = '' default_expr_c = Expression(default_expr) acl_read_permissions_c = [] acl_read_roles_c = [] acl_read_expr_c = None acl_write_permissions_c = [] acl_write_roles_c = [] acl_write_expr_c = None read_process_expr_c = None write_process_expr_c = None _properties_post_process_split = ( ('acl_read_permissions', 'acl_read_permissions_c', ',;'), ('acl_read_roles', 'acl_read_roles_c', ',; '), ('acl_write_permissions', 'acl_write_permissions_c', ',;'), ('acl_write_roles', 'acl_write_roles_c', ',; '), ) _properties_post_process_tales = ( ('default_expr', 'default_expr_c'), ('acl_read_expr', 'acl_read_expr_c'), ('acl_write_expr', 'acl_write_expr_c'), ('read_process_expr', 'read_process_expr_c'), ('write_process_expr', 'write_process_expr_c'), ) def __init__(self, id, **kw): self.id = id self.manage_changeProperties(**kw) security.declarePrivate('getDefault') def getDefault(self): """Get the default value for this field.""" if not self.default_expr_c: return None expr_context = self._createDefaultExpressionContext() return self.default_expr_c(expr_context) def _createDefaultExpressionContext(self): """Create an expression context for default value evaluation.""" mapping = { 'field': self, 'user': getSecurityManager().getUser(), 'portal': getToolByName(self, 'portal_url').getPortalObject(), 'DateTime': DateTime, 'nothing': None, } return getEngine().getContext(mapping) security.declarePrivate('computeDependantFields') def computeDependantFields(self, schemas, data, context=None): """Compute dependant fields. Has access to the current schemas, and may update the data from the datamodel. The context argument is passed to look for placeful information. This is used for fields that update other fields when they are themselves updated. """ pass security.declarePublic('getFieldId') def getFieldId(self): """Get this field's id.""" id = self.getId() if hasattr(self, 'getIdUnprefixed'): # Inside a FolderWithPrefixedIds. return self.getIdUnprefixed(id) else: # Standalone field. return id getFieldIdProperty = ComputedAttribute(getFieldId, 1) # # Import/export # def _exportValue(self, value): """Export this field's value as a string. Returns the string and a dict with any info needed if it makes sense and will be needed for import. Called by the datamodel during export. """ # Default implementation suitable for simple fields. if value is None: return '', {'none': 'true'} else: return str(value), {} def _importValue(self, svalue, info): """Import field value. Returns a value. Receives a string and additional info as arguments. """ if info and info['none'] == 'true': return None raise NotImplementedError # # Storage interaction # def _createStorageExpressionContext(self, value, data): """Create an expression context for field storage process.""" # Put all the names in the data in the namespace. mapping = data.copy() mapping.update({ 'value': value, 'data': data, 'field': self, 'user': getSecurityManager().getUser(), 'portal': getToolByName(self, 'portal_url').getPortalObject(), 'DateTime': DateTime, 'nothing': None, }) return getEngine().getContext(mapping) security.declarePrivate('processValueAfterRead') def processValueAfterRead(self, value, data): """Process value after read from storage.""" if not self.read_process_expr_c: return value expr_context = self._createStorageExpressionContext(value, data) return self.read_process_expr_c(expr_context) security.declarePrivate('processValueBeforeWrite') def processValueBeforeWrite(self, value, data): """Process value before write to storage.""" if not self.write_process_expr_c: return value expr_context = self._createStorageExpressionContext(value, data) return self.write_process_expr_c(expr_context) # # ACLs # def _createAclExpressionContext(self, datamodel): """Create an expression context for ACL evaluation.""" context = datamodel._context mapping = { 'field': self, 'datamodel': datamodel, 'user': datamodel._acl_cache_user, 'roles': datamodel._acl_cache_user_roles, 'nothing': None, # Useful for objects 'context': context, 'proxy': datamodel._proxy, # Useful for directories 'dir': context, } return getEngine().getContext(mapping) def _checkAccess(self, datamodel, context, acl_permissions, acl_roles, acl_expr_c, exception, StringType=type('')): """Check that field can be accesed. Raises an exception if not. The datamodel is used to cache often used things. """ user = datamodel._acl_cache_user if acl_permissions: perms_cache = datamodel._acl_cache_permissions ok = 0 for perm in acl_permissions: ok = perms_cache.get(perm) if ok is None: roles = rolesForPermissionOn(perm, context) if type(roles) is StringType: roles = [roles] ok = user.allowed(context, roles) perms_cache[perm] = ok if ok: break if not ok: raise exception(self.getFieldId(), 'permissions') if acl_roles: user_roles = datamodel._acl_cache_user_roles ok = 0 for role in acl_roles: if role in user_roles: ok = 1 break if not ok: raise exception(self.getFieldId(), 'roles') if acl_expr_c: expr_context = self._createAclExpressionContext(datamodel) if not acl_expr_c(expr_context): raise exception(self.getFieldId(), 'expression') def checkReadAccess(self, datamodel, context): """Check that field can be read. Raises an exception if not. The datamodel is used to cache often used things. """ self._checkAccess(datamodel, context, self.acl_read_permissions_c, self.acl_read_roles_c, self.acl_read_expr_c, ReadAccessError) def checkWriteAccess(self, datamodel, context): """Check that field can be written. Raises an exception if not. """ self._checkAccess(datamodel, context, self.acl_write_permissions_c, self.acl_write_roles_c, self.acl_write_expr_c, WriteAccessError) # # Validation # # XXX this is never called yet. security.declarePublic('validate') def validate(self, value): """Validate a value.""" raise NotImplementedError InitializeClass(Field) class CPSField(Field): """Persistent Field.""" meta_type = "CPS Field" security = ClassSecurityInfo() security.declareObjectProtected(View) # XXX correct ? InitializeClass(CPSField) addCPSFieldForm = DTMLFile('zmi/field_addform', globals()) def addCPSField(container, id, REQUEST=None): """Add a CPS Field.""" ob = CPSField(id) container._setObject(id, ob) ob = container._getOb(id) if REQUEST is not None: REQUEST.RESPONSE.redirect(ob.absolute_url() + "/manage_main") def propertiesWithType(properties, id, type): properties = deepcopy(properties) for prop in properties: if prop['id'] == id: prop['type'] = type return properties class FieldRegistry: """Registry of the available field types.""" def __init__(self): self._field_types = [] self._field_classes = {} def register(self, cls): """Register a class for a field.""" field_type = cls.meta_type self._field_types.append(field_type) self._field_classes[field_type] = cls def listFieldTypes(self): """Return the list of field types.""" return self._field_types[:] def makeField(self, field_type, id, **kw): """Factory to make a field of the given type.""" try: cls = self._field_classes[field_type] except KeyError: raise KeyError("No field type '%s'" % field_type) return cls(id, **kw) # Singleton FieldRegistry = FieldRegistry() CPSSchemas-0.19.0/FileUtils.py0100444000374200017510000000445110030542431014306 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: FileUtils.py,v 1.8 2003/11/28 13:53:23 fermigier Exp $ """FileUtils Utilities to deal with files: conversion to HTML, or text. """ from zLOG import LOG, DEBUG from Products.CMFCore.utils import getToolByName def _convertFileToMimeType(file, mime_type, context=None): """Convert a file to a new mime type. The file argument may be a Zope File object or None. The context argument is used to find placeful tools. Returns a string, or None if no conversion is possible. """ if file is None: return None transformer = getToolByName(context, 'portal_transforms', None) if transformer is None: LOG('convertFileToText', DEBUG, 'No portal_transforms') return None raw = str(file) if not raw: return None LOG('convertFileToText', DEBUG, 'File is %s' % repr(file)) current_mime_type = getattr(file, 'content_type', 'application/octet-stream') data = transformer.convertTo(mime_type, raw, mimetype=current_mime_type, # filename='fooXXX', encoding='', ) if not data: return None return data.getData() def convertFileToText(file, context=None): """Convert a file to text. Returns a string, or None if no conversion is possible. """ return _convertFileToMimeType(file, 'text/plain', context=context) def convertFileToHtml(file, context=None): """Convert a file to HTML. Returns a string, or None if no conversion is possible. """ return _convertFileToMimeType(file, 'text/html', context=context) CPSSchemas-0.19.0/FolderWithPrefixedIds.py0100444000374200017510000000670210030542431016605 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: FolderWithPrefixedIds.py,v 1.5 2003/09/12 18:17:58 guillaum Exp $ """ Folder whose subobjects' ids are automatically prefixed, so that they can be arbitrary. """ from Globals import InitializeClass from AccessControl import ClassSecurityInfo from OFS.Folder import Folder from Products.CMFCore.CMFCorePermissions import AccessContentsInformation class FolderWithPrefixedIds(Folder): """Folder with prefixed ids. All subobjects' ids are prefixed, so that they can be arbitrary. """ prefix = 'prefix__' security = ClassSecurityInfo() security.declarePrivate('addSubObject') def addSubObject(self, ob): """Add a subobject, with a correctly prefixed id. Returns the subobject in its acquisition chain. """ id = ob.getId() if not id.startswith(self.prefix): id = self.prefix + id ob._setId(id) self._setObject(id, ob) return self._getOb(id) security.declarePrivate('delSubObject') def delSubObject(self, id): """Delete a subobject, with a correctly prefixed id.""" if not id.startswith(self.prefix): id = self.prefix + id self._delObject(id) security.declarePublic('getIdUnprefixed') def getIdUnprefixed(self, id): """ """ if id.startswith(self.prefix): return id[len(self.prefix):] else: return id # Simple dict-like access without prefix def __getitem__(self, key): """Dictionary-like access without prefix.""" prefix = self.prefix if not key.startswith(prefix): key = prefix + key try: return self._getOb(key) except AttributeError: raise KeyError(key) security.declareProtected(AccessContentsInformation, 'keys') def keys(self): """Return subobjects ids without prefix.""" keys = [] prefix = self.prefix prefixlen = len(prefix) for id in self.objectIds(): if id.startswith(prefix): keys.append(id[prefixlen:]) return keys security.declareProtected(AccessContentsInformation, 'items') def items(self): """Return items, ids without prefix.""" items = [] prefix = self.prefix prefixlen = len(prefix) for id, value in self.objectItems(): if id.startswith(prefix): items.append((id[prefixlen:], value)) return items security.declareProtected(AccessContentsInformation, 'has_key') def has_key(self, key): """Test if key is present.""" if not key.startswith(self.prefix): key = self.prefix + key return key in self.objectIds() InitializeClass(FolderWithPrefixedIds) CPSSchemas-0.19.0/IVocabulary.py0100444000374200017510000000347210030542431014630 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: IVocabulary.py,v 1.1 2003/12/28 20:08:37 guillaum Exp $ """IVocabulary Vocabulary interfaces. """ from Interface import Interface class IVocabulary(Interface): """Interface for a basic Vocabulary. """ def __delitem__(key): """Delete an item from the vocabulary.""" def set(key, label, msgid=None): """Set a label for a key.""" def __getitem__(key): """Get a label for a key.""" def get(key, default=None): """Get a label for a key, default to None.""" def getMsgid(key, default=None): """Get a msgid for a key, default to None.""" def has_key(key): """Test if a key is present.""" def keys(): """Get the ordered list of keys.""" def items(): """Get the ordered list of (key, value).""" def values(): """Get the ordered list of values.""" class ITreeVocabulary(IVocabulary): """Interface for a tree-like vocabulary. """ def getDepth(key): """Get the depth of a key.""" def itemsWithDepth(): """Get the ordered list of (key, value, depth).""" CPSSchemas-0.19.0/LICENSE.TXT0100444000374200017510000004363410030542431013525 0ustar benzope GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. CPSSchemas-0.19.0/Layout.py0100444000374200017510000004464510030542431013674 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Authors: Lennart Regebro # Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: Layout.py,v 1.45 2003/12/13 09:34:24 fermigier Exp $ """Layout A layout describes how to render a set of widgets. """ from zLOG import LOG, DEBUG from copy import deepcopy from Globals import InitializeClass, DTMLFile from AccessControl import ClassSecurityInfo from OFS.Folder import Folder from Products.CMFCore.CMFCorePermissions import View from Products.CMFCore.CMFCorePermissions import ManagePortal from Products.CMFCore.CMFCorePermissions import ViewManagementScreens from Products.CMFCore.utils import SimpleItemWithProperties from Products.CMFCore.utils import getToolByName from Products.CPSSchemas.FolderWithPrefixedIds import FolderWithPrefixedIds from Products.CPSSchemas.WidgetTypesTool import WidgetTypeRegistry class LayoutContainer(Folder): """Layout Tool Stores persistent layout objects. """ meta_type = 'CPS Layout Container' security = ClassSecurityInfo() def __init__(self, id): self._setId(id) security.declarePrivate('addLayout') def addLayout(self, id, layout): """Add a layout.""" self._setObject(id, layout) return self._getOb(id) # # ZMI # def all_meta_types(self): return ({'name': 'CPS Layout', 'action': 'manage_addCPSLayoutForm', 'permission': ManagePortal}, ) security.declareProtected(ViewManagementScreens, 'manage_addCPSLayoutForm') manage_addCPSLayoutForm = DTMLFile('zmi/layout_addform', globals()) security.declareProtected(ManagePortal, 'manage_addCPSLayout') def manage_addCPSLayout(self, id, REQUEST=None): """Add a layout, called from the ZMI.""" layout = CPSLayout(id) layout = self.addLayout(id, layout) if REQUEST is not None: REQUEST.RESPONSE.redirect(layout.absolute_url()+'/manage_main' '?manage_tabs_message=Added.') else: return layout InitializeClass(LayoutContainer) ###################################################################### class Layout(FolderWithPrefixedIds, SimpleItemWithProperties): """Basic Layout. A layout describes how to render a set of widgets. A layout can be rendered in several layout_modes (view, edit, create, editlayout, etc.). The rendered widgets themselves can only have two mode: 'view' and 'edit'. So the layout has to choose the widget modes depending on the layout_mode and various information about the widgets and their fields, notably read-only mode and ACLs. Layout rendering occurs with the following step: - prepareLayoutWidgets(): updates datastructure from field values, - (optional) manual updating of datastructure from request, - computeLayoutStructure(): computes layout_structure, - (optional) validateLayoutStructure(): validates and updates datamodel, or sets errors in datastructure, - renderLayoutStructure(): renders each widget into layout_structure, - renderLayoutStyle(): returns the final rendering using the style method. """ _properties = ( {'id': 'style_prefix', 'type': 'string', 'mode': 'w', 'label': 'Prefix for zpt'}, {'id': 'flexible_widgets', 'type': 'tokens', 'mode': 'w', 'label': 'Allowed widgets in flexible'}, ) style_prefix = '' flexible_widgets = [] prefix = 'w__' id = None security = ClassSecurityInfo() security.setDefaultAccess('allow') def __init__(self, **kw): layoutdef = {'ncols': 1, 'rows': []} self.setLayoutDefinition(layoutdef) self.manage_changeProperties(**kw) security.declarePrivate('_getFlexibleWidgetsInfo') def _getFlexibleWidgetsInfo(self, n=0): """Return allowed widgets information.""" items = [] for item in self.flexible_widgets: v = item.split(':') if len(v) > n and v[n]: items.append(v[n]) else: items.append(None) return items security.declarePrivate('getFlexibleWidgetIds') def getFlexibleWidgetIds(self): """Return allowed flexible widget ids.""" return self._getFlexibleWidgetsInfo() security.declarePrivate('getFlexibleWidgetOccurences') def getFlexibleWidgetOccurences(self): """Return a list of maximum number of flexible widgets. 0 is no limit.""" return self._getFlexibleWidgetsInfo(n=1) security.declarePrivate('normalizeLayoutDefinition') def normalizeLayoutDefinition(self, layoutdef): """Normalize a layout definition. Removes empty rows, normalize last cells so all widths are equal, recomputes ncols. """ rows = layoutdef['rows'] # Find max width. maxw = 1 for row in rows: w = 0 for cell in row: ncols = cell.get('ncols', 1) cell['ncols'] = ncols w += ncols if w > maxw: maxw = w layoutdef['ncols'] = maxw # Normalize short widths. for row in rows: w = 0 for cell in row: if cell is row[-1]: cell['ncols'] = maxw - w else: w += cell['ncols'] # Remove empty rows. layoutdef['rows'] = filter(None, rows) return layoutdef security.declarePrivate('setLayoutDefinition') def setLayoutDefinition(self, layoutdef): """Set the layout definition.""" layoutdef = self.normalizeLayoutDefinition(layoutdef) self._layoutdef = deepcopy(layoutdef) security.declareProtected(View, 'getLayoutDefinition') def getLayoutDefinition(self): """Get the layout definition.""" return deepcopy(self._layoutdef) security.declarePrivate('removeHiddenWidgets') def removeHiddenWidgets(self, layout_structure): """Remove cells of hidden widgets. """ # XXX hiding a cell should be made more configurable, # decide if it gets set to '', or if it is removed and # its space contributed to the left or right cell. for row in layout_structure['rows']: new_row = [] for cell in row: if cell['widget_mode'] != 'hidden': new_row.append(cell) row[:] = new_row # Re-normalize after removed cells. self.normalizeLayoutDefinition(layout_structure) security.declarePrivate('prepareLayoutWidgets') def prepareLayoutWidgets(self, datastructure, **kw): """Prepare the layout widgets. Prepare all the widgets and thus updates the datastructure. """ for widget_id, widget in self.items(): if not widget.isHidden(): widget.prepare(datastructure) security.declarePrivate('computeLayoutStructure') def computeLayoutStructure(self, layout_mode, datamodel): """Compute the layout structure. Chooses the mode for all the widgets. Removes hidden ones. Returns a layout structure, which is a dictionary with keys: - layout - layout_id - widgets - rows Cells in a row have additionnal keys: - widget - widget_mode - widget_rendered (In addition to widget_id and ncols of the standard data.) """ layout_structure = self.getLayoutDefinition() # get a copy layout_structure['layout'] = self layout_structure['layout_id'] = self.getId() # XXX FIXME remove # Choose the mode for all the widgets. widgets = {} for widget_id, widget in self.items(): if not widget.isHidden(): mode = widget.getModeFromLayoutMode(layout_mode, datamodel) widgets[widget_id] = { 'widget': widget, 'widget_mode': mode, } layout_structure['widgets'] = widgets # Store computed widget info in row/cell structure. for row in layout_structure['rows']: for cell in row: cell.update(widgets[cell['widget_id']]) # Eliminate hidden widgets. self.removeHiddenWidgets(layout_structure) return layout_structure security.declarePrivate('validateLayoutStructure') def validateLayoutStructure(self, layout_structure, datastructure, **kw): """Validate the layout. Only validates the widgets that are in 'edit' mode. """ ok = 1 for row in layout_structure['rows']: for cell in row: if cell['widget_mode'] == 'edit': widget = cell['widget'] ok = widget.validate(datastructure, **kw) and ok return ok security.declarePrivate('renderLayoutStructure') def renderLayoutStructure(self, layout_structure, datastructure, **kw): """Render the layout structure. Renders the widgets in their chosen mode. After rendering, the structure may be updated because some empty widgets may have been removed. """ widget_infos = layout_structure['widgets'] for row in layout_structure['rows']: for cell in row: widget = cell['widget'] mode = cell['widget_mode'] rendered = widget.render(mode, datastructure, widget_infos=widget_infos, **kw) rendered = rendered.strip() cell['widget_rendered'] = rendered if widget.hidden_empty and not rendered: cell['widget_mode'] = 'hidden' # Eliminate hidden widgets. self.removeHiddenWidgets(layout_structure) security.declarePrivate('renderLayoutStyle') def renderLayoutStyle(self, layout_structure, datastructure, context, **kw): """Applies the layout style method to the rendered widgets. Returns the rendered string. """ layout_mode = kw['layout_mode'] layout_meth = self.style_prefix + layout_mode layout_style = getattr(context, layout_meth, None) if layout_style is None: raise ValueError("No layout method '%s' for layout '%s'" % (layout_meth, self.getId())) # compute the flexible_widgets list flexible_widgets = [] if layout_mode == 'edit': ltool = getToolByName(self, 'portal_layouts') layout_global = ltool[self.getId()] widget_ids = [] for widget_id, widget in self.items(): if not widget.isHidden(): widget_ids.append(widget_id) flexible_widget_ids = layout_global.getFlexibleWidgetIds() flexible_occurences = layout_global.getFlexibleWidgetOccurences() flexible_widgets = [] i = 0 for wid in flexible_widget_ids: max_widget = flexible_occurences[i] i += 1 if max_widget: nb_widget = 0 for w in widget_ids: if w.startswith(wid): nb_widget += 1 if nb_widget >= int(max_widget): continue flexible_widgets.append(layout_global[wid]) rendered = layout_style(layout=layout_structure, datastructure=datastructure, flexible_widgets=flexible_widgets, **kw) return rendered def __repr__(self): return '' % `self.getLayoutDefinition()` InitializeClass(Layout) class CPSLayout(Layout): """Persistent Layout.""" meta_type = "CPS Layout" security = ClassSecurityInfo() def __init__(self, id, **kw): self.id = id Layout.__init__(self, **kw) security.declarePrivate('addWidget') def addWidget(self, id, wtid, **kw): """Add a new widget instance.""" wtool = getToolByName(self, 'portal_widget_types') widget_type = wtool[wtid] widget = widget_type.makeInstance(id, **kw) return self.addSubObject(widget) # # ZMI # def all_meta_types(self): # List of meta types contained in Folder, for copy/paste support. return [ {'name': WidgetTypeRegistry.getClass(wt).meta_type, 'action': '', 'permission': ManagePortal} for wt in WidgetTypeRegistry.listWidgetTypes()] def filtered_meta_types(self): # List of types available in Folder menu. wtool = getToolByName(self, 'portal_widget_types') return [ {'name': wtid, 'action': 'manage_addCPSWidgetForm/'+wtid.replace(' ', ''), 'permission': ManagePortal} for wtid in wtool.objectIds()] manage_options = ( {'label': 'Widgets', 'action': 'manage_main', }, {'label': 'Layout', 'action': 'manage_editLayout', }, ) + SimpleItemWithProperties.manage_options + ( {'label': 'Export', 'action': 'manage_export', }, ) security.declareProtected(ManagePortal, 'manage_editLayout') manage_editLayout = DTMLFile('zmi/layout_editform', globals()) security.declareProtected(ManagePortal, 'manage_export') manage_export = DTMLFile('zmi/layout_export', globals()) security.declareProtected(ManagePortal, 'manage_addCPSWidgetForm') manage_addCPSWidgetForm = DTMLFile('zmi/widget_addform', globals()) security.declareProtected(ManagePortal, 'getUnstrippedWidgetTypeId') def getUnstrippedWidgetTypeId(self, swtid): """Get an unstripped version of a widget type id.""" wtool = getToolByName(self, 'portal_widget_types') twtid = swtid.replace(' ', '') for wtid in wtool.objectIds(): if wtid.replace(' ', '') == twtid: return wtid raise ValueError(swtid) security.declareProtected(ManagePortal, 'manage_addCPSWidget') def manage_addCPSWidget(self, id, swtid, REQUEST=None, **kw): """Add a widget, called from the ZMI.""" if REQUEST is not None: kw.update(REQUEST.form) for key in ('id', 'swtid'): if kw.has_key(key): del kw[key] wtid = self.getUnstrippedWidgetTypeId(swtid) widget = self.addWidget(id, wtid, **kw) if REQUEST is not None: REQUEST.RESPONSE.redirect(widget.absolute_url()+ '/manage_workspace') else: return widget security.declareProtected(ManagePortal, 'manage_changeLayout') def manage_changeLayout(self, addrow=0, delcell=0, widencell=0, shrinkcell=0, splitcell=0, REQUEST=None, **kw): """Change a layout.""" if REQUEST is not None: kw.update(REQUEST.form) layoutdef = self.getLayoutDefinition() nrow = 0 rows = layoutdef['rows'] for row in rows: nrow += 1 ncell = 0 somedel, somesplit = 0, 0 for cell in row: ncell += 1 cell['widget_id'] = kw.get('cell_%d_%d' % (nrow, ncell), '') if kw.get('check_%d_%d' % (nrow, ncell)): if delcell: cell['del'] = 1 somedel = 1 if splitcell: cell['split'] = 1 somesplit = 1 if widencell: cell['ncols'] = cell['ncols']+1 if shrinkcell: cell['ncols'] = max(1, cell['ncols']-1) if somedel: newrow = [cell for cell in row if not cell.get('del')] rows[nrow-1] = newrow if somesplit: newrow = [] for cell in row: newrow.append(cell) if cell.get('split'): cell['ncols'] = max(1, cell['ncols']-1) del cell['split'] newrow.append({'ncols': 1, 'widget_id': ''}) rows[nrow-1] = newrow if addrow: rows.append([{'ncols': 1, 'widget_id': ''}]) layoutdef['rows'] = rows self.setLayoutDefinition(layoutdef) if REQUEST is not None: REQUEST.RESPONSE.redirect(self.absolute_url()+'/manage_editLayout' '?manage_tabs_message=Changed.') security.declareProtected(ManagePortal, 'manage_addLayoutRow') def manage_addLayoutRow(self, REQUEST=None, **kw): """Add a row to a layout.""" return self.manage_changeLayout(addrow=1, REQUEST=REQUEST, **kw) security.declareProtected(ManagePortal, 'manage_deleteCell') def manage_deleteCell(self, REQUEST=None, **kw): """Delete a cell from a layout.""" return self.manage_changeLayout(delcell=1, REQUEST=REQUEST, **kw) security.declareProtected(ManagePortal, 'manage_widenCell') def manage_widenCell(self, REQUEST=None, **kw): """Widen a cell from a layout.""" return self.manage_changeLayout(widencell=1, REQUEST=REQUEST, **kw) security.declareProtected(ManagePortal, 'manage_shrinkCell') def manage_shrinkCell(self, REQUEST=None, **kw): """Shrink a cell from a layout.""" return self.manage_changeLayout(shrinkcell=1, REQUEST=REQUEST, **kw) security.declareProtected(ManagePortal, 'manage_splitCell') def manage_splitCell(self, REQUEST=None, **kw): """Split a cell in two.""" return self.manage_changeLayout(splitcell=1, REQUEST=REQUEST, **kw) InitializeClass(CPSLayout) CPSSchemas-0.19.0/LayoutsTool.py0100444000374200017510000000252310030542431014702 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: LayoutsTool.py,v 1.4 2003/09/08 17:49:36 guillaum Exp $ """Layouts Tool The Layouts Tool manages layouts. """ from Globals import InitializeClass from AccessControl import ClassSecurityInfo from Products.CMFCore.utils import UniqueObject from Products.CPSSchemas.Layout import LayoutContainer class LayoutsTool(UniqueObject, LayoutContainer): """Layouts Tool Stores persistent layout objects. """ id = 'portal_layouts' meta_type = 'CPS Layouts Tool' security = ClassSecurityInfo() def __init__(self): LayoutContainer.__init__(self, self.id) InitializeClass(LayoutsTool) CPSSchemas-0.19.0/Makefile0100444000374200017510000000017210030542431013470 0ustar benzope.PHONY: clean check check: pychecker2 *.py clean: find . -name '*~' | xargs rm -f find . -name '*pyc' | xargs rm -f CPSSchemas-0.19.0/PropertiesPostProcessor.py0100444000374200017510000000703410030542431017310 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: PropertiesPostProcessor.py,v 1.3 2003/12/08 18:18:40 guillaum Exp $ """PropertiesPostProcessor Provide the opportunity to react after a ZMI properties change. """ from ExtensionClass import Base from Globals import InitializeClass from AccessControl import ClassSecurityInfo from Products.CMFCore.CMFCorePermissions import ManageProperties from Products.CMFCore.Expression import Expression class PropertiesPostProcessor(Base): """ Provide the opportunity to react after a ZMI properties change. _propertiesBaseClass must be set to the class whose code we call to the the actual properties change. """ security = ClassSecurityInfo() security.declareProtected(ManageProperties, 'manage_editProperties') def manage_editProperties(self, REQUEST): """Edit object properties via the web. Computes internal values for the acls. """ self._propertiesBaseClass.manage_editProperties(self, REQUEST) self._postProcessProperties() if REQUEST is not None: message = "Saved changes." # XXX Will be rendered twice but what the heck... return self.manage_propertiesForm(self, REQUEST, manage_tabs_message=message) security.declareProtected(ManageProperties, 'manage_changeProperties') def manage_changeProperties(self, REQUEST=None, **kw): """Change existing object properties. Computes internal values for the acls. """ if REQUEST is not None: for k, v in REQUEST.items(): kw[k] = v self._propertiesBaseClass.manage_changeProperties(self, **kw) self._postProcessProperties() if REQUEST is not None: message = "Saved changes." return self.manage_propertiesForm(self, REQUEST, manage_tabs_message=message) _properties_post_process_split = () _properties_post_process_tales = () def _postProcessProperties(self): """Post-processing after properties change.""" # Split on some separator. for attr_str, attr, seps in self._properties_post_process_split: v = [getattr(self, attr_str)] for sep in seps: vv = [] for s in v: vv.extend(s.split(sep)) v = vv v = [s.strip() for s in v] v = filter(None, v) setattr(self, attr_str, '; '.join(v)) setattr(self, attr, v) # TALES expression. for attr_str, attr in self._properties_post_process_tales: p = getattr(self, attr_str).strip() if p: v = Expression(p) else: v = None setattr(self, attr, v) InitializeClass(PropertiesPostProcessor) CPSSchemas-0.19.0/README.txt0100444000374200017510000000420010030542431013522 0ustar benzopeCPSSchemas ========== $Id: README.txt,v 1.7 2003/10/19 12:24:28 fermigier Exp $ This package adds a framework to deal with fields, schemas, widgets, layouts and vocabularies, the way they are displayed to the user and the way user input is validated. Schemas define what's stored in an object, at the level of individual fields. A field can be an integer, a string, a list of strings, a file object, etc. Vocabularies define an ordered list of options presented to the user and the associated underlying values stored in the object. For instance a list of countries where only country codes are stored but full country names are displayed. Widgets define how one or several fields from a schema are displayed to the user. They can be displayed in several modes (typically "view" and "edit"). Some modes may take input from the user and validate what the user entered, so that if the entry is incorrect an appropriate message can be displayed. Widgets can be parametrized and rewritten by the administrator if a different widget is needed. A Layout is a way to assemble several widgets together to display them. A layout adds a level of graphical display that can for instance add labels before the widgets, or borders, or display validation errors. Layouts, like widgets, can be displayed in several modes. The above talks about storing data in an object, but using a storage adapter it is possible to do anything else with the data (sending it to an SQL database, accumulating it for statistics, or just getting the resulting dictionary for further treatment). More information You can find more information about CPS3 in the "EuroPython slides":http://www.europython.org/Talks/Slides/cps_europython_2003.pdf See also the "Nuxeo web site":http://www.nuxeo.com/en/ and "CPS Project":http://www.cps-project.org/ for more details. There is now a "cps-devel mailing list":http://lists.nuxeo.com/mailman/listinfo/cps-devel for CPS3 (and CPS2) developers. CPS users lists ("cps-users (english)":http://lists.nuxeo.com/mailman/listinfo/cps-users and "cps-users-fr (french)":ttp://lists.nuxeo.com/mailman/listinfo/cps-users-fr) are also available. CPSSchemas-0.19.0/Schema.py0100444000374200017510000001224610030542431013607 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Authors: Florent Guillaume # Lennart Regebro # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: Schema.py,v 1.23 2004/03/15 20:51:04 fermigier Exp $ """Schema A Schema stores a set of fields defining the data stored in an object. """ from zLOG import LOG, DEBUG from Globals import InitializeClass, DTMLFile from AccessControl import ClassSecurityInfo from OFS.Folder import Folder from Products.CMFCore.CMFCorePermissions import ManagePortal from Products.CPSSchemas.FolderWithPrefixedIds import FolderWithPrefixedIds from Products.CPSSchemas.Field import FieldRegistry class SchemaContainer(Folder): """Schema Container Stores the definition of schemas. """ meta_type = 'CPS Schema Container' security = ClassSecurityInfo() def __init__(self, id): self._setId(id) security.declarePrivate('addSchema') def addSchema(self, id, schema): """Add a schema.""" self._setObject(id, schema) return self._getOb(id) # # ZMI # def all_meta_types(self): return ({'name': 'CPS Schema', 'action': 'manage_addCPSSchemaForm', 'permission': ManagePortal}, ) security.declareProtected(ManagePortal, 'manage_addCPSSchemaForm') manage_addCPSSchemaForm = DTMLFile('zmi/schema_addform', globals()) security.declareProtected(ManagePortal, 'manage_addCPSSchema') def manage_addCPSSchema(self, id, REQUEST=None): """Add a schema, called from the ZMI.""" schema = CPSSchema(id) schema = self.addSchema(id, schema) if REQUEST: REQUEST.RESPONSE.redirect(schema.absolute_url()+'/manage_main' '?manage_tabs_message=Added.') else: return schema InitializeClass(SchemaContainer) class CPSSchema(FolderWithPrefixedIds): # XXX: the Schema class is already persistent. """Persistent Schema.""" meta_type = "CPS Schema" prefix = 'f__' security = ClassSecurityInfo() def __init__(self, id, title='', schema=None, **kw): self.id = id self.title = title # XXX: can we remove this + the schema and **kw parameters ? #if schema is None: # schema = Schema() #self.setSchema(schema) security.declarePrivate('addField') def addField(self, id, field_type, **kw): """Add a new field instance.""" field = FieldRegistry.makeField(field_type, id, **kw) return self.addSubObject(field) # # ZMI # _properties = () manage_options = ( {'label': 'Schema', 'action': 'manage_editSchema', }, ) + FolderWithPrefixedIds.manage_options[1:] + ( {'label': 'Export', 'action': 'manage_export', }, ) security.declareProtected(ManagePortal, 'manage_editSchema') manage_editSchema = DTMLFile('zmi/schema_editform', globals()) security.declareProtected(ManagePortal, 'manage_export') manage_export = DTMLFile('zmi/schema_export', globals()) security.declareProtected(ManagePortal, 'manage_main') manage_main = manage_editSchema security.declareProtected(ManagePortal, 'manage_addField') def manage_addField(self, id, field_type, REQUEST=None, **kw): """Add a field TTW.""" if REQUEST: kw.update(REQUEST.form) for key in ('id', 'field_type'): if kw.has_key(key): del kw[key] field = self.addField(id, field_type, **kw) if REQUEST: REQUEST.RESPONSE.redirect(field.absolute_url()+'/manage_workspace' '?manage_tabs_message=Added.') else: return field security.declareProtected(ManagePortal, 'manage_delFieldItems') def manage_delFieldItems(self, ids, REQUEST=None): """Add a field TTW.""" self.manage_delObjects(ids) if REQUEST: REQUEST.RESPONSE.redirect(self.absolute_url()+'/manage_editSchema' '?manage_tabs_message=Deleted.') security.declareProtected(ManagePortal, 'listFieldTypes') def listFieldTypes(self): """List all field types.""" return FieldRegistry.listFieldTypes() InitializeClass(CPSSchema) addCPSSchemaForm = DTMLFile('zmi/schema_addform', globals()) def addCPSSchema(container, id, REQUEST=None): """Add a CPS Schema.""" ob = CPSSchema(id) container._setObject(id, ob) ob = container._getOb(id) if REQUEST: REQUEST.RESPONSE.redirect(ob.absolute_url() + "/manage_main") CPSSchemas-0.19.0/SchemasTool.py0100444000374200017510000000260410030542431014625 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: SchemasTool.py,v 1.5 2003/09/08 17:49:36 guillaum Exp $ """Schemas Tool """ from Globals import InitializeClass from AccessControl import ClassSecurityInfo from Products.CMFCore.utils import UniqueObject from Products.CPSSchemas.Schema import SchemaContainer class SchemasTool(UniqueObject, SchemaContainer): """Schemas Tool The Schemas Tool stores the definition of standard schemas. A schema describes a set of fields that can store data. """ id = 'portal_schemas' meta_type = 'CPS Schemas Tool' security = ClassSecurityInfo() def __init__(self): SchemaContainer.__init__(self, self.id) InitializeClass(SchemasTool) CPSSchemas-0.19.0/StorageAdapter.py0100444000374200017510000002056610030542431015320 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: StorageAdapter.py,v 1.25 2004/03/15 20:50:31 fermigier Exp $ """ Storage Adapters A storage adapter is used by a DataModel to get/set the data from/to somewhere. It is is parameterised on one hand by some context, for instance an object, and on the other hand by the schema that drives it. A storage adapter can also be linked to no object, for instance for object creation. The most basic implementation is using attributes on an object. A more complex one can be a storage to an SQL table. Another one could be a setting of attributes in the ZODB that knows about File and Image fields and makes them available as subobjects so that they are visible in the ZMI. """ from zLOG import LOG, DEBUG, ERROR from Acquisition import aq_base class BaseStorageAdapter: """Base Storage Adapter Base class for storage adapters. """ def __init__(self, schema, field_ids=None, **kw): """Create a StorageAdapter for a schema. If field_ids is specified, only those fields will be managed. """ self._schema = schema if field_ids is None: field_ids = schema.keys() field_items = [] writable_field_items = [] for field_id, field in schema.items(): if field_id in field_ids: field_items.append((field_id, field)) if not field.write_ignore_storage: writable_field_items.append((field_id, field)) self._field_items = field_items self._writable_field_items = writable_field_items def getSchema(self): """Get schema this adapter is about.""" return self._schema def getFieldItems(self): """Get the field ids and the fields.""" return self._field_items def getWritableFieldItems(self): """Get the writable field ids and the fields.""" return self._writable_field_items def getDefaultData(self): """Get the default data from the fields' default values. Returns a mapping. """ data = {} for field_id, field in self.getFieldItems(): data[field_id] = field.getDefault() return data # # API called by DataModel # def getData(self): """Get data from the object, returns a mapping.""" return self._getData() def setData(self, data): """Set data to the object, from a mapping.""" self._setData(data) # # Internal API for subclasses # def _getData(self, **kw): """Get data from the object, returns a mapping.""" data = {} for field_id, field in self.getFieldItems(): if field.read_ignore_storage: value = field.getDefault() else: value = self._getFieldData(field_id, field, **kw) data[field_id] = value self._getDataDoProcess(data, **kw) return data def _getDataDoProcess(self, data, **kw): """Process data after read.""" for field_id, field in self.getFieldItems(): value = data[field_id] data[field_id] = field.processValueAfterRead(value, data) def _getFieldData(self, field_id, field, **kw): """Get data from one field.""" raise NotImplementedError def _setData(self, data, **kw): """Set data to the object, from a mapping.""" data = self._setDataDoProcess(data, **kw) for field_id, field in self.getWritableFieldItems(): self._setFieldData(field_id, field, data[field_id], **kw) def _setDataDoProcess(self, data, **kw): """Process data before write. Returns a copy, without the fields that are not stored. """ new_data = {} for field_id, field in self.getFieldItems(): if field.write_ignore_storage: continue value = data[field_id] new_data[field_id] = field.processValueBeforeWrite(value, data) return new_data def _setFieldData(self, field_id, field, value, **kw): """Set data for one field.""" raise NotImplementedError class AttributeStorageAdapter(BaseStorageAdapter): """Attribute Storage Adapter This adapter simply gets and sets data from/to an attribute. """ def __init__(self, schema, ob, **kw): """Create an Attribute Storage Adapter for a schema. The object passed is the one on which to get/set attributes. """ self._ob = ob BaseStorageAdapter.__init__(self, schema, **kw) def setContextObject(self, ob): """Set a new underlying object for this adapter. If a getData/setData is later done, it will be done on this new object. This is used by CPS to switch to a writable object after unfreezing. """ self._ob = ob def _getFieldData(self, field_id, field): """Get data from one field.""" ob = self._ob if not hasattr(aq_base(ob), field_id): # Use default from field. return field.getDefault() return getattr(ob, field_id) def _setFieldData(self, field_id, field, value): """Set data for one field.""" setattr(self._ob, field_id, value) def _getContentUrl(self, object, field_id, file_name): return '%s/downloadFile/%s/%s' % ( object.absolute_url(), field_id, file_name) ACCESSOR = [] ACCESSOR_READ_ONLY = [] class MetaDataStorageAdapter(BaseStorageAdapter): """MetaData Storage Adapter This adapter simply gets and sets metadata using X() and setX() methods for standard CMF Dublin Core methods, or using specific attributes otherwise. """ _field_attributes = { 'Creator': ACCESSOR_READ_ONLY, 'CreationDate': ACCESSOR_READ_ONLY, 'Title': ACCESSOR, 'Subject': ACCESSOR, 'Description': ACCESSOR, 'Contributors': ACCESSOR, 'ModificationDate': ACCESSOR, 'EffectiveDate': ACCESSOR, 'ExpirationDate': ACCESSOR, 'Format': ACCESSOR, 'Language': ACCESSOR, 'Rights': ACCESSOR, # XXX move these to accessors too using a monkey-patch. 'Coverage': 'coverage', 'Source': 'source', 'Relation': 'relation', } def __init__(self, schema, ob, **kw): self._ob = ob BaseStorageAdapter.__init__(self, schema, **kw) def setContextObject(self, ob): """Set a new underlying object for this adapter.""" self._ob = ob def _getFieldData(self, field_id, field): """Get data from one field. Calls the getter method. """ ob = self._ob if ob is None: # Creation return field.getDefault() attr = self._field_attributes.get(field_id) if attr is None: raise ValueError("Field %s not allowed by MetaDataStorageAdapter" % field_id) elif attr is ACCESSOR or attr is ACCESSOR_READ_ONLY: return getattr(ob, field_id)() elif hasattr(aq_base(ob), attr): return getattr(ob, attr) else: # Use default from field. return field.getDefault() def _setFieldData(self, field_id, field, value): """Set data for one field. Calls the setter method. """ ob = self._ob attr = self._field_attributes.get(field_id) if attr is None: raise ValueError("Field %s not allowed by MetaDataStorageAdapter" % field_id) elif attr is ACCESSOR: getattr(ob, 'set'+field_id)(value) elif attr is ACCESSOR_READ_ONLY: raise ValueError("Field %s is read-only" % field_id) else: setattr(ob, attr, value) CPSSchemas-0.19.0/VocabulariesTool.py0100444000374200017510000000707110030542431015664 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: VocabulariesTool.py,v 1.6 2003/11/16 21:15:06 fermigier Exp $ """Vocabularies Tool """ from Globals import InitializeClass, DTMLFile from AccessControl import ClassSecurityInfo from OFS.Folder import Folder from Products.CMFCore.utils import UniqueObject from Products.CMFCore.CMFCorePermissions import ManagePortal class VocabulariesTool(UniqueObject, Folder): """Vocabularies Tool The Vocabularies Tool stores the definition of vocabularies. A vocabulary describes the correspondance between a list of internal values and their human-readable couterpart (maybe internationalized). """ id = 'portal_vocabularies' meta_type = 'CPS Vocabularies Tool' security = ClassSecurityInfo() # # ZMI # def all_meta_types(self): # Stripping is done to be able to pass a type in the URL. return [ {'name': dt, 'action': 'manage_addCPSVocabularyForm/' + dt.replace(' ', ''), 'permission': ManagePortal} for dt in VocabularyTypeRegistry.listTypes()] security.declareProtected(ManagePortal, 'manage_addCPSVocabularyForm') manage_addCPSVocabularyForm = DTMLFile('zmi/vocabulary_addform', globals()) security.declareProtected(ManagePortal, 'manage_addCPSVocabulary') def manage_addCPSVocabulary(self, id, meta_type='CPS Vocabulary', REQUEST=None, **kw): """Add a vocabulary, called from the ZMI.""" container = self cls = VocabularyTypeRegistry.getType(meta_type) ob = cls(id, **kw) container._setObject(id, ob) ob = container._getOb(id) if REQUEST is not None: REQUEST.RESPONSE.redirect(ob.absolute_url()+'/manage_workspace' '?manage_tabs_message=Added.') else: return ob security.declareProtected(ManagePortal, 'getVocabularyMetaType') def getVocabularyMetaType(self, meta_type): """Get an unstripped version of a vocabulary meta type.""" return VocabularyTypeRegistry.getType(meta_type).meta_type InitializeClass(VocabulariesTool) class VocabularyTypeRegistry: """Registry of the available vocabulary types. Internally strips spaces, to be able to use arguments extracted from URL components. """ def __init__(self): self._types = {} def register(self, cls): """Register a vocabulary type.""" mt = cls.meta_type.replace(' ', '') self._types[mt] = cls def listTypes(self): """List vocabulary types.""" types = [cls.meta_type for cls in self._types.values()] types.sort() return types def getType(self, meta_type): """Get a vocabulary type.""" mt = meta_type.replace(' ', '') return self._types[mt] # Singleton VocabularyTypeRegistry = VocabularyTypeRegistry() CPSSchemas-0.19.0/Vocabulary.py0100444000374200017510000002530410030542431014515 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: Vocabulary.py,v 1.20 2004/01/22 18:04:24 guillaum Exp $ """Vocabulary Vocabularies store a correspondance between keys and a human-readable label. They can be ordered, and may get their data from an external or computed source. """ from zLOG import LOG, DEBUG from types import StringType from Globals import InitializeClass, DTMLFile from AccessControl import ClassSecurityInfo from AccessControl import getSecurityManager from AccessControl import Unauthorized from Persistence import Persistent from Products.CMFCore.CMFCorePermissions import View, ManagePortal from Products.CMFCore.utils import SimpleItemWithProperties from Products.CPSSchemas.PropertiesPostProcessor import PropertiesPostProcessor from IVocabulary import IVocabulary builtins_list = list class Vocabulary(Persistent): """Vocabulary Base class for explicit vocabularies. """ __implements__ = IVocabulary security = ClassSecurityInfo() def __init__(self, tuples=None, list=None, dict=None): """Initialize a vocabularies. Allowed parameter syntaxes are: - Vocabulary((('foo', "Foo"), ('bar', "Bar"))) Preferred - Vocabulary(tuples=(('foo', "Foo"), ('bar', "Bar"))) Same as first. - Vocabulary(('foo', 'bar')) Values are same as keys. - Vocabulary(list=('foo', 'bar')) Values are same as keys, alternate syntax. - Vocabulary(tuples=('foo', 'bar')) Values are same as keys, other syntax. - Vocabulary(list=('foo', 'bar'), dict={'foo':"Foo", 'bar':"Bar"}) Old syntax. - Vocabulary(dict={'foo':"Foo", 'bar':"Bar"}) Old syntax, key order is random. """ self.clear() l = [] d = {} if tuples is not None: if tuples and isinstance(tuples[0], StringType): # Vocabulary(('foo', 'bar')) l = builtins_list(tuples) for k in l: d[k] = k else: # Vocabulary((('foo', "Foo"), ('bar', "Bar"))) for k, v in tuples: l.append(k) d[k] = v elif dict is not None: d = dict.copy() if list is not None: # Vocabulary(list=('foo',), dict={'foo':"Foo"}) l = builtins_list(list) else: # Vocabulary(dict={'foo':"Foo", 'bar':"Bar"}) l = dict.keys() elif list is not None: # Vocabulary(list=('foo', 'bar')) l = builtins_list(list) for k in l: d[k] = k else: # Vocabulary() pass self._list = l self._dict = d def __repr__(self): return '' % repr(self._dict) def clear(self): """Clear the vocabulary.""" self._list = [] self._dict = {} self._msgids = {} def __delitem__(self, key): self._p_changed = 1 del self._dict[key] try: del self._msgids[key] except KeyError: # __init__ doesn't initialize _msgids so this can't be # *del*eted directly pass self._list.remove(key) def set(self, key, label, msgid=None): """Set a label for a key.""" self._p_changed = 1 if not self._dict.has_key(key): self._list.append(key) self._dict[key] = label self._msgids[key] = msgid def __getitem__(self, key): """Get a label for a key.""" return self._dict[key] def get(self, key, default=None): """Get a label for a key, default to None.""" try: v = self._dict.get(key, default) except TypeError: # XXX temporary fix, don't know why sometime rendering try to do # get([]) that returning a typeError return '' return v def getMsgid(self, key, default=None): """Get a msgid for a key, default to None.""" return self._msgids.get(key, default) def has_key(self, key): """Test if a key is present.""" return self._dict.has_key(key) def keys(self): """Get the ordered list of keys.""" return self._list[:] def items(self): """Get the ordered list of (key, value).""" return [(key, self._dict.get(key)) for key in self._list] def values(self): """Get the ordered list of values.""" return [self._dict.get(key) for key in self._list] def orderKeys(self, keys): """Set the order of keys.""" raise NotImplementedError InitializeClass(Vocabulary) class CPSVocabulary(PropertiesPostProcessor, SimpleItemWithProperties): """Persistent Vocabulary.""" __implements__ = IVocabulary meta_type = "CPS Vocabulary" security = ClassSecurityInfo() security.declareObjectProtected(View) _propertiesBaseClass = SimpleItemWithProperties _properties = ( {'id': 'title', 'type': 'string', 'mode': 'w', 'label': 'Title'}, {'id': 'title_msgid', 'type': 'string', 'mode': 'w', 'label': 'Title msgid'}, {'id': 'description', 'type': 'text', 'mode': 'w', 'label':'Description'}, {'id': 'acl_write_roles', 'type': 'string', 'mode': 'w', 'label':'ACL: write roles'}, ) title = '' title_msgid = '' description = '' acl_write_roles = 'Manager' acl_write_roles_c = ['Manager'] _properties_post_process_split = ( ('acl_write_roles', 'acl_write_roles_c', ',; '), ) user_modified = 0 def __init__(self, id, tuples=None, list=None, dict=None, title='', **kw): self.id = id self.title = title vocab = Vocabulary(tuples=tuples, list=list, dict=dict) self.setVocabulary(vocab) security.declareProtected(ManagePortal, 'setVocabulary') def setVocabulary(self, vocab): # XXX check base class ? self._vocab = vocab security.declareProtected(ManagePortal, '__delitem__') def __delitem__(self, key): del self._vocab[key] security.declareProtected(ManagePortal, 'set') def set(self, key, label, msgid=None): return self._vocab.set(key, label, msgid) security.declareProtected(View, '__getitem__') def __getitem__(self, key): return self._vocab[key] security.declareProtected(View, 'get') def get(self, key, default=None): return self._vocab.get(key, default) security.declareProtected(View, 'getMsgid') def getMsgid(self, key, default=None): return self._vocab.getMsgid(key, default) security.declareProtected(View, 'keys') def keys(self): return self._vocab.keys() security.declareProtected(View, 'items') def items(self): return self._vocab.items() security.declareProtected(View, 'values') def values(self): return self._vocab.values() security.declareProtected(View, 'has_key') def has_key(self, key): return self._vocab.has_key(key) # # Management # security.declarePublic('isWriteAllowed') def isWriteAllowed(self): """Test if the user can write to this vocabulary.""" return getSecurityManager().getUser().has_role( self.acl_write_roles) security.declareProtected(ManagePortal, 'isUserModified') def isUserModified(self): """Tell if the vocabulary has been modified by a user. """ return self.user_modified # # ZMI # manage_options = ( {'label': 'Vocabulary', 'action': 'manage_editVocabulary', }, ) + SimpleItemWithProperties.manage_options + ( {'label': 'Export', 'action': 'manage_export', }, ) security.declareProtected(ManagePortal, 'manage_editVocabulary') manage_editVocabulary = DTMLFile('zmi/vocabulary_editform', globals()) security.declareProtected(ManagePortal, 'manage_export') manage_export = DTMLFile('zmi/vocabulary_export', globals()) security.declareProtected(ManagePortal, 'manage_main') manage_main = manage_editVocabulary security.declarePrivate('_checkWriteAllowed') def _checkWriteAllowed(self): """Check that user can write to this vocabulary.""" if not self.isWriteAllowed(): raise Unauthorized("No write access to vocabulary") security.declarePublic('manage_addVocabularyItem') def manage_addVocabularyItem(self, new_key, new_label, new_msgid, REQUEST=None): """Add a vocabulary item.""" self._checkWriteAllowed() self.set(new_key, new_label, new_msgid) self.user_modified = 1 if REQUEST is not None: return self.manage_main(REQUEST, manage_tabs_message='Added.') security.declarePublic('manage_changeVocabulary') def manage_changeVocabulary(self, form={}, REQUEST=None): """Change a vocabulary. The form parameter must contains the full new vocabulary as a dict with keys key_0, label_0, msgid_0, etc. """ self._checkWriteAllowed() form = form.copy() if REQUEST is not None: form.update(REQUEST.form) vocab = Vocabulary() i = -1 while 1: i += 1 k = 'key_%d' % i if not form.has_key(k): break vocab.set(form[k], form['label_%d' % i], form['msgid_%d' % i]) self.setVocabulary(vocab) self.user_modified = 1 if REQUEST is not None: return self.manage_main(REQUEST, manage_tabs_message='Changed.') security.declarePublic('manage_delVocabularyItems') def manage_delVocabularyItems(self, keys, REQUEST=None): """Delete vocabulary items.""" self._checkWriteAllowed() for key in keys: del self[key] self.user_modified = 1 if REQUEST is not None: return self.manage_main(REQUEST, manage_tabs_message='Deleted.') InitializeClass(CPSVocabulary) CPSSchemas-0.19.0/Widget.py0100444000374200017510000002514010030542431013627 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: Widget.py,v 1.36 2004/03/23 12:43:11 fermigier Exp $ """Widget Abstract base classes for widgets, graphical representation of data. Widget is the base widget class An instance w of it is parametrized, notably by one or several field names. It can then be rendered by passing it a datastructure. """ from zLOG import LOG, DEBUG from Globals import InitializeClass, DTMLFile from AccessControl import ClassSecurityInfo from Products.CMFCore.utils import SimpleItemWithProperties from Products.CMFCore.utils import getToolByName from Products.CPSSchemas.Field import WriteAccessError from Products.CPSSchemas.PropertiesPostProcessor import PropertiesPostProcessor from Products.CMFCore.Expression import getEngine def widgetname(id): """Return the name of the widget as used in HTML forms.""" return 'widget__' + id class Widget(PropertiesPostProcessor, SimpleItemWithProperties): """Basic Widget Class. A widget is used as a component of a layout, to display or receive input for some data. A widget is responsible for turning one or several basic data types from a datastructure into a visible representation, and doing the opposite when input is received. When rendering, the widget has access to the datastructure to render but also to the datamodel to be able to render available choices in a vocabulary for instance. A widget can be "rendered" in several modes, the basic ones are: - view: the standard rendering view, - edit: the standard editing view, - modify: a pseudo-view that parses user input into the datastructure. A widget may have some additional parameters that describe certain aspects of its graphical representation or behavior. """ security = ClassSecurityInfo() _propertiesBaseClass = SimpleItemWithProperties _properties = ( {'id': 'title', 'type': 'string', 'mode': 'w', 'label': 'Title'}, {'id': 'fields', 'type': 'tokens', 'mode': 'w', 'label': 'Fields'}, {'id': 'is_required', 'type': 'boolean', 'mode': 'w', 'label': 'Required widget'}, {'id': 'label', 'type': 'string', 'mode': 'w', 'label': 'Label in view layout mode'}, {'id': 'label_edit', 'type': 'string', 'mode': 'w', 'label': 'Label in edit layout mode'}, {'id': 'description', 'type': 'text', 'mode': 'w', 'label': 'Description'}, {'id': 'help', 'type': 'text', 'mode': 'w', 'label': 'Help'}, {'id': 'is_i18n', 'type': 'boolean', 'mode': 'w', 'label': 'Label is i18n'}, {'id': 'readonly_layout_modes', 'type': 'tokens', 'mode': 'w', 'label': 'Read-only in layout modes'}, {'id': 'hidden_layout_modes', 'type': 'tokens', 'mode': 'w', 'label': 'Hidden in layout modes'}, {'id': 'hidden_readonly_layout_modes', 'type': 'tokens', 'mode': 'w', 'label': 'Hidden if readonly in layout modes'}, {'id': 'hidden_empty', 'type': 'boolean', 'mode': 'w', 'label': 'Hidden if empty'}, {'id': 'hidden_if_expr', 'type': 'text', 'mode': 'w', 'label': 'Hide the widget if the given TAL expression returns true'}, # {'id': 'css_class', 'type': 'string', 'mode': 'w', 'label': 'CSS class for view'}, ) fields = [] is_required = 0 label = '' label_edit = '' description = '' help = '' is_i18n = 0 css_class = '' readonly_layout_modes = [] hidden_layout_modes = [] hidden_readonly_layout_modes = [] hidden_empty = 0 hidden_if_expr = '' widget_type = '' # Not a property by default field_types = [] field_inits = [] # default settings for fields created in flexible mode # using the same order as in field_types hidden_if_expr_c = None _properties_post_process_tales = ( ('hidden_if_expr', 'hidden_if_expr_c'), ) def __init__(self, id, widgettype, **kw): self._setId(id) self.widget_type = widgettype self.manage_changeProperties(**kw) security.declarePublic('getWidgetId') def getWidgetId(self): """Get this widget's id.""" id = self.getId() if hasattr(self, 'getIdUnprefixed'): # Inside a FolderWithPrefixedIds. return self.getIdUnprefixed(id) else: # Standalone field. return id security.declarePublic('getHtmlWidgetId') def getHtmlWidgetId(self): """Get the html-form version of this widget's id.""" return widgetname(self.getWidgetId()) # # Widget access control # def _createHiddenExpressionContext(self, datamodel): """Create an expression context for hidden evaluation.""" wftool = getToolByName(self, 'portal_workflow') portal = getToolByName(self, 'portal_url').getPortalObject() proxy = datamodel._proxy if proxy is not None: review_state = wftool.getInfoFor(proxy, 'review_state') else: review_state = None data = { 'widget': self, 'datamodel': datamodel, 'user': datamodel._acl_cache_user, 'nothing': None, 'context': datamodel._context, 'portal': portal, 'proxy': proxy, 'portal_workflow': wftool, 'review_state': review_state, } return getEngine().getContext(data) security.declarePrivate('_isReadOnly') def _isReadOnly(self, datamodel): """Return true if the widget is read-only. This checks the managed fields for write access. """ try: for field_id in self.fields: datamodel.checkWriteAccess(field_id) except WriteAccessError: return 1 else: return 0 security.declarePrivate('isReadOnly') def isReadOnly(self, datamodel, layout_mode): """Return true if the widget is read-only in the layout_mode.""" if layout_mode in self.readonly_layout_modes: return 1 return self._isReadOnly(datamodel) security.declarePrivate('getModeFromLayoutMode') def getModeFromLayoutMode(self, layout_mode, datamodel): """Get the mode for this widget.""" if layout_mode in self.hidden_layout_modes: return 'hidden' if self.hidden_if_expr_c: # Creating the context for evaluating the TAL expression expr_context = self._createHiddenExpressionContext(datamodel) if self.hidden_if_expr_c(expr_context): return 'hidden' readonly = None if layout_mode in self.hidden_readonly_layout_modes: readonly = self.isReadOnly(datamodel, layout_mode) if readonly: return 'hidden' if layout_mode.startswith('view'): return 'view' if (layout_mode.startswith('edit') or layout_mode.startswith('create') or layout_mode.startswith('search')): if readonly is None: readonly = self.isReadOnly(datamodel, layout_mode) if readonly: return 'view' else: return 'edit' raise ValueError("Unknown layout mode '%s'" % layout_mode) # # May be overloaded. # security.declarePrivate('getFieldTypes') def getFieldTypes(self): """Get the types of the fields for this widget. Used by dynamic widget creation to create its needed fields. """ return self.field_types security.declarePrivate('getFieldInits') def getFieldInits(self): nb_field = len(self.getFieldTypes()) if len(self.field_inits) == nb_field: return self.field_inits # return empty inits return None # # To be implemented by widget concrete classes. # def prepare(self, datastructure, **kw): """Prepare datastructure from datamodel.""" raise NotImplementedError def validate(self, datastructure, **kw): """Validate datastructure and update datamodel.""" raise NotImplementedError def render(self, mode, datastructure, **kw): """Render in mode from datastructure.""" raise NotImplementedError InitializeClass(Widget) class CPSWidget(Widget): """Persistent Widget.""" meta_type = "CPS Widget" security = ClassSecurityInfo() def __init__(self, id, widgettype, **kw): #self.fields = [id] Widget.__init__(self, id, widgettype, **kw) security.declarePrivate('isHidden') def isHidden(self): """Check if the widget is hidden Hidden widget are used as template to create flexible widgets. Returns true if the widget is hidden. """ return (self.fields and self.fields[0] == '?') security.declarePrivate('hide') def hide(self): """Hide the widget. A hidden widget is not displayed or validated, it is used in flexible mode to produce new widgets. """ self.fields = ['?'] InitializeClass(CPSWidget) addCPSWidgetForm = DTMLFile('zmi/widget_addform', globals()) def addCPSWidget(container, id, REQUEST=None): """Add a CPS Widget.""" ob = CPSWidget(id) container._setObject(id, ob) ob = container._getOb(id) if REQUEST is not None: REQUEST.RESPONSE.redirect(ob.absolute_url() + "/manage_main") class CPSWidgetType(SimpleItemWithProperties): """Persistent Widget Type.""" meta_type = "CPS Widget Type" security = ClassSecurityInfo() cls = None def __init__(self, id, **kw): self._setId(id) security.declarePrivate('makeInstance') def makeInstance(self, id, **kw): """Create an instance of this widget type.""" return self.cls(id, self.getId(), **kw) # # ZMI # title = '' _properties = ( {'id': 'title', 'type': 'string', 'mode': 'w', 'label': 'Title'}, ) InitializeClass(CPSWidgetType) CPSSchemas-0.19.0/WidgetTypesTool.py0100444000374200017510000001002710030542431015510 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: WidgetTypesTool.py,v 1.7 2003/12/14 15:04:32 fermigier Exp $ """Widget Types Tool The Widget Types Tool manages the available widget types. """ from zLOG import LOG, DEBUG from Globals import InitializeClass, DTMLFile from AccessControl import ClassSecurityInfo from OFS.Folder import Folder from Products.CMFCore.CMFCorePermissions import ManagePortal from Products.CMFCore.utils import UniqueObject class WidgetTypesTool(UniqueObject, Folder): """Widget Types Tool Stores the available widget types. """ id = 'portal_widget_types' meta_type = 'CPS Widget Types Tool' security = ClassSecurityInfo() # # ZMI # def all_meta_types(self): return [ {'name': wt, 'action': 'manage_addCPSWidgetTypeForm/' + wt.replace(' ', ''), 'permission': ManagePortal} for wt in WidgetTypeRegistry.listWidgetTypes()] security.declareProtected(ManagePortal, 'manage_addCPSWidgetTypeForm') manage_addCPSWidgetTypeForm = DTMLFile('zmi/widgettype_addform', globals()) security.declareProtected(ManagePortal, 'getUnstrippedWidgetType') def getUnstrippedWidgetType(self, widget_type): """Get an unstripped version of a widget type name.""" swt = widget_type.replace(' ', '') for wt in WidgetTypeRegistry.listWidgetTypes(): if wt.replace(' ', '') == swt: return wt raise ValueError(widget_type) security.declareProtected(ManagePortal, 'manage_addCPSWidgetType') def manage_addCPSWidgetType(self, id, swt, REQUEST=None): """Add a widget type instance.""" wt = self.getUnstrippedWidgetType(swt) widget_type_instance = WidgetTypeRegistry.makeWidgetTypeInstance(wt, id) self._setObject(widget_type_instance.getId(), widget_type_instance) widget_type_instance = self._getOb(widget_type_instance.getId()) if REQUEST: REQUEST.RESPONSE.redirect(self.absolute_url()+'/manage_workspace') else: return widget_type_instance InitializeClass(WidgetTypesTool) class WidgetTypeRegistry: """Registry of the available widget types. This stores python classes for widget types, and python classes for widgets. Not to be confused with the administrator-visible widget types stored in portal_widget_types that are actually instances of those registered here. """ def __init__(self): self._widget_types = [] self._widget_type_classes = {} self._widget_classes = {} def register(self, mcls, cls): """Register a class for a widget type.""" widget_type = mcls.meta_type self._widget_types.append(widget_type) self._widget_type_classes[widget_type] = mcls self._widget_classes[widget_type] = cls def listWidgetTypes(self): """Return the list of widget types.""" return self._widget_types[:] def makeWidgetTypeInstance(self, widget_type, id, **kw): """Factory to make a widget type instance of the given type with id = .""" return self._widget_type_classes[widget_type](id, **kw) def getClass(self, widget_type): """Get the instance class for a widget of the given type.""" return self._widget_classes[widget_type] # Singleton WidgetTypeRegistry = WidgetTypeRegistry() CPSSchemas-0.19.0/__init__.py0100444000374200017510000000352610030542431014147 0ustar benzope# (C) Copyright 2003 Nuxeo SARL # Author: Florent Guillaume # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License version 2 as published # by the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # $Id: __init__.py,v 1.11 2004/02/19 11:29:38 ben Exp $ from Products.CMFCore import utils from Products.CMFCore.DirectoryView import registerDirectory from Products.CMFCore.CMFCorePermissions import ManagePortal import Field import Schema import Layout import VocabulariesTool from VocabulariesTool import VocabularyTypeRegistry from Vocabulary import CPSVocabulary import SchemasTool import LayoutsTool import WidgetTypesTool import BasicFields import BasicWidgets import ExtendedWidgets import EpozPatch tools = ( VocabulariesTool.VocabulariesTool, SchemasTool.SchemasTool, LayoutsTool.LayoutsTool, WidgetTypesTool.WidgetTypesTool, ) registerDirectory('skins', globals()) def initialize(registrar): registrar.registerClass( Schema.CPSSchema, permission=ManagePortal, constructors=(Schema.addCPSSchemaForm, Schema.addCPSSchema,), ) utils.ToolInit( 'CPS Document Tools', tools = tools, product_name = 'CPSSchemas', icon = 'tool.gif', ).initialize(registrar) VocabularyTypeRegistry.register(CPSVocabulary) CPSSchemas-0.19.0/HISTORY.txt0100444000374200017510000004510210030542431013734 0ustar benzope******************************************* ** CPSSchemas V0.19.0 [R1 build 2004/03/25-11:40 by ben] Requires: ~~~~~~~~~ - New features: ~~~~~~~~~~~~~ - xhtmlize Bug fixes: ~~~~~~~~~~ - Fix datamodel.get when key is missing. - UrlWidget don't check bla-%20foo url New internal features: ~~~~~~~~~~~~~~~~~~~~~~ - boolean widget handle string value '0' as false ******************************************* ** CPSSchemas V0.18.1 [R1 build 2004/03/09-10:37 by ben] Requires: ~~~~~~~~~ - New features: ~~~~~~~~~~~~~ - Bug fixes: ~~~~~~~~~~ - Rich Text Editor is not localized New internal features: ~~~~~~~~~~~~~~~~~~~~~~ - ******************************************* ** CPSSchemas V0.18.0 [R1 build 2004/03/08-14:18 by ben] Requires: ~~~~~~~~~ - New features: ~~~~~~~~~~~~~ - new Identifier Widget - new Heading Widget rendering with H tag Bug fixes: ~~~~~~~~~~ - #336: File uploading fails for some extensions - AttachedFile no mimetype icons if file extension have uppercase char - AttachedFile/Image/File return invalid file when choose keep under Mac and IE New internal features: ~~~~~~~~~~~~~~~~~~~~~~ - Datamodel add_roles setting split into convenience function. - improve attachedFile rendering ******************************************* ** CPSSchemas V0.17.2 [R1 build 2004/02/25-08:46 by ben] Requires: ~~~~~~~~~ - New features: ~~~~~~~~~~~~~ - Bug fixes: ~~~~~~~~~~ - Vocabulary management screens only work with plain CPS Vocabularies. New internal features: ~~~~~~~~~~~~~~~~~~~~~~ - ******************************************* ** CPSSchemas V0.17.1 [R1 build 2004/02/19-15:56 by ben] Requires: ~~~~~~~~~ - New features: ~~~~~~~~~~~~~ - Bug fixes: ~~~~~~~~~~ - AttachedFile widget: incorrect content type for file attachement make portal transform unable to extract text - #197: FileWidget download link is badly cached - Image widget display windows full path of src as alt and title - Epoz editor don't use cps css New internal features: ~~~~~~~~~~~~~~~~~~~~~~ - Storage adapters always propagate **kw arguments to the base adapter. - Don't fail on ReadAccessError when doing datamodel.get('foo') but return the default value. - _getContentUrl now receives the file_name as argument too. ******************************************* ** CPSSchemas V0.17.0 [R1 build 2004/02/18-09:34 by regebro] Requires: ~~~~~~~~~ - use Epoz 7.4 for trendy xhtml New features: ~~~~~~~~~~~~~ - Removed the deprecated AutoIndex field. - widget text editor does true wysiwyg, using cps css - DateWidget can now use javascript to auto-tabulate between the fields. Bug fixes: ~~~~~~~~~~ - New internal features: ~~~~~~~~~~~~~~~~~~~~~~ - ******************************************* ** CPSSchemas V0.16.0 [R1 build 2004/02/13-14:33 by regebro] Requires: ~~~~~~~~~ - A recent version of PortalTransforms, at least PortalTransforms-1.0 and preferably PortalTransforms-1.0.3 New features: ~~~~~~~~~~~~~ - Handling of OpenOffice.org mimetypes if this is not already provided by the host system New internal features: ~~~~~~~~~~~~~~~~~~~~~~ - Changed the widget_type parameter in __init__ to widgettype to avoid clashes with the widget_type keyword. ******************************************* ** CPSSchemas V0.15.0 [R1 build 2004/02/08-08:01 by fermigier] ZODB Requires: ~~~~~~~~~~~~~~ - Convert metadata storage for Coverage, Source and Relation by running once the external method CPSSchemas.convert_metadata. New features: ~~~~~~~~~~~~~ - Password widget: able to define a policy for password validation: checking min, max size checking lower, upper, digit or extra chararcter - A new AutoIndex field for automatically generating numbers useful for indexes. Bug fixes: ~~~~~~~~~~ - renderHtmlTag unable to generate