def __call__(self): settings = get_settings() self.organization_name = settings.organization_name self.campaign = self.context.get_fundraising_campaign() self.page = self.context.get_fundraising_campaign_page() self.donation_receipt_legal = self.campaign.donation_receipt_legal self.products = [] if self.context.products: for product in self.context.products: price, quantity, product_uuid = product.split('|', 2) total = int(price) * int(quantity) product = uuidToObject(product_uuid) if not product: continue if product.donation_only: price = total quantity = '-' self.products.append({ 'price': price, 'quantity': quantity, 'product': product, 'total': total, }) self.is_personal = self.page.is_personal() module = os.sys.modules[martian.util.caller_module()] _prefix = os.path.dirname(module.__file__) pt = PageTemplateFile('donation_templates/receipt.pt') return pt.pt_render({'view': self})
class GooglechartField(BaseField): """ """ read_template = PageTemplateFile('googlechart_read.pt') edit_template = PageTemplateFile('googlechart_edit.pt') def validate(self, submittedValue): """ """ errors = [] # no validation needed (we do not want to parse the GoogleChart # param) return errors def processInput(self, submittedValue): """ """ lines = submittedValue.replace('\r', '').split('\n') params = {} for l in lines: if "=" in l: (key, value) = l.split('=') else: key = l value = '' params[key] = value return params
class NumberField(BaseField): """ """ read_template = PageTemplateFile('number_read.pt') edit_template = PageTemplateFile('number_edit.pt') def validate(self, submittedValue): """ """ errors = [] fieldname = self.context.id if self.context.number_type == "INTEGER": try: long(submittedValue) except: errors.append(fieldname + PlominoTranslate( _(" must be an integer (submitted value was: "), self.context) + submittedValue + ")") elif self.context.number_type == "FLOAT": try: float(submittedValue) except: errors.append(fieldname + PlominoTranslate( _(" must be a float (submitted value was: "), self.context) + submittedValue + ")") elif self.context.number_type == "DECIMAL": try: Decimal(str(submittedValue)) except: errors.append(fieldname + PlominoTranslate( _(" must be a decimal (submitted value was: "), self.context) + submittedValue + ")") return errors def processInput(self, submittedValue): """ """ if self.context.number_type == "INTEGER": return long(submittedValue) elif self.context.number_type == "FLOAT": return float(submittedValue) elif self.context.number_type == "DECIMAL": return Decimal(str(submittedValue)) else: return submittedValue def format_value(self, v): """ """ str_v = "" if v not in (None, "") and self.context.format: try: str_v = self.context.format % v except TypeError: str_v = "Formatting error" else: str_v = str(v) return str_v
def get_pt(self, text=b'<html />'): with tempfile.NamedTemporaryFile(mode='wb', delete=False) as f: f.write(text) self.addCleanup(os.unlink, f.name) pt = PageTemplateFile(f.name) pt.read() return pt
def get_pt(self, text): f = open(self.TEMPFILENAME, "wb") f.write(text) f.close() pt = PageTemplateFile(self.TEMPFILENAME) pt.read() return pt
class SelectionField(BaseField): """ """ read_template = PageTemplateFile('selection_read.pt') edit_template = PageTemplateFile('selection_edit.pt') def getSelectionList(self, doc): """ Return the values list. Format: label|value, use label as value if no label. """ # if formula available, use formula, else use manual entries f = self.context.selectionlistformula if f: # if no doc provided (if OpenForm action), we use the PlominoForm if doc: obj = doc else: obj = self.context try: s = self.context.runFormulaScript( SCRIPT_ID_DELIMITER.join(['field', self.context.getParentNode().id, self.context.id, 'SelectionListFormula']), obj, f) except PlominoScriptException, e: p = self.context.absolute_url_path() e.reportError( '%s field selection list formula failed' % self.context.id, path=p + '/getSettings?key=selectionlistformula') s = [] else:
def render_javascript(charts, packages): """Render the javascript for the charts and packages""" render_charts = [] for chart in charts: if 'charttype' in chart and 'data' in chart: render_charts.append(chart) if len(render_charts) == 0: return None pagetemplate = PageTemplateFile('templates/javascript.pt') context = {'packages': "'%s'" % ','.join(packages), 'charts': render_charts} return pagetemplate.pt_render(namespace=context)
class SelectionField(SelectionFieldBase): """ """ implements(ISelectionField) plomino_field_parameters = { 'interface': ISelectionField, 'label': "Chosen", 'index_type': "KeywordIndex" } read_template = PageTemplateFile('chosen_read.pt') edit_template = PageTemplateFile('chosen_edit.pt')
def render_javascript(charts, packages): """Render the javascript for the charts and packages""" render_charts = [] for chart in charts: if 'charttype' in chart and 'data' in chart: render_charts.append(chart) if len(render_charts) == 0: return None pagetemplate = PageTemplateFile('templates/javascript.pt') context = { 'packages': "'%s'" % ','.join(packages), 'charts': render_charts } return pagetemplate.pt_render(namespace=context)
class AttachmentField(BaseField): """ """ read_template = PageTemplateFile('attachment_read.pt') edit_template = PageTemplateFile('attachment_edit.pt') def processInput(self, strValue): """ """ # only called in during validation if not strValue: return None strValue = normalizeString(strValue) return {strValue: 'application/unknown'}
class TeaserRenderer(object): template = PageTemplateFile('teaser.pt') def __init__(self, context, data, request): self.context = context self.data = data self.request = request def __call__(self): return self.template(options=self) @property def display_columns(self): return int(self.data.display_columns) @property def table_rows(self): count = len(self.teasers) if count == 1: return count rows = count / 2 if count % 2 != 0: rows += 1 return rows @instance_property def teasers(self): return get_teasers(self.context, self.data, self.request)
def render(self): if self.__searchFailed: r = '''<div class="error" id="post-search-timeout"> <p><strong>Posts Failed to Load</strong></p> <p>Sorry, the posts failed to load, because the server took too long to respond. <em>Please try again later.</em> </p> </div>''' else: if not self.__updated: raise UpdateNotCalled() pageTemplate = PageTemplateFile(self.pageTemplateFileName) onlyGroup = False if self.view.group_count() == 1: onlyGroup = self.view.group_count() onlyAuthor = False if self.view.author_count() == 1: onlyAuthor = self.view.author_count() if self.posts: r = pageTemplate(view=self, onlyGroup=onlyGroup, onlyAuthor=onlyAuthor) else: r = '<p id="post-search-none">No posts found.</p>' return r
class BooleanField(BaseField): """ """ read_template = PageTemplateFile('boolean_read.pt') edit_template = PageTemplateFile('boolean_edit.pt') def processInput(self, strValue): """ """ if type(strValue) is bool: return strValue if strValue == "1": return True else: return False
def render(self): if not self.__updated: raise interfaces.UpdateNotCalled pageTemplate = PageTemplateFile(self.pageTemplateFileName) return pageTemplate(view=self, requiredWidgetsArray=self.requiredWidgetsArray)
def update(self): self.updated = True self.pageTemplate = PageTemplateFile(self.pageTemplateFileName) self.finalSize = self.get_final_size() self.finalWidth = self.finalSize[0] self.finalHeight = self.finalSize[1] self.imageUrl = self.get_image_url()
def render(self): if not self.__updated: raise UpdateNotCalled pageTemplate = PageTemplateFile(self.pageTemplateFileName) retval = pageTemplate(view=self, currentSite=self.currentSite, siteMemberships=self.siteMemberships) return retval
def render(self): if not self.__updated: raise UpdateNotCalled pageTemplate = PageTemplateFile(self.pageTemplateFileName) retval = pageTemplate(visibility=self.visibility, webVisibility=self.webVisibility, emailVisibility=self.emailVisibility) return retval
def main(argv=None): if argv is None: argv = sys.argv[1:] if not len(argv) == 1: print "Usage: grok2html OUTDIR" sys.exit(1) source_dir = os.path.dirname(__file__) www_dir = os.path.abspath(argv[0]) if not os.path.isdir(www_dir): print "OUTDIR '%s' does not exist." % (www_dir, ) sys.exit(1) os.chdir(source_dir) rest_files = [] rest_files.append( RestFile('index', os.path.join(source_dir, 'index.txt'), os.path.join(www_dir, 'index.html'))) rest_files.append( RestFile('about', os.path.join(source_dir, 'about.txt'), os.path.join(www_dir, 'about.html'))) rest_files.append( RestFile('tutorial', os.path.join(source_dir, 'tutorial.txt'), os.path.join(www_dir, 'tutorial.html'))) rest_files.append( RestFile('mini-index', os.path.join(source_dir, 'minitutorials', 'index.txt'), os.path.join(www_dir, 'minitutorials', 'index.html'))) rest_files.append( RestFile('searching', os.path.join(source_dir, 'minitutorials', 'searching.txt'), os.path.join(www_dir, 'minitutorials', 'searching.html'))) rest_files.append( RestFile('macros', os.path.join(source_dir, 'minitutorials', 'macros.txt'), os.path.join(www_dir, 'minitutorials', 'macros.html'))) rest_files.append( RestFile('testing', os.path.join(source_dir, 'minitutorials', 'testing.txt'), os.path.join(www_dir, 'minitutorials', 'testing.html'))) rest_files.append( RestFile('xmlrpc', os.path.join(source_dir, 'minitutorials', 'xmlrpc.txt'), os.path.join(www_dir, 'minitutorials', 'xmlrpc.html'))) rest_files.append( RestFile('permissions', os.path.join(source_dir, 'minitutorials', 'permissions.txt'), os.path.join(www_dir, 'minitutorials', 'permissions.html'))) rest_files.append( RestFile( 'zc.buildout', 'http://svn.zope.org/*checkout*/zc.buildout/trunk/doc/tutorial.txt', os.path.join(www_dir, 'minitutorials', 'buildout.html'))) template = PageTemplateFile(os.path.join(source_dir, 'template.pt')) create_html(rest_files, template)
class RecaptchaField(BaseField): """ """ implements(IRecaptchaField) plomino_field_parameters = { 'interface': IRecaptchaField, 'label': "Recaptcha", } read_template = PageTemplateFile('recaptcha_read.pt') edit_template = PageTemplateFile('recaptcha_edit.pt') def validate(self, submittedValue): """ """ errors = self.restrictedTraverse('@@captcha').verify() return errors
def exportData(self, context, out): template = PageTemplateFile('xml/%s' % _FILENAME, globals()) # .__of__(context.getSite()) info = self._getExportInfo(context) if info: context.writeDataFile('%s' % _FILENAME, template(info=info).encode('utf-8'), 'text/xml') print >> out, "GenericSetup Configuration for ldap exported"
def render(self): if not self.__updated: raise UpdateNotCalled() if self.results: pageTemplate = PageTemplateFile(self.pageTemplateFileName) r = pageTemplate(view=self) else: r = '<p id="file-search-none">No files found.</p>' return r
class DbUploadField(BaseField): """ """ implements(IDbUploadField) plomino_field_parameters = {'interface': IDbUploadField, 'label':"DB upload", 'index_type':"ZCTextIndex"} read_template = PageTemplateFile('templates/dbupload_read.pt') edit_template = PageTemplateFile('templates/dbupload_edit.pt') def validate(self, submittedValue): """ validate """ errors = [] return errors def processInput(self, submittedValue): """ """ # only called in during validation if not submittedValue: return None if isinstance(submittedValue, FileUpload): doc = self.context.REQUEST.PARENTS[0] import pdb;pdb.set_trace() #strValue = normalizeString(strValue) #return {strValue: 'application/unknown'} def getIcon(self): """
def update(self): self.updated = True self.pageTemplate = PageTemplateFile(self.pageTemplateFileName) self.finalSize = self.get_final_size() self.finalWidth = self.finalSize[0] self.finalHeight = self.finalSize[1] self.imageUrl = self.get_image_url() self.image = self.smallImage if self.resizeNeeded else self.origImg # --=mpj17=-- The page template uses self.image.ct, rather than # self.image.contentType because it will drop the attribute if it # is None, but self.image.contentType is never None, just ''. # A similar issue hits self.sizes and self.srcset below ct = self.image.contentType self.image.ct = ct if ct else None
def panellayout(_context, name, title, description, template, layer): component = { 'name': name, 'title': title, 'description': description, 'template': PageTemplateFile(template), } adapter = lambda request: component _context.action( discriminator=('panellayout', name, layer), callable=handler, args=('registerAdapter', adapter, (layer, ), ILayout, name, _context.info), )
def render(self): if not self.__updated: raise UpdateNotCalled retval = '' feed_urls = self.feed_config.urls feeds = [] for url in feed_urls: fname = md5.new(url).hexdigest() try: dataDir = locateDataDirectory('groupserver.GSFeedParser.data') v = pickle.load(file(os.path.join(dataDir, fname))) feeds.append(v) except: pass pageTemplate = self.cookedTemplates.get(self.atomTemplate) if not pageTemplate: pageTemplate = PageTemplateFile(self.atomTemplate) self.cookedTemplates.add(self.atomTemplate, pageTemplate) for feed in feeds: for entry in feed.entries: if entry.has_key('content'): if isinstance(entry.content[0], unicode): content = entry.content else: content = entry.content[0] else: content = getattr(entry, 'summary', '') if isinstance(content, dict): content = content.value retval += pageTemplate(view=self, entry=entry) return retval
def render(self): if not self.__updated: raise UpdateNotCalled if self.__searchFailed: r = '''<div class="error" id="topic-serch-timeout"> <p><strong>Topics Failed to Load</strong></p> <p>Sorry, the topics failed to load, because the server took too long to respond. <em>Please try again later.</em> </p> </div>''' else: pageTemplate = PageTemplateFile(self.pageTemplateFileName) group_count = self.view.group_count() if group_count == 1: onlyGroup = True else: onlyGroup = False if self.topics: r = pageTemplate(view=self, onlyGroup=onlyGroup) else: r = '<p id="topic-search-none">No topics found.</p>' return r
class NameField(BaseField): """ """ read_template = PageTemplateFile('name_read.pt') edit_template = PageTemplateFile('name_edit.pt') def _getNamesIds(self): """ Return Plone members as [(name, userid), ...] Honor the restricttogroup field and the portal's do_not_list_users property. """ if self.context.restricttogroup: group = self.context.portal_groups.getGroupById( self.context.restricttogroup) if group: names_ids = [ (m.getProperty("fullname"), m.getProperty('id')) for m in group.getGroupMembers()] else: return [] elif self.context.getParentDatabase().do_not_list_users: return None else: names_ids = [ (m.getProperty("fullname"), m.getId()) for m in self.context.getPortalMembers()] names_ids.sort(key=lambda (username, userid): username.lower()) return names_ids def getSelectionList(self, doc=None): """ Fullname/ID list in selectionlist format: fullname|userid """ names_ids = self._getNamesIds() if not names_ids: return None s = ['|'] for username, userid in names_ids: if not username: s.append("%s|%s" % (userid, userid)) else: s.append("%s|%s" % (username, userid)) return s def getFullname(self, userid): """ Return member fullname if available """ if not userid: return '' mt = api.portal.get().portal_membership user = mt.getMemberById(userid) if user: fullname = user.getProperty('fullname') if fullname: return fullname else: return userid else: return userid def getFilteredNames(self, filter): """ Return a JSON list of users, filtered by id or name. """ names_ids = self._getNamesIds() if filter: names_ids = [ {'id': userid, 'text': username} for (username, userid) in names_ids[:20] if filter.lower() in username.lower() or filter.lower() in userid.lower()] return json.dumps( {'results': names_ids, 'total': len(names_ids)}) def getCurrent(self, values): if isinstance(values, basestring): values = [values] return ["%s:%s" % (id, self.getFullname(id)) for id in values]
def __init__(self, *args, **kwargs): self.target_language = None if kwargs.has_key('target_language'): self.target_language = kwargs['target_language'] kwargs.pop('target_language') PageTemplateFile.__init__(self, *args, **kwargs)
def render(self): if not self.__updated: raise UpdateNotCalled pageTemplate = PageTemplateFile(self.pageTemplateFileName) return pageTemplate(view=self)
class GooglevisualizationField(BaseField): """ GooglevisualizationField allows to render a datatable using the Google Visualization tools. The field value should be list of lists. Each child list contains the values for the columns declared in the Google Visualization javascript code. Example: If the columns declaration is: gvisudata.addColumn('string', 'Name'); gvisudata.addColumn('string', 'Manager'); gvisudata.addColumn('string', 'ToolTip'); (typical case when using orgchart package) then the field value should look like: [['\'Mike\',\'Mike<div style="color:red; font-style:italic">President</div>\'', "''", "'The pres'"], ["'Tim'", "'Mike'", "'vp'"], ["'Tom'", "'Mike'", "'chief'"]] Notes: - strings must be enclosed in quotes (as they will be inserted in JS code) - when editing the field value from the form, the rows are separated with a newline, and the cells are separated with a pipe: 'Mike','Mike<div style="color:red; font-style:italic">President</div>'|''|'The pres' 'Tim'|'Mike'|'vp' 'Tom'|'Mike'|'chief' More information about Google Visualization javascript APIs: http://code.google.com/intl/en/apis/visualization/documentation/ """ read_template = PageTemplateFile('googlevisualization_read.pt') edit_template = PageTemplateFile('googlevisualization_edit.pt') def validate(self, submittedValue): """ """ errors = [] # no validation needed return errors def processInput(self, submittedValue): """ """ lines = submittedValue.replace('\r', '').split('\n') datatable = [] for l in lines: datatable.append(l.split('|')) return datatable def jscode(self, datatable): """ Return Google visualization JS code """ if type(datatable) is dict: # if dict, we convert it to googleviz compliant array labels = datatable.keys() labels.sort() tmp = [] for label in labels: valuelist = ["'%s'" % label] for e in asList(datatable[label]): if isinstance(e, basestring): valuelist.append("'%s'" % e) else: valuelist.append(str(e)) tmp.append(valuelist) datatable = tmp rows = [] i = 0 for row in datatable: j = 0 for cell in row: rows.append( js_row_template % { 'chartid': self.chartid, 'row_nr': i, 'col_nr': j, 'cell': cell }) j = j + 1 i = i + 1 js = js_func_template % { 'jssettings': self.jssettings, 'chartid': self.chartid, 'num_rows': str(len(datatable)), 'rows': ''.join(rows) } return js
def render(path, options): tpl = PageTemplateFile(path, globals()) ns = tpl.pt_getContext((), options) return tpl.pt_render(ns)
def pt_getContext(self, args=(), options={}, **kw): rval = PageTemplateFile.pt_getContext(self, args=args) options.update(rval) return options
def pt_getContext(self, args=(), options={}, **kw): """Add our data into ZPT's defaults""" rval = PageTemplateFile.pt_getContext(self, args=args) options.update(rval) return options
text = RichText(title=u'Text', required=False) view_more_url = TextLine( title=u'View More URL', required=False, ) count = Int( title=u'Number of items to display, per source', required=False, default=6, ) DAVIZ_TPL = PageTemplateFile('pt/zoom_cell_daviz.pt') GENERIC_TPL = PageTemplateFile('pt/zoom_cell_generic.pt') tile_zooms = { 'http://www.eea.europa.eu/portal_types/' + 'DavizVisualization#DavizVisualization': DAVIZ_TPL, } class DavizListingTile(PersistentCoverTile): """ Base class for Daviz listing tiles It accepts both ElasticSearch and Sparql query objects. """ is_configurable = False
class DatagridField(BaseField): """ """ implements(IDatagridField) plomino_field_parameters = { 'interface': IDatagridField, 'label': "Datagrid", 'index_type': "ZCTextIndex" } read_template = PageTemplateFile('datagrid_read.pt') edit_template = PageTemplateFile('datagrid_edit.pt') def getParameters(self): """ """ return self.jssettings def processInput(self, submittedValue): """ """ try: return json.loads(submittedValue) except: return [] def rows(self, value, rendered=False): """ """ if value is None or value == "": value = [] if isinstance(value, basestring): return value if isinstance(value, DateTime): value = DateToString(value) if isinstance(value, dict): if rendered: value = value['rendered'] else: value = value['rawdata'] return value def tojson(self, value, rendered=False): """ """ rows = self.rows(value, rendered) return json.dumps(rows) def getActionLabel(self, action_id): """ """ db = self.context.getParentDatabase() if action_id == "add": label = PlominoTranslate("datagrid_add_button_label", db) child_form_id = self.associated_form if child_form_id is not None: child_form = db.getForm(child_form_id) if child_form: label += " " + child_form.Title() return label if action_id == "delete": return PlominoTranslate("datagrid_delete_button_label", db) if action_id == "edit": return PlominoTranslate("datagrid_edit_button_label", db) return "" def getFieldValue(self, form, doc, editmode, creation, request): """ """ fieldValue = BaseField.getFieldValue(self, form, doc, editmode, creation, request) if not fieldValue: return fieldValue # if doc is not a PlominoDocument, no processing needed if not doc or doc.isNewDocument(): return fieldValue rawValue = fieldValue mode = self.context.getFieldMode() mapped_fields = [] if self.field_mapping: mapped_fields = [f.strip() for f in self.field_mapping.split(',')] # item names is set by `PlominoForm.createDocument` item_names = doc.getItem(self.context.id + '_itemnames') if mapped_fields: if not item_names: item_names = mapped_fields # fieldValue is a array, where we must replace raw values with # rendered values child_form_id = self.associated_form if child_form_id is not None: db = self.context.getParentDatabase() child_form = db.getForm(child_form_id) # zip is procrustean: we get the longest of mapped_fields or # fieldValue mapped = [] for row in fieldValue: if len(row) < len(item_names): row = (row + [''] * (len(item_names) - len(row))) row = dict(zip(item_names, row)) mapped.append(row) fieldValue = mapped fields = {} for f in mapped_fields + item_names: fields[f] = None fields = fields.keys() field_objs = [child_form.getFormField(f) for f in fields] # avoid bad field ids field_objs = [f for f in field_objs if f is not None] #DBG fields_to_render = [f.id for f in field_objs if f.getFieldType() not in ["DATETIME", "NUMBER", "TEXT", "RICHTEXT"]] #DBG fields_to_render = [f.id for f in field_objs if f.getFieldType() not in ["DOCLINK", ]] fields_to_render = [ f.id for f in field_objs if f.getFieldMode() in [ "DISPLAY", ] or f.getFieldType() not in ["TEXT", "RICHTEXT"] ] if fields_to_render: rendered_values = [] for row in fieldValue: row['Form'] = child_form_id row['Plomino_Parent_Document'] = doc.id tmp = TemporaryDocument(db, child_form, row, real_doc=doc) tmp = tmp.__of__(db) for f in fields: if f in fields_to_render: row[f] = tmp.getRenderedItem(f) rendered_values.append(row) fieldValue = rendered_values if mapped_fields and child_form_id: mapped = [] for row in fieldValue: mapped.append([row[c] for c in mapped_fields]) fieldValue = mapped return {'rawdata': rawValue, 'rendered': fieldValue}
def get(self): my_pt = PageTemplateFile('main.pt') context = {'rows': ['apple', 'banana', 'carrot'], 'foo':'bar'} self.response.out.write(my_pt.pt_render(namespace=context))