Python plonetabs._函数代码示例

    def manage_validateAction(self, action_id, cat_name):
        """Check whether action with given id exists in cat_name category"""
        errors = []
        act_id = ""
        category = ""
        action = ""

        act_id = action_id

        try:
            category = self.getActionCategory(cat_name)
        except Exception:
            errors.append(
                self.translate(
                    _(u"'${cat_name}' action category does not exist.",
                      mapping={'cat_name': cat_name})))

        try:
            action = category[act_id]
        except Exception:
            errors.append(
                self.translate(
                    _(u"No '${id}' action in '${cat_name}' category.",
                      mapping={'id': act_id, 'cat_name': cat_name})))
        return (act_id, category, action, errors)

    def manage_ajax_saveAction(self, form):
        """Manage Method to update action"""
        # extract posted data
        id, cat_name, data = self.parseEditForm(form)

        # get category and action to edit
        category = self.getActionCategory(cat_name)
        action = category[id]

        # validate posted data
        errors = self.validateActionFields(
            cat_name, data, allow_dup=(id == data['id']))

        if not errors:
            action = self.updateAction(id, cat_name, data)
            content = self.getActionsList(category=cat_name, tabs=[action, ])
            resp_dict = {
                'content': content,
                'status_code': 200,
                'status_message': self.translate(
                    _(u"'${id}' action successfully updated.",
                      mapping={'id': action.id}))
            }
        else:
            resp_dict = {
                'content': errors,
                'status_code': 500,
                'status_message': self.translate(
                    _("Please correct the indicated errors."))
            }
        return resp_dict

    def manage_ajax_toggleActionsVisibility(self, form):
        # Toggle visibility for portal actions
        resp_dict = {}

        # TODO: parse, validate form
        id = form['orig_id']
        cat_name = form['category']
        checked = form['visibility']

        act_id, category, action, errors = self.manage_validateAction(
            id, cat_name)

        if not errors:
            self.updateAction(act_id, cat_name, {
                'id': act_id,
                'visible': (checked == 'true') or False
            })
            if checked == 'true':
                message = self.translate(
                    _(u"'${id}' action is now visible.",
                      mapping={'id': act_id}))
            else:
                message = self.translate(
                    _(u"'${id}' action is now invisible.",
                      mapping={'id': act_id}))
            resp_dict['status_message'] = message
            resp_dict['status_code'] = 200
        else:
            resp_dict['status_message'] = errors
            resp_dict['status_code'] = 500
        return resp_dict

    def getPageTitle(self, category="portal_tabs"):
        """See interface"""
        portal_props = self.portal_properties
        default_title = _(u"Plone '${cat_name}' Configuration",
                          mapping={'cat_name': category})

        if not hasattr(portal_props, PROPERTY_SHEET):
            return default_title

        sheet = getattr(portal_props, PROPERTY_SHEET)
        if not hasattr(sheet, FIELD_NAME):
            return default_title

        field = sheet.getProperty(FIELD_NAME)
        dict = {}
        for line in field:
            cat, title = line.split("|", 2)
            dict[cat] = title

        title = dict.get(category, None)
        if title is None:
            return default_title

        charset = self._charset()
        if not isinstance(title, unicode):
            title = title.decode(charset)

        return _(title)

    def manage_editAction(self, form, errs):
        """Manage Method to update action"""
        # extract posted data
        id, cat_name, data = self.parseEditForm(form)

        # get category and action to edit
        category = self.getActionCategory(cat_name)
        action = category[id]

        # validate posted data
        errors = self.validateActionFields(
            cat_name, data, allow_dup=(id == data['id']))

        if not errors:
            action = self.updateAction(id, cat_name, data)
            IStatusMessage(self.request).addStatusMessage(
                _(u"'${id}' action saved.", mapping={'id': action.id}),
                type="info")
            self.redirect(search="category=%s" % cat_name)
            return False
        else:
            errs.update(self.processErrors(
                errors, sufix='_%s' % id))  # add edit form sufix to error ids
            IStatusMessage(self.request).addStatusMessage(_(
                u"Please correct the indicated errors."), type="error")
            return True

    def manage_ajax_addAction(self, form):
        # extract posted data
        resp_dict = {}
        cat_name = form['category']
        id, ie7bad_category, data = self.parseAddForm(form)

        # validate posted data
        errors = self.validateActionFields(cat_name, data)

        if not errors:
            action = self.addAction(cat_name, data)
            # add one more action to actions list
            content = self.getActionsList(
                category=cat_name, tabs=[
                    action,
                ])
            resp_dict['content'] = content
            resp_dict['status_code'] = 200
            resp_dict['status_message'] = self.translate(
                _(u"'${id}' action successfully added.",
                  mapping={'id': action.id}))
        else:
            resp_dict['status_message'] = self.translate(
                _("Please correct the indicated errors."))
            resp_dict['status_code'] = 500
            resp_dict['content'] = errors
        return resp_dict

    def kss_toggleRootsVisibility(self, id, checked="0"):
        """Toggle visibility for portal root objects (exclude_from_nav)"""
        portal = self.plone_portal_state.portal()

        # remove prefix, added for making ids on configlet unique ("roottabs_")
        obj_id = id[len("roottabs_") :]

        if obj_id not in portal.objectIds():
            raise KSSExplicitError("Object with %s id doesn't" " exist in portal root." % obj_id)

        if checked == "1":
            checked = True
        else:
            checked = False

        portal[obj_id].update(excludeFromNav=not checked)

        # update client
        ksscore = self.getCommandSet("core")
        if checked:
            ksscore.removeClass(ksscore.getHtmlIdSelector(id), value="invisible")
            message = _(u"'${id}' object was included into navigation.", mapping={"id": obj_id})
        else:
            ksscore.addClass(ksscore.getHtmlIdSelector(id), value="invisible")
            message = _(u"'${id}' object was excluded from navigation.", mapping={"id": obj_id})

        # update global-sections viewlet
        self.updatePortalTabsPageSection()

        # issue portal status message
        self.kss_issueMessage(message)

    def manage_ajax_moveAction(self, form):
        cat_name = form['category']
        category = self.getActionCategory(cat_name)
        components = urllib.unquote(form['actions']).split('&')
        if self.sufix == '':
            ids = [component[len(self.prefix):] for component in components]
        else:
            ids = [component[len(self.prefix):-len(self.sufix)]
                   for component in components]
        # do actual sorting
        resp = category.moveObjectsByDelta(ids, -len(category.objectIds()))

        if resp:
            resp_dict = {
                'status_code': 200,
                'status_message': self.translate(
                    _("Actions successfully sorted."))
            }
        else:
            resp_dict = {
                'status_code': 500,
                'status_message': self.translate(
                    _("There was error while sorting, or list not changed"))
            }
        return resp_dict

    def kss_toggleGeneratedTabs(self, field, checked="0"):
        """Toggle autogenaration setting on configlet"""
        if checked == "1":
            self.setSiteProperties(**{field: False})
            if field == "disable_nonfolderish_sections":
                message = _(u"Generated not folderish tabs switched on.")
            else:
                message = _(u"Generated tabs switched on.")
        else:
            self.setSiteProperties(**{field: True})
            if field == "disable_nonfolderish_sections":
                message = _(u"Generated not folderish tabs switched off.")
            else:
                message = _(u"Generated tabs switched off.")

        # update client
        ksscore = self.getCommandSet("core")
        content = self.getGeneratedTabs()
        ksscore.replaceInnerHTML(ksscore.getHtmlIdSelector("roottabs"), content)

        # update global-sections viewlet
        self.updatePortalTabsPageSection()

        # issue portal status message
        self.kss_issueMessage(message)

 def test_getPageTitle(self):
     self.assertEquals(self.panel.getPageTitle(),
                       _(u"Portal Tabs Configuration"),
                       'getPageTitle method is broken')
     self.assertEquals(self.panel.getPageTitle(category='notexists'),
                       _(u"Plone '${cat_name}' Configuration",
                         mapping={'cat_name': 'notexists'}),
                       'getPageTitle method is broken')

    def kss_addAction(self, cat_name):
        """KSS method to add new portal action"""
        # extract posted data
        id, ie7bad_category, data = self.parseAddForm(self.request.form)

        # validate posted data
        errors = self.validateActionFields(cat_name, data)

        # if not errors find (or create) category and set action to it
        ksscore = self.getCommandSet("core")
        if not errors:
            action = self.addAction(cat_name, data)

            # update client
            # add one more action to actions list
            content = self.getActionsList(category=cat_name, tabs=[action])
            ksscore.insertHTMLAsLastChild(ksscore.getHtmlIdSelector("tabslist"), content)

            # update reorder controls
            # self.kss_checkReorderControls(cat_name)

            # hide adding form
            ksscore.removeClass(ksscore.getHtmlIdSelector("addaction"), "adding")
            self.kss_toggleCollapsible(
                ksscore.getCssSelector("form[name=addaction_form] " ".headerAdvanced"), collapse="true"
            )

            # set client state var 'plonetabs-addingTitle' to empty
            # string for correct id autogeneration functionality
            ksscore.setStateVar("plonetabs-addingTitle", "")

            # reset adding form
            self.kss_resetForm(ksscore.getHtmlIdSelector("addaction"))

            # remove focus from name input
            self.kss_blur(ksscore.getHtmlIdSelector("actname"))

            message = _(u"'${id}' action successfully added.", mapping={"id": action.id})
            msgtype = "info"

            # update page
            self.updatePage(cat_name)
        else:
            # expand advanced section if there are errors in id or condition
            if "id" in errors or "available_expr" in errors:
                self.kss_toggleCollapsible(
                    ksscore.getCssSelector("form[name=addaction_form] " ".headerAdvanced"), collapse="false"
                )

            message = _(u"Please correct the indicated errors.")
            msgtype = "error"

        # update errors on client form
        self.kss_issueErrors(errors)

        # issue portal status message
        self.kss_issueMessage(message, msgtype)

    def kss_changeCategory(self, cat_name):
        """Change action category to manage"""
        ksscore = self.getCommandSet("core")

        # update actions list
        actionslist = self.getActionsList(category=cat_name)
        ksscore.replaceInnerHTML(ksscore.getHtmlIdSelector("tabslist"), actionslist)

        # update autogenerated sections
        section = self.getAutoGenereatedSection(cat_name)
        ksscore.replaceHTML(ksscore.getHtmlIdSelector("autogeneration_section"), section)
        # and title
        ts = getToolByName(self.context, "translation_service")
        title = ts.translate(self.getPageTitle(cat_name), context=self.context)
        ksscore.replaceInnerHTML(ksscore.getHtmlIdSelector("plonetabs-form-title"), title)

        # update category hidden field on adding form
        ksscore.setAttribute(
            ksscore.getCssSelector("form[name=addaction_form] input[name=category]"), "value", cat_name
        )

        # update state variable 'plonetabs-category' on client
        ksscore.setStateVar("plonetabs-category", cat_name)

        # hide adding form
        self.kss_hideAddForm()

        # issue portal status message
        self.kss_issueMessage(_(u"Category changed successfully."))

    def manage_setAutogeneration(self, form, errors):
        """Process managing autogeneration settings"""

        # set excludeFromNav property for root objects
        portal = self.plone_portal_state.portal()
        generated_tabs = form.get("generated_tabs", '0')
        nonfolderish_tabs = form.get("nonfolderish_tabs", '0')

        for item in self.getRootTabs():
            obj = getattr(portal, item['id'], None)
            if obj is not None:
                checked = form.get(item['id'], None)
                if checked == '1':
                    obj.update(excludeFromNav=False)
                else:
                    obj.update(excludeFromNav=True)

        # set disable_folder_sections property
        if int(generated_tabs) == 1:
            self.setSiteProperties(disable_folder_sections=False)
        else:
            self.setSiteProperties(disable_folder_sections=True)

        # set disable_nonfolderish_sections property
        if int(nonfolderish_tabs) == 1:
            self.setSiteProperties(disable_nonfolderish_sections=False)
        else:
            self.setSiteProperties(disable_nonfolderish_sections=True)

        # after successfull form processing make redirect with good message
        IStatusMessage(self.request).addStatusMessage(_(u"Changes saved!"),
                                                      type="info")
        self.redirect()
        return False

    def manage_ajax_toggleGeneratedTabs(self, form):
        """Toggle autogenaration setting on configlet"""
        resp_dict = {}
        errors = []

        # TODO: parse, validate form
        checked = form['generated_tabs']
        field = form['field']

        if field in GENERATED_TABS_FIELDS:
            if checked == 'true':
                self.setSiteProperties(**{field: False})
                message = self.translate(GENERATED_TABS_FIELDS[field][0])
            else:
                self.setSiteProperties(**{field: True})
                message = self.translate(GENERATED_TABS_FIELDS[field][1])
            content = self.getGeneratedTabs()
            resp_dict['content'] = content
            resp_dict['status_code'] = 200
            resp_dict['status_message'] = message
        else:
            resp_dict['status_message'] = self.translate(
                _("Invalid property name."))
            resp_dict['status_code'] = 500
        return resp_dict

    def kss_hideAddForm(self):
        """"Hide Add form, reset it and remove error messages"""
        # no server changes, only update client
        ksscore = self.getCommandSet("core")

        # hide form itself
        ksscore.removeClass(ksscore.getHtmlIdSelector('addaction'), 'adding')

        # collapse advanced section
        self.kss_toggleCollapsible(
            ksscore.getCssSelector('form[name=addaction_form] .headerAdvanced'),
            collapse='true')

        # reset form inputs
        self.kss_resetForm(ksscore.getHtmlIdSelector('addaction'))

        # set client state var 'plonetabs-addingTitle' to empty string for
        # correct id autogeneration functionality
        ksscore.setStateVar('plonetabs-addingTitle', '')

        # remove form errors if such exist
        self.kss_issueErrors({})

        # issue portal status message
        self.kss_issueMessage(_(u"Adding canceled."))