class SubKssView(PloneKSSView):
column_two = ZopeTwoPageTemplateFile('sub-in.pt')
edit_sub_page = ZopeTwoPageTemplateFile('edit_sub.pt')
def subscribeAuthenticatedMember(self):
sm = ISubscriptionManager(self.context)
sm.subscribeAuthenticatedMember()
core = self.getCommandSet("core")
core.replaceInnerHTML("#subscription", self.column_two())
return self.render()
def unsubscribeAuthenticatedMember(self):
sm = ISubscriptionManager(self.context)
sm.unsubscribeAuthenticatedMember()
core = self.getCommandSet("core")
core.replaceInnerHTML("#subscription", self.column_two())
return self.render()
def subscribeNotified(self):
# use the adapter to configure the subscribers
obj = self.context.aq_inner
adapted = ISubscriptionManager(obj)
form = self.request.form
if form.has_key('persons'):
adapted.setSubscribedMembers(form['persons'])
if form.has_key('notified'):
sendNotification(self, obj)
else:
persons = self.context.getProperty('object_subscribers')
for person in persons:
adapted.unsubscribeMember(person)
ksscore = self.getCommandSet('core')
#cp_view = zope.component.getMultiAdapter((obj, self.request, self), name='zopen.subscription')
#content_html = cp_view.render()
#print content_html
#ksscore.replaceInnerHTML('dl.GeditNotified', content_html)
ksscore.replaceHTML("#subscription", self.column_two())
self.getCommandSet('plone').issuePortalMessage(
translate(_(u'modified_success', default="Modified success."),
context=self.request),
translate(_(u'Info', default='Info'), context=self.request))
return self.render()
def editSub(self):
core = self.getCommandSet("core")
core.replaceInnerHTML("#sub_m", self.edit_sub_page())
return self.render()
def render_macro(self, macro, extra_context={}):
"""
Returns a rendered page template which contains nothing but a
provided macro.
o macro: the macro list representation which should be
rendered within the returned template object.
"""
template = ZopeTwoPageTemplateFile('macro_snippet.pt').__of__(self)
template._cook_check()
extra_context['macro'] = macro
return template.pt_render(extra_context=extra_context)
class PersonSearchView(formbase.FormBase):
""" person searching view """
form_fields = form.Fields(*searchFields(IPersonTable))
form_fields = form.Fields(form_fields, for_input=True)
form_fields = form_fields.omit('created', 'address')
template = ZopeTwoPageTemplateFile('person_search.pt')
results = None
@form.action("Search", condition=form.haveInputWidgets)
def handle_search(self, action, data):
self.results = self.search(data)
def search(self, data):
domain_class = self.context.domain_model
d = {}
for name in domain_class.c.keys():
v = data.get(name)
if v:
d[name] = v
if not d:
return []
return self.context.query(**d)
def renderResults(self):
columns = SearchColumns
formatter = table.StandaloneFullFormatter(
self.context,
self.request,
self.results or (),
prefix="form",
visible_column_names=[c.name for c in columns],
columns=columns)
formatter.cssClasses['table'] = 'listing'
return formatter()
class ShoppingCartListing( ContainerViewlet ):
actions = ContainerViewlet.actions.copy()
columns = [
column.SelectionColumn( lambda item: item.item_id, name="selection"),
column.GetterColumn( title=_(u"Name"), getter=lineItemURL ),
column.GetterColumn( title=_(u"Price"), getter=lineItemPrice ),
]
selection_column = columns[0]
template = ZopeTwoPageTemplateFile('templates/cart-listing.pt')
formatter_factory = CartFormatter
def __init__( self, *args, **kw):
super( ShoppingCartListing, self ).__init__( *args, **kw )
for column in self.columns:
if hasattr(column, 'title'):
column.title = utranslate(domain='plonegetpaid',
msgid=column.title,
context=self.request)
def getContainerContext( self ):
return self.__parent__.cart
def isOrdered( self, *args ):
# shopping cart should not be ordered, so override this with False
return False
class TopicHidden(FileHidden):
index = ZopeTwoPageTemplateFile('browser/templates/topic.pt')
def __init__(self, context, request):
request.form['q'] = request.URL
request.form['f'] = request['postId']
FileHidden.__init__(self, context, request)
def AddViewFactory(name, schema, label, permission, layer,
template, default_template, bases, for_,
fields, content_factory, arguments,
keyword_arguments, set_before_add, set_after_add,
menu=u''):
class_ = makeClassForTemplate(template, globals(), used_for=schema,
bases=bases)
class_.schema = schema
class_.label = label
class_.fieldNames = fields
class_._factory = content_factory
class_._arguments = arguments
class_._keyword_arguments = keyword_arguments
class_._set_before_add = set_before_add
class_._set_after_add = set_after_add
class_.generated_form = ZopeTwoPageTemplateFile(default_template)
if layer is None:
layer = IDefaultBrowserLayer
s = zope.component.getGlobalSiteManager()
s.registerAdapter(class_, (for_, layer), Interface, name)
# Reminder: the permission we got has already been processed by
# BaseFormDirective, that means that zope.Public has been
# translated to the CheckerPublic object
protectClass(class_, permission)
initializeClass(class_)
class OrderFulfillmentComponent(core.ComponentViewlet):
""" workflow actions and details on order fulfillment status
"""
order = 5
template = ZopeTwoPageTemplateFile('templates/order-fulfillment.pt')
prefix = "orderfulfillment"
def render(self):
return self.__of__(self.__parent__).template()
def show(self, **kw):
return True
def update(self):
self.setupActions()
return super(OrderFulfillmentComponent, self).update()
def setupActions(self):
wf = self.__parent__.context.fulfillment_workflow
transitions = wf.getManualTransitionIds()
self.actions = bindTransitions(
self, transitions,
wf_name='order.fulfillment') #, wf=wf.workflow() )
def fulfillment_status(self):
return self.__parent__.context.fulfillment_state
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'layout'
widget_label = _('Layout selection')
view_js = '++resource++cpskin.faceted.widgets.layout.view.js'
edit_js = '++resource++cpskin.faceted.widgets.layout.edit.js'
view_css = '++resource++cpskin.faceted.widgets.layout.view.css'
edit_css = '++resource++cpskin.faceted.widgets.layout.edit.css'
index = ZopeTwoPageTemplateFile('layout.pt', globals())
edit_schema = AbstractWidget.edit_schema.copy() + EditSchema
edit_schema['title'].default = 'Layout'
def __init__(self, *args, **kwargs):
super(Widget, self).__init__(*args, **kwargs)
self.voc = getUtility(
IVocabularyFactory,
name='cpskin.vocabularies.faceted_layout',
)(self.context)
@property
def values(self):
return [self.voc.getTerm(v) for v in self.data.get('values', [])]
class ContentMenuProvider(BaseContentMenuProvider):
render = ZopeTwoPageTemplateFile('contentmenu.pt')
def menu(self):
items = BaseContentMenuProvider.menu(self)
removeWFMenu = False
wfmenuitems = [
k for k in items if k.has_key('extra') and k['extra'].has_key('id')
and k['extra']['id'] == 'plone-contentmenu-workflow'
]
if len(wfmenuitems) > 0:
wfmenuitem = wfmenuitems[0]
if wfmenuitem.has_key('submenu'):
submenus = wfmenuitem['submenu']
#first check for policy access.
if submenus <> None:
policyresults = [
k for k in submenus
if k.has_key('extra') and k['extra'].has_key('id')
and k['extra']['id'] == 'policy'
]
if len(policyresults) > 0:
from ubify.cyninv2theme import checkHasPermission
if not checkHasPermission('Manage portal',
self.context):
submenus.remove(policyresults[0])
return items
class FBSetPasswordForm(SetPasswordForm):
pageTemplateFileName = 'browser/templates/setpassword.pt'
template = ZopeTwoPageTemplateFile(pageTemplateFileName)
@form.action(label=u'Set', failure='handle_set_action_failure')
def handle_set(self, action, data):
assert self.context
assert self.form_fields
assert action
assert data
pu = IGSPasswordUser(self.userInfo)
pu.set_password(data['password1'])
userInfo = createObject('groupserver.LoggedInUser', self.context)
uri = '%s/fb_register_profile.html' % userInfo.url
cf = str(data.get('came_from'))
if cf == 'None':
cf = ''
gid = str(data.get('groupId'))
if gid == 'None':
gid = ''
uri = '%s?form.joinable_groups:list=%s&form.came_from=%s' %\
(uri, gid, cf)
return self.request.response.redirect(uri)
class UserInterfaceTests(BrowserView):
"""
Search through all the core javascript for tests files and send them back to the client
to be evaluated.
Any javascript file that starts with a "test" is considered a test file
"""
__call__ = ZopeTwoPageTemplateFile("templates/userinterfacetests.pt")
def getTestFiles(self):
testFiles = self.getAllCoreJSTestFiles()
for resource in getAllZenPackResources():
testFiles.extend(
self.getTestFilesFromResource(resource['name'],
resource['directory']))
return testFiles
def getTestFilesFromResource(self, resource, path):
tests = []
resourcePath = "++resource++%s%s" % (resource,
path.split("resources")[1])
for root, dirs, files in os.walk(path):
for f in files:
if f.lower().startswith('test') and f.lower().endswith('.js'):
testPath = os.path.join(root, f)
tests.append(testPath.replace(path, resourcePath))
return tests
def getAllCoreJSTestFiles(self):
resource = "zenui"
path = zenPath('Products', 'ZenUI3', 'browser', 'resources', 'js',
'zenoss')
test = self.getTestFilesFromResource(resource, path)
log.info("Got the following tests %s", test)
return test
class GSManageGroupMembersForm(GroupForm):
pageTemplateFileName = 'browser/templates/manage_members.pt'
template = ZopeTwoPageTemplateFile(pageTemplateFileName)
label = _('manage-members', 'Manage members')
def __init__(self, group, request):
super(GSManageGroupMembersForm, self).__init__(group, request)
self.groupName = self.groupInfo.name
self.showOnly = request.form.get('showOnly', '')
self.page = request.form.get('page', '1')
self.__form_fields = None
@property
def form_fields(self):
# Deliberately not a @Lazy property. See handle_change below.
if self.__form_fields is None:
if (not (self.memberManager.postingIsSpecial)
and not ('form.ptnCoachRemove' in self.request.form)
and not (self.groupInfo.ptn_coach)):
self.request.form['form.ptnCoachRemove'] = 'True'
if self.showOnly or not (self.memberManager.membersToShow):
retval = self.memberManager.form_fields.omit('ptnCoachRemove')
else:
retval = self.memberManager.form_fields
self.__form_fields = retval
return self.__form_fields
def setUpWidgets(self, ignore_request=False, data={}):
self.adapters = {}
self.widgets = form.setUpWidgets(self.form_fields,
self.prefix,
self.context,
self.request,
form=self,
data=data,
ignore_request=ignore_request)
for widget in self.widgets:
widget._displayItemForMissingValue = False
assert self.widgets
@form.action(label=_('change', 'Change'),
name='change',
failure='handle_change_action_failure')
def handle_change(self, action, data):
self.status = self.memberManager.make_changes(data)
# Reset the form_fields cache so that the
# page reloads with the updated widgets
self.__form_fields = None
def handle_change_action_failure(self, action, data, errors):
if len(errors) == 1:
self.status = '<p>There is an error:</p>'
else:
self.status = '<p>There are errors:</p>'
@Lazy
def memberManager(self):
retval = GSGroupMemberManager(self.groupInfo.groupObj, self.page,
self.showOnly)
return retval
class ManageManyMembers(GroupForm):
'''The *Manage Members* page is slow when there are many members. This
page provides a nice list of members that can be selected and then managed.'''
pageTemplateFileName = 'browser/templates/manage_many_members.pt'
template = ZopeTwoPageTemplateFile(pageTemplateFileName)
def __init__(self, context, request):
super(ManageManyMembers, self).__init__(context, request)
@Lazy
def form_fields(self):
retval = form.Fields(IGSManageManyMembers, render_context=False)
retval['members'].custom_widget = multi_check_box_widget
return retval
@form.action(label='Manage',
name='manage',
failure='handle_manage_action_failure')
def handle_manage(self, action, data):
self.status = 'Should manage {0}'.format(data['members'])
membersToManage = quote(' '.join(data['members']))
u = '{0}/managemembers.html?showOnly={1}'
uri = to_ascii(u.format(self.groupInfo.relative_url(),
membersToManage))
return self.request.RESPONSE.redirect(uri)
def handle_manage_action_failure(self, action, data, errors):
if len(errors) == 1:
self.status = '<p>There is an error:</p>'
else:
self.status = '<p>There are errors:</p>'
class GDWCheckoutAddress(CheckoutAddress):
template = ZopeTwoPageTemplateFile("templates/checkout-address.pt")
form_fields = form.Fields(interfaces.IBillingAddress,
interfaces.IShippingAddress,
interfaces.IUserContactInformation)
form_fields['ship_country'].custom_widget = CountrySelectionWidget
form_fields['bill_country'].custom_widget = CountrySelectionWidget
actions = CheckoutAddress.actions.copy()
def setupDataAdapters(self):
self.adapters = {}
user = getSecurityManager().getUser()
contact_info = component.queryAdapter(
user, interfaces.IUserContactInformation)
if contact_info is None:
contact_info = MyContactInfo()
billing_address = component.queryAdapter(user,
interfaces.IBillingAddress)
if billing_address is None:
billing_address = MyBillAddressInfo()
shipping_address = component.queryAdapter(user,
interfaces.IShippingAddress)
if shipping_address is None:
shipping_address = MyShipAddressInfo()
self.adapters[interfaces.IUserContactInformation] = contact_info
self.adapters[interfaces.IShippingAddress] = shipping_address
self.adapters[interfaces.IBillingAddress] = billing_address
return
class CCExpirationDateWidget(WithTemplateWidget, DateWidget):
template = ZopeTwoPageTemplateFile(
'templates/cc-expiration-date-widget.pt')
def months(self):
utility = getUtility(IMonthsAndYears)
return utility.months
def years(self):
utility = getUtility(IMonthsAndYears)
return utility.years
def getFormMonth(self):
return self.request.get('%s_month' % self.name)
def getFormYear(self):
return self.request.get('%s_year' % self.name)
def _getFormInput(self):
return ('%s-%s' % (self.getFormYear(), self.getFormMonth()))
def _toFieldValue(self, input):
return super(CCExpirationDateWidget, self)._toFieldValue(input)
def hasInput(self):
return self.getFormMonth() and self.getFormYear()
def __call__(self):
(_context, name, for_, permission, layer, class_, allowed_interface,
allowed_attributes) = self.args
required = {}
cdict = {}
pages = {}
for pname, attribute, template in self.pages:
try:
s = getGlobalService(Presentation)
except ComponentLookupError, err:
pass
if template:
cdict[pname] = ZopeTwoPageTemplateFile(template)
if attribute and attribute != name:
cdict[attribute] = cdict[pname]
else:
if not hasattr(class_, attribute):
raise ConfigurationError("Undefined attribute", attribute)
attribute = attribute or pname
required[pname] = permission
pages[pname] = attribute
class PayableFormView(BaseFormView):
adapters = None
interface = None
marker = None
form_fields = form.FormFields()
template = ZopeTwoPageTemplateFile('templates/payable-form.pt')
class TemplateForm(Acquisition.Explicit, zope.formlib.form.AddForm):
zope.interface.implements(zope.formlib.interfaces.IPageForm)
template = ZopeTwoPageTemplateFile('template.pt')
title = u"Template"
description = u""
def __init__(self, context, request):
super(TemplateForm, self).__init__(context, request)
# This needs to stay here, otherwise the publisher falls
# on its face. :/
self.request.debug = None
def _add_activity(self, class_, title):
# XXX This is a repeating pattern and should be refactored.
uid = Products.AlphaFlow.utils.generateUniqueId(class_.__name__)
activity = class_()
activity.title = title
activity.id = uid
self.context[uid] = activity
return self.context[uid]
@zope.formlib.form.action(zope.formlib.form._("Apply"),
condition=zope.formlib.form.haveInputWidgets)
def handle_save(self, action, data):
self.create(data)
return """<a href="call-function://loadActivityPanel">
class PersonEditView(formbase.EditFormBase):
form_fields = form.Fields(IPersonTable)
form_fields = form_fields.omit('person_id', 'address_id')
form_fields['address'].custom_widget = CustomWidgetFactory(
AddressWidget, Address)
template = ZopeTwoPageTemplateFile('person_edit.pt')
prefix = 'edit'
@form.action("Apply", condition=form.haveInputWidgets)
def handle_edit_action(self, action, data):
if applyChanges(self.context, self.form_fields, data, self.adapters):
zope.event.notify(
zope.app.event.objectevent.ObjectModifiedEvent(self.context))
formatter = self.request.locale.dates.getFormatter(
'dateTime', 'medium')
try:
time_zone = idatetime.ITZInfo(self.request)
except TypeError:
time_zone = pytz.UTC
status = _("Updated on ${date_time}",
mapping={
'date_time':
formatter.format(datetime.datetime.now(time_zone))
})
self.status = status
else:
self.status = _('No changes')
def update(self, *args, **kw):
super(PersonEditView, self).update(*args, **kw)
self.request.set('portal_status_message', self.status)
class OrderCSVComponent(core.ComponentViewlet):
template = ZopeTwoPageTemplateFile('templates/orders-export-csv.pt')
order = 3
def render(self):
return self.template()
@form.action(_(u"Export Search"))
def export_search(self, action, data):
search = self.manager.get('orders-search')
listing = self.manager.get('order-listing')
io = StringIO.StringIO()
writer = csv.writer(io)
writer.writerow([c.name for c in listing.columns])
field_getters = []
for column in listing.columns:
if column.name == 'Order Id':
field_getters.append(lambda x, y: x.order_id)
else:
field_getters.append(column.getter)
for order in search.results:
writer.writerow([getter(order, None) for getter in field_getters])
# um.. send to user, we need to inform our view, to do the appropriate thing
# since we can't directly control the response rendering from the viewlet
self._parent._download_content = ('text/csv', io.getvalue(),
'OrderSearchExport')
class MarscatControlPanel(FieldsetsInputForm):
"""A simple form to manage mars categories."""
implements(IPloneControlPanelForm, IMarscatSchema)
template = ZopeTwoPageTemplateFile('marscat_import.pt')
form_fields = form.FormFields(IMarscatSchema)
label = _(u'Import Categories')
description = _(
u"From this form, you can import more categories in the system.")
form_name = _(u'Categories Import')
def hasCatContainer(self):
container = getToolByName(self.context, CAT_CONTAINER, None)
if container is not None:
return True
return False
@form.action(_(u"create_marscats_container",
default=u'Create categories repository'),
name=u'create_cats')
def handle_create_catcontainer(self, action, data):
context = aq_inner(self.context)
context._setObject(
CAT_CONTAINER,
MarsCategoriesContainer(CAT_CONTAINER, title='Mars Categories'))
context.marscategories.update(excludeFromNav=True)
self.status = _(u'Created the categories container.')
@form.action(_(u"import_marscats", default=u'Import'), name=u'import_cats')
def handle_import_categories(self, action, data):
context = aq_inner(self.context.marscategories)
context.importCatsFromText(data['cats_import'])
self.status = _(u'Imported categories.')
def EditViewFactory(name, schema, label, permission, layer,
template, default_template, bases, for_, fields,
fulledit_path=None, fulledit_label=None, menu=u''):
class_ = makeClassForTemplate(template, globals(), used_for=schema,
bases=bases)
class_.schema = schema
class_.label = label
class_.fieldNames = fields
class_.fulledit_path = fulledit_path
if fulledit_path and (fulledit_label is None):
fulledit_label = "Full edit"
class_.fulledit_label = fulledit_label
class_.generated_form = ZopeTwoPageTemplateFile(default_template)
if layer is None:
layer = IDefaultBrowserLayer
s = zope.component.getGlobalSiteManager()
s.registerAdapter(class_, (for_, layer), Interface, name)
# Reminder: the permission we got has already been processed by
# BaseFormDirective, that means that zope.Public has been
# translated to the CheckerPublic object
protectClass(class_, permission)
initializeClass(class_)
class MembraneTypesView(FormControllerView):
"""
ZMI page for managing the membrane types.
"""
template = ZopeTwoPageTemplateFile('membrane_types.pt')
def _control(self):
"""
Specify the membrane types.
"""
new_mem_types = set(self.request.get('membrane_types', []))
old_mem_types = set(self.context.listMembraneTypes())
for portal_type in old_mem_types.difference(new_mem_types):
self.context.unregisterMembraneType(portal_type)
for portal_type in new_mem_types.difference(old_mem_types):
self.context.registerMembraneType(portal_type)
user_adder = self.request.get('user_adder', self.context.user_adder)
self.context.user_adder = user_adder
def availableAdders(self):
"""
Return the set of available IUserAdder utilities.
"""
adders = getUtilitiesFor(IUserAdder)
return [adder[0] for adder in adders]
class ITInfrastructure(BrowserView):
__call__ = ZopeTwoPageTemplateFile("templates/itinfrastructure.pt")
def getTrees(self):
router = DeviceRouter(self.context.dmd, {})
method = router.getTree
settings = self.context.dmd.UserInterfaceSettings.getInterfaceSettings(
)
if settings['incrementalTreeLoad']:
method = router.asyncGetTree
deviceTree = method('/zport/dmd/Devices')
# system
systemTree = method('/zport/dmd/Systems')
# groups
groupTree = method('/zport/dmd/Groups')
# location
locTree = method('/zport/dmd/Locations')
js = """
Zenoss.env.device_tree_data = %s;
Zenoss.env.system_tree_data = %s;
Zenoss.env.group_tree_data = %s;
Zenoss.env.location_tree_data = %s;
""" % (json.dumps(deviceTree), json.dumps(systemTree),
json.dumps(groupTree), json.dumps(locTree))
return js
class TeamListProvider(Explicit):
implements(ITeamSelectionProvider)
adapts(Interface, IDefaultBrowserLayer, IBrowserView)
is_template_setting = False
def __init__(self, context, request, view):
self.__parent__ = view
self.view = view
self.context = context
self.request = request
# From IContentProvider
def update(self):
context = self.context
if self.cat_context:
context = self.cat_context
self.actionbaseurl = context.absolute_url() + '/'
self.teams = ITeamManager(context).getTeams()
self.content_info = ITeamManager(context).getContentInfo()
self.canModify = _checkPermission('Modify portal content', context)
render = ZopeTwoPageTemplateFile('list.pt')
def teamDeletable(self, id):
context = self.context
if self.cat_context:
context = self.cat_context
self.actionbaseurl = context.absolute_url() + '/'
return ITeamManager(context).teamDeletable(id)
class ShoppingCartActions( FormViewlet ):
template = ZopeTwoPageTemplateFile('templates/cart-actions.pt')
def render( self ):
return self.template()
def doesCartContainItems( self, *args ):
return bool( len( self.__parent__.cart ) )
def isLoggedIn( self, *args ):
return getSecurityManager().getUser().getId() is not None
def isAnonymous( self, *args ):
return getSecurityManager().getUser().getId() is None
@form.action(_("Register another person"), name='continue-shopping')
def handle_continue_shopping( self, action, data ):
# Go back to the registration form
portal = getToolByName( self.context, 'portal_url').getPortalObject()
url = portal.absolute_url() + '/registrations'
return self.request.RESPONSE.redirect( url )
@form.action(_("Checkout and Pay for Registrations"), condition="doesCartContainItems", name="Checkout")
def handle_checkout( self, action, data ):
# go to order-create
# force ssl? redirect host? options
portal = getToolByName( self.context, 'portal_url').getPortalObject()
url = portal.absolute_url() + '/registrations/@@getpaid-checkout-wizard#content'
return self.request.RESPONSE.redirect( url )
class SubscriberCheck(ViewletBase):
template = ZopeTwoPageTemplateFile("subscribe.pt")
def has_any(self):
tool = getToolByName(self.context, ID)
my_path = '/'.join(self.context.getPhysicalPath())
for obj in tool.subscribers:
if my_path in obj:
return True
return False
def render(self):
tool = getToolByName(self.context, ID, None)
if not tool:
return '<div>HELPME</div>'
checkPermission = self.context.portal_membership.checkPermission
can_list_subscribers = checkPermission('Manage Portal', self.context)
sub = ''
if can_list_subscribers:
if self.has_any():
sub = '<a target="_blank" href="%s/list_subscribers">Show Subscribers</a>' % self.context.absolute_url()
else:
sub = 'No Subscribers'
if self.context.meta_type in ['PloneboardForum', 'PloneboardConversation']:
return sub + self.template()
else:
return sub
def EditViewFactory(name,
schema,
label,
permission,
layer,
template,
default_template,
bases,
for_,
fields,
fulledit_path=None,
fulledit_label=None,
menu=u''):
s = getGlobalService(Presentation)
class_ = makeClassForTemplate(template,
globals(),
used_for=schema,
bases=bases)
class_.schema = schema
class_.label = label
class_.fieldNames = fields
class_.fulledit_path = fulledit_path
if fulledit_path and (fulledit_label is None):
fulledit_label = "Full edit"
class_.fulledit_label = fulledit_label
class_.generated_form = ZopeTwoPageTemplateFile(default_template)
s.provideView(for_, name, IBrowserRequest, class_, layer)
protectClass(class_, permission)
initializeClass(class_)
class Forbidden(BaseError, grok.View):
grok.name('error.html')
grok.context(IForbidden)
index = ZopeTwoPageTemplateFile('browser/templates/forbidden.pt')
status = 403
def supportMessage(self):
m = '''Hi! I saw a Forbidden (403) page when I went to
%(url)s
I expected to see...
-----
Technical details:
Code: 403
URL: %(url)s
Referer: %(referer)s
''' % {
'url': self.errorUrl,
'referer': self.refererUrl
}
retval = quote(m)
return retval
class Widget(AbstractWidget):
""" Widget
"""
# Widget properties
widget_type = 'portlet'
widget_label = _('Plone portlet')
groups = (DefaultSchemata, LayoutSchemata)
index = ZopeTwoPageTemplateFile('widget.pt', globals())
@property
def macro(self):
""" Get macro
"""
macro = self.data.get('macro', '')
if not macro:
raise ValueError('Empty macro %s' % macro)
macro_list = macro.replace('here/', '', 1)
macro_list = macro_list.split('/macros/')
if len(macro_list) != 2:
raise ValueError('Invalid macro: %s' % macro)
path, mode = macro_list
path = path.split('/')
try:
template = self.context.restrictedTraverse(path)
template = getattr(template, 'index', template)
if template:
return template.macros[mode]
except Exception:
# This means we didn't have access or it doesn't exist
raise
raise ValueError("Invalid macro: %s" % macro)
class DeviceDetails(BrowserView):
__call__ = ZopeTwoPageTemplateFile('templates/devdetail.pt')
def getComponentTree(self):
router = DeviceRouter(self.context.dmd, {});
uid = self.context.getPrimaryId()
tree = router.getComponentTree(uid)
js = """
Zenoss.env.componentTree = %s;
""" % json.dumps(tree)
return js
def fetchLeftHandMenu(self):
router = DetailNavRouter(self.context.dmd, {})
menuIds = ['More','Add','TopLevel','Manage']
uid = self.context.getPrimaryId()
response = router.getDetailNavConfigs(uid=uid, menuIds=menuIds)
js = """
Zenoss.env.lefthandnav = %s;
""" % json.dumps(response.data)
return js
def getInfoObject(self):
info = IInfo(self.context)
# links is very expensive so do not marshal that
keys = [key for key in dir(info)
if not key.startswith('_') and not callable(getattr(info, key)) and key not in ('links', 'uptime', 'events', 'deviceClass') ]
response = dict(data=Zuul.marshal(info, keys))
js = """
Zenoss.env.infoObject = %s;
""" % (json.dumps(response))
return js
