예제 #1
0
class Addtoblock(SekizaiTag):
    name = 'addtoblock'

    options = Options(
        Argument('name'),
        Flag('strip', default=False, true_values=['strip']),
        parser_class=AddtoblockParser,
    )

    def render_tag(self, context, name, strip, nodelist):
        rendered_contents = nodelist.render(context)
        if strip:
            rendered_contents = rendered_contents.strip()
        varname = get_varname()
        context[varname][name].append(rendered_contents)
        return ""
예제 #2
0
파일: cms_tags.py 프로젝트: wdong0472/vtest
class RenderPlugin(Tag):
    template = 'cms/content.html'
    name = 'render_plugin'
    options = Options(Argument('plugin'))

    def render_tag(self, context, plugin):
        if not plugin:
            return ''

        content_renderer = context['cms_content_renderer']
        content = content_renderer.render_plugin(
            instance=plugin,
            context=context,
            editable=content_renderer.user_is_on_edit_mode(),
        )
        return content
예제 #3
0
class ShowFeedback(Tag):
    name = 'show_feedback'

    options = Options(Argument('form_key', required=False, resolve=False))

    def render_tag(self, context, form_key):
        form_key = form_key if form_key else DEFAULT_FORM_KEY
        form = get_feedback_form(form_key)()
        if PREFIX_KEY_FIELDS:
            form.prefix = form_key

        return render_to_string([
            'feedback/%s/feedback.html' % form_key,
            'feedback/feedback.html',
        ], {'form': form},
                                context_instance=RequestContext(
                                    context['request']))
예제 #4
0
class ShowSlider(Tag):
    name = 'show_slider'
    options = Options(Argument('key', required=False, resolve=False))

    def render_tag(self, context, key=None):
        try:
            if key:
                slides = Slider.objects.get(key=key).slides.filter(show=True)
            else:
                obj = context.get('current_page')
                obj_ct = ContentType.objects.get_for_model(obj)
                slides = Slide.objects.filter(content_type=obj_ct, object_id=obj.id, show=True)
                key = 'frontpage'
            template = 'sliders/%s/slider.html' % key
            return render_to_string(template, {'slides': slides}, context['request'])
        except ObjectDoesNotExist:
            return ''
예제 #5
0
class Subscribe(InclusionTag):
    name = 'mailchimp_subscribe_form'
    template = 'cmsplugin_mailchimp/subscribe.html'
    options = Options(
        Argument('list_id'),
        StringArgument('template',
                       default='cmsplugin_mailchimp/subscribe.html',
                       required=False),
    )

    def get_context(self, context, list_id, template):
        subscribeForm = SubscribeForm(initial={'list_id': list_id})
        return context.update({
            'csrf_token': context['csrf_token'],
            'form': subscribeForm,
            'template': template,
        })
예제 #6
0
class CMSToolbar(RenderBlock):
    name = 'cms_toolbar'

    options = Options(
        Argument('name', required=False),  # just here so sekizai thinks this is a RenderBlock
        parser_class=SekizaiParser,
    )

    def render_tag(self, context, name, nodelist):
        # render JS
        request = context.get('request', None)
        toolbar = getattr(request, 'toolbar', None)
        if toolbar:
            toolbar.init_toolbar(request)
            toolbar.populate()
        if request and 'cms-toolbar-login-error' in request.GET:
            context['cms_toolbar_login_error'] = request.GET['cms-toolbar-login-error'] == '1'
        context['cms_version'] =  __version__
        context['django_version'] = DJANGO_VERSION
        context['python_version'] = PYTHON_VERSION
        context['cms_edit_on'] = get_cms_setting('CMS_TOOLBAR_URL__EDIT_ON')
        context['cms_edit_off'] = get_cms_setting('CMS_TOOLBAR_URL__EDIT_OFF')
        if toolbar and toolbar.show_toolbar:
            language = toolbar.toolbar_language
            with force_language(language):
                # needed to populate the context with sekizai content
                render_to_string('cms/toolbar/toolbar_javascript.html', flatten_context(context))
                context['addons'] = mark_safe(toolbar.render_addons(context))
        else:
            language = None
        # render everything below the tag
        rendered_contents = nodelist.render(context)
        # sanity checks
        if not request:
            return rendered_contents
        if not toolbar:
            return rendered_contents
        if not toolbar.show_toolbar:
            return rendered_contents
        # render the toolbar content
        request.toolbar.post_template_populate()
        with force_language(language):
            addons = mark_safe(toolbar.post_template_render_addons(context))
            toolbar = render_to_string('cms/toolbar/toolbar.html', flatten_context(context))
        # return the toolbar content and the content below
        return '%s\n%s\n%s' % (toolbar, addons, rendered_contents)
예제 #7
0
class PaginationCtl(InclusionTag):
    name = 'pagination_ctl'
    template = 'templatetags/pagination_ctl.html'

    options = Options(
        Argument('page', required=True, resolve=True),
        KeywordArgument('url', default='', required=False, resolve=True),
        KeywordArgument('url_args', default={}, required=False, resolve=True)
    )

    def get_context(self, context, page, url='', url_args={}):
        url = url.get('url', '')
        page_obj = page

        url_params = url_args.get('url_args', {})
        if 'page' in url_params:
            del url_params['page']

        url_args = urllib.urlencode(url_params)

        pages = []
        paginator = page_obj.paginator
        max_pages = 9

        if paginator.num_pages < max_pages:
            pages = range(1, paginator.num_pages + 1)

        else:
            half = max_pages // 2
            page_start = int(page_obj.number - half)

            if (page_start + max_pages) > paginator.num_pages:
                page_start = paginator.num_pages - max_pages

            if page_start > 0:
                pages = range(page_start, page_start + max_pages + 1)

            else:
                pages = range(1, max_pages + 1)

        return {
            'page_obj': page_obj,
            'url': url,
            'url_params': url_args,
            'page_range': pages
        }
예제 #8
0
class CMSToolbar(RenderBlock):
    name = 'cms_toolbar'

    options = Options(
        Argument('name', required=False
                 ),  # just here so sekizai thinks this is a RenderBlock
        parser_class=SekizaiParser,
    )

    def render_tag(self, context, name, nodelist):
        # render JS
        request = context.get('request', None)
        toolbar = getattr(request, 'toolbar', None)
        if toolbar:
            toolbar.populate()
        if request and 'cms-toolbar-login-error' in request.GET:
            context['cms_toolbar_login_error'] = request.GET[
                'cms-toolbar-login-error'] == '1'
        context['cms_version'] = __version__
        if toolbar and toolbar.show_toolbar:
            language = toolbar.toolbar_language
            with force_language(language):
                # needed to populate the context with sekizai content
                render_to_string('cms/toolbar/toolbar_javascript.html',
                                 context)
                clipboard = mark_safe(
                    render_to_string('cms/toolbar/clipboard.html', context))
        else:
            language = None
            clipboard = ''
        # render everything below the tag
        rendered_contents = nodelist.render(context)
        # sanity checks
        if not request:
            return rendered_contents
        if not toolbar:
            return rendered_contents
        if not toolbar.show_toolbar:
            return rendered_contents
        # render the toolbar content
        request.toolbar.post_template_populate()
        with force_language(language):
            context['clipboard'] = clipboard
            content = render_to_string('cms/toolbar/toolbar.html', context)
        # return the toolbar content and the content below
        return '%s\n%s' % (content, rendered_contents)
예제 #9
0
class RenderPlaceholderField(InclusionTag):
    """
    Inclusion tag for static placeholder.
    RUS: Класс тега для статического заполнителя.
    """

    template = 'edw_fluent/partials/_renderplaceholder.html'
    name = 'render_placeholder_field'

    options = Options(Argument('placeholder_id', resolve=True), )

    def get_context(self, context, placeholder_id):
        """
        RUS: Возвращает контекст, дополненный id заполнителя.
        """
        placeholder_object = Placeholder.objects.get(id=placeholder_id)
        context.update({'placeholder_object': placeholder_object})
        return context
예제 #10
0
class GetTermTree(BaseRetrieveDataTag):
    name = 'get_term_tree'
    queryset = TermModel.objects.toplevel()
    serializer_class = TermTreeSerializer
    action = 'tree'

    options = Options(MultiKeywordArgument('kwargs', required=False), 'as',
                      Argument('varname', required=False, resolve=False))

    def render_tag(self, context, kwargs, varname):
        queryset = self.get_queryset()
        serializer = self.get_serializer(queryset, many=True, context=context)
        data = serializer.data
        if varname:
            context[varname] = data
            return ''
        else:
            return self.to_json(data)
예제 #11
0
class MainMenu(ShowMenu):
    name = 'main_menu'

    options = Options(
        IntegerArgument('from_level', default=0, required=False),
        StringArgument('template',
                       default='cms/bootstrap3/main-menu.html',
                       required=False),
        StringArgument('namespace', default=None, required=False),
        StringArgument('root_id', default=None, required=False),
        Argument('next_page', default=None, required=False),
    )

    def get_context(self, context, from_level, template, namespace, root_id,
                    next_page):
        return super(MainMenu,
                     self).get_context(context, from_level, 1, 1, 1, template,
                                       namespace, root_id, next_page)
예제 #12
0
class SkillsTotal(MetricTotalTag):
    options = Options(
        KeywordArgument('garden', required=False),
        KeywordArgument('start', required=False),
        KeywordArgument('end', required=False),
        KeywordArgument('shared', required=True),
        'as',
        Argument('varname', resolve=False, required=False),
    )

    def get_metric_model(self):
        return SmartsAndSkills

    def get_value(self, context, garden, start, end, shared):
        shared = shared['shared']
        kwargs = self.args_to_dict(garden, start, end)
        records = self.get_records(**kwargs)
        return records.aggregate(total=Sum(shared))['total']
예제 #13
0
class StaticPlaceholderNode(Tag):
    name = 'static_placeholder'
    options = PlaceholderOptions(
        Argument('code', required=True),
        MultiValueArgument('extra_bits', required=False, resolve=False),
        blocks=[
            ('endstatic_placeholder', 'nodelist'),
        ]
    )

    def render_tag(self, context, code, extra_bits, nodelist=None):
        # TODO: language override (the reason this is not implemented, is that language selection is buried way
        #       down somewhere in some method called in render_plugins. There it gets extracted from the request
        #       and a language in request.GET always overrides everything.)
        if not code:
            # an empty string was passed in or the variable is not available in the context
            if nodelist:
                return nodelist.render(context)
            return ''
        request = context.get('request', False)
        if not request:
            if nodelist:
                return nodelist.render(context)
            return ''
        if isinstance(code, StaticPlaceholder):
            static_placeholder = code
        else:
            if 'site' in extra_bits:
                site = Site.objects.get_current()
                static_placeholder, __ = StaticPlaceholder.objects.get_or_create(code=code, site_id=site.pk, defaults={'name': code,
                    'creation_method': StaticPlaceholder.CREATION_BY_TEMPLATE})
            else:
                static_placeholder, __ = StaticPlaceholder.objects.get_or_create(code=code, site_id__isnull=True, defaults={'name': code,
                    'creation_method': StaticPlaceholder.CREATION_BY_TEMPLATE})
        if not hasattr(request, 'static_placeholders'):
            request.static_placeholders = []
        request.static_placeholders.append(static_placeholder)
        if hasattr(request, 'toolbar') and request.toolbar.edit_mode:
            placeholder = static_placeholder.draft
        else:
            placeholder = static_placeholder.public
        placeholder.is_static = True
        content = render_placeholder(placeholder, context, name_fallback=code, default=nodelist)
        return content
예제 #14
0
class FrontEditModelTag(Tag):
    name = 'front_edit_model'
    options = Options(Argument('instance', resolve=False, required=True),
                      blocks=[
                          ('end_front_edit_model', 'nodelist'),
                      ])

    def render_tag(self, context, instance='', nodelist=None):
        obj = context.get('object', None)
        model_placeholder = getattr(obj, instance)
        hash_val = Placeholder.key_for(str(model_placeholder.id))
        cache_key = "front-edit-%s" % hash_val

        val = cache.get(cache_key)
        if val is None:
            try:
                val = Placeholder.objects.get(key=hash_val).value
                cache.set(cache_key, val, 3600 * 24)
            except Placeholder.DoesNotExist:
                pass

        if val is None and nodelist:
            val = nodelist.render(context)

        classes = ['editable']

        user = context.get('request', None) and context.get('request').user

        user_can_change = False
        if obj:
            opts = type(obj)._meta
            codename = get_permission_codename('change', opts)
            change_perm = '{}.{}'.format(opts.app_label, codename)
            user_can_change = user.has_perm(change_perm)

        if django_front_settings.DJANGO_FRONT_PERMISSION(
                user) or user_can_change:
            render = six.text_type(smart_text(val)).strip()
            if not strip_tags(render).strip():
                classes.append('empty-editable')

            return '<div class="%s" id="%s">%s</div>' % (' '.join(classes),
                                                         hash_val, render)
        return val or ''
예제 #15
0
파일: get_agenda.py 프로젝트: Level-Up/DDDM
class get_agenda(Tag):
    """
    Fetches all sessions
    
    Usage:
    {% get_agenda as agenda %}
    {% for session in agenda %}
    """

    options = Options('as', Argument('varname', required=False, resolve=False))

    def render_tag(self, context, varname):
        agenda = []

        for slot in Slot.objects.all():
            qs = Session.objects.filter(slot=slot).order_by("room")
            sessions = []

            if qs:
                for s in qs:
                    speaker = "%s %s" % (s.speaker.first_name, s.speaker.
                                         last_name) if s.speaker else None
                    speaker_id = s.speaker.pk if s.speaker else None
                    sessions.append({
                        "speaker": speaker,
                        "speaker_id": speaker_id,
                        "title": s.title,
                        "url": s.get_absolute_url(),
                        "excerpt": s.excerpt,
                        "room": s.room,
                        "is_break": s.is_break
                    })

            agenda.append({
                "start": slot.start,
                "end": slot.end,
                "sessions": sessions
            })

        if varname:
            context[varname] = agenda
            return ''
        else:
            return agenda
예제 #16
0
class SkillsExamples(MetricRecordsMixin, AsTag):
    options = Options(
        KeywordArgument('garden', required=False),
        KeywordArgument('start', required=False),
        KeywordArgument('end', required=False),
        KeywordArgument('shared', required=True),
        'as',
        Argument('varname', resolve=False, required=False),
    )

    def get_metric_model(self):
        return SmartsAndSkills

    def get_value(self, context, garden, start, end, shared):
        shared = shared['shared']
        kwargs = self.args_to_dict(garden, start, end)
        records = self.get_records(**kwargs).order_by('recorded')
        return OrderedDict([(r.recorded, getattr(r, '%s_examples' % shared))
                            for r in records])
예제 #17
0
파일: amenu_tags.py 프로젝트: ludbek/amenu
class RenderMenu(InclusionTag):
    """
    Renders children of given menu to given depth.
    """
    name = "render_menu"
    template = "amenu/render_menu.html"

    options = Options(
        Argument('page', required=True),
        IntegerArgument('depth', required=True),
    )

    def get_context(self, context, page, depth):
        if depth is not 0:
            context['depth'] = depth - 1
            context['pages'] = page.get_children()
        else:
            context = None
        return context
예제 #18
0
class FrontEditTag(Tag):
    name = 'front_edit'
    options = Options(
        Argument('name', resolve=False, required=True),
        MultiValueArgument('extra_bits', required=False, resolve=True),
        blocks=[('end_front_edit', 'nodelist')],
    )

    def render_tag(self, context, name, extra_bits, nodelist=None):
        hash_val = Placeholder.key_for(name, *extra_bits)
        cache_key = "front-edit-%s" % hash_val

        val = cache.get(cache_key)
        if val is None:
            try:
                val = Placeholder.objects.get(key=hash_val).value
                cache.set(cache_key, val, 3600 * 24)
            except Placeholder.DoesNotExist:
                pass

        if val is None and nodelist:
            val = nodelist.render(context)

        classes = ['editable']

        if getattr(django_front_settings,
                   'DJANGO_FRONT_EXTRA_CONTAINER_CLASSES', None):
            classes.append(
                six.text_type(django_front_settings.
                              DJANGO_FRONT_EXTRA_CONTAINER_CLASSES))

        user = context.get('request', None) and context.get('request').user
        if django_front_settings.DJANGO_FRONT_PERMISSION(user):
            render = six.text_type(smart_text(val)).strip()
            if not strip_tags(render).strip():
                classes.append('empty-editable')

            return '<div class="%s" id="%s">%s</div>' % (
                ' '.join(classes),
                hash_val,
                render,
            )
        return val or ''
예제 #19
0
class StaticPlaceholderNode(Tag):
    name = 'static_placeholder'
    options = PlaceholderOptions(Argument('code', required=True),
                                 MultiValueArgument('extra_bits',
                                                    required=False,
                                                    resolve=False),
                                 blocks=[
                                     ('endstatic_placeholder', 'nodelist'),
                                 ])

    def render_tag(self, context, code, extra_bits, nodelist=None):
        content_renderer = context.get('cms_content_renderer')

        if not code or not content_renderer:
            # an empty string was passed in or the variable is not available in the context
            # OR cms_content_renderer is missing from context
            if nodelist:
                return nodelist.render(context)
            return ''

        if isinstance(code, StaticPlaceholder):
            static_placeholder = code
        else:
            kwargs = {
                'code': code,
                'defaults': {
                    'creation_method': StaticPlaceholder.CREATION_BY_TEMPLATE
                }
            }

            if 'site' in extra_bits:
                kwargs['site'] = Site.objects.get_current()
            else:
                kwargs['site_id__isnull'] = True
            static_placeholder = StaticPlaceholder.objects.get_or_create(
                **kwargs)[0]

        content = content_renderer.render_static_placeholder(
            static_placeholder,
            context=context,
            nodelist=nodelist,
        )
        return content
예제 #20
0
class CMSEditableObjectBlock(CMSEditableObject):
    """
    Templatetag that links a content extracted from a generic django model
    to the model admin changeform.

    The rendered content is to be specified in the enclosed block.
    """
    name = 'render_model_block'
    options = Options(
        Argument('instance'),
        Argument('edit_fields', default=None, required=False),
        Argument('language', default=None, required=False),
        Argument('view_url', default=None, required=False),
        Argument('view_method', default=None, required=False),
        'as',
        Argument('varname', required=False, resolve=False),
        blocks=[('endrender_model_block', 'nodelist')],
    )

    def render_tag(self, context, **kwargs):
        """
        Renders the block and then inject the resulting HTML in the template
        context
        """
        context.push()
        template = self.get_template(context, **kwargs)
        data = self.get_context(context, **kwargs)
        data['content'] = mark_safe(kwargs['nodelist'].render(data))
        data['rendered_content'] = data['content']
        output = render_to_string(template, data)
        context.pop()
        if kwargs.get('varname'):
            context[kwargs['varname']] = output
            return ''
        else:
            return output

    def get_context(self, context, instance, edit_fields, language, view_url,
                    view_method, varname, nodelist):
        """
        Uses _get_empty_context and adds the `instance` object to the local
        context. Context here is to be intended as the context of the nodelist
        in the block.
        """
        extra_context = self._get_empty_context(context, instance, edit_fields,
                                                language, view_url,
                                                view_method)
        extra_context['instance'] = instance
        extra_context['render_model_block'] = True
        return extra_context
예제 #21
0
class StrideRenderer(Tag):
    """
    Render the serialized content of a placeholder field using the full cascade of plugins.
    {% render_cascade "cascade-data.json" %}

    Keyword arguments:
    datafile -- Filename containing the cascade tree. Must be file locatable by Django's
    static file finders.
    """
    name = 'render_cascade'
    options = Options(
        Argument('datafile'),
    )

    def render_tag(self, context, datafile):
        from sekizai.helpers import get_varname as get_sekizai_context_key
        from cmsplugin_cascade.strides import StrideContentRenderer

        cache = caches['default']
        tree_data_key = 'cascade-strides:' + datafile
        tree_data = cache.get(tree_data_key) if cache else None
        if tree_data is None:
            jsonfile = finders.find(datafile)
            if not jsonfile:
                raise IOError("Unable to find file: {}".format(datafile))

            with io.open(jsonfile) as fp:
                tree_data = json.load(fp)

        content_renderer = StrideContentRenderer(context['request'])
        with context.push(cms_content_renderer=content_renderer):
            content = content_renderer.render_cascade(context, tree_data)

        # some templates use Sekizai's templatetag `addtoblock` or `add_data`, which have to be re-added to the context
        cache = caches['default']
        if cache:
            sekizai_context_key = get_sekizai_context_key()
            SEKIZAI_CONTENT_HOLDER = cache.get_or_set(sekizai_context_key, context.get(sekizai_context_key))
            if SEKIZAI_CONTENT_HOLDER:
                for name in SEKIZAI_CONTENT_HOLDER:
                    context[sekizai_context_key][name] = SEKIZAI_CONTENT_HOLDER[name]
        return content
class RenderIdentifier(Tag):
    """
    Given a CMS Placeholder page identifier, render the content of the placeholder field.
    """
    name = 'render_identifier'
    options = Options(
        Argument('page_identifier'),
    )

    def render_tag(self, context, page_identifier):
        request = context.get('request', None)
        if not request:
            return ''
        if not page_identifier:
            return ''
        placeholders = CMSPlaceholder.objects.filter(page_identifier=page_identifier)
        if not placeholders:
            return ""
        ph = placeholders[0]
        return safe(ph.cmscontent_placeholder.render(context, None))
예제 #23
0
class CMSToolbar(RenderBlock):
    name = 'cms_toolbar'

    options = Options(
        Argument('name', required=False),  # just here so sekizai thinks this is a RenderBlock
        parser_class=SekizaiParser,
    )

    def render_tag(self, context, name, nodelist):
        request = context.get('request')

        if not request:
            return nodelist.render(context)

        toolbar = get_toolbar_from_request(request)

        if toolbar and toolbar.show_toolbar:
            toolbar.init_toolbar(request)
            return toolbar.render_with_structure(context, nodelist)
        return nodelist.render(context)
예제 #24
0
class RenderPlugin(InclusionTag):
    template = 'cms/content.html'
    name = 'render_plugin'
    options = Options(
        Argument('plugin')
    )

    def get_processors(self, context, plugin, placeholder):
        #
        # Prepend frontedit toolbar output if applicable. Moved to its own
        # method to aide subclassing the whole RenderPlugin if required.
        #
        request = context['request']
        toolbar = getattr(request, 'toolbar', None)
        if toolbar and toolbar.edit_mode and placeholder.has_change_permission(request) and getattr(placeholder, 'is_editable', True):
            from cms.middleware.toolbar import toolbar_plugin_processor
            processors = (toolbar_plugin_processor,)
        else:
            processors = None
        return processors

    def get_context(self, context, plugin):

        # Prepend frontedit toolbar output if applicable
        if not plugin:
            return {'content': ''}

        try:
            placeholder = context['cms_placeholder_instance']
        except KeyError:
            placeholder = plugin.placeholder

        processors = self.get_processors(context, plugin, placeholder)

        return {
            'content': plugin.render_plugin(
                context,
                placeholder=placeholder,
                processors=processors
            )
        }
예제 #25
0
class ShowMenu(InclusionTag):
    name = 'show_menu'
    template = 'workmate/menu/dummy.html'

    options = Options(
        StringArgument('template', default='workmate/menu/menu.html', required=False),
        StringArgument('namespace', default=None, required=False),
        Argument('next_page', default=None, required=False),
    )

    def get_context(self, context, template, namespace, next_page):
        request = context['request']
        nodes = menu_pool.get_nodes(request, namespace)
        nodes = check_visibility(nodes)
        nodes = sorted(nodes, key=lambda n: (n.menu_sort_order, n.menu_title, n.sort_order, n.title))

        context['nodes'] = nodes
        context['template'] = template
        context['namespace'] = namespace

        return context
예제 #26
0
class Nav(Tag):
    '''
    Render the sidebar navigation
    '''
    name = 'nav'
    options = Options(
        Argument('hub', required=True, resolve=True),
        blocks=[('enter_submenu', 'item'), ('end_submenu', 'enter_submenu'), ('endnav', 'end_submenu')],
    )

    def render_tag(self, context, hub, item, **kwargs):
        output = ""
        for x in hub.root_navigations(context['request']):
            context.push()
            context['nav_item'] = x
            if x.step_type in kwargs:
                output += kwargs[x.step_type].render(context)
            else:
                output += item.render(context)
            context.pop()
        return output
예제 #27
0
class PageLanguageUrl(InclusionTag):
    """
    Displays the url of the current page in the defined language.
    You can set a language_changer function with the set_language_changer function in the utils.py if there is no page.
    This is needed if you have slugs in more than one language.
    """
    name = 'page_language_url'
    template = 'cms/content.html'

    options = Options(Argument('lang'), )

    def get_context(self, context, lang):
        try:
            # If there's an exception (500), default context_processors may not be called.
            request = context['request']
        except KeyError:
            return {'template': 'cms/content.html'}
        if hasattr(request, "_language_changer"):
            try:
                setattr(request._language_changer, 'request', request)
            except AttributeError:
                pass
            url = "/%s" % lang + request._language_changer(lang)
        else:
            page = request.current_page
            if page == "dummy":
                return {'content': ''}
            try:
                url = page.get_absolute_url(language=lang, fallback=False)
                url = "/" + lang + url
            except:
                # no localized path/slug
                if settings.CMS_HIDE_UNTRANSLATED:
                    # redirect to root url if CMS_HIDE_UNTRANSLATED
                    url = '/' + lang + '/'
                else:
                    # If untranslated pages are shown, this will not redirect
                    # at all.
                    url = ''
        return {'content': url}
예제 #28
0
class PluginChildClasses(InclusionTag):
    """
    Accepts a placeholder or a plugin and renders the allowed plugins for this.
    """

    template = "cms/toolbar/dragitem_menu.html"
    name = "plugin_child_classes"
    options = Options(Argument('obj'))

    def get_context(self, context, obj):
        # Prepend frontedit toolbar output if applicable
        request = context['request']
        page = request.current_page
        child_plugin_classes = []
        if isinstance(obj, CMSPlugin):
            slot = context['slot']
            plugin = obj
            plugin_class = plugin.get_plugin_class()
            if plugin_class.allow_children:
                instance, plugin = plugin.get_plugin_instance()
                childs = [
                    plugin_pool.get_plugin(cls)
                    for cls in plugin.get_child_classes(slot, page)
                ]
                # Builds the list of dictionaries containing module, name and value for the plugin dropdowns
                child_plugin_classes = get_toolbar_plugin_struct(
                    childs, slot, page, parent=plugin_class)
        elif isinstance(obj, PlaceholderModel):
            placeholder = obj
            page = placeholder.page if placeholder else None
            if not page:
                page = getattr(request, 'current_page', None)
            if placeholder:
                slot = placeholder.slot
            else:
                slot = None
            # Builds the list of dictionaries containing module, name and value for the plugin dropdowns
            child_plugin_classes = get_toolbar_plugin_struct(
                plugin_pool.get_all_plugins(slot, page), slot, page)
        return {'plugin_classes': child_plugin_classes}
예제 #29
0
class ShowSubMenu(InclusionTag):
    """
    show the sub menu of the current nav-node.
    -levels: how many levels deep
    -temlplate: template used to render the navigation
    """
    name = 'show_sub_menu'
    template = 'menu/dummy.html'

    options = Options(
        IntegerArgument('levels', default=100, required=False),
        Argument('template', default='menu/sub_menu.html', required=False),
    )

    def get_context(self, context, levels, template):
        try:
            # If there's an exception (500), default context_processors may not be called.
            request = context['request']
        except KeyError:
            return {'template': 'menu/empty.html'}
        nodes = menu_pool.get_nodes(request)
        children = []
        for node in nodes:
            if node.selected:
                cut_after(node, levels, [])
                children = node.children
                for child in children:
                    child.parent = None
                children = menu_pool.apply_modifiers(children,
                                                     request,
                                                     post_cut=True)
        context.update({
            'children': children,
            'template': template,
            'from_level': 0,
            'to_level': 0,
            'extra_inactive': 0,
            'extra_active': 0
        })
        return context
class CurrentCurrencyTag(Tag):
    name = 'get_current_currency'
    options = Options(
        'as',
        Argument('varname', resolve=False, required=False),
    )

    def render_tag(self, context, varname):
        code = get_currency_code(context['request'])
        try:
            currency = Currency.active.get(code=code)
        except Currency.DoesNotExist:
            try:
                currency = Currency.active.default()
            except Currency.DoesNotExist:
                currency = None  # shit happens...

        if varname:
            context[varname] = currency
            return ''
        else:
            return currency