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."))

    def kss_editAction(self):
        """Update action's properties"""
        id, cat_name, data = self.parseEditForm(self.request.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']))

        html_id = '%s%s%s' % (self.prefix, id, self.sufix)
        ksscore = self.getCommandSet('core')
        kssplone = self.getCommandSet('plone')
        if not errors:
            action = self.updateAction(id, cat_name, data)

            # update client
            # replace action item with updated one
            content = self.getActionsList(category=cat_name, tabs=[action,])
            ksscore.replaceHTML(ksscore.getHtmlIdSelector(html_id), content)

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

            # update page
            self.updatePage(cat_name)
        else:
            # issue error messages
            self.kss_issueErrors(errors, editform=id)

            # expand advanced section if there are errors in id,
            # action url or condition
            if errors.has_key('id') or errors.has_key('available_expr') or \
                errors.has_key('url_expr'):
                self.kss_toggleCollapsible(
                    ksscore.getCssSelector('#%s .headerAdvanced' % html_id),
                    collapse='false')

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

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

    def kss_toggleActionsVisibility(self, id, checked="0", cat_name=None):
        """Toggle visibility for portal actions"""
        # validate input
        act_id, category, action = self.kss_validateAction(id, cat_name)
        self.updateAction(act_id, cat_name, {"id": act_id, "visible": (checked == "1") or False})

        # update client
        ksscore = self.getCommandSet("core")
        if checked == "1":
            ksscore.removeClass(ksscore.getHtmlIdSelector(id), value="invisible")
            message = _(u"'${id}' action is now visible.", mapping={"id": act_id})
        else:
            ksscore.addClass(ksscore.getHtmlIdSelector(id), value="invisible")
            message = _(u"'${id}' action is now invisible.", mapping={"id": act_id})
        self.updatePage(cat_name)

        # issue portal status message
        self.kss_issueMessage(message)

    def manage_moveUpAction(self, form, errs):
        """Manage Method for moving up given action by one position"""
        # extract posted data
        id, cat_name, data = self.parseEditForm(form)

        # get category and action to move
        category = self.getActionCategory(cat_name)
        if id in category.objectIds():
            self.moveAction(id, cat_name, steps=1)
            IStatusMessage(self.request).addStatusMessage(
                _(u"'${id}' action moved up.", mapping={'id': id}), type="info")
            self.redirect(search="category=%s" % cat_name)
            return False
        else:
            IStatusMessage(self.request).addStatusMessage(
                _(u"No '${id}' action in '${cat_name}' category.",
                  mapping={'id': id, 'cat_name': cat_name}), type="error")
            return True

    def kss_validateAction(self, id, cat_name):
        """Check whether action with given id exists in cat_name category"""
        try:
            category = self.getActionCategory(cat_name)
        except Exception:
            raise KSSExplicitError, \
                  _(u"'${cat_name}' action category does not exist.",
                    mapping={'cat_name': cat_name})

        # extract action id from given list item id on client
        action_id = self.sufix and id[len(self.prefix):-len(self.sufix)] or \
                    id[len(self.prefix):]
        try:
            action = category[action_id]
        except Exception:
            raise KSSExplicitError, \
                  _(u"No '${id}' action in '${cat_name}' category.",
                    mapping={'id': action_id, 'cat_name': cat_name})

        return (action_id, category, action)

    def kss_hideEditForm(self, id, cat_name):
        """Hide edit form for given action"""
        act_id, category, action = self.kss_validateAction(id, cat_name)

        # update client
        ksscore = self.getCommandSet("core")
        content = self.getActionsList(category=cat_name, tabs=[action])
        ksscore.replaceHTML(ksscore.getHtmlIdSelector(id), content)

        # issue portal status message
        self.kss_issueMessage(_(u"Changes discarded."))