Not working on Django 1.11

[mbi]

When a snippet is rendered in Django-CMS 3.4.5 and Django 1.11, the following exception is raised:

TypeError: context must be a dict rather than Context.

This is due to cms_plugins.py#L34 using Context instead of a plain dict when rendering.

[djpremier]

Hello, I do not know if it is the correct form, but for me it worked:

cms_plugins.py

import sys

from django import template
from django.template.context import Context
from django.utils.safestring import mark_safe
from django.utils.translation import ugettext_lazy as _

from cms.plugin_base import CMSPluginBase
from cms.plugin_pool import plugin_pool

from .models import SnippetPtr

class SnippetPlugin(CMSPluginBase):
model = SnippetPtr
name = _('Snippet')
render_template = 'djangocms_snippet/snippet.html'
text_enabled = True
text_editor_preview = False

def render(self, context, instance, placeholder):
    context.update({
        'placeholder': placeholder,
        'object': instance,
    })
    try:
        t = template.Template(instance.snippet.html)
        if instance.snippet.template:
            context.update({
                'html': mark_safe(instance.snippet.html)
            })
        content = t.render(Context(context))
    except template.TemplateDoesNotExist:
        content = _('Template %(template)s does not exist.') % {
            'template': instance.snippet.template}
    except Exception:
        exc = sys.exc_info()[0]
        content = str(exc)
    context.update({
        'content': mark_safe(content),
    })
    return context

plugin_pool.register_plugin(SnippetPlugin)

snippet_tags.py

"""
Snippet template tags
"""
from contextlib import contextmanager

from django import template
from django.utils import six
from django.utils.html import escape
from django.utils.safestring import mark_safe
from django.utils.translation import ugettext_lazy as _

from djangocms_snippet.models import Snippet

register = template.Library()

@contextmanager
def exceptionless(truth):
# Accepts one truth parameter, when 'False' normal behavior
# when 'True' any expection will be suppressed
try:
yield
except Exception:
if truth:
# WARNING: suppressing exception
pass
else:
# Reraising exception
raise

class SnippetFragment(template.Node):
"""
Get a snippet HTML fragment
"""

def __init__(self, snippet_id_varname, *args):
    """
    :type insert_instance_varname: string or object
                                   ``django.db.models.Model``
    :param insert_instance_varname: Instance variable name or a string slug
                                    or object id
    """
    self.parse_until = False
    self.snippet_id_varname = template.Variable(snippet_id_varname)
    if args and 'or' in args:
        # We are in a 'parse util' case
        # ALERT: Exceptions will be suppressed to avoid errors from bad
        # tag content
        # Maybe we could analyze more usage case to catch only exceptions
        # related to bad tag content
        self.parse_until = True
        self.nodelist = args[1]

def render(self, context):
    """
    :type context: object ``django.template.Context``
    :param context: Context tag object

    :rtype: string
    :return: the HTML for the snippet
    """
    # Default assume this is directly an instance
    snippet_instance = self.snippet_id_varname.resolve(context)
    # Assume this is slug
    with exceptionless(self.parse_until):
        if isinstance(snippet_instance, six.string_types):
            snippet_instance = Snippet.objects.get(slug=snippet_instance)
        # Assume this is an id
        elif isinstance(snippet_instance, int):
            snippet_instance = Snippet.objects.get(pk=snippet_instance)

        return mark_safe(self.get_content_render(context,
                                                 snippet_instance))

    # Rely on the fact that manager something went wrong
    # render the fallback template
    return self.nodelist.render(context)

def get_content_render(self, context, instance):
    """
    Render the snippet HTML, using a template if defined in its instance
    """
    context.update({
        'object': instance,
    })
    try:
        t = template.Template(instance.html)
        if instance.template:
            context.update({
                'html': mark_safe(instance.html)
            })
        content = t.render(template.Context(context))
    except template.TemplateDoesNotExist:
        content = _('Template %(template)s does not exist.') % {
            'template': instance.template}
    except Exception as e:
        content = escape(str(e))
        if self.parse_until:
            # In case we are running 'exceptionless'
            # Re-raise exception in order not to get the
            # error rendered
            raise
    return content

@register.tag(name='snippet_fragment')
def do_snippet_fragment(parser, token):
"""
Display a snippet HTML fragment

Usage : ::
    {% snippet_fragment [Snippet ID or instance] %}

    {% snippet_fragment [Snippet ID or instance] or %}
        ...This is a fallback...
    {% endsnippet_fragment %}
"""
args = token.split_contents()
if len(args) < 2:
    raise template.TemplateSyntaxError(
        'You need to specify at least a "snippet" ID, slug or instance')
if 'or' in args:
    # Catch contents between tags and pass to renderer
    args.append(parser.parse(('endsnippet_fragment',)))
    parser.delete_first_token()
return SnippetFragment(*args[1:])

do_snippet_fragment.is_safe = True

And in my template the 'html' tag did not work, for that I had to use 'snippet_fragment'

[adrien-delhorme]

I confirm that the plugin does not work with Django 1.11.
I made a pull request #51 from a commit of @mbi.

[sparrowme]

Workaround found?

Update: @adrien-delhorme pull request appears to accomplish the same goal.

The issue is related to the fact that in 1.10+, it appears that render requires a dict and not a Context object which now throws an error. I chased this as far as finding the following:

The django Context Base class has a flatten function to turn the Context object's dicts into a single flat dict. So I cheated a little... and flattened the object before the render and removed the Context() calls from the try.. Perhaps the context should be flattened before it is passed to render?? Maybe someone can take it from here and point out the right way to do it.

in cms_plugins.py

....
class SnippetPlugin(CMSPluginBase):
    model = SnippetPtr
    name = _('Snippet')
    render_template = 'djangocms_snippet/snippet.html'
    text_enabled = True
    text_editor_preview = False

    def render(self, context, instance, placeholder):
        context=context.flatten() #!!!!! Add the flatten function here!!!!
        context.update({
            'placeholder': placeholder,
            'object': instance,
        })
        try:
            if instance.snippet.template:
                t = template.loader.get_template(instance.snippet.template)
                context.update({
                    'html': mark_safe(instance.snippet.html)
                })
                #content = t.render(Context(context))
                content = t.render(context)
            else:
                t = template.Template(instance.snippet.html)
                #content = t.render(Context(context))
                content = t.render(context)
....

[mariuskueng]

This problem still occurs with Django 2.1 and DjangoCMS 3.6. I could solve it with the workaround @worraps mentions.

I suggest to open this issue again.

[FinalAngel]

@mariuskueng @worraps @adrien-delhorme

would: #62

fix the issue for you?

[mariuskueng]

@FinalAngel yes, it works. Thank you!

[FinalAngel]

awesome :)