Example #1
0
def mark_tag(request, **kwargs):#tagging system
    action = kwargs['action']
    post_data = simplejson.loads(request.raw_post_data)
    raw_tagnames = post_data['tagnames']
    reason = kwargs.get('reason', None)
    #separate plain tag names and wildcard tags

    tagnames, wildcards = forms.clean_marked_tagnames(raw_tagnames)
    cleaned_tagnames, cleaned_wildcards = request.user.mark_tags(
                                                            tagnames,
                                                            wildcards,
                                                            reason = reason,
                                                            action = action
                                                        )

    #lastly - calculate tag usage counts
    tag_usage_counts = dict()
    for name in tagnames:
        if name in cleaned_tagnames:
            tag_usage_counts[name] = 1
        else:
            tag_usage_counts[name] = 0

    for name in wildcards:
        if name in cleaned_wildcards:
            tag_usage_counts[name] = models.Tag.objects.filter(
                                        name__startswith = name[:-1]
                                    ).count()
        else:
            tag_usage_counts[name] = 0

    return HttpResponse(simplejson.dumps(tag_usage_counts), mimetype="application/json")
Example #2
0
def subscribe_for_tags(request):
    """process subscription of users by tags"""
    #todo - use special separator to split tags
    tag_names = request.REQUEST.get('tags','').strip().split()
    pure_tag_names, wildcards = forms.clean_marked_tagnames(tag_names)
    if request.user.is_authenticated():
        if request.method == 'POST':
            if 'ok' in request.POST:
                request.user.mark_tags(
                            pure_tag_names,
                            wildcards,
                            reason = 'good',
                            action = 'add'
                        )
                request.user.message_set.create(
                    message = _('Your tag subscription was saved, thanks!')
                )
            else:
                message = _(
                    'Tag subscription was canceled (<a href="%(url)s">undo</a>).'
                ) % {'url': request.path + '?tags=' + request.REQUEST['tags']}
                request.user.message_set.create(message = message)
            return HttpResponseRedirect(reverse('index'))
        else:
            data = {'tags': tag_names}
            return render_into_skin('subscribe_for_tags.html', data, request)
    else:
        all_tag_names = pure_tag_names + wildcards
        message = _('Please sign in to subscribe for: %(tags)s') \
                    % {'tags': ', '.join(all_tag_names)}
        request.user.message_set.create(message = message)
        request.session['subscribe_for_tags'] = (pure_tag_names, wildcards)
        return HttpResponseRedirect(url_utils.get_login_url())
Example #3
0
def subscribe_for_tags(request):
    """process subscription of users by tags"""
    tag_names = request.REQUEST.get('tags', '').strip().split()
    pure_tag_names, wildcards = forms.clean_marked_tagnames(tag_names)
    if request.user.is_authenticated():
        if request.method == 'POST':
            if 'ok' in request.POST:
                request.user.mark_tags(pure_tag_names,
                                       wildcards,
                                       reason='good',
                                       action='add')
                request.user.message_set.create(
                    message=_('Your tag subscription was saved, thanks!'))
            else:
                message = _(
                    'Tag subscription was canceled (<a href="%(url)s">undo</a>).'
                ) % {
                    'url': request.path + '?tags=' + request.REQUEST['tags']
                }
                request.user.message_set.create(message=message)
            return HttpResponseRedirect(reverse('index'))
        else:
            data = {'tags': tag_names}
            return render_into_skin('subscribe_for_tags.html', data, request)
    else:
        all_tag_names = pure_tag_names + wildcards
        message = _('Please sign in to subscribe for: %(tags)s') \
                    % {'tags': ', '.join(all_tag_names)}
        request.user.message_set.create(message=message)
        request.session['subscribe_for_tags'] = (pure_tag_names, wildcards)
        return HttpResponseRedirect(reverse('user_signin'))
Example #4
0
def subscribe_for_tags(request):
    """process subscription of users by tags"""
    # todo - use special separator to split tags
    tag_names = request.REQUEST.get("tags", "").strip().split()
    pure_tag_names, wildcards = forms.clean_marked_tagnames(tag_names)
    if request.user.is_authenticated():
        if request.method == "POST":
            if "ok" in request.POST:
                request.user.mark_tags(pure_tag_names, wildcards, reason="good", action="add")
                request.user.message_set.create(message=_("Your tag subscription was saved, thanks!"))
            else:
                message = _('Tag subscription was canceled (<a href="%(url)s">undo</a>).') % {
                    "url": request.path + "?tags=" + request.REQUEST["tags"]
                }
                request.user.message_set.create(message=message)
            return HttpResponseRedirect(reverse("index"))
        else:
            data = {"tags": tag_names}
            return render_into_skin("subscribe_for_tags.html", data, request)
    else:
        all_tag_names = pure_tag_names + wildcards
        message = _("Please sign in to subscribe for: %(tags)s") % {"tags": ", ".join(all_tag_names)}
        request.user.message_set.create(message=message)
        request.session["subscribe_for_tags"] = (pure_tag_names, wildcards)
        return HttpResponseRedirect(url_utils.get_login_url())
Example #5
0
def mark_tag(request, **kwargs):  #tagging system
    action = kwargs['action']
    post_data = simplejson.loads(request.raw_post_data)
    raw_tagnames = post_data['tagnames']
    reason = kwargs.get('reason', None)
    #separate plain tag names and wildcard tags

    tagnames, wildcards = forms.clean_marked_tagnames(raw_tagnames)
    cleaned_tagnames, cleaned_wildcards = request.user.mark_tags(tagnames,
                                                                 wildcards,
                                                                 reason=reason,
                                                                 action=action)

    #lastly - calculate tag usage counts
    tag_usage_counts = dict()
    for name in tagnames:
        if name in cleaned_tagnames:
            tag_usage_counts[name] = 1
        else:
            tag_usage_counts[name] = 0

    for name in wildcards:
        if name in cleaned_wildcards:
            tag_usage_counts[name] = models.Tag.objects.filter(
                name__startswith=name[:-1]).count()
        else:
            tag_usage_counts[name] = 0

    return HttpResponse(simplejson.dumps(tag_usage_counts),
                        mimetype="application/json")
Example #6
0
def mark_tag(request, **kwargs):  # tagging system
    if request.user.is_anonymous():
        msg = _('anonymous users cannot %(perform_action)s') % \
            {'perform_action': _('mark or unmark tags')}
        raise exceptions.PermissionDenied(msg + ' ' + get_login_link())

    action = kwargs['action']
    post_data = json.loads(request.raw_post_data)
    raw_tagnames = post_data['tagnames']
    reason = post_data['reason']
    assert reason in ('good', 'bad', 'subscribed')
    # separate plain tag names and wildcard tags
    tagnames, wildcards = forms.clean_marked_tagnames(raw_tagnames)

    if request.user.is_administrator() and 'user' in post_data:
        user = get_object_or_404(models.User, pk=post_data['user'])
    else:
        user = request.user

    cleaned_tagnames, cleaned_wildcards = user.mark_tags(
                                                     tagnames,
                                                     wildcards,
                                                     reason=reason,
                                                     action=action
                                                )

    # lastly - calculate tag usage counts
    tag_usage_counts = dict()
    for name in tagnames:
        if name in cleaned_tagnames:
            tag_usage_counts[name] = 1
        else:
            tag_usage_counts[name] = 0

    for name in wildcards:
        if name in cleaned_wildcards:
            tag_usage_counts[name] = models.Tag.objects.filter(
                                        name__startswith = name[:-1],
                                        language_code=translation.get_language()
                                    ).count()
        else:
            tag_usage_counts[name] = 0

    return tag_usage_counts
Example #7
0
def mark_tag(request, **kwargs):  # tagging system

    if request.user.is_anonymous():
        msg = _("anonymous users cannot %(perform_action)s") % {"perform_action": _("mark or unmark tags")}
        raise exceptions.PermissionDenied(msg + " " + get_login_link())

    action = kwargs["action"]
    post_data = simplejson.loads(request.body)
    raw_tagnames = post_data["tagnames"]
    reason = post_data["reason"]
    assert reason in ("good", "bad", "subscribed")
    # separate plain tag names and wildcard tags
    if action == "remove":
        tagnames, wildcards = forms.classify_marked_tagnames(raw_tagnames)
    else:
        tagnames, wildcards = forms.clean_marked_tagnames(raw_tagnames)

    if request.user.is_administrator() and "user" in post_data:
        user = get_object_or_404(models.User, pk=post_data["user"])
    else:
        user = request.user

    cleaned_tagnames, cleaned_wildcards = user.mark_tags(tagnames, wildcards, reason=reason, action=action)

    # lastly - calculate tag usage counts
    tag_usage_counts = dict()
    for name in tagnames:
        if name in cleaned_tagnames:
            tag_usage_counts[name] = 1
        else:
            tag_usage_counts[name] = 0

    for name in wildcards:
        if name in cleaned_wildcards:
            tag_usage_counts[name] = models.Tag.objects.filter(
                name__startswith=name[:-1], language_code=translation.get_language()
            ).count()
        else:
            tag_usage_counts[name] = 0

    return tag_usage_counts
Example #8
0
def mark_tag(request, **kwargs):  # tagging system
    if request.user.is_anonymous():
        msg = _('anonymous users cannot %(perform_action)s') % \
            {'perform_action': _('mark or unmark tags')}
        raise exceptions.PermissionDenied(msg + ' ' + get_login_link())

    action = kwargs['action']
    post_data = json.loads(request.raw_post_data)
    raw_tagnames = post_data['tagnames']
    reason = post_data['reason']
    assert reason in ('good', 'bad', 'subscribed')
    # separate plain tag names and wildcard tags
    tagnames, wildcards = forms.clean_marked_tagnames(raw_tagnames)

    if request.user.is_administrator() and 'user' in post_data:
        user = get_object_or_404(models.User, pk=post_data['user'])
    else:
        user = request.user

    cleaned_tagnames, cleaned_wildcards = user.mark_tags(tagnames,
                                                         wildcards,
                                                         reason=reason,
                                                         action=action)

    # lastly - calculate tag usage counts
    tag_usage_counts = dict()
    for name in tagnames:
        if name in cleaned_tagnames:
            tag_usage_counts[name] = 1
        else:
            tag_usage_counts[name] = 0

    for name in wildcards:
        if name in cleaned_wildcards:
            tag_usage_counts[name] = models.Tag.objects.filter(
                name__startswith=name[:-1],
                language_code=translation.get_language()).count()
        else:
            tag_usage_counts[name] = 0

    return tag_usage_counts
Example #9
0
def subscribe_for_tags(request):
    """process subscription of users by tags"""
    # TODO - use special separator to split tags
    tag_names = request.REQUEST.get('tags', '').strip().split()
    pure_tag_names, wildcards = forms.clean_marked_tagnames(tag_names)
    if request.user.is_authenticated():
        if request.method == 'POST':
            if 'ok' in request.POST:
                request.user.mark_tags(pure_tag_names,
                                       wildcards,
                                       reason='good',
                                       action='add')
                # request.user.message_set.create(message=_('Your tag subscription was saved, thanks!'))
                django_messages.info(
                    request, _('Your tag subscription was saved, thanks!'))
            else:
                message = _(
                    'Tag subscription was canceled (<a href="%(url)s">undo</a>).'
                ) % {
                    'url':
                    escape(request.path) + '?tags=' + request.REQUEST['tags']
                }
                # request.user.message_set.create(message=message)
                django_messages.info(request, message)
            return redirect('index')
        else:
            data = {'tags': tag_names}
            return render(request, 'subscribe_for_tags.jinja', data)
    else:
        all_tag_names = pure_tag_names + wildcards
        message = _('Please sign in to subscribe for: %(tags)s') % {
            'tags': ', '.join(all_tag_names)
        }
        # request.user.message_set.create(message=message)
        django_messages.info(request, message)
        request.session['subscribe_for_tags'] = (pure_tag_names, wildcards)
        return redirect(url_utils.get_login_url())