Пример #1
0
def feedback(request):
    data = {'page_class': 'meta'}
    form = None

    if askbot_settings.ALLOW_ANONYMOUS_FEEDBACK is False:
        if request.user.is_anonymous():
            message = _('Please sign in or register to send your feedback')
            request.user.message_set.create(message=message)
            redirect_url = get_login_url() + '?next=' + request.path
            return HttpResponseRedirect(redirect_url)

    if request.method == "POST":
        form = FeedbackForm(
            is_auth=request.user.is_authenticated(),
            data=request.POST
        )
        if form.is_valid():
            if not request.user.is_authenticated():
                data['email'] = form.cleaned_data.get('email',None)
            data['message'] = form.cleaned_data['message']
            data['name'] = form.cleaned_data.get('name',None)
            template = get_template('email/feedback_email.txt', request)
            message = template.render(RequestContext(request, data))
            mail_moderators(_('Q&A forum feedback'), message)
            msg = _('Thanks for the feedback!')
            request.user.message_set.create(message=msg)
            return render_into_skin("autoclose.html", data, request)
    else:
        form = FeedbackForm(is_auth = request.user.is_authenticated(),
                            initial={'next':get_next_url(request)})

    data['form'] = form
    return render_into_skin('feedback.html', data, request)
Пример #2
0
def faq(request):
    if getattr(askbot_settings, 'FORUM_FAQ',''):
        text = _(getattr(askbot_settings, 'FORUM_FAQ',''))
        data = {
            'gravatar_faq_url': reverse('faq') + '#gravatar',
            #'send_email_key_url': reverse('send_email_key'),
            'ask_question_url': reverse('ask'),
            'page_class': 'meta',
        }
        forum_faq = render_text_into_skin(text, data, request)
        data_out = {
            'gravatar_faq_url': reverse('faq') + '#gravatar',
            #'send_email_key_url': reverse('send_email_key'),
            'ask_question_url': reverse('ask'),
            'page_class': 'meta',
            'forum_faq' : forum_faq,
        }
        return render_into_skin('faq.html', data_out, request)
    data = {
        'gravatar_faq_url': reverse('faq') + '#gravatar',
        #'send_email_key_url': reverse('send_email_key'),
        'ask_question_url': reverse('ask'),
        'page_class': 'meta',
    }   
    return render_into_skin('faq_static.html', data, request)
Пример #3
0
def faq(request):
    if askbot_settings.FORUM_FAQ.strip() != "":
        data = {"title": _("FAQ"), "content": askbot_settings.FORUM_FAQ, "page_class": "meta"}
        return render_into_skin("static_page.html", data, request)
    else:
        data = {
            "gravatar_faq_url": reverse("faq") + "#gravatar",
            "ask_question_url": reverse("ask"),
            "page_class": "meta",
        }
        return render_into_skin("faq_static.html", data, request)
Пример #4
0
def faq(request):
    if askbot_settings.FORUM_FAQ.strip() != '':
        return render_into_skin(
            'static_page.html',
            {'title': _('FAQ'), 'content': askbot_settings.FORUM_FAQ},
            request
        )
    else:
        data = {
            'gravatar_faq_url': reverse('faq') + '#gravatar',
            'ask_question_url': reverse('ask'),
            'page_class': 'meta',
        }
        return render_into_skin('faq_static.html', data, request)
Пример #5
0
def user_tags(request, user, context):
    """a view showing users subscribed and ignored tags"""
    subscribed_tags = models.Tag.objects.filter(
                            user_selections__reason__contains = 'S',
                            user_selections__user = user
                        )
    ignored_tags = models.Tag.objects.filter(
                            user_selections__reason__contains = 'I',
                            user_selections__user = user
                        )
    favorite_tags = models.Tag.objects.filter(
                            user_selections__reason__contains = 'F',
                            user_selections__user = user
                        )
    strategy = user.email_tag_filter_strategy
    tag_subscription_status = dict(const.TAG_EMAIL_FILTER_STRATEGY_CHOICES)[strategy]
    data = {
        'tag_subscription_status': tag_subscription_status,
        'subscribed_tags': subscribed_tags,
        'subscribed_wildcards': user.get_selected_wildcard_tags('subscribed'),
        'ignored_tags': ignored_tags,
        'ignored_wildcards': user.get_selected_wildcard_tags('ignored'),
        'favorite_tags': favorite_tags,
        'favorite_wildcards': user.get_selected_wildcard_tags('followed'),
        'use_wildcards': askbot_settings.USE_WILDCARD_TAGS,
        'view_user': user
    }
    context.update(data)
    return render_into_skin('user_profile/user_tags.html', data, request)
Пример #6
0
def confirm(request, amount):
    """
    List of Questions, Tagged questions, and Unanswered questions.
    matching search query or user selection
    """
    if request.user.is_anonymous():
        request.user.message_set.create(message = unicode('您要先登入後才能購買iBon! <a href="/account/signin/?bext=/">立刻登入</a>'))
        return HttpResponseRedirect(reverse('index'))
    user=request.user
    comment = user.username+unicode('產生iBon購買條碼, 金額:')+unicode(amount)+unicode('元')
    transaction = Transaction(
                        user=user,
                        income=0,
                        outcome=0,
                        comment=comment,
                        #question = fake_question,
						invoice=False,
                        trans_at=datetime.datetime.now(),
                        transaction_type=twmodeconst.TYPE_TRANSACTION_BUY_IBON_ISSUE, #todo: fix magic number
                        balance=user.balance,
                        question_id=None
                    )

    transaction.save()
    
    template_data = {
        'Roturl': 'http://www.keepwin.com.tw/payment/Roturl/',
        'Data_id': transaction.id,             
        'amount':amount,
        'user':user,
        'ip':get_client_ip(request),
        }

        #return render_into_skin('main_page_twmode.html', template_data, request)
    return render_into_skin('payment_confirm.html', template_data, request)
Пример #7
0
def privacy(request):
    data = {
        'title': _('Privacy policy'),
        'page_class': 'meta',
        'content': askbot_settings.FORUM_PRIVACY
    }
    return render_into_skin('static_page.html', data, request)
Пример #8
0
def add(request, extra_context=None, next_override=None,
        upload_form=UploadAvatarForm, *args, **kwargs):
    if extra_context is None:
        extra_context = {}
    avatar, avatars = _get_avatars(request.user)
    upload_avatar_form = upload_form(request.POST or None,
        request.FILES or None, user=request.user)
    if request.method == "POST" and 'avatar' in request.FILES:
        if upload_avatar_form.is_valid():
            avatar = Avatar(
                user = request.user,
                primary = True,
            )
            image_file = request.FILES['avatar']
            avatar.avatar.save(image_file.name, image_file)
            avatar.save()
            request.user.message_set.create(
                message=_("Successfully uploaded a new avatar."))
            if notification:
                _notification_updated(request, avatar)
            return HttpResponseRedirect(next_override or _get_next(request))
    data = { 
        'avatar': avatar, 
        'avatars': avatars, 
        'upload_avatar_form': upload_avatar_form,
        'next': next_override or _get_next(request),
        'view_user': request.user,
        'page_class': 'avatar-page',
    }
    if extra_context:
        data.update(extra_context)

    return render_into_skin('avatar/add.html', data, request)
Пример #9
0
def delete(request, extra_context=None, next_override=None, *args, **kwargs):
    if extra_context is None:
        extra_context = {}
    avatar, avatars = _get_avatars(request.user)
    delete_avatar_form = DeleteAvatarForm(request.POST or None,
        user=request.user, avatars=avatars)
    if request.method == 'POST':
        if delete_avatar_form.is_valid():
            ids = delete_avatar_form.cleaned_data['choices']
            if unicode(avatar.id) in ids and avatars.count() > len(ids):
                # Find the next best avatar, and set it as the new primary
                for a in avatars:
                    if unicode(a.id) not in ids:
                        a.primary = True
                        a.save()
                        if notification:
                            _notification_updated(request, a)
                        break
            Avatar.objects.filter(id__in=ids).delete()
            request.user.message_set.create(
                message=_("Successfully deleted the requested avatars."))
            return HttpResponseRedirect(next_override or _get_next(request))
    data = {
        'avatar': avatar, 
        'avatars': avatars,
        'delete_avatar_form': delete_avatar_form,
        'next': next_override or _get_next(request),
        'view_user': request.user,
        'page_class': 'avatar-page',
    }
    if extra_context:
        data.update(extra_context)

    return render_into_skin('avatar/confirm_delete.html', data, request)
Пример #10
0
def import_data(request):
    """a view allowing the site administrator
    upload stackexchange data
    """
    #allow to use this view to site admins
    #or when the forum in completely empty
    if request.user.is_anonymous() or (not request.user.is_administrator()):
        if models.Post.objects.get_questions().exists():
            raise Http404

    if request.method == 'POST':
        #if not request.is_ajax():
        #    raise Http404

        form = forms.DumpUploadForm(request.POST, request.FILES)
        if form.is_valid():
            dump_file = form.cleaned_data['dump_file']
            dump_storage = tempfile.NamedTemporaryFile()

            #save the temp file
            for chunk in dump_file.chunks():
                dump_storage.write(chunk)
            dump_storage.flush()

            return HttpResponse(__import_se_data(dump_storage))
            #yield HttpResponse(_('StackExchange import complete.'), mimetype='text/plain')
            #dump_storage.close()
    else:
        form = forms.DumpUploadForm()

    data = {
        'dump_upload_form': form,
        'need_configuration': (not stackexchange.is_ready())
    }
    return render_into_skin('import_data.html', data, request)
Пример #11
0
def widgets(request):
    data = {
        'ask_widgets': models.AskWidget.objects.all().count(),
        'question_widgets': models.QuestionWidget.objects.all().count(),
        'page_class': 'widgets'
    }
    return render_into_skin('embed/widgets.html', data, request)
Пример #12
0
def question_widget(request, widget_id):
    """Returns the first x questions based on certain tags.
    @returns template with those questions listed."""
    # make sure this is a GET request with the correct parameters.
    widget = get_object_or_404(models.QuestionWidget, pk=widget_id)

    if request.method != 'GET':
        raise Http404

    filter_params = {}

    if widget.tagnames:
        filter_params['tags__name__in'] = widget.tagnames.split(' ')

    if widget.group:
        filter_params['groups'] = widget.group

    #simple title search for now
    if widget.search_query:
        filter_params['title__icontains'] = widget.search_query

    if filter_params:
        threads = models.Thread.objects.filter(**filter_params).order_by(
            widget.order_by)[:widget.question_number]
    else:
        threads = models.Thread.objects.all().order_by(
            widget.order_by)[:widget.question_number]

    data = {'threads': threads, 'widget': widget}

    return render_into_skin('embed/question_widget.html', data, request)
Пример #13
0
def edit_widget(request, model, widget_id):
    model_class = _get_model(model)
    form_class = _get_form(model)
    widget = get_object_or_404(model_class, pk=widget_id)
    if request.method == 'POST':
        form = form_class(request.POST)
        if form.is_valid():
            form_dict = dict.copy(form.cleaned_data)
            for key in widget.__dict__:
                if key.endswith('_id'):
                    form_key = key.split('_id')[0]
                    if form_dict[form_key]:
                        form_dict[key] = form_dict[form_key].id
                    del form_dict[form_key]
                else:
                    continue

            widget.__dict__.update(form_dict)
            widget.save()
            return redirect('list_widgets', model=model)
    else:
        initial_dict = dict.copy(widget.__dict__)
        for key in initial_dict:
            if key.endswith('_id'):
                new_key = key.split('_id')[0]
                initial_dict[new_key] = initial_dict[key]
                del initial_dict[key]
            else:
                continue

        del initial_dict['_state']
        form = form_class(initial=initial_dict)

    data = {'form': form, 'action': 'edit', 'widget_name': model}
    return render_into_skin('embed/widget_form.html', data, request)
Пример #14
0
def new_solution_form(request, mid, pid):
    exercise_post = models.Post.objects.filter(
                                post_type = 'exercise',
                                id = mid
                            ).select_related('thread')[0]

    problem_post = models.Post.objects.filter(
                                post_type = 'problem',
                                id = pid
                            ).select_related('thread')[0]
    thread = exercise_post.thread
    initial = {
        'wiki': exercise_post.wiki and askbot_settings.WIKI_ON,
        'email_notify': thread.is_followed_by(request.user)
    }
    solution_form = SolutionForm(initial)
    # if exercise doesn't exist, redirect to main page
    data = {
        'pid': pid,
        'mid': mid,
        'exercise': exercise_post,
        'problem': problem_post,
        'thread': thread,
        'solution_form': solution_form
        }
    return render_into_skin('exercise/solution_form.html', data, request)
Пример #15
0
def user_reputation(request, user, context):
    reputes = models.Repute.objects.filter(user=user).select_related(
        'question', 'question__thread', 'user').order_by('-reputed_at')

    # prepare data for the graph - last values go in first
    rep_list = [
        '[%s,%s]' % (calendar.timegm(datetime.datetime.now().timetuple()) *
                     1000, user.reputation)
    ]
    for rep in reputes:
        rep_list.append('[%s,%s]' %
                        (calendar.timegm(rep.reputed_at.timetuple()) * 1000,
                         rep.reputation))
    reps = ','.join(rep_list)
    reps = '[%s]' % reps

    data = {
        'active_tab': 'users',
        'page_class': 'user-profile-page',
        'tab_name': 'reputation',
        'tab_description': _('user karma'),
        'page_title': _("Profile - User's Karma"),
        'reputation': reputes,
        'reps': reps
    }
    context.update(data)
    return render_into_skin('user_profile/user_reputation.html', context,
                            request)
Пример #16
0
def validation_email_sent(request):
    """this function is called only if EMAIL_VALIDATION setting is
    set to True bolean value, basically dead now"""
    assert askbot_settings.EMAIL_VALIDATION == True
    logging.debug("")
    data = {"email": request.user.email, "change_email_url": reverse("user_changeemail"), "action_type": "validate"}
    return render_into_skin("authopenid/changeemail.html", data, request)
Пример #17
0
def send_email_key(request):
    """
    url = /email/sendkey/

    view that is shown right after sending email key
    email sending is called internally

    raises 404 if email validation is off
    if current email is valid shows 'key_not_sent' view of 
    authopenid/changeemail.html template
    """
    if askbot_settings.EMAIL_VALIDATION == True:
        if request.user.email_isvalid:
            data = {
                'email': request.user.email, 
                'action_type': 'key_not_sent', 
                'change_link': reverse('user_changeemail')
            }
            return render_into_skin(
                        'authopenid/changeemail.html',
                        data,
                        request
                    )
        else:
            send_new_email_key(request.user)
            return validation_email_sent(request)
    else:
        raise Http404
Пример #18
0
def add(request, extra_context=None, next_override=None,
        upload_form=UploadAvatarForm, *args, **kwargs):
    if extra_context is None:
        extra_context = {}
    avatar, avatars = _get_avatars(request.user)
    upload_avatar_form = upload_form(request.POST or None,
        request.FILES or None, user=request.user)
    if request.method == "POST" and 'avatar' in request.FILES:
        if upload_avatar_form.is_valid():
            avatar = Avatar(
                user = request.user,
                primary = True,
            )
            image_file = request.FILES['avatar']
            avatar.avatar.save(image_file.name, image_file)
            avatar.save()
            request.user.message_set.create(
                message=_("Successfully uploaded a new avatar."))
            if notification:
                _notification_updated(request, avatar)
            return HttpResponseRedirect(next_override or _get_next(request))
    data = { 
        'avatar': avatar, 
        'avatars': avatars, 
        'upload_avatar_form': upload_avatar_form,
        'next': next_override or _get_next(request),
        'view_user': request.user,
        'page_class': 'avatar-page',
    }
    if extra_context:
        data.update(extra_context)

    return render_into_skin('avatar/add.html', data, request)
Пример #19
0
def send_email_key(request):
    """
    url = /email/sendkey/

    view that is shown right after sending email key
    email sending is called internally

    raises 404 if email validation is off
    if current email is valid shows 'key_not_sent' view of 
    authopenid/changeemail.html template
    """
    if askbot_settings.EMAIL_VALIDATION == True:
        if request.user.email_isvalid:
            data = {
                'email': request.user.email,
                'action_type': 'key_not_sent',
                'change_link': reverse('user_changeemail')
            }
            return render_into_skin('authopenid/changeemail.html', data,
                                    request)
        else:
            send_new_email_key(request.user)
            return validation_email_sent(request)
    else:
        raise Http404
Пример #20
0
def retag_question(request, id):
    """retag question view
    """
    question = get_object_or_404(models.Question, id=id)

    try:
        request.user.assert_can_retag_question(question)
        if request.method == "POST":
            form = forms.RetagQuestionForm(question, request.POST)
            if form.is_valid():
                if form.has_changed():
                    request.user.retag_question(question=question, tags=form.cleaned_data["tags"])
                if request.is_ajax():
                    response_data = {"success": True, "new_tags": question.tagnames}
                    data = simplejson.dumps(response_data)
                    return HttpResponse(data, mimetype="application/json")
                else:
                    return HttpResponseRedirect(question.get_absolute_url())
            elif request.is_ajax():
                response_data = {"message": unicode(form.errors["tags"]), "success": False}
                data = simplejson.dumps(response_data)
                return HttpResponse(data, mimetype="application/json")
        else:
            form = forms.RetagQuestionForm(question)

        data = {"active_tab": "questions", "question": question, "form": form}
        return render_into_skin("question_retag.html", data, request)
    except exceptions.PermissionDenied, e:
        if request.is_ajax():
            response_data = {"message": unicode(e), "success": False}
            data = simplejson.dumps(response_data)
            return HttpResponse(data, mimetype="application/json")
        else:
            request.user.message_set.create(message=unicode(e))
            return HttpResponseRedirect(question.get_absolute_url())
Пример #21
0
def reopen(request, id):#re-open question
    """view to initiate and process
    question close

    this is not an ajax view
    """

    question = get_object_or_404(models.Post, post_type='question', id=id)
    # open question
    try:
        if request.method == 'POST' :
            request.user.reopen_question(question)
            return HttpResponseRedirect(question.get_absolute_url())
        else:
            request.user.assert_can_reopen_question(question)
            closed_by_profile_url = question.thread.closed_by.get_profile_url()
            closed_by_username = question.thread.closed_by.username
            data = {
                'question' : question,
                'closed_by_profile_url': closed_by_profile_url,
                'closed_by_username': closed_by_username,
            }
            return render_into_skin('reopen.html', data, request)

    except exceptions.PermissionDenied, e:
        request.user.message_set.create(message = unicode(e))
        return HttpResponseRedirect(question.get_absolute_url())
Пример #22
0
def close(request, id):#close question
    """view to initiate and process
    question close
    """
    question = get_object_or_404(models.Post, post_type='question', id=id)
    try:
        if request.method == 'POST':
            form = forms.CloseForm(request.POST)
            if form.is_valid():
                reason = form.cleaned_data['reason']

                request.user.close_question(
                                        question = question,
                                        reason = reason
                                    )
            return HttpResponseRedirect(question.get_absolute_url())
        else:
            request.user.assert_can_close_question(question)
            form = forms.CloseForm()
            data = {
                'question': question,
                'form': form,
            }
            return render_into_skin('close.html', data, request)
    except exceptions.PermissionDenied, e:
        request.user.message_set.create(message = unicode(e))
        return HttpResponseRedirect(question.get_absolute_url())
Пример #23
0
def about(request, template='about.html'):
    title = _('About %(site)s') % {'site': askbot_settings.APP_SHORT_NAME}
    data = {
        'title': title,
        'content': askbot_settings.FORUM_ABOUT
    }
    return render_into_skin('static_page.html', data, request)
Пример #24
0
def user_reputation(request, user):
    reputes = models.Repute.objects.filter(user=user).order_by("-reputed_at")
    # select_related() adds stuff needed for the query
    reputes = reputes.select_related("question__title", "question__id", "user__username")
    # prepare data for the graph
    rep_list = []
    # last values go in first
    rep_list.append("[%s,%s]" % (calendar.timegm(datetime.datetime.now().timetuple()) * 1000, user.reputation))
    # ret remaining values in
    for rep in reputes:
        dic = "[%s,%s]" % (calendar.timegm(rep.reputed_at.timetuple()) * 1000, rep.reputation)
        rep_list.append(dic)
    reps = ",".join(rep_list)
    reps = "[%s]" % reps

    data = {
        "active_tab": "users",
        "page_class": "user-profile-page",
        "tab_name": "reputation",
        "tab_description": _("user reputation in the community"),
        "page_title": _("profile - user reputation"),
        "view_user": user,
        "reputation": reputes,
        "reps": reps,
    }
    return render_into_skin("user_profile/user_reputation.html", data, request)
Пример #25
0
def user_votes(request, user, context):
    all_votes = list(models.Vote.objects.filter(user=user))
    votes = []
    for vote in all_votes:
        post = vote.voted_post
        if post.is_question():
            vote.title = post.thread.title
            vote.question_id = post.id
            vote.answer_id = 0
            votes.append(vote)
        elif post.is_answer():
            vote.title = post.thread.title
            vote.question_id = post.thread._question_post().id
            vote.answer_id = post.id
            votes.append(vote)

    votes.sort(key=operator.attrgetter("id"), reverse=True)

    data = {
        "active_tab": "users",
        "page_class": "user-profile-page",
        "tab_name": "votes",
        "tab_description": _("user vote record"),
        "page_title": _("profile - votes"),
        "votes": votes[: const.USER_VIEW_DATA_SIZE],
    }
    context.update(data)
    return render_into_skin("user_profile/user_votes.html", context, request)
Пример #26
0
def user_favorites(request, user, context):
    favorited_q_id_list = models.FavoriteQuestion.objects.filter(user=user).values_list("question__id", flat=True)
    questions = (
        models.Question.objects.filter(id__in=favorited_q_id_list)
        .order_by("-score", "-last_activity_at")
        .select_related(
            "last_activity_by__id",
            "last_activity_by__username",
            "last_activity_by__reputation",
            "last_activity_by__gold",
            "last_activity_by__silver",
            "last_activity_by__bronze",
        )[: const.USER_VIEW_DATA_SIZE]
    )
    data = {
        "active_tab": "users",
        "page_class": "user-profile-page",
        "tab_name": "favorites",
        "tab_description": _("users favorite questions"),
        "page_title": _("profile - favorite questions"),
        "questions": questions,
        "favorited_myself": favorited_q_id_list,
    }
    context.update(data)
    return render_into_skin("user_profile/user_favorites.html", context, request)
Пример #27
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())
Пример #28
0
def user_votes(request, user, context):
    all_votes = list(models.Vote.objects.filter(user=user))
    votes = []
    for vote in all_votes:
        post = vote.voted_post
        if post.is_question():
            vote.title = post.thread.title
            vote.question_id = post.id
            vote.answer_id = 0
            votes.append(vote)
        elif post.is_answer():
            vote.title = post.thread.title
            vote.question_id = post.thread._question_post().id
            vote.answer_id = post.id
            votes.append(vote)

    votes.sort(key=operator.attrgetter('id'), reverse=True)

    data = {
        'active_tab':'users',
        'page_class': 'user-profile-page',
        'tab_name' : 'votes',
        'tab_description' : _('user vote record'),
        'page_title' : _('profile - votes'),
        'votes' : votes[:const.USER_VIEW_DATA_SIZE]
    }
    context.update(data)
    return render_into_skin('user_profile/user_votes.html', context, request)
Пример #29
0
def privacy(request):
    data = {
        'title': _('Privacy policy'),
        'page_class': 'meta',
        'content': askbot_settings.FORUM_PRIVACY
    }
    return render_into_skin('static_page.html', data, request)
Пример #30
0
def exercise_widget(request, widget_id):
    """Returns the first x exercises based on certain tags.
    @returns template with those exercises listed."""
    # make sure this is a GET request with the correct parameters.
    widget = get_object_or_404(models.ExerciseWidget, pk=widget_id)

    if request.method != 'GET':
        raise Http404

    filter_params = {}

    if widget.tagnames:
        filter_params['tags__name__in'] = widget.tagnames.split(' ')

    if widget.group:
        filter_params['groups'] = widget.group

    #simple title search for now
    if widget.search_query:
        filter_params['title__icontains'] = widget.search_query

    if filter_params:
        threads = models.Thread.objects.filter(**filter_params).order_by(widget.order_by)[:widget.exercise_number]
    else:
        threads = models.Thread.objects.all().order_by(widget.order_by)[:widget.exercise_number]

    data = {
             'threads': threads,
             'widget': widget
           }

    return render_into_skin('embed/exercise_widget.html', data, request)
Пример #31
0
def widgets(request):
    data = {
        'ask_widgets': models.AskWidget.objects.all().count(),
        'exercise_widgets': models.ExerciseWidget.objects.all().count(),
        'page_class': 'widgets'
    }
    return render_into_skin('embed/widgets.html', data, request)
Пример #32
0
def user_votes(request, user, context):
    all_votes = list(models.Vote.objects.filter(user=user))
    votes = []
    for vote in all_votes:
        post = vote.voted_post
        if post.is_question():
            vote.title = post.thread.title
            vote.question_id = post.id
            vote.answer_id = 0
            votes.append(vote)
        elif post.is_answer():
            vote.title = post.thread.title
            vote.question_id = post.thread._question_post().id
            vote.answer_id = post.id
            votes.append(vote)

    votes.sort(key=operator.attrgetter('id'), reverse=True)

    data = {
        'active_tab': 'users',
        'page_class': 'user-profile-page',
        'tab_name': 'votes',
        'tab_description': _('user vote record'),
        'page_title': _('profile - votes'),
        'votes': votes[:const.USER_VIEW_DATA_SIZE]
    }
    context.update(data)
    return render_into_skin('user_profile/user_votes.html', context, request)
Пример #33
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())
Пример #34
0
def delete(request, extra_context=None, next_override=None, *args, **kwargs):
    if extra_context is None:
        extra_context = {}
    avatar, avatars = _get_avatars(request.user)
    delete_avatar_form = DeleteAvatarForm(request.POST or None,
        user=request.user, avatars=avatars)
    if request.method == 'POST':
        if delete_avatar_form.is_valid():
            ids = delete_avatar_form.cleaned_data['choices']
            if unicode(avatar.id) in ids and avatars.count() > len(ids):
                # Find the next best avatar, and set it as the new primary
                for a in avatars:
                    if unicode(a.id) not in ids:
                        a.primary = True
                        a.save()
                        if notification:
                            _notification_updated(request, a)
                        break
            Avatar.objects.filter(id__in=ids).delete()
            request.user.message_set.create(
                message=_("Successfully deleted the requested avatars."))
            return HttpResponseRedirect(next_override or _get_next(request))
    data = {
        'avatar': avatar, 
        'avatars': avatars,
        'delete_avatar_form': delete_avatar_form,
        'next': next_override or _get_next(request),
        'view_user': request.user,
        'page_class': 'avatar-page',
    }
    if extra_context:
        data.update(extra_context)

    return render_into_skin('avatar/confirm_delete.html', data, request)
Пример #35
0
def show_group_join_requests(request, user, context):
    """show group join requests to admins who belong to the group"""
    if request.user.is_administrator_or_moderator() is False:
        raise Http404

    #get group to which user belongs
    groups = request.user.get_groups()
    #construct a dictionary group id --> group object
    #to avoid loading group via activity content object
    groups_dict = dict([(group.id, group) for group in groups])

    #get join requests for those groups
    group_content_type = ContentType.objects.get_for_model(models.Group)
    join_requests = models.Activity.objects.filter(
                        activity_type=const.TYPE_ACTIVITY_ASK_TO_JOIN_GROUP,
                        content_type=group_content_type,
                        object_id__in=groups_dict.keys()
                    ).order_by('-active_at')
    data = {
        'active_tab':'users',
        'page_class': 'user-profile-page',
        'tab_name' : 'join_requests',
        'tab_description' : _('group joining requests'),
        'page_title' : _('profile - moderation'),
        'groups_dict': groups_dict,
        'join_requests': join_requests
    }
    context.update(data)
    return render_into_skin('user_inbox/group_join_requests.html', context, request)
Пример #36
0
def import_data(request):
    """a view allowing the site administrator
    upload stackexchange data
    """
    #allow to use this view to site admins
    #or when the forum in completely empty
    if request.user.is_anonymous() or (not request.user.is_administrator()):
        if models.Post.objects.get_questions().exists():
            raise Http404

    if request.method == 'POST':
        #if not request.is_ajax():
        #    raise Http404

        form = forms.DumpUploadForm(request.POST, request.FILES)
        if form.is_valid():
            dump_file = form.cleaned_data['dump_file']
            dump_storage = tempfile.NamedTemporaryFile()

            #save the temp file
            for chunk in dump_file.chunks():
                dump_storage.write(chunk)
            dump_storage.flush()

            return HttpResponse(__import_se_data(dump_storage))
            #yield HttpResponse(_('StackExchange import complete.'), mimetype='text/plain')
            #dump_storage.close()
    else:
        form = forms.DumpUploadForm()

    data = {
        'dump_upload_form': form,
        'need_configuration': (not stackexchange.is_ready())
    }
    return render_into_skin('import_data.html', data, request)
Пример #37
0
def user_favorites(request, user, context):
    favorited_q_id_list= models.FavoriteQuestion.objects.filter(
                                    user = user
                                ).values_list('question__id', flat=True)
    questions = models.Question.objects.filter(
                                    id__in=favorited_q_id_list
                                ).order_by(
                                    '-score', '-last_activity_at'
                                ).select_related(
                                    'last_activity_by__id',
                                    'last_activity_by__username',
                                    'last_activity_by__reputation',
                                    'last_activity_by__gold',
                                    'last_activity_by__silver',
                                    'last_activity_by__bronze'
                                )[:const.USER_VIEW_DATA_SIZE]
    data = {
        'active_tab':'users',
        'page_class': 'user-profile-page',
        'tab_name' : 'favorites',
        'tab_description' : _('users favorite questions'),
        'page_title' : _('profile - favorite questions'),
        'questions' : questions,
        'favorited_myself': favorited_q_id_list,
    }
    context.update(data)
    return render_into_skin('user_profile/user_favorites.html', context, request)
Пример #38
0
def user_reputation(request, user, context):
    reputes = (
        models.Repute.objects.filter(user=user)
        .select_related("question", "question__thread", "user")
        .order_by("-reputed_at")
    )

    # prepare data for the graph - last values go in first
    rep_list = ["[%s,%s]" % (calendar.timegm(datetime.datetime.now().timetuple()) * 1000, user.reputation)]
    for rep in reputes:
        rep_list.append("[%s,%s]" % (calendar.timegm(rep.reputed_at.timetuple()) * 1000, rep.reputation))
    reps = ",".join(rep_list)
    reps = "[%s]" % reps

    data = {
        "active_tab": "users",
        "page_class": "user-profile-page",
        "tab_name": "reputation",
        "tab_description": _("user reputation in the community"),
        "page_title": _("profile - user reputation"),
        "reputation": reputes,
        "reps": reps,
    }
    context.update(data)
    return render_into_skin("user_profile/user_reputation.html", context, request)
Пример #39
0
def list_widgets(request, model):
    model_class = _get_model(model)
    widgets = model_class.objects.all()
    data = {
            'widgets': widgets,
            'widget_name': model
           }
    return render_into_skin('embed/list_widgets.html', data, request)
Пример #40
0
def about(request, template='about.html'):
    title = _('About %(site)s') % {'site': askbot_settings.APP_SHORT_NAME}
    data = {
        'title': title,
        'page_class': 'meta',
        'content': askbot_settings.FORUM_ABOUT
    }
    return render_into_skin('static_page.html', data, request)
Пример #41
0
def faq(request):
    data = {
        'gravatar_faq_url': reverse('faq') + '#gravatar',
        #'send_email_key_url': reverse('send_email_key'),
        'ask_question_url': reverse('ask'),
        'page_class': 'meta',
    }
    return render_into_skin('faq.html', data, request)
Пример #42
0
def faq(request):
    data = {
        'gravatar_faq_url': reverse('faq') + '#gravatar',
        #'send_email_key_url': reverse('send_email_key'),
        'ask_question_url': reverse('ask'),
        'page_class': 'meta',
    }
    return render_into_skin('faq.html', data, request)
Пример #43
0
def users(request):
    is_paginated = True
    sortby = request.GET.get('sort', 'reputation')
    suser = request.REQUEST.get('query', "")
    try:
        page = int(request.GET.get('page', '1'))
    except ValueError:
        page = 1

    if suser == "":
        if sortby == "newest":
            order_by_parameter = '-date_joined'
        elif sortby == "last":
            order_by_parameter = 'date_joined'
        elif sortby == "user":
            order_by_parameter = 'username'
        else:
            # default
            order_by_parameter = '-reputation'

        objects_list = Paginator(
            models.User.objects.all().order_by(order_by_parameter),
            const.USERS_PAGE_SIZE)
        base_url = reverse('users') + '?sort=%s&' % sortby
    else:
        sortby = "reputation"
        objects_list = Paginator(
            models.User.objects.filter(
                username__icontains=suser).order_by('-reputation'),
            const.USERS_PAGE_SIZE)
        base_url = reverse('users') + '?name=%s&sort=%s&' % (suser, sortby)

    try:
        users_page = objects_list.page(page)
    except (EmptyPage, InvalidPage):
        users_page = objects_list.page(objects_list.num_pages)

    paginator_data = {
        'is_paginated': is_paginated,
        'pages': objects_list.num_pages,
        'page': page,
        'has_previous': users_page.has_previous(),
        'has_next': users_page.has_next(),
        'previous': users_page.previous_page_number(),
        'next': users_page.next_page_number(),
        'base_url': base_url
    }
    paginator_context = extra_tags.cnprog_paginator(paginator_data)
    data = {
        'active_tab': 'users',
        'page_class': 'users-page',
        'users': users_page,
        'suser': suser,
        'keywords': suser,
        'tab_id': sortby,
        'paginator_context': paginator_context
    }
    return render_into_skin('users.html', data, request)
Пример #44
0
def delete_widget(request, model, widget_id):
    model_class = _get_model(model)
    widget = get_object_or_404(model_class, pk=widget_id)
    if request.method == "POST":
        widget.delete()
        return redirect('list_widgets', model=model)
    else:
        return render_into_skin('embed/delete_widget.html',
                {'widget': widget, 'widget_name': model}, request)
Пример #45
0
def faq(request):
    if askbot_settings.FORUM_FAQ.strip() != '':
        data = {
            'title': _('FAQ'),
            'content': askbot_settings.FORUM_FAQ,
            'page_class': 'meta',
        }
        return render_into_skin(
            'static_page.html',
            data,
            request
        )
    else:
        data = {
            'gravatar_faq_url': reverse('faq') + '#gravatar',
            'ask_question_url': reverse('ask'),
            'page_class': 'meta',
        }
        return render_into_skin('faq_static.html', data, request)
Пример #46
0
def user_network(request, user, context):
    if 'followit' not in django_settings.INSTALLED_APPS:
        raise Http404
    data = {
        'tab_name': 'network',
        'followed_users': user.get_followed_users(),
        'followers': user.get_followers(),
    }
    context.update(data)
    return render_into_skin('user_profile/user_network.html', context, request)
Пример #47
0
def groups(request, id=None, slug=None):
    """output groups page
    """
    if askbot_settings.GROUPS_ENABLED == False:
        raise Http404
    groups = models.Tag.group_tags.get_all()
    can_edit = request.user.is_authenticated() and \
            request.user.is_administrator_or_moderator()
    data = {'groups': groups, 'can_edit': can_edit, 'active_tab': 'users'}
    return render_into_skin('groups.html', data, request)
Пример #48
0
def edit_answer(request, id):
    answer = get_object_or_404(models.Answer, id=id)
    try:
        request.user.assert_can_edit_answer(answer)
        latest_revision = answer.get_latest_revision()
        if request.method == "POST":
            if 'select_revision' in request.POST:
                # user has changed revistion number
                revision_form = forms.RevisionForm(
                                                answer, 
                                                latest_revision,
                                                request.POST
                                            )
                if revision_form.is_valid():
                    # Replace with those from the selected revision
                    rev = revision_form.cleaned_data['revision']
                    selected_revision = models.AnswerRevision.objects.get(
                                                            answer = answer,
                                                            revision = rev
                                                        )
                    form = forms.EditAnswerForm(answer, selected_revision)
                else:
                    form = forms.EditAnswerForm(
                                            answer,
                                            latest_revision,
                                            request.POST
                                        )
            else:
                form = forms.EditAnswerForm(answer, latest_revision, request.POST)
                revision_form = forms.RevisionForm(answer, latest_revision)

                if form.is_valid():
                    if form.has_changed():
                        request.user.edit_answer(
                                answer = answer,
                                body_text = form.cleaned_data['text'],
                                revision_comment = form.cleaned_data['summary'],
                                wiki = form.cleaned_data.get('wiki', answer.wiki),
                                #todo: add wiki field to form
                            )
                    return HttpResponseRedirect(answer.get_absolute_url())
        else:
            revision_form = forms.RevisionForm(answer, latest_revision)
            form = forms.EditAnswerForm(answer, latest_revision)
        data = {
            'active_tab': 'questions',
            'answer': answer,
            'revision_form': revision_form,
            'form': form,
        }
        return render_into_skin('answer_edit.html', data, request)

    except exceptions.PermissionDenied, e:
        request.user.message_set.create(message = unicode(e))
        return HttpResponseRedirect(answer.get_absolute_url())
Пример #49
0
def validation_email_sent(request):
    """this function is called only if EMAIL_VALIDATION setting is
    set to True bolean value, basically dead now"""
    assert (askbot_settings.EMAIL_VALIDATION == True)
    logging.debug('')
    data = {
        'email': request.user.email,
        'change_email_url': reverse('user_changeemail'),
        'action_type': 'validate'
    }
    return render_into_skin('authopenid/changeemail.html', data, request)
Пример #50
0
def tags(request):  #view showing a listing of available tags - plain list
    stag = ""
    is_paginated = True
    sortby = request.GET.get('sort', 'used')
    try:
        page = int(request.GET.get('page', '1'))
    except ValueError:
        page = 1

    if request.method == "GET":
        stag = request.GET.get("query", "").strip()
        if stag != '':
            objects_list = Paginator(
                models.Tag.objects.filter(
                    deleted=False, name__icontains=stag).exclude(used_count=0),
                DEFAULT_PAGE_SIZE)
        else:
            if sortby == "name":
                objects_list = Paginator(
                    models.Tag.objects.all().filter(deleted=False).exclude(
                        used_count=0).order_by("name"), DEFAULT_PAGE_SIZE)
            else:
                objects_list = Paginator(
                    models.Tag.objects.all().filter(deleted=False).exclude(
                        used_count=0).order_by("-used_count"),
                    DEFAULT_PAGE_SIZE)

    try:
        tags = objects_list.page(page)
    except (EmptyPage, InvalidPage):
        tags = objects_list.page(objects_list.num_pages)

    paginator_data = {
        'is_paginated': is_paginated,
        'pages': objects_list.num_pages,
        'page': page,
        'has_previous': tags.has_previous(),
        'has_next': tags.has_next(),
        'previous': tags.previous_page_number(),
        'next': tags.next_page_number(),
        'base_url': reverse('tags') + '?sort=%s&amp;' % sortby
    }
    paginator_context = extra_tags.cnprog_paginator(paginator_data)
    data = {
        'active_tab': 'tags',
        'page_class': 'tags-page',
        'tags': tags,
        'stag': stag,
        'tab_id': sortby,
        'keywords': stag,
        'paginator_context': paginator_context
    }
    return render_into_skin('tags.html', data, request)
Пример #51
0
def retag_question(request, id):
    """retag question view
    """
    question = get_object_or_404(models.Post, id=id)

    try:
        request.user.assert_can_retag_question(question)
        if request.method == 'POST':
            form = forms.RetagQuestionForm(question, request.POST)

            if form.is_valid():
                if form.has_changed():
                    request.user.retag_question(question=question,
                                                tags=form.cleaned_data['tags'])
                if request.is_ajax():
                    response_data = {
                        'success': True,
                        'new_tags': question.thread.tagnames
                    }

                    if request.user.message_set.count() > 0:
                        #todo: here we will possibly junk messages
                        message = request.user.get_and_delete_messages()[-1]
                        response_data['message'] = message

                    data = simplejson.dumps(response_data)
                    return HttpResponse(data, mimetype="application/json")
                else:
                    return HttpResponseRedirect(question.get_absolute_url())
            elif request.is_ajax():
                response_data = {
                    'message': format_errors(form.errors['tags']),
                    'success': False
                }
                data = simplejson.dumps(response_data)
                return HttpResponse(data, mimetype="application/json")
        else:
            form = forms.RetagQuestionForm(question)

        data = {
            'active_tab': 'questions',
            'question': question,
            'form': form,
        }
        return render_into_skin('question_retag.html', data, request)
    except exceptions.PermissionDenied, e:
        if request.is_ajax():
            response_data = {'message': unicode(e), 'success': False}
            data = simplejson.dumps(response_data)
            return HttpResponse(data, mimetype="application/json")
        else:
            request.user.message_set.create(message=unicode(e))
            return HttpResponseRedirect(question.get_absolute_url())
Пример #52
0
def edit_solution(request, id):
    solution = get_object_or_404(models.Post, id=id)
    revision = solution.get_latest_revision()
    try:
        request.user.assert_can_edit_solution(solution)
        if request.method == "POST":
            if request.POST['select_revision'] == 'true':
                # user has changed revistion number
                revision_form = forms.RevisionForm(solution, revision,
                                                   request.POST)
                if revision_form.is_valid():
                    # Replace with those from the selected revision
                    rev = revision_form.cleaned_data['revision']
                    revision = solution.revisions.get(revision=rev)
                    form = forms.EditProblemForm(solution, revision)
                else:
                    form = forms.EditProblemForm(solution, revision,
                                                 request.POST)
            else:
                form = forms.EditProblemForm(solution, revision, request.POST)
                revision_form = forms.RevisionForm(solution, revision)

                if form.is_valid():
                    if form.has_changed():
                        user = form.get_post_user(request.user)
                        user.edit_solution(
                            solution=solution,
                            body_text=form.cleaned_data['text'],
                            revision_comment=form.cleaned_data['summary'],
                            wiki=form.cleaned_data.get('wiki', solution.wiki),
                            is_private=form.cleaned_data.get(
                                'is_private', False)
                            #todo: add wiki field to form
                        )
                    return HttpResponseRedirect(solution.get_absolute_url())
        else:
            revision_form = forms.RevisionForm(solution, revision)
            form = forms.EditProblemForm(solution, revision)
            if request.user.can_make_group_private_posts():
                form.initial['post_privately'] = solution.is_private()
        data = {
            'page_class': 'edit-problem-page',
            'active_tab': 'exercises',
            'solution': solution,
            'revision': revision,
            'revision_form': revision_form,
            'form': form,
        }
        return render_into_skin('solution_edit.html', data, request)

    except exceptions.PermissionDenied, e:
        request.user.message_set.create(message=unicode(e))
        return HttpResponseRedirect(solution.get_absolute_url())
Пример #53
0
def ask_widget_complete(request):
    exercise_url = request.session.get('widget_exercise_url')
    custom_css = request.session.get('widget_css')
    if exercise_url:
        del request.session['widget_exercise_url']
    else:
        exercise_url = '#'

    if custom_css:
        del request.session['widget_css']

    data = {'exercise_url': exercise_url, 'custom_css': custom_css}
    return render_into_skin('embed/ask_widget_complete.html', data, request)
Пример #54
0
def cats(request):
    """
    View that renders a simple page showing the categories tree widget.
    It uses JSON to send tree data in the context to the client.
    """
    if askbot_settings.ENABLE_CATEGORIES:
        return render_into_skin(
            'categories.html',
            {'cats_tree':simplejson.dumps(generate_tree())},
            request
        )
    else:
        raise Http404
Пример #55
0
def logout(request):  #refactor/change behavior?
    #currently you click logout and you get
    #to this view which actually asks you again - do you really want to log out?
    #I guess rationale was to tell the user that s/he may be still logged in
    #through their external login sytem and we'd want to remind them about it
    #however it might be a little annoying
    #why not just show a message: you are logged out of forum, but
    #if you really want to log out -> go to your openid provider
    data = {
        'next': get_next_url(request),
        'page_class': 'meta',
    }
    return render_into_skin('logout.html', data, request)
Пример #56
0
def user_email_subscriptions(request, user, context):

    logging.debug(get_request_info(request))
    if request.method == 'POST':
        email_feeds_form = forms.EditUserEmailFeedsForm(request.POST)
        tag_filter_form = forms.TagFilterSelectionForm(request.POST, instance=user)
        if email_feeds_form.is_valid() and tag_filter_form.is_valid():

            action_status = None
            tag_filter_saved = tag_filter_form.save()
            if tag_filter_saved:
                action_status = _('changes saved')
            if 'save' in request.POST:
                feeds_saved = email_feeds_form.save(user)
                if feeds_saved:
                    action_status = _('changes saved')
            elif 'stop_email' in request.POST:
                email_stopped = email_feeds_form.reset().save(user)
                initial_values = forms.EditUserEmailFeedsForm.NO_EMAIL_INITIAL
                email_feeds_form = forms.EditUserEmailFeedsForm(initial=initial_values)
                if email_stopped:
                    action_status = _('email updates canceled')
    else:
        #user may have been created by some app that does not know
        #about the email subscriptions, in that case the call below
        #will add any subscription settings that are missing
        #using the default frequencies
        user.add_missing_askbot_subscriptions()

        #initialize the form
        email_feeds_form = forms.EditUserEmailFeedsForm()
        email_feeds_form.set_initial_values(user)
        tag_filter_form = forms.TagFilterSelectionForm(instance=user)
        action_status = None

    data = {
        'active_tab': 'users',
        'page_class': 'user-profile-page',
        'tab_name': 'email_subscriptions',
        'tab_description': _('email subscription settings'),
        'page_title': _('profile - email subscriptions'),
        'email_feeds_form': email_feeds_form,
        'tag_filter_selection_form': tag_filter_form,
        'action_status': action_status,
    }
    context.update(data)
    return render_into_skin(
        'user_profile/user_email_subscriptions.html',
        context,
        request
    )
Пример #57
0
def edit_user(request, id):
    """View that allows to edit user profile.
    This view is accessible to profile owners or site administrators
    """
    user = get_object_or_404(models.User, id=id)
    if not(request.user == user or request.user.is_superuser):
        raise Http404
    if request.method == "POST":
        form = forms.EditUserForm(user, request.POST)
        if form.is_valid():
            new_email = sanitize_html(form.cleaned_data['email'])

            set_new_email(user, new_email)

            if askbot_settings.EDITABLE_SCREEN_NAME:
                new_username = sanitize_html(form.cleaned_data['username'])
                if user.username != new_username:
                    group = user.get_personal_group()
                    user.username = new_username
                    group.name = format_personal_group_name(user)
                    group.save()

            user.real_name = sanitize_html(form.cleaned_data['realname'])
            user.website = sanitize_html(form.cleaned_data['website'])
            user.location = sanitize_html(form.cleaned_data['city'])
            user.date_of_birth = form.cleaned_data.get('birthday', None)
            user.about = sanitize_html(form.cleaned_data['about'])
            user.country = form.cleaned_data['country']
            user.show_country = form.cleaned_data['show_country']
            user.show_marked_tags = form.cleaned_data['show_marked_tags']
            user.save()
            # send user updated signal if full fields have been updated
            award_badges_signal.send(None,
                            event = 'update_user_profile',
                            actor = user,
                            context_object = user
                        )
            return HttpResponseRedirect(user.get_profile_url())
    else:
        form = forms.EditUserForm(user)

    data = {
        'active_tab': 'users',
        'page_class': 'user-profile-edit-page',
        'form' : form,
        'marked_tags_setting': askbot_settings.MARKED_TAGS_ARE_PUBLIC_WHEN,
        'support_custom_avatars': ('avatar' in django_settings.INSTALLED_APPS),
        'view_user': user,
    }
    return render_into_skin('user_profile/user_edit.html', data, request)
Пример #58
0
def badge(request, id):
    #todo: supplement database data with the stuff from badges.py
    badge = get_object_or_404(BadgeData, id=id)
    badge_recipients = User.objects.filter(award_user__badge=badge).annotate(
        last_awarded_at=Max('award_user__awarded_at'),
        award_count=Count('award_user')).order_by('-last_awarded_at')

    data = {
        'active_tab': 'badges',
        'badge_recipients': badge_recipients,
        'badge': badge,
        'page_class': 'meta',
    }
    return render_into_skin('badge.html', data, request)