Example #1
0
def topnav(context):
    node = context.get('instance')
    request = context.get('request')
    language = get_active_language(request)

    nav = []

    ## Find top/secondlevel published nodes in one query XXX
    for toplevel in queries.toplevel_visible_children(language=language):
        ## make sure /foo/bar does not match in /football by adding the /
        item = dict(active=False, node=toplevel)
        content = toplevel.content(language=language)
        item['url'] = toplevel.get_absolute_url(language=language)
        item['title'] = content.title if content else ""

        if toplevel == node or \
           (node and node.path.startswith(toplevel.path + '/')):
            item['active'] = True

        sub = []
        for secondlevel in queries.get_visible_children(toplevel, language=language):
            slitem = dict(node=secondlevel)
            content = secondlevel.content(language=language)
            slitem['url'] = secondlevel.get_absolute_url(language=language)
            slitem['title'] = content.title if content else ""

            sub.append(slitem)

        item['sub'] = sub
        nav.append(item)
    return dict(toplevel=nav)
def languages(request):
    if len(settings.LANGUAGES) <= 1:
        return None

    current_language = get_active_language()
    current_label = dict(settings.LANGUAGES).get(current_language,
                                                 current_language)

    res = []

    ld = getattr(settings, 'LANGUAGE_DOMAINS', {})

    for lang, label in settings.CONTENT_LANGUAGES:
        if lang == current_language:
            is_current = True
        else:
            is_current = False

        url = Node.root().get_absolute_url(language=lang)
        has_translation = False

        domain = ld.get(lang)
        if domain:
            protocol = "https" if request.is_secure() else "http"
            url = "%s://%s%s" % (protocol, domain, url)

        res.append(dict(id=lang, label=label, url=url,
                        has_translation=has_translation,
                        is_current=is_current))
    return dict(languages=dict(current=dict(id=current_language, label=current_label),
                languages=res))
Example #3
0
def contentlisting_context(handler, request, node):
    language = get_active_language()

    q = node_proxy_factory(Node, language).objects.children(node).filter(contentbase__language=language).order_by("position")

    if not access.has_access(request.user, node):
        q = q.public()

    return dict(contents=q)
Example #4
0
    def show_translate(self):
        if self.status == 'special':  ## special page
            return False

        ## do not show when creating or updating
        if self.status in ("update", "create"):
            return False
        active_language = get_active_language(self.request)

        ## there's an instance, it has (primary) content but not in the
        ## active language
        if self.instance and self.instance.primary_content() and not self.instance.content(language=active_language):
            return True
        return False
Example #5
0
def blog_context(handler, request, node):
    """ provide context both in Page as in Blog context """
    ## XXX This context provider will not work for non-valve (derived) blogs
    ## due to the hardcoded ValveEntry.classname dependency
    ctx = {}

    ctx['body_class'] = "wheelcms_valve"

    try:
        p = max(1, int(request.GET.get('page', 1)))
    except (ValueError, TypeError):
        p = 1

    kw = {}
    if not handler.hasaccess():
        kw['contentbase__state'] = "published"

    language = get_active_language()
    kw['contentbase__language'] = language

    category_slug = request.GET.get('category', '')
    if category_slug:
        ## XXX Untested
        category = handler.instance.child(category_slug, language=language)
        kw['contentbase__categories'] = category

    try:
        ownerid = int(request.GET.get('ownerid', ''))
        kw['contentbase__owner__id'] = ownerid
    except ValueError:
        pass
    ## this will actually ignore the blog publication state! XXX
    ctx['paginator'] = paginator = SectionedPaginator(
         node_proxy_factory(Node, language)
         .objects.offspring(node)
         .filter(contentbase__meta_type=ValveEntry.classname, **kw)
         .order_by("-contentbase__created"), 4)
    b, m, e = paginator.sections(p, windowsize=6)
    ctx['begin'] = b
    ctx['middle'] = m
    ctx['end'] = e

    try:
        ctx['page'] = paginator.page(p)
    except InvalidPage:
        ctx['page'] = paginator.page(1)

    return ctx
Example #6
0
    def resolve(cls, nodepath):
        """ resolve a node path to an actual node in correct language 
            context. """
        ## Do a bit of path normalization: Except for root, start with /,
        ## remove trailing /
        ## Old 'coerce' used to
        # locale.activate_content_language(None)
        ## Is that necessary for anything?
        if nodepath in ("/", ""):
            nodepath = ""
        else:
            nodepath = "/{0}".format(nodepath.strip('/'))

        language = get_active_language()

        return Node.get(nodepath, language=language)
Example #7
0
    def translations(self):
        """
            Return data for the translations/languages menu. This means
            "switch to" options for translated languages and "translate to"
            for untranslated languages.

            If there's no second language (ignoring 'Any'), don't return
            anything; this will hide the translation menu entirely.
        """
        if not self.instance or self.status == Toolbar.SPECIAL:
            return None

        if len(settings.CONTENT_LANGUAGES) == 1:
            return None

        active = None
        translated = []
        untranslated = []

        active_language = get_active_language()

        for (lang, langtitle) in translate.languages():
            option = dict(id=lang, language=langtitle)
            content = self.instance.content(language=lang)

            ## In view mode toch edit tonen om vertaling te maken!
            base_url = "switch_admin_language?path=" + self.instance.tree_path + "&switchto=" + lang
            if lang == active_language:
                active = option
            else:
                if self.status == Toolbar.UPDATE:
                    option["action_url"] = base_url + "&rest=edit"
                elif self.status == Toolbar.VIEW:
                    option["action_url"] = base_url + ""
                elif self.status == Toolbar.LIST:
                    option["action_url"] = base_url + "&rest=list"
                elif self.status == Toolbar.CREATE:
                    option["action_url"] = (
                        base_url + "&rest=" + urllib2.quote("create?type=" + self.request.GET.get("type"))
                    )

                if content and self.status != Toolbar.CREATE:
                    translated.append(option)
                else:
                    untranslated.append(option)

        return dict(active=active, translated=translated, untranslated=untranslated)
Example #8
0
def navigation_items(request, node):
    language = get_active_language()

    nav = []

    ## remove visible_children? Unnecessary with permission checks

    ## Find top/secondlevel published nodes in one query XXX
    for toplevel in queries.toplevel_visible_children(language=language):
        ## make sure /foo/bar does not match in /football by adding the /
        item = dict(active=False, node=toplevel)
        content = toplevel.content(language=language)

        if content:
            spoke = content.spoke()
            perm = spoke.permissions.get('view')
            if not auth.has_access(request, spoke, spoke, perm):
                continue

        item['url'] = toplevel.get_absolute_url(language=language)
        item['title'] = content.title if content else ""

        if toplevel == node or \
           (node and node.path.startswith(toplevel.path + '/')):
            item['active'] = True

        sub = []
        for secondlevel in queries.get_visible_children(toplevel, language=language):
            slitem = dict(node=secondlevel)
            content = secondlevel.content(language=language)
            spoke = content.spoke()
            perm = spoke.permissions.get('view')
            if not auth.has_access(request, spoke, spoke, perm):
                continue

            slitem['url'] = secondlevel.get_absolute_url(language=language)
            slitem['title'] = content.title if content else ""

            sub.append(slitem)

        item['sub'] = sub
        nav.append(item)
    return dict(toplevel=nav)
Example #9
0
    def show_translate(self):
        """
            The translate button is shown on pages that are not available
            in the current (admin) language. E.g. a page is written in english
            but the admin language is set to Spanish, you will get a 'translate'
            button in stead of an 'edit' button (with the exact same action,
            though!)
        """
        if self.status == Toolbar.SPECIAL:  ## special page
            return False

        ## do not show when creating or updating
        if self.status in (Toolbar.UPDATE, Toolbar.CREATE):
            return False
        active_language = get_active_language()

        ## there's an instance, it has (primary) content but not in the
        ## active language
        if self.instance and self.instance.primary_content() and not self.instance.content(language=active_language):
            return True
        return False
Example #10
0
    def get(self, request):
        page = int(request.REQUEST.get('page', 1))

        sqs = SearchQuerySet()
        language = utils.get_active_language()

        sqs = sqs.filter(language__in=(language, "any"))

        if not self.hasaccess():
            sqs = sqs.filter(state__in=("visible", "published"))

        form = self.context['form'] = SearchForm(self.request.REQUEST,
                                          searchqueryset=sqs)

        if page < 1:
            page = 1

        if form.is_valid():
            self.context['query'] = form.cleaned_data['q']

            self.context['paginator'] = paginator = \
                      SectionedPaginator(form.search(), self.results_per_page)

            try:
                self.context['page'] = paginator.page(page)
            except InvalidPage:
                return self.notfound()

            self.context['GET_string'] = urllib.urlencode([(k, v)
                    for (k, v) in self.request.REQUEST.iteritems()
                    if k != 'page'])

            b, m, e = paginator.sections(page, windowsize=4)

            self.context['begin'] = b
            self.context['middle'] = m
            self.context['end'] = e

        ## move to wheecms_axle folder?
        return self.template("search/search.html")
Example #11
0
    def translations(self):
        if not self.instance or self.status == "special":
            return None

        active = None
        translated = []
        untranslated = []

        active_language = get_active_language(self.request)

        for (lang, langtitle) in translate.languages():
            option = dict(id=lang, language=langtitle)
            content = self.instance.content(language=lang)

            ## In view mode toch edit tonen om vertaling te maken!
            base_url = "switch_admin_language?path=" + self.instance.tree_path + "&language=" + lang
            if lang == active_language:
                active = option
            else:
                if self.status == "update":
                    option['action_url'] = base_url + '&rest=edit'
                elif self.status == "view":
                    option['action_url'] = base_url + ''
                elif self.status == "list":
                    option['action_url'] = base_url + '&rest=list'
                elif self.status == "create":
                    option['action_url'] = base_url + '&rest=' + urllib2.quote('create?type=' + self.request.GET.get('type'))

                if content and self.status != 'create':
                    translated.append(option)
                else:
                    untranslated.append(option)

        return dict(active=active,
                    translated=translated,
                    untranslated=untranslated)
Example #12
0
def get_language():
    return get_active_language()
Example #13
0
 def active_language(self):
     return get_active_language()
Example #14
0
    def get(self, request, nodepath=None, handlerpath="", action="", **kw):
        """
            instance - the path to a piece of content
            path - remaining, specifies operation to be invoked.
                   To be deprecated in favor of +actins
        """

        self.toolbar = get_toolbar()

        # locale.activate_content_language(None)

        self.instance = self.resolve(nodepath)

        ## an action may end in slash: remove it
        if action:
            action = action.rstrip('/')

        language = get_active_language()

        if self.toolbar:
            self.toolbar.instance = self.instance
            self.toolbar.status = Toolbar.VIEW

        if self.instance is None:
            return self.notfound()

        ## make sure the instance is part of the context
        self.context['instance'] = self.instance

        ## pre_handler is to be deprecated. It also depends on self.instance
        self.pre_handler()

        spoke = self.spoke(language=language)
        ## retrieve content type info
        if spoke:
            ## update the context with addtional data from the spoke
            self.context.update(spoke.context(self, self.request,
                                self.instance))
            perm = spoke.permissions.get('view')
        else:
            perm = Spoke.permissions.get('view')

        ## Set default current tab
        self.context['tab_action'] = 'attributes'

        try:
            if handlerpath:
                handler = gethandler(self, handlerpath)
                if handler:
                    return handler()
                return self.notfound()

            if action:
                action_handler = action_registry.get(action, self.instance.path,
                                                 spoke)
                if action_handler is None:
                    return self.notfound()
                ## Should the (decorator for) the action handler do permission checks?
                required_permission = getattr(action_handler, 'permission', perm)
                if required_permission is None:
                    # default to spoke permission
                    required_permission = perm
                if not auth.has_access(self.request, spoke, spoke, required_permission):
                    return self.forbidden()

                ## if there's an action, assume it's actually an update action.
                if self.toolbar:
                    self.toolbar.status = Toolbar.UPDATE

                ## Update context if it's a tab action
                if tabaction(action_handler):
                    self.context['tab_action'] = tabaction(action_handler)
                return action_handler(self, request, action)

            if not handlerpath:
                ## special case: post to content means edit/update
                if self.is_post:
                    return self.edit()
                return self.view()
            return self.notfound()
        finally: # XXX Does this work as expected?
            self.post_handler()
Example #15
0
def handle_comment_post(handler, request, action):
    """
        Action to create a comment on any Spoke
    """
    form = CommentForm(request.POST)
    if not form.is_valid():
        ## since we're redirecting, use sessions to temporarily store
        ## the comment data
        request.session['comment_post'] = request.POST
        return handler.redirect(handler.instance.get_absolute_url(),
                                error=ugettext("Please fix your errors"),
                                hash="commentform")

    name = request.POST.get('name')
    body = request.POST.get('body')
    captcha = request.POST.get('body')

    ## if someone tries really really hard...
    id = "%s-%s" % (timezone.now().strftime("%Y%m%d%H%M%S"),
                    random.randint(0,1000))
    title = _("Comment by %(owner)s on %(date)s") % \
              dict(owner=name, date=timezone.now())

    n = handler.instance.add(id)
    lang = get_active_language()

    c = Comment(title=title, name=name, body=body, node=n,
                state="pending", language=lang).save()

    if 'posted_comments' not in request.session:
        request.session['posted_comments'] = []
    request.session['posted_comments'].append(c.node.path)
    request.session.modified = True


    baseconf = BaseConfiguration.config()
    try:
        notify = baseconf.comments.get().notify_address.strip()
    except Configuration.DoesNotExist:
        notify = ""

    sender = baseconf.sendermail.strip()

    if notify and sender:
        content = handler.instance.content()
        domain = Site.objects.get_current().domain
        content_url = "http://%s%s" % (domain, content.get_absolute_url())
        comment_url = "http://%s%s" % (domain, n.get_absolute_url())

        send_mail('New comment on "%s"' % content.title,
        """A new comment has been posted on "%(title)s" %(content_url)s

Name: %(name)s
Content:
%(body)s

View/edit/delete comment: %(comment_url)sedit#collapseadvanced""" % dict(title=content.title,
                  content_url=content_url,
                  comment_url=comment_url,
                  name=name, body=body),

                  sender,
                  [notify],
                  fail_silently=True)

    ## log details (ip, etc) in description, or add extra fields
    ## send notification, if enabled
    ## optionally 'recognize' the user and show the comment only to him/her
    ## allow approval/rejection of comment through view?

    return handler.redirect(handler.instance.get_absolute_url(),
                            info="Your comment is being processed")