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)
