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