def test_override_template(self):
        """
        """
        self.create_doc()
        doc = self.portal.doc
        overrider = IOverrider(doc)

        doc.setTitle("Foobar")

        template = u"Title {{ context.Title() }}"
        storage = IOverrideStorage(doc)
        storage.enabled_overrides = ["getUnfilteredTemplate"]
        storage.getUnfilteredTemplate = template

        self.assertEqual(overrider.getUnfilteredTemplate(), template)
Exemple #2
0
    def test_render_mobile_override(self):
        """ Render a document with mobile overrides enabled.

        """

        self.setDiscriminateMode("mobile")

        self.create_doc()
        doc = self.portal.doc
        doc.setTitle("Not reached") # This title should not be visible in mobile mode
        overrider = IOverrider(doc)
        storage = IOverrideStorage(doc)
        storage.enabled_overrides = ["Title"]
        storage.Title = u"Foobar"

        self.portal.portal_workflow.doActionFor(doc, "submit")
        self.portal.portal_workflow.doActionFor(doc, "publish")


        browser = self.browser
        browser.open(self.portal.doc.absolute_url())
        html = browser.contents

        self.assertTrue(MOBILE_HTML_MARKER in html, "Got page:" + html)
        assert "Foobar" in html
    def test_override_not_enabled(self):
        """ Do not enable override, but have the field filled in
        """

        self.setDiscriminateMode("web")

        self.create_doc()
        doc = self.portal.doc
        overrider = IOverrider(doc)

        doc.setTitle("Foobar")

        template = u"Title {{context.Title()}}"
        storage = IOverrideStorage(doc)
        storage.getUnfilteredTemplate = template

        self.assertNotEqual(overrider.getUnfilteredTemplate(), template)
    def test_has_overrides(self):
        """ Document object overrides are enabled by default
        """
        self.create_doc()
        doc = self.portal.doc
        overrider = IOverrider(doc)
        assert overrider != None

        assert overrider.schema != None
        self.assertEqual(overrider._getOverrideFieldNames(), ["Title", "Description", "getText"])

        # Set one override enabled and check it is read properly
        storage = IOverrideStorage(doc)

        storage.enabled_overrides = ["Title"]
        self.assertEqual(overrider._isOverrideEnabled("Title", storage), True)
        self.assertEqual(overrider._isOverrideEnabled("Description", storage), False)

        # Set overriden title
        storage.Title = u"Foobar"

        # Call title accessor by emulator IOverrider steps
        # and see each microstep completes
        self.assertTrue(overrider._isOverride("Title"))
        storage = IOverrideStorage(self.portal.doc)
        self.assertTrue(overrider._isOverrideEnabled("Title", storage))
        self.assertEqual(overrider._getOverrideOrOrignal("Title")(), u"Foobar")

        assert overrider.Title() == u"Foobar"
Exemple #5
0
    def test_helper_view_web(self):
        """
        See that we get proper proxy object through helper view.
        """
        self.setDiscriminateMode(MobileRequestType.WEB)
        self.create_doc()
        doc = self.portal.doc
        doc.setTitle("Not reached")
        overrider = IOverrider(doc)
        storage = IOverrideStorage(doc)
        storage.enabled_overrides = ["Title"]
        storage.Title = u"Foobar"

        helper = doc.restrictedTraverse("multichannel_overrider")
        context = helper() # Return mobile proxy object with overriden values

        # In web mode, you dont get override
        self.assertEqual(context.Title(), "Not reached")
    def __init__(self, context, request):
        grok.View.__init__(self, context, request)

        self.overrider = IOverrider(self.context)
class EasyTemplateMobile(grok.View):
    """ Enable viewing of templated pages with mobile overrides
    """

    grok.require("zope2.View") # TODO: How to make grok accept permissions as pseudo-constants
    grok.context(ITemplatedDocument)

    def __init__(self, context, request):
        grok.View.__init__(self, context, request)

        self.overrider = IOverrider(self.context)

    def title(self):
        """
        """
        return self.overrider.Title()

    def description(self):
        """
        """
        return self.overrider.Description()

    def cooked_text(self):
        """
        @return: Resulting HTML of evaluated template
        """
        return self._cookTemplate()

    def outputTemplateErrors(self, messages):
        """ Write template errors to the user and the log output. """
        outputTemplateErrors(messages, request=self.request, logger=logger, context=self.context)

    def getTemplateSource(self):
        """ Try look up what text box we use for mobile rendering

        1. Mobile "raw template" input

        2. Mobile WYSIWYG

        3. Generic raw template

        4. Generic WYWIWYG

        """

        storage = IOverrideStorage(self.context)

        # TODO: Bad API, will be changed
        if self.overrider._isOverrideEnabled("getUnfilteredTemplate", storage):
            # Raw HTML code for mobile
            text = self.overrider.getUnfilteredTemplate()
        elif self.overrider._isOverrideEnabled("getText", storage):
            # WYSIWYG HTML code for mobile
            text = self.overrider.getText()
        else:
            # Choose between normal kupu editor input
            # and unfiltered input
            unfiltered = self.context.getRawUnfilteredTemplate()

            if unfiltered != None and unfiltered.strip() != "":
                # We are using raw HTML input
                text = unfiltered.decode("utf-8")
            else:
                text = self.context.getText().decode("utf-8")

        return text

    def compile(self, text):
        """ Compile the template. """
        engine = getEngine()

        if text == None:
            text = ""

        # TODO: Compile template only if the context has been changed
        t, messages = engine.loadString(text, False)
        return t, messages


    def _cookTemplate(self):
        """ Cook the view mode output. """

        context = getTemplateContext(self.context)

        text = self.getTemplateSource()
        t, messages = self.compile(text)

        self.outputTemplateErrors(messages)
        if not t:
            return ERROR_MESSAGE

        output, messages = t.evaluate(context)
        self.outputTemplateErrors(messages)
        if not output:
            return ERROR_MESSAGE

        return unicode(output).encode("utf-8")