def render(self): self.request.response.setHeader('content-type', 'application/pdf') #rmlPageTemplate = pagetemplate.RMLPageTemplateFile('casexit_templates/pdf.pt') #return rmlPageTemplate( # Title=(self.context.Title())) rml_doc = ViewPageTemplateFile('casexit_templates/pdf.pt')(self) return parseString(rml_doc.encode('utf-8')).read() # def render(self): # """Returns PDF as a binary stream.""" # # Use your favourite templating language here to create the RML string. # # The generated document might depend on the web request parameters, # # database lookups and so on - we'll leave that up to you. # rml = getRML(request) # buf = cStringIO.StringIO() # rml2pdf.go(rml, outputFileName=buf) # buf.reset() # pdfData = buf.read() # response = HttpResponse(mimetype='application/pdf')
def testInitWithType(self): t = ViewPageTemplateFile('test.pt', content_type="text/plain") t._cook_check() self.assertEquals(t.content_type, "text/plain") t = ViewPageTemplateFile('testxml.pt', content_type="text/plain") t._cook_check() self.assertEquals(t.content_type, "text/xml")
def __call__(self): template = ViewPageTemplateFile(SIMPLE) return template(self)
def __call__(self): template = ViewPageTemplateFile(PROJECT) return template(self)
from getpaid.core import interfaces from Products.PloneGetPaid.browser.cart import ShoppingCartActions from Products.Five.browser.pagetemplatefile import ZopeTwoPageTemplateFile from Products.PloneGetPaid.i18n import _ from Products.PloneGetPaid.browser.cart import (CartFormatter, ShoppingCartListing, lineItemURL, formatLinkCell, lineItemPrice, lineItemTotal) from zope.formlib import form from Products.CMFPlone.i18nl10n import utranslate from Products.CMFCore.utils import getToolByName from zc.table import column # override template CartFormatter.renderExtra = ViewPageTemplateFile( 'templates/cart-listing-extras.pt') class GDWShoppingCartActions(ShoppingCartActions): """ """ template = ZopeTwoPageTemplateFile('templates/cart-actions.pt') @form.action(_("Continue Shopping"), name='continue-shopping') def handle_continue_shopping(self, action, data): portal = getToolByName(self.context, 'portal_url').getPortalObject() boutique = getattr(portal, 'shop') return self.request.RESPONSE.redirect(boutique.absolute_url()) @form.action(_("Checkout"), condition="doesCartContainItems",
def __call__(self): self.request.response.setHeader('content-type', 'application/pdf') rml_doc = ViewPageTemplateFile('print_survey.pt')(self) return parseString(rml_doc.encode('utf-8')).read()
class CallToActionWidget(SimpleInputWidget): template = ViewPageTemplateFile('calltoactionwidget.pt') def __init__(self, field, request): SimpleInputWidget.__init__(self, field, request) def checkedCallToActions(self): """ for backwards compatibility """ if len(self._data) > 0: if type(self._data[0]) == tuple: return self._data else: new_data = [] for d in self._data: split_data = d.split("|") new_data = (split_data[0], split_data[1], split_data[2]) return new_data else: return [] self._data def actions(self): if self.request.form.has_key( 'updateSelection') or self.request.form.has_key('addRow'): return self.getInputValue() if type(self._data) == list: return self.checkedCallToActions() else: return [] def __call__(self): return self.template(self) def getInputValue(self): form = self.request.form value = [] number_of_actions = int(form['numberofactions']) for i in range(0, number_of_actions): keyname = 'actionname-%s' % i keylink = 'actionlink-%s' % i if form.has_key(keyname) and form.has_key(keylink): name = form[keyname] link = form[keylink] if len(name) > 0 and len(link) > 0: if form.has_key('actiondelete-%s' % i) and form['actiondelete-%s' % i] == "on": pass else: if form.has_key( 'actionnewwindow-%s' % i) and form['actionnewwindow-%s' % i] == "on": newwindow = form[('actionnewwindow-%s' % i)] value.append((name, link, newwindow)) else: value.append((name, link, "off")) return value def hasInput(self): form = self.request.form res = [ k for k in form.keys() if 'actioname' in k or 'actionlink' in k or 'newwindow' in k ] return len(res) > 0
class SelectDateWidget(zope.app.form.browser.widget.SimpleInputWidget): """A more user freindly date input. """ __call__ = ViewPageTemplateFile("templates/selectdatewidget.pt") _missing = u"" minYear = None maxYear = None minYearDelta = 100 maxYearDelta = 5 js_file = open(path + "/templates/yui-calwidget.js", "r") js_template = js_file.read() js_file.close() def __init__(self, *args): super(SelectDateWidget, self).__init__(*args) need("yui-core") need("yui-calendar") need("yui-container") need("yui-element") need("yui-button") self.minDate = datetime.date.today() - datetime.timedelta( self.minYearDelta * 365) self.maxDate = datetime.date.today() + datetime.timedelta( self.maxYearDelta * 365) @property def time_zone(self): """Returns something like: tzinfo=<DstTzInfo 'Africa/Nairobi' LMT+2:27:00 STD> """ try: time_zone = idatetime.ITZInfo(self.request) except TypeError: time_zone = pytz.UTC return time_zone @property def field_name(self): return self.name.replace(".", "__") def set_min_date(self, date): if date: if type(date) == datetime.date: self.minDate = date elif type(date) == datetime.datetime: self.minDate = date.date() else: self.minDate = (datetime.date.today() - datetime.timedelta(self.minYearDelta * 365)) else: self.minDate = (datetime.date.today() - datetime.timedelta(self.minYearDelta * 365)) def set_max_date(self, date): if date: if type(date) == datetime.date: self.maxDate = date elif type(date) == datetime.datetime: self.maxDate = date.date() else: self.maxDate = (datetime.date.today() + datetime.timedelta(self.maxYearDelta * 365)) else: self.maxDate = (datetime.date.today() + datetime.timedelta(self.maxYearDelta * 365)) def jstr(self, alist): return u'["' + u'", "'.join(alist) + u'"]' def get_js(self): pagedate = datetime.date.today() if self.maxDate < pagedate: pagedate = self.maxDate if ((type(self._data) == datetime.date) or (type(self._data) == datetime.datetime)): pagedate = self._data calendar = self.request.locale.dates.calendars["gregorian"] month = _(u"Choose Month") year = _(u"Enter Year") submit = _("OK") cancel = _(u"Cancel") invalidYear = _(u"Please enter a valid year") months_short = self.jstr(calendar.getMonthAbbreviations()) months_long = self.jstr(calendar.getMonthNames()) w_day_1char = self.jstr( [dn[:1] for dn in calendar.getDayAbbreviations()]) w_day_short = self.jstr( [dn[:2] for dn in calendar.getDayAbbreviations()]) w_day_medium = self.jstr(calendar.getDayAbbreviations()) w_day_long = self.jstr(calendar.getDayNames()) return self.js_template % { "name": self.field_name, "sel_day": self._day_name, "sel_month": self._month_name, "sel_year": self._year_name, "txt_date": self.date_name, "mindate": self.minDate.strftime("%m/%d/%Y"), "maxdate": self.maxDate.strftime("%m/%d/%Y"), "pagedate": pagedate.strftime("%m/%Y"), "months_short": months_short, "months_long": months_long, "w_day_1char": w_day_1char, "w_day_short": w_day_short, "w_day_medium": w_day_medium, "w_day_long": w_day_long, "month": translate(str(month), domain="bungeni", context=self.request), "year": translate(str(year), domain="bungeni", context=self.request), "submit": translate(str(submit), domain="bungeni", context=self.request), "cancel": translate(str(cancel), domain="bungeni", context=self.request), "invalidYear": translate(str(invalidYear), domain="bungeni", context=self.request) } def _days(self): dl = [] for i in range(1, 32): dl.append("%02d" % (i)) return dl def _months(self): """ return a dict of month values and names""" calendar = self.request.locale.dates.calendars["gregorian"] i = 0 months = [] for month in calendar.getMonthNames(): i = i + 1 months.append({"num": "%02d" % i, "name": month}) return months @property def _years(self): minYear = self.minYear if self.minDate: minYear = self.minDate.year if minYear is None: minYear = datetime.date.today().year - int(self.minYearDelta) maxYear = self.maxYear if self.maxDate: maxYear = self.maxDate.year if maxYear is None: maxYear = datetime.date.today().year + int(self.maxYearDelta) return range(maxYear, minYear - 1, -1) @property def _day_name(self): return self.name.replace(".", "__") + "__day" @property def _month_name(self): return self.name.replace(".", "__") + "__month" @property def _year_name(self): return self.name.replace(".", "__") + "__year" @property def date_name(self): return self.name.replace(".", "__") + "__date" def hasInput(self): """Widgets need to determine whether the request contains an input value for them """ return (self._day_name in self.request.form and self._month_name in self.request.form and self._year_name in self.request.form) def _hasPartialInput(self): return (self._day_name in self.request.form or self._month_name in self.request.form or self._year_name in self.request.form) def _getFormInput(self): """extract the input value from the submitted form """ return (self._getFieldInput(self._day_name), self._getFieldInput(self._month_name), self._getFieldInput(self._year_name)) def _getFieldInput(self, name): return self.request.form.get(name, self._missing) def _toFieldValue(self, (day, month, year)): """convert the input value to an value suitable for the field.""" if day == self._missing or month == self._missing or year == self._missing: if self.required: return self.context.missing_value else: if day + month + year == self._missing: return None else: return self.context.missing_value else: try: time_zone = self.time_zone return datetime.date(year=int(year), month=int(month), day=int(day)) #tzinfo=time_zone) except ValueError, e: raise ConversionError(_(u"Incorrect string data for date"), e)
class FileAddWidget(FileInputWidget): __call__ = ViewPageTemplateFile("templates/addfilewidget.pt")
class TestViewZPT(PlacefulSetup, unittest.TestCase): def setUp(self): super(TestViewZPT, self).setUp() self.t = ViewPageTemplateFile('test.pt') self.context = C1() def testNamespaceContextAvailable(self): context = self.context request = None namespace = self.t.pt_getContext(InstanceWithContext(context), request) self.failUnless(namespace['context'] is context) self.failUnless('views' in namespace) def testNamespaceHereNotAvailable(self): request = None self.assertRaises(AttributeError, self.t.pt_getContext, InstanceWithoutContext(), request) def testViewMapper(self): the_view = "This is the view" the_view_name = "some view name" def ViewMaker(*args, **kw): return the_view from zope.component.interfaces import IPresentationRequest ztapi.provideView(I1, IPresentationRequest, Interface, the_view_name, ViewMaker) class MyRequest(object): implements(IPresentationRequest) request = MyRequest() namespace = self.t.pt_getContext(InstanceWithContext(self.context), request) views = namespace['views'] self.failUnless(the_view is views[the_view_name]) def test_debug_flags(self): from zope.publisher.browser import TestRequest self.request = TestRequest() self.request.debug.sourceAnnotations = False self.assert_('test.pt' not in self.t(self)) self.request.debug.sourceAnnotations = True self.assert_('test.pt' in self.t(self)) t = ViewPageTemplateFile('testsimpleviewclass.pt') self.request.debug.showTAL = False self.assert_('metal:' not in t(self)) self.request.debug.showTAL = True self.assert_('metal:' in t(self)) def test_render_sets_content_type_unless_set(self): from zope.publisher.browser import TestRequest t = ViewPageTemplateFile('test.pt') self.request = TestRequest() response = self.request.response self.assert_(not response.getHeader('Content-Type')) t(self) self.assertEquals(response.getHeader('Content-Type'), 'text/html') self.request = TestRequest() response = self.request.response response.setHeader('Content-Type', 'application/x-test-junk') t(self) self.assertEquals(response.getHeader('Content-Type'), 'application/x-test-junk')
class ReclassifyItemAction(ViewletBase): template = ViewPageTemplateFile('reclassify_action.pt') def render(self): return self.template()
class ContentSearch(grok.View): """ returns the html with the list of results and icons """ grok.context(Interface) grok.name('content-search') grok.require('zope2.View') list_template = ViewPageTemplateFile('screenlets_templates/search_list.pt') tree_template = ViewPageTemplateFile('screenlets_templates/tree_template.pt') def update(self): query = self.request.get('q', None) self.tab = self.request.get('tab', None) b_size = 10 page = int(self.request.get('page', 0)) strategy = SitemapNavtreeStrategy(self.context) uids = None if self.tab == 'content-tree': # XXX: not implemented pass # portal_state = getMultiAdapter((self.context, self.request), # name=u'plone_portal_state') # portal = portal_state.portal() # query_tree = {'sort_on': 'getObjPositionInParent', # 'sort_order': 'asc', # 'is_default_page': False} # strategy.rootPath = portal.absolute_url_path() # data = buildFolderTree(portal, # obj=portal, # query=query_tree, # strategy=strategy) # result = data.get('children', []) else: if self.tab == 'clipboard': # XXX: not implemented pass # brains = list(self.search(''))[:2] # uids = [b.UID for b in brains] result = self.search(query, uids=uids, b_start=page * b_size, b_size=b_size) result = [strategy.decoratorFactory({'item': node}) for node in result] self.level = 1 self.children = result def render(self): # if self.tab == 'content-tree': # # XXX: not implemented # return self.tree_template(children=self.children, level=1) return self.list_template() def search(self, query=None, b_start=None, b_size=None, uids=None): catalog = getToolByName(self.context, 'portal_catalog') registry = getUtility(IRegistry) settings = registry.forInterface(ICoverSettings) searchable_types = settings.searchable_content_types #temporary we'll only list published elements catalog_query = {'sort_on': 'effective', 'sort_order': 'descending'} catalog_query['portal_type'] = searchable_types if b_start >= 0 and b_size: catalog_query['b_start'] = b_start catalog_query['b_size'] = b_size if query: catalog_query = {'SearchableText': '%s*' % query} if uids: catalog_query['UID'] = uids results = catalog(**catalog_query) return results def getTermByBrain(self, brain, real_value=True): portal_tool = getToolByName(self.context, "portal_url") self.portal_path = portal_tool.getPortalPath() value = brain.getPath()[len(self.portal_path):] return SimpleTerm(value, token=brain.getPath(), title=brain.Title)
class ColumnRenderer(BaseRenderer): """ display items in a single row table """ title = 'Column Renderer' template = ViewPageTemplateFile('templates/column.pt')
def renderTopic(self): """Render the registred topic.""" path = self.context.path view = ViewPageTemplateFile(path) return view(self)
class ZodbInfoView(TimedMixin, VeryCarefulView): """Zodb browser view""" template = ViewPageTemplateFile('templates/zodbinfo.pt') confirmation_template = ViewPageTemplateFile('templates/confirm_rollback.pt') version = __version__ homepage = __homepage__ def render(self): self.reset_mark(getFullRequestUrl(self.request)) pruneTruncations() self.obj = self.selectObjectToView() self.debug_mark('- loading object history') # Not using IObjectHistory(self.obj) because LP: #1185175 self.history = getObjectHistory(self.obj) self.latest = True self.debug_mark('- loading object state') if self.request.get('tid'): self.state = ZodbObjectState(self.obj, p64(int(self.request['tid'], 0)), _history=self.history) self.latest = False else: self.state = ZodbObjectState(self.obj, _history=self.history) if 'CANCEL' in self.request: self._redirectToSelf() return '' if 'ROLLBACK' in self.request: rtid = p64(int(self.request['rtid'], 0)) self.requestedState = self._tidToTimestamp(rtid) if self.request.get('confirmed') == '1': self.history.rollback(rtid) transaction.get().note(u'Rollback to old state %s' % self.requestedState) self.made_changes = True self._redirectToSelf() return '' # will show confirmation prompt return self.confirmation_template() self.debug_mark('- rendering') try: return self.template() finally: self.debug_mark('- done (%s)' % formatTime(self.time_elapsed())) def _redirectToSelf(self): self.request.response.redirect(self.getUrl()) def selectObjectToView(self): obj = None if 'oid' not in self.request: obj = self.findClosestPersistent() # Sanity check: if we're running in standalone mode, # self.context is a Folder in the just-created MappingStorage, # which we're not interested in. if obj is not None and obj._p_jar is not self.jar: obj = None if obj is None: if 'oid' in self.request: try: oid = int(self.request['oid'], 0) except ValueError: raise UserError('OID is not an integer: %r' % self.request['oid']) else: oid = self.getRootOid() try: obj = self.jar.get(p64(oid)) except POSKeyError: raise UserError('There is no object with OID 0x%x' % oid) return obj def getRequestedTid(self): if 'tid' in self.request: return self.request['tid'] else: return None def getRequestedTidNice(self): if 'tid' in self.request: return self._tidToTimestamp(p64(int(self.request['tid'], 0))) else: return None def getObjectId(self): return self.state.getObjectId() def getObjectIdHex(self): return '0x%x' % self.state.getObjectId() def getObjectType(self): return getObjectType(self.obj) def getObjectTypeShort(self): return getObjectTypeShort(self.obj) def getStateTid(self): return u64(self.state.tid) def getStateTidNice(self): return self._tidToTimestamp(self.state.tid) def getPickleSize(self): return len(self.state.pickledState) def getRootOid(self): root = self.jar.root() try: root = root[ZopePublication.root_name] except KeyError: pass return u64(root._p_oid) def locate_json(self, path): # AJAX view return json.dumps(self.locate(path)) def truncated_ajax(self, id): # AJAX view return TRUNCATIONS.get(id) def locate(self, path): not_found = object() # marker # our current position # partial -- path of the last _persistent_ object # here -- path of the last object traversed # oid -- oid of the last _persistent_ object # obj -- last object traversed partial = here = '/' oid = self.getRootOid() obj = self.jar.get(p64(oid)) steps = path.split('/') if steps and steps[0]: # 0x1234/sub/path -> start traversal at oid 0x1234 try: oid = int(steps[0], 0) except ValueError: pass else: partial = here = hex(oid) try: obj = self.jar.get(p64(oid)) except KeyError: oid = self.getRootOid() return dict(error='Not found: %s' % steps[0], partial_oid=oid, partial_path='/', partial_url=self.getUrl(oid)) steps = steps[1:] for step in steps: if not step: continue if not here.endswith('/'): here += '/' here += step try: child = obj[step] except Exception: child = getattr(obj, step, not_found) if child is not_found: return dict(error='Not found: %s' % here, partial_oid=oid, partial_path=partial, partial_url=self.getUrl(oid)) obj = child if isinstance(obj, Persistent): partial = here oid = u64(obj._p_oid) if not isinstance(obj, Persistent): return dict(error='Not persistent: %s' % here, partial_oid=oid, partial_path=partial, partial_url=self.getUrl(oid)) return dict(oid=oid, url=self.getUrl(oid)) def getUrl(self, oid=None, tid=None): if oid is None: oid = self.getObjectId() url = "@@zodbbrowser?oid=0x%x" % oid if tid is None and 'tid' in self.request: url += "&tid=" + self.request['tid'] elif tid is not None: url += "&tid=0x%x" % tid return url def getBreadcrumbs(self): self.debug_mark('- rendering breadcrumbs') breadcrumbs = [] state = self.state seen_root = False while True: url = self.getUrl(state.getObjectId()) if state.isRoot(): breadcrumbs.append(('/', url)) seen_root = True else: if breadcrumbs: breadcrumbs.append(('/', None)) if not state.getName() and state.getParentState() is None: # not using hex() because we don't want L suffixes for # 64-bit values breadcrumbs.append(('0x%x' % state.getObjectId(), url)) break breadcrumbs.append((state.getName() or '???', url)) state = state.getParentState() if state is None: if not seen_root: url = self.getUrl(self.getRootOid()) breadcrumbs.append(('/', None)) breadcrumbs.append(('...', None)) breadcrumbs.append(('/', url)) break return breadcrumbs[::-1] def getPath(self): return ''.join(name for name, url in self.getBreadcrumbs()) def getBreadcrumbsHTML(self): html = [] for name, url in self.getBreadcrumbs(): if url: html.append('<a href="%s">%s</a>' % (escape(url, True), escape(name, False))) else: html.append(escape(name, False)) return ''.join(html) def getDisassembledPickleData(self): self.debug_mark('- rendering pickle') pickle = BytesIO(self.state.pickledState) out = StringIO() memo = {} # 1st pickle: the class try: pickletools.dis(pickle, out, memo) except Exception as e: out.write(''.join(traceback.format_exception_only(type(e), e))) # 2st pickle: actual instance data out.write('\n') try: pickletools.dis(pickle, out, memo) except Exception as e: out.write(''.join(traceback.format_exception_only(type(e), e))) return out.getvalue() def listAttributes(self): self.debug_mark('- rendering attributes') attrs = self.state.listAttributes() if attrs is None: return None return [ZodbObjectAttribute(name, value, self.state.requestedTid) for name, value in sorted(attrs)] def listItems(self): self.debug_mark('- rendering items') items = self.state.listItems() if items is None: return None return [ZodbObjectAttribute(name, value, self.state.requestedTid) for name, value in items] def _loadHistoricalState(self): results = [] for d in self.history: try: interp = ZodbObjectState(self.obj, d['tid'], _history=self.history) state = interp.asDict() error = interp.getError() except Exception as e: state = {} error = '%s: %s' % (e.__class__.__name__, e) results.append(dict(state=state, error=error)) results.append(dict(state={}, error=None)) return results def listHistory(self): """List transactions that modified a persistent object.""" if 'nohist' in self.request: return [] self.debug_mark('- rendering history') state = self._loadHistoricalState() results = [] for n, d in enumerate(self.history): self.debug_mark('- rendering history #%s' % n) utc_timestamp = str(time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(d['time']))) local_timestamp = str(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(d['time']))) try: user_location, user_id = d['user_name'].split() except ValueError: user_location = None user_id = d['user_name'] url = self.getUrl(tid=u64(d['tid'])) current = (d['tid'] == self.state.tid and self.state.requestedTid is not None) curState = state[n]['state'] oldState = state[n + 1]['state'] diff = compareDictsHTML(curState, oldState, d['tid']) results.append(dict(utid=u64(d['tid']), href=url, current=current, error=state[n]['error'], diff=diff, user_id=user_id, user_location=user_location, utc_timestamp=utc_timestamp, local_timestamp=local_timestamp, **d)) # number in reverse order for i in range(len(results)): results[i]['index'] = len(results) - i return results def _tidToTimestamp(self, tid): if isinstance(tid, bytes) and len(tid) == 8: return str(TimeStamp(tid)) return tid_repr(tid)
class ZodbHistoryView(TimedMixin, VeryCarefulView): """Zodb history view""" template = ViewPageTemplateFile('templates/zodbhistory.pt') version = __version__ homepage = __homepage__ page_size = 5 def update(self): pruneTruncations() if 'page_size' in self.request: self.page_size = max(1, int(self.request['page_size'])) self.debug_mark('Loading history') self.history = IDatabaseHistory(self.jar) self.request.hold(Cleanup(self.history.cleanup)) if 'page' in self.request: self.page = int(self.request['page']) elif 'tid' in self.request: tid = int(self.request['tid'], 0) self.debug_mark('- finding transaction page') self.page = self.findPage(p64(tid)) else: self.page = 0 self.last_page = max(0, len(self.history) - 1) // self.page_size if self.page > self.last_page: self.page = self.last_page self.last_idx = max(0, len(self.history) - self.page * self.page_size) self.first_idx = max(0, self.last_idx - self.page_size) def render(self): self.reset_mark(getFullRequestUrl(self.request)) self.update() try: return self.template() finally: self.debug_mark('- done (%s)' % formatTime(self.time_elapsed())) def getUrl(self, tid=None): url = "@@zodbbrowser_history" if tid is None and 'tid' in self.request: url += "?tid=" + self.request['tid'] elif tid is not None: url += "?tid=0x%x" % tid return url def findPage(self, tid): try: pos = list(self.history.tids).index(tid) except ValueError: return 0 else: return (len(self.history) - pos - 1) // self.page_size def listHistory(self): self.debug_mark('- listing history') if 'tid' in self.request: requested_tid = p64(int(self.request['tid'], 0)) else: requested_tid = None results = [] for n, d in enumerate(self.history[self.first_idx:self.last_idx]): utid = u64(d.tid) ts = TimeStamp(d.tid).timeTime() utc_timestamp = time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(ts)) local_timestamp = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)) try: user_location, user_id = d.user.split() except ValueError: user_location = None user_id = d.user if isinstance(user_location, bytes): user_location = user_location.decode('UTF-8', 'replace') if isinstance(user_id, bytes): user_id = user_id.decode('UTF-8', 'replace') description = d.description if isinstance(description, bytes): description = description.decode('UTF-8', 'replace') try: size = d._tend - d._tpos except AttributeError: size = None self.debug_mark('- listing 0x%x (%s)' % (utid, formatSize(size))) ext = d.extension if isinstance(d.extension, dict) else {} objects = [] for idx, record in enumerate(d): url = "@@zodbbrowser?oid=0x%x&tid=0x%x" % (u64(record.oid), utid) if 'fast' in self.request or ( self.time_elapsed() > 10 and idx > 10 and 'full' not in self.request): objects.append(dict( oid=u64(record.oid), path='0x%x' % u64(record.oid), oid_repr=oid_repr(record.oid), class_repr='', url=url, repr='(view object)', )) else: obj = self.jar.get(record.oid) objects.append(dict( oid=u64(record.oid), path=getObjectPath(obj, d.tid), oid_repr=oid_repr(record.oid), class_repr=getObjectType(obj), url=url, repr=IValueRenderer(obj).render(d.tid), )) if len(objects) == 1: summary = '1 object record' else: summary = '%d object records' % len(objects) if size is not None: summary += ' (%s)' % formatSize(size) results.append(dict( index=(self.first_idx + n + 1), utc_timestamp=utc_timestamp, local_timestamp=local_timestamp, user_id=user_id, user_location=user_location, description=description, utid=utid, current=(d.tid == requested_tid), href=self.getUrl(tid=utid), size=size, summary=summary, hidden=(len(objects) > 5), objects=objects, **ext )) if results and not requested_tid and self.page == 0: results[-1]['current'] = True self.debug_mark('- back to rendering') return results[::-1]
def setUp(self): super(TestViewZPT, self).setUp() self.t = ViewPageTemplateFile('test.pt') self.context = C1()
class FileEditWidget(FileInputWidget): __call__ = ViewPageTemplateFile("templates/editfilewidget.pt")
class LookupRecipientSource(object): implements(IRecipientSource) name = 'group_autocomplete_recipient_lookup' form_label = 'Send to' def __init__(self, context, request): self.context = context self.request = request self.settings = get_recipient_settings(context, self.name) def lookup(self): info = [] person = self.request.get('megaphone-person-email') for entry in self.all_entries(): if entry['email'] == person: info.append(entry) return info def all_entries(self): json_data = getUtility(IGroupSource, self.name) info = [] for id_, entry in self.settings: if entry['recipient_type'] == self.name: for group in entry['settingsdata']: info += json_data[group] return info snippet = ViewPageTemplateFile('autocomplete_snippet.pt') def render_form(self): recipients = [r for r in self.all_entries()] if len(recipients): return self.snippet(recipients=recipients, script=self.script()) return '' def script(self): return """ $(document).ready(function () { $('#megaphone-person-ac').autocomplete({ source: %s, focus: function (event, ui) { $('#megaphone-person-ac').val(ui.item.label); $('#megaphone-person-email').val(ui.item.value); $('#megaphone-person-address').show(); $('#megaphone-person-address').html(ui.item.address); return false }, select: function(event, ui) { $('#megaphone-person-ac').val(ui.item.label); $('#megaphone-person-email').val(ui.item.value); $('#megaphone-person-address').show(); $('#megaphone-person-address').html(ui.item.address); return false }, change: function (event, ui) { $('#megaphone-person-ac').val(ui.item.label); $('#megaphone-person-email').val(ui.item.value); $('#megaphone-person-address').show(); $('#megaphone-person-address').html(ui.item.address); return false } }) }) """ % json.dumps([{ 'label': ' '.join([i['honorific'], i['first'], i['last']]), 'value': i['email'], 'address': ('Present Address\n%s\n\nPermanent Address\n%s' % ( i['Present Address'], i['Permanent Address']) ).replace('\n','<br/>') } for i in self.all_entries()])
class SelectDateTimeWidget(SelectDateWidget): __call__ = ViewPageTemplateFile("templates/selectdatetimewidget.pt") @property def _hour_name(self): return self.name.replace(".", "__") + "__hour" @property def _minute_name(self): return self.name.replace(".", "__") + "__minute" def hasInput(self): return (super(SelectDateTimeWidget, self).hasInput() and self._hour_name in self.request.form and self._minute_name in self.request.form) def _hasPartialInput(self): return (super(SelectDateTimeWidget, self)._hasPartialInput() or self._hour_name in self.request.form or self._minute_name in self.request.form) def _getFormInput(self): return (super(SelectDateTimeWidget, self)._getFormInput() + (self._getFieldInput( self._hour_name), self._getFieldInput(self._minute_name))) def _hours(self): hl = [] for i in range(0, 24): hl.append("%02d" % (i)) return hl def _minutes(self): ml = [] for i in range(0, 60, 5): ml.append("%02d" % (i)) return ml def _toFormValue(self, value): if value == self.context.missing_value and self.required: d = datetime.datetime.now() return (d.day, d.month, d.year, d.hour, d.minute) else: try: return (value.day, value.month, value.year, value.hour, value.minute) except: return ("0", "0", "0", "0", "0") def _toFieldValue(self, (day, month, year, hour, minute)): if (day == self._missing or month == self._missing or year == self._missing or hour == self._missing or minute == self._missing): if self.required: return self.context.missing_value else: if day + month + year + hour + minute == self._missing: return None else: return self.context.missing_value else: try: time_zone = self.time_zone return datetime.datetime( year=int(year), month=int(month), day=int(day), hour=int(hour), minute=int(minute), ) except ValueError, e: raise ConversionError( _(u"Incorrect string data for date and time"), e)
class CarouselBannerPlugin(AnalyticsBaseTrackingPlugin): """ A tracking plugin to track clicks on Carousel banners. """ __call__ = ViewPageTemplateFile('banner.pt')
def composerdata_from_subscription(subscription): return utils.AttributeToDictProxy(subscription.composer_data) class HTMLTemplateVocabularyFactory(object): interface.implements(schema.interfaces.IVocabularyFactory) def __call__(self, context): names = [ x[0] for x in component.getUtilitiesFor(IHTMLComposerTemplate) ] return schema.vocabulary.SimpleVocabulary.fromValues(names) default_template = ViewPageTemplateFile('browser/composer-html.pt') class HTMLComposer(persistent.Persistent): """ >>> from zope.interface.verify import verifyClass >>> from collective.dancing.interfaces import IHTMLComposer >>> verifyClass(IHTMLComposer, HTMLComposer) True """ interface.implements(IHTMLComposer) title = _(u'HTML E-Mail') schema = IHTMLComposerSchema
class DefaultRenderer(BaseRenderer): """ the default renderer from plone.portlet.collection """ title = 'Default Renderer' schema = IDefaultSchema template = ViewPageTemplateFile('templates/default.pt')
class HTMLComposer(persistent.Persistent): """ >>> from zope.interface.verify import verifyClass >>> from collective.dancing.interfaces import IHTMLComposer >>> verifyClass(IHTMLComposer, HTMLComposer) True """ interface.implements(IHTMLComposer) title = _(u'HTML E-Mail') schema = IHTMLComposerSchema encoding = 'utf-8' stylesheet = u"" from_name = u"" from_address = u"" replyto_address = u"" subject = u"${site_title}: ${channel_title}" header_text = u"<h1>${subject}</h1>" footer_text = u"" template_name = 'default' confirm_template = ViewPageTemplateFile('browser/composer-html-confirm.pt') forgot_template = ViewPageTemplateFile('browser/composer-html-forgot.pt') @staticmethod def secret(data): salt = component.getUtility(collective.singing.interfaces.ISalt) return md5.new("%s%s" % (data['email'], salt)).hexdigest() context = None # XXX: Needs refactoring because currently these ugly wrapper methods are # required to allow TinyMCE Editor to load on channel edit form. @property def _get_site(self): return zopeappcomponenthooks.getSite() @property def request(self): return self._get_site.REQUEST @property def portal_url(self): return self._get_site.portal_url @property def portal_membership(self): return self._get_site.portal_membership @property def wysiwyg_support(self): return self._get_site.wysiwyg_support @property def portal_properties(self): return self._get_site.portal_properties @property def portal_skins(self): return self._get_site.portal_skins @property def _from_address(self): properties = component.getUtility( Products.CMFCore.interfaces.IPropertiesTool) charset = properties.site_properties.getProperty( 'default_charset', 'utf-8') name = self.from_name or properties.email_from_name mail = self.from_address or properties.email_from_address if not isinstance(name, unicode): name = name.decode(charset) if not isinstance(mail, unicode): # mail has to be be ASCII!! mail = mail.decode(charset).encode('us-ascii', 'replace') #TODO : assert that mail is now valid. (could have '?' from repl.) return formataddr((str(Header(name, charset)), mail)) @property def language(self): return self.request.get('LANGUAGE') def _vars(self, subscription, items=()): """Provide variables for the template. Override this or '_more_vars' in your custom HTMLComposer to pass different variables to the templates. """ vars = {} site = component.getUtility( Products.CMFPlone.interfaces.IPloneSiteRoot) site = utils.fix_request(site, 0) fix_urls = lambda t: transform.URL(site).__call__(t, subscription) vars['channel'] = subscription.channel vars['site_url'] = site.absolute_url() site_title = site.Title() if not isinstance(site_title, unicode): site_title = unicode(site_title, 'UTF-8') vars['site_title'] = site_title vars['channel_title'] = subscription.channel.title vars['subject'] = self.subject # Why would header_text or footer_text ever be None? vars['header_text'] = fix_urls(self.header_text or u"") vars['footer_text'] = fix_urls(self.footer_text or u"") vars['stylesheet'] = self.stylesheet vars['from_addr'] = self._from_address headers = vars['more_headers'] = {} if self.replyto_address: headers['Reply-To'] = self.replyto_address # This is so brittle, it hurts my eyes. Someone convince me # that this needs to become another component: for index, item in enumerate(items): formatted, original = item title = getattr(original, 'Title', lambda: formatted)() vars['item%s_title' % index] = title vars.update(self._more_vars(subscription, items)) def subs(name): vars[name] = string.Template(vars[name]).safe_substitute(vars) for name in 'subject', 'header_text', 'footer_text': subs(name) # It'd be nice if we could use an adapter here to override # variables. We'd probably want to pass 'items' along to that # adapter. return vars def _more_vars(self, subscription, items): """Less generic variables. """ vars = {} channel = subscription.channel site = component.getUtility( Products.CMFPlone.interfaces.IPloneSiteRoot) site = utils.fix_request(site, 0) secret_var = '$%s' % template_var('secret') vars['confirm_url'] = ( '%s/confirm-subscription.html?secret=%s' % (site.portal_newsletters.absolute_url(), secret_var)) vars['unsubscribe_url'] = ('%s/unsubscribe.html?secret=%s' % (channel.absolute_url(), secret_var)) vars['my_subscriptions_url'] = ( '%s/../../my-subscriptions.html?secret=%s' % (channel.absolute_url(), secret_var)) vars['to_addr'] = '$%s' % template_var('to_addr') return vars def _subscription_vars(self, subscription): """Variables that are expected to be unique to every subscription. """ vars = {} vars[template_var('secret')] = self.secret(subscription.composer_data) vars[template_var('to_addr')] = subscription.composer_data['email'] for k, v in subscription.composer_data.items(): vars[template_var(k)] = v return vars @volatile.cache(_render_cachekey) def _render(self, vars, items): if getattr(self, 'template', None) is not None: # This instance has overridden the template attribute. # We'll use that template. Note that this will be a bound template, # so we will need to "unbind" it by accessing im_func directly. template = self.template.im_func else: template = component.getUtility(IHTMLComposerTemplate, name=self.template_name) html = template( self, contents=[i[0] for i in items], items=[dict(formatted=i[0], original=i[1]) for i in items], **vars) return utils.compactify(html) def render(self, subscription, items=(), override_vars=None): vars = self._vars(subscription, items) subscription_vars = self._subscription_vars(subscription) if override_vars is None: override_vars = {} vars.update(override_vars) html = self._render(vars, items) html = string.Template(html).safe_substitute(subscription_vars) message = collective.singing.mail.create_html_mail( vars['subject'], html, from_addr=vars['from_addr'], to_addr=subscription_vars[template_var('to_addr')], headers=vars.get('more_headers'), encoding=self.encoding) return collective.singing.message.Message(message, subscription) def render_confirmation(self, subscription): vars = self._vars(subscription) subscription_vars = self._subscription_vars(subscription) if 'confirmation_subject' not in vars: vars['confirmation_subject'] = zope.i18n.translate( _(u"Confirm your subscription with ${channel-title}", mapping={'channel-title': subscription.channel.title}), target_language=self.language) html = self.confirm_template(**vars) html = utils.compactify(html) html = string.Template(html).safe_substitute(subscription_vars) message = collective.singing.mail.create_html_mail( vars['confirmation_subject'], html, from_addr=vars['from_addr'], to_addr=subscription_vars[template_var('to_addr')], headers=vars.get('more_headers'), encoding=self.encoding) # status=None prevents message from ending up in any queue return collective.singing.message.Message(message, subscription, status=None) def render_forgot_secret(self, subscription): vars = self._vars(subscription) subscription_vars = self._subscription_vars(subscription) if 'forgot_secret_subject' not in vars: vars['forgot_secret_subject'] = zope.i18n.translate( _(u"Change your subscriptions with ${site_title}", mapping={'site_title': vars['site_title']}), target_language=self.language) html = self.forgot_template(**vars) html = utils.compactify(html) html = string.Template(html).safe_substitute(subscription_vars) message = collective.singing.mail.create_html_mail( vars['forgot_secret_subject'], html, from_addr=vars['from_addr'], to_addr=subscription_vars[template_var('to_addr')], headers=vars.get('more_headers'), encoding=self.encoding) # status=None prevents message from ending up in any queue return collective.singing.message.Message(message, subscription, status=None)
class PageLayout(grok.View): """ Renders a layout for the cover object. """ grok.context(ICover) grok.name('layout') grok.require('zope2.View') pagelayout = ViewPageTemplateFile('layout_templates/pagelayout.pt') row = ViewPageTemplateFile('layout_templates/row.pt') group = ViewPageTemplateFile('layout_templates/group.pt') tile = ViewPageTemplateFile('layout_templates/tile.pt') generalmarkup = ViewPageTemplateFile('layout_templates/generalmarkup.pt') def get_layout(self): layout = json.loads(self.context.cover_layout) return layout def render_section(self, section, mode): if 'type' in section: if section['type'] == u'row': return self.row(section=section, mode=mode) if section['type'] == u'group': return self.group(section=section, mode=mode) if section['type'] == u'tile': return self.tile(section=section, mode=mode) else: return self.generalmarkup(section=section, mode=mode) def is_user_allowed_in_group(self): return True def tile_is_configurable(self, tile_type): tile = self.context.restrictedTraverse(str(tile_type)) return tile.is_configurable def tile_is_droppable(self, tile_type): tile = self.context.restrictedTraverse(str(tile_type)) return tile.is_droppable def tile_is_editable(self, tile_type): tile = self.context.restrictedTraverse(str(tile_type)) return tile.is_editable def can_compose_tile_class(self, tile_type, tile_id): tile = self.context.restrictedTraverse("%s/%s" % (str(tile_type), str(tile_id))) if not tile.isAllowedToEdit(): return "disabled" else: return "" def render_view(self): # XXX: There *must* be a better way of doing this, maybe write it # in the request ? sending it as parameter is way too ugly return self.pagelayout(mode="view") def render_compose(self): # XXX: There *must* be a better way of doing this, maybe write it # in the request ? sending it as parameter is way too ugly return self.pagelayout(mode="compose") def render_layout_edit(self): # XXX: There *must* be a better way of doing this, maybe write it # in the request ? sending it as parameter is way too ugly return self.pagelayout(mode="layout_edit") def accepted_ct_for_tile(self, tile_type): tile = self.context.restrictedTraverse(str(tile_type)) accepted_ct = tile.accepted_ct() return json.dumps(accepted_ct)