Example #1
0
def user_edit(request, uid):
    "User's profile page"
    user = models.User.objects.select_related('profile').get(id=uid)
    
    if not user.profile.editable(request.user):
        messages.error(request, "unable to edit this user")
        return html.redirect("/user/show/%s/" % uid)
        
    if request.method == 'GET':
        initial = dict(
            display_name = user.profile.display_name,
            email      = user.email or '',
            location   = user.profile.location or '',
            website    = user.profile.website or '',
            about_me   = user.profile.about_me or ''
        )
        form = UserForm(initial)
        return html.template(request, name='user.edit.html', user=user, form=form)
    elif request.method == 'POST':
        
        form = UserForm(request.POST)
        if not form.is_valid():
            return html.template(request, name='user.edit.html', user=user, form=form)
        else:
            for field in "display_name about_me website location".split():
                setattr(user.profile, field, form.cleaned_data[field])
            user.email = form.cleaned_data['email']
            user.profile.save()
            user.save()
            return html.redirect("/user/show/%s/" % user.id)
Example #2
0
def new_post(request, pid=0, post_type=POST_QUESTION):
    "Handles the creation of a new post"
    
    user   = request.user
    name   = "post.edit.html"
    parent = models.Post.objects.get(pk=pid) if pid else None
    root   = parent.root if parent else None
    toplevel = (pid == 0)
    factory  = formdef.ChildContent if pid else formdef.TopLevelContent
    
    params = html.Params(tab='new', title="New post", toplevel=toplevel)
    
    if request.method == 'GET':
        # no incoming data, render form
        form = factory()
        return html.template(request, name=name, form=form, params=params)
    
    # process the incoming data
    assert request.method == 'POST', "Method=%s" % request.method
    
    form = factory(request.POST)
    if not form.is_valid():
        # returns with an error message
        return html.template(request, name=name, form=form, params=params)

    # form is valid at this point, create the post
    params = dict(author=user, type=post_type, parent=parent, root=root)
    params.update(form.cleaned_data)
    
    with transaction.commit_on_success():
        post = models.Post.objects.create(**params)
        post.set_tags()
        post.save()
    return redirect(post)
Example #3
0
def new_post(request, pid=0, post_type=POST_QUESTION):
    "Handles the creation of a new post"
    
    user   = request.user
    name   = "post.edit.html"
    parent = models.Post.objects.get(pk=pid) if pid else None
    root   = parent.root if parent else None
    toplevel = (pid == 0)
    factory  = formdef.ChildContent if pid else formdef.TopLevelContent

    params = html.Params(tab='new', title="New post", toplevel=toplevel)
    
    if request.method == 'GET':
        # no incoming data, render form
        form = factory()
        return html.template(request, name=name, form=form, params=params)
    
    # process the incoming data
    assert request.method == 'POST', "Method=%s" % request.method

    form = factory(request.POST)

    # throttle new users to no more than 3 posts per 2 hours
    MIN_AGE, MIN_COUNT = 6, 2
    brand_new = (datetime.now() - user.date_joined) < timedelta(hours=MIN_AGE)
    too_many = models.Post.objects.filter(author=user).count() >= MIN_COUNT

    if brand_new and too_many:
        messages.error(request, "Brand new users (accounts less than 6 hours old) may not create more than 2 posts. Apologies \
            if that interferes with your usage, it is an anti-spam measure. Gives us a chance to ban the spamming bots")
        return html.template(request, name=name, form=form, params=params)

    if not form.is_valid():
        # returns with an error message
        return html.template(request, name=name, form=form, params=params)

    # form is valid at this point, create the post
    params = dict(author=user, type=post_type, parent=parent, root=root)

    # form may contain a variable number of elements
    for attr in "title content tag_val type".split():
        if attr in form.cleaned_data:
            params[attr] = form.cleaned_data[attr]

    with transaction.commit_on_success():
        post = models.Post.objects.create(**params)
        post.set_tags()
        #post.save()

    return redirect(post)
Example #4
0
def badge_show(request, bid):
    "Shows users that have earned a certain badge"
    page = None
    badge  = models.Badge.objects.get(id=bid)
    awards = models.Award.objects.filter(badge=badge).select_related('user', 'user_profile').order_by("-date")
    page  = get_page(request, awards, per_page=24)
    return html.template(request, name='badge.show.html', page=page, badge=badge)
Example #5
0
def more(request, pid):
    counts = request.session.get(SESSION_POST_COUNT, {})
    form = SearchForm()
    params = html.Params(tab='search', q="", sort='')
    res = more_like_this(request=request, pid=pid)
    page = get_page(request, res, per_page=10)
    return html.template(request, name='search.html', page=page, params=params, counts=counts, form=form)
Example #6
0
def post_show(request, pid):
    "Returns a question with all answers"
    
    qs = models.Post.objects
    question = qs.select_related('children', 'votes').get(id=pid)
        
    #qs = models.Post.all_objects if 'view_deleted' in request.permissions else models.Post.objects
    answers = models.Post.objects.filter(parent=question, post_type=POST_ANSWER).select_related('author', 'author__profile') 
    answers = answers.order_by('-answer_accepted','-score')

    if request.user.is_authenticated():
        notes = models.Note.objects.filter(target=request.user, post=question).all().delete()
        votes = models.Vote.objects.filter(author=request.user, post__id__in=[ question.id ] + [a.id for a in answers] ) 
        
        # updates the viewcounter once within a session, Alex says to move to IP based counting TODO
        viewed = request.session.get(VIEWED_KEY, set())
        if question.id not in viewed:
            viewed.add(question.id)
            question.views += 1
            question.save()
            request.session[VIEWED_KEY] = viewed
    else:
        notes, votes = [], []
        
        
    up_votes = set(vote.post.id for vote in votes if vote.type == const.VOTE_UP)
    down_votes = set(vote.post.id for vote in votes if vote.type == const.VOTE_DOWN)
     
    return html.template( request, name='post.show.html', question=question, answers=answers, up_votes=up_votes, down_votes=down_votes )
Example #7
0
def question_unanswered(request, uid=0, post_type=None):
    "Lists all the questions"
    params = html.Params()
    params.setr('Filter: unanswered')
    qs = get_posts(request).filter(answer_count=0)
    page = get_page(request, qs) 
    return html.template(request, name='post.list.html', page=page, params=params)
Example #8
0
def show_tag(request, tag_name=None):
    "Display posts by a certain tag"
    user = request.user
    # populate the session data
    sess = middleware.Session(request)
    
    # get the sort order
    sort_type = sess.sort_order()
    
    # select based on history
    tab, pill = "posts", sess.get_tab()
    
    params = html.Params(nav='', tab=tab, sort='' )
    
    # the params object will carry
    layout = settings.USER_PILL_BAR if auth else settings.ANON_PILL_BAR
    
    # wether to show the type of the post
    params  = html.Params(tab=tab, pill=pill, sort=sort_type, sort_choices=SORT_CHOICES, layout=layout, title="Tagged as %s" % tag_name)
    
    msg = 'Filtering by tag: <b>%s</b>. Subscribe to an <a href="/feeds/tag/%s/">RSS feed</a> to this tag.' % (tag_name,tag_name)
    messages.info(request, msg)
    posts = models.query_by_tags(user=user, text=tag_name)
    posts = apply_sort(request=request, posts=posts, order=sort_type)
    page  = get_page(request, posts, per_page=20)

    return html.template( request, name='index.html', page=page, params=params)
Example #9
0
def main(request):
    "Main search"
    counts = request.session.get(SESSION_POST_COUNT, {})

    q = request.GET.get('q', '')  # query
    t = request.GET.get('t', 'all')  # type

    params = html.Params(tab='search', q=q, sort='', t=t)
    subset = get_subset(t)

    if params.q:
        form = SearchForm(request.GET)
        results = search_results(request=request, text=params.q, subset=subset)
        posts = Post.objects.filter(id__in=[row['pid']
                                            for row in results]).exclude(
                                                status=POST_DELETED)
        for post, row in zip(posts, results):
            post.context = row['content']

        #size = len(results)
        #messages.info(request, 'Searched results for: %s found %d results' % (params.q, size))

    else:
        form = SearchForm()
        res = []
        objects = []

    page = get_page(request, posts, per_page=25)
    return html.template(request,
                         name='search.html',
                         page=page,
                         params=params,
                         counts=counts,
                         form=form)
Example #10
0
def request_info(request, pid):
    "Requests information from a source"
    user = request.user
    post = models.Post.objects.get(id=pid)
    
    params = html.Params(site_domain = settings.SITE_DOMAIN, user=user, post=post)
    params.subject = "Your expert advice is needed at Biostar"
    
    if user.is_authenticated():
        params.display_name, score = user.profile.display_name, user.profile.score
    else:
        params.display_name, score = "Anonymous", 0
    
    params.body = html.fill(name='pages/request-info.txt', params=params)
     
    LIMIT = 5
    disabled = score < LIMIT
    
    if disabled:
        messages.error(request, "Note: users with fewer than %s reputation points may not send messages via Biostar. You have %s points" % (LIMIT, score))
    elif 'submit' in request.POST:
        form = formdef.RequestInfo(request.POST) 
        if form.is_valid():
            send_mail(subject=params.subject, from_email=settings.DEFAULT_FROM_EMAIL, message=params.body, recipient_list=[settings.DEFAULT_FROM_EMAIL, form.cleaned_data['email']], fail_silently=False)
            messages.info(request, "Your message has been sent.")
            return html.redirect( post.get_absolute_url() )
        else:
           messages.error(request, "%s" % form.errors) 
        
    return html.template(request, name='pages/request-info.html', params=params)
Example #11
0
def main(request):
    "Main search"
    counts = request.session.get(SESSION_POST_COUNT, {})
    
    q = request.GET.get('q','') # query
    t = request.GET.get('t','all')  # type
    
    params = html.Params(tab='search', q=q, sort='', t=t)
    subset = get_subset(t)
   
    if params.q:
        form = SearchForm(request.GET)
        results  = search_results(request=request, text=params.q, subset=subset)
        posts = Post.objects.filter(id__in=[row['pid'] for row in results]).exclude(status=POST_DELETED)
        for post, row in zip(posts, results):
            post.context = row['content']

        #size = len(results)
        #messages.info(request, 'Searched results for: %s found %d results' % (params.q, size))

    else:
        form = SearchForm()
        res  = []
        objects = []

    page = get_page(request, posts, per_page=25)
    return html.template(request, name='search.html', page=page, params=params, counts=counts, form=form)
Example #12
0
def user_profile(request, uid):
    "User's profile page"

    user = request.user
    target  = models.User.objects.get(id=uid)
    
    if target == user:
        notes = models.Note.objects.filter(target=target).select_related('author', 'author__profile', 'root').order_by('-date')
        page  = get_page(request, notes, per_page=10)
        # we evalute it here so that subsequent status updates won't interfere
        page.object_list = list(page.object_list)
        models.Note.objects.filter(target=target).update(unread=False)
    else:
        page = None

    # we need to collate and count the awards
    awards = models.Award.objects.filter(user=target).select_related('badge').order_by('-date')
    
    answer_count = models.Post.objects.filter(author=target, post_type=POST_ANSWER).count()
    question_count = models.Post.objects.filter(author=target, post_type=POST_QUESTION).count()
    comment_count = models.Post.objects.filter(author=target, post_type=POST_COMMENT).count()
    post_count = models.Post.objects.filter(author=target).count()
    vote_count = models.Vote.objects.filter(author=target).count()
    award_count = models.Award.objects.filter(user=target).count()
    
    params = html.Params(question_count=question_count, answer_count=answer_count, 
        comment_count=comment_count, post_count=post_count, vote_count=vote_count, award_count=award_count)
    
    # it the target personal information writable
    target.editable   = target.profile.editable(user)
    target.authorized = target.profile.authorize(user)
    return html.template(request, name='user.profile.html', awards=awards,
        user=request.user,target=target, params=params, page=page)
Example #13
0
def main(request):
    "Main search"
    counts = request.session.get(SESSION_POST_COUNT, {})

    q = request.GET.get('q', '')  # query
    t = request.GET.get('t', 'all')  # type

    params = html.Params(tab='search', q=q, sort='')
    subset = get_subset(t)

    if params.q:
        form = SearchForm(request.GET)
        res = search_results(request=request, text=params.q, subset=subset)
        size = len(res)
        messages.info(
            request,
            'Searched results for: %s found %d results' % (params.q, size))
    else:
        form = SearchForm()
        res = []

    page = get_page(request, res, per_page=10)
    return html.template(request,
                         name='search.html',
                         page=page,
                         params=params,
                         counts=counts,
                         form=form)
Example #14
0
def request_info(request, pid):
    "Requests information from a source"
    user = request.user
    post = models.Post.objects.get(id=pid)
    
    params = html.Params(site_domain = settings.SITE_DOMAIN, user=user, post=post)
    params.subject = "Your expert advice is needed at Biostar"
    
    if user.is_authenticated():
        params.display_name, score = user.profile.display_name, user.profile.score
    else:
        params.display_name, score = "Anonymous", 0
    
    params.body = html.fill(name='pages/request-info.txt', params=params)
     
    LIMIT = 5
    disabled = score < LIMIT
    
    if disabled:
        messages.error(request, "Note: users with fewer than %s reputation points may not send messages via Biostar. You have %s points" % (LIMIT, score))
    elif 'submit' in request.POST:
        form = formdef.RequestInfo(request.POST) 
        if form.is_valid():
            send_mail(subject=params.subject, from_email=settings.DEFAULT_FROM_EMAIL, message=params.body, recipient_list=[settings.DEFAULT_FROM_EMAIL, form.cleaned_data['email']], fail_silently=False)
            messages.info(request, "Your message has been sent.")
            return html.redirect( post.get_absolute_url() )
        else:
           messages.error(request, "%s" % form.errors) 
        
    return html.template(request, name='pages/request-info.html', params=params)
Example #15
0
def about(request):
    "Renders the about page"

    post_count = models.Post.objects.filter(status=POST_OPEN).count()
    question_count = models.Post.objects.filter(status=POST_OPEN,
                                                type=POST_QUESTION).count()
    answer_count = models.Post.objects.filter(status=POST_OPEN,
                                              type=POST_ANSWER).count()
    comment_count = models.Post.objects.filter(status=POST_OPEN,
                                               type=POST_COMMENT).count()
    user_count = models.User.objects.filter(
        profile__status=USER_ACTIVE).count()

    mods = models.User.objects.filter(
        profile__type=USER_MODERATOR).select_related("profile").order_by(
            '-profile__score').all()
    admins = models.User.objects.filter(
        profile__type=USER_ADMIN).select_related("profile").order_by(
            '-profile__score').all()
    managers = models.User.objects.filter(
        email=settings.ADMINS[0][1]).select_related("profile").order_by(
            '-profile__score').all()
    navloc = dict(about="active")
    params = html.Params(nav='about',
                         post_count=post_count,
                         user_count=user_count,
                         question_count=question_count,
                         answer_count=answer_count,
                         comment_count=comment_count,
                         admins=admins,
                         mods=mods,
                         navloc=navloc,
                         managers=managers)

    return html.template(request, name='pages/about.html', params=params)
Example #16
0
def show_user(request, uid, post_type=''):
    "Displays posts by a user"

    user = models.User.objects.filter(
        id=uid).select_related('profile').all()[0]
    params = html.Params(nav='',
                         tab='user',
                         sort='',
                         title="Activity for user %s" %
                         user.profile.display_name)

    # notification
    messages.info(request, 'Filtering by user: %s' % user.profile.display_name)

    post_type = POST_REV_MAP.get(post_type.lower())
    if post_type:
        posts = get_post_manager(request).filter(
            type=post_type, author=user).order_by('-creation_date')
    else:
        posts = get_post_manager(request).filter(
            type__in=POST_TOPLEVEL, author=user).order_by('-creation_date')

    posts = posts.select_related('author', 'author__profile', 'root')
    page = get_page(request, posts, per_page=20)
    return html.template(request, name='index.html', page=page, params=params)
Example #17
0
def show_tag(request, tag_name=None):
    "Display posts by a certain tag"
    user = request.user
    # populate the session data
    sess = middleware.Session(request)

    # get the sort order
    sort_type = sess.sort_order()

    # select based on history
    tab, pill = "posts", sess.get_tab()

    params = html.Params(nav='', tab=tab, sort='')

    # the params object will carry
    layout = settings.USER_PILL_BAR if auth else settings.ANON_PILL_BAR

    # wether to show the type of the post
    params = html.Params(tab=tab,
                         pill=pill,
                         sort=sort_type,
                         sort_choices=SORT_CHOICES,
                         layout=layout,
                         title="Tagged as %s" % tag_name)

    msg = 'Filtering by tag: <b>%s</b>. Subscribe to an <a href="/feeds/tag/%s/">RSS feed</a> to this tag.' % (
        tag_name, tag_name)
    messages.info(request, msg)
    posts = models.query_by_tags(user=user, text=tag_name)
    posts = apply_sort(request=request, posts=posts, order=sort_type)
    page = get_page(request, posts, per_page=20)

    return html.template(request, name='index.html', page=page, params=params)
Example #18
0
def user_profile(request, uid, tab='activity'):
    "User's profile page"

    if not models.User.objects.filter(id=uid):
        messages.error(request, "This user does not exist. It has perhaps been deleted.")
        return html.redirect("/")
        
    user = request.user
    target = models.User.objects.get(id=uid)
    awards = []
    page   = None
    
    # some information is only visible to the user
    target.writeable = auth.authorize_user_edit(target=target, user=user, strict=False)
    target.showall = (target == user)

    params = html.Params(tab=tab, sort='', title="User %s" % target.profile.display_name)

    # these do not actually get executed unless explicitly rendered in the page
    bookmarks = models.Vote.objects.filter(author=target, type=VOTE_BOOKMARK).select_related('post', 'post__author__profile').order_by('id')
    awards = models.Award.objects.filter(user=target).select_related('badge').order_by('-date')

    # we need to collate and count the awards
    answer_count = models.Post.objects.filter(author=target, type=POST_ANSWER).count()
    question_count = models.Post.objects.filter(author=target, type=POST_QUESTION).count()
    comment_count = models.Post.objects.filter(author=target, type=POST_COMMENT).count()
    post_count = models.Post.objects.filter(author=target).count()
    vote_count = models.Vote.objects.filter(author=target).count()
    award_count = models.Award.objects.filter(user=target).count()
    note_count  = models.Note.objects.filter(target=target, unread=True).count()
    bookmarks_count  = models.Vote.objects.filter(author=target, type=VOTE_BOOKMARK).count()
    
    if tab in [ 'activity', 'created' ]:
        if tab == 'created':
            notes = models.Note.objects.filter(sender=target, target=target, type=NOTE_USER).select_related('author', 'author__profile', 'root').order_by('-date')
        else:
            notes = models.Note.objects.filter(target=target, type=NOTE_USER).exclude(sender=target).select_related('author', 'author__profile', 'root').order_by('-date')
            
        page  = get_page(request, notes, per_page=15)
        # we evalute it here so that subsequent status updates won't interfere
        page.object_list = list(page.object_list)
        if user == target:
            models.Note.objects.filter(target=target, unread=True).update(unread=False)
            models.UserProfile.objects.filter(user=target).update(new_messages=0)
            note_count = 0
            
    elif tab == 'bookmarks':
        bookmarks = models.Vote.objects.filter(author=target, type=VOTE_BOOKMARK).select_related('post', 'post__author__profile').order_by('-date')
        page  = get_page(request, bookmarks, per_page=15)
    
    elif tab =="moderator":
        notes = models.Note.objects.filter(target=target, type=NOTE_MODERATOR).select_related('author', 'author__profile').order_by('-date')
        page  = get_page(request, notes, per_page=15)

    params.update(dict(question_count=question_count, answer_count=answer_count, note_count=note_count, bookmarks_count=bookmarks_count,
            comment_count=comment_count, post_count=post_count, vote_count=vote_count, award_count=award_count))
    
    return html.template(request, name='user.profile.html', awards=awards,
        user=request.user,target=target, params=params, page=page)
Example #19
0
def revision_show(request, pid):
    post = models.Post.objects.get(pk=pid)
    revs = post.revisions.order_by('-date').select_related(
        'author', 'lastedit_author')
    return html.template(request,
                         name='revision.show.html',
                         revs=revs,
                         post=post)
Example #20
0
def show_tag(request, tag_name=None):
    "Display posts by a certain tag"
    user = request.user
    params = html.Params(nav='', tab='tags')
    messages.warning(request, 'Filtering by tag: %s' % tag_name)
    posts = models.query_by_tags(user=user, text=tag_name).order_by('-rank')
    page  = get_page(request, posts, per_page=20)
    return html.template( request, name='index.html', page=page, params=params)
Example #21
0
def rss(request):
    "Renders the rss feed page"
    user = request.user
    params = html.Params(nav='rss')
    return html.template(request,
                         name='pages/rss.html',
                         params=params,
                         user=user)
Example #22
0
def google(request):
    "Renders the rss feed page"
    user = request.user
    params = html.Params(nav='google')
    return html.template(request,
                         name='pages/google.html',
                         params=params,
                         user=user)
Example #23
0
def user_edit(request, uid):
    "User's profile page"
    
    target = models.User.objects.select_related('profile').get(id=uid)
    
    allow = auth.authorize_user_edit(target=target, user=request.user, strict=False)
    if not allow:
        messages.error(request, "unable to edit this user")
        return html.redirect(target.profile.get_absolute_url() )
    
    # valid incoming fields
    fields = "display_name about_me website location my_tags scholar hide_ads".split()
        
    if request.method == 'GET':
        initial = dict(email=target.email)
        for field in fields:
            initial[field] = getattr(target.profile, field) or ''                
        form = UserForm(initial)
        return html.template(request, name='user.edit.html', target=target, form=form)
    elif request.method == 'POST':
        
        form = UserForm(request.POST)
        if not form.is_valid():
            return html.template(request, name='user.edit.html', target=target, form=form)
        else:
            for field in fields:
                setattr(target.profile, field, form.cleaned_data[field])

            # hiding ads requires a minimum reputation
            if target.profile.hide_ads and target.profile.score < settings.AD_MIN_REP:
                target.profile.hide_ads = False
                messages.warning(request, "The reputation needed to hide ads is %s" % (settings.AD_MIN_REP * 10))

            # check the new email
            new_email = form.cleaned_data['email'].strip()
            if new_email != target.email and models.User.objects.filter(email=new_email):
                # cannot set your email to an existing other user 'semail
                messages.error(request, "This email is aready taken - please merge the accounts!")
            else:
                target.email = new_email
            
            target.profile.save()
            target.save()
            
            url = reverse('main.server.views.user_profile', kwargs=dict(uid=target.id))
            return html.redirect(url)
Example #24
0
def post_edit(request, pid=0):
    "Handles the editing of an existing post"

    user = request.user
    name = "post.edit.html"
    post = models.Post.objects.get(pk=pid)

    if not post.open and not user.can_moderate:
        messages.error(request, 'Post is closed. It may not be edited.')
        return redirect(post.root)

    # verify that this user may indeed modify the post
    if not auth.authorize_post_edit(post=post, user=request.user,
                                    strict=False):
        messages.error(request, 'User may not edit the post.')
        return redirect(post.root)

    toplevel = post.top_level
    factory = formdef.TopLevelContent if toplevel else formdef.ChildContent

    params = html.Params(tab='edit', title="Edit post", toplevel=toplevel)
    if request.method == 'GET':
        # no incoming data, render prefilled form
        form = factory(initial=dict(title=post.title,
                                    content=post.content,
                                    tag_val=post.tag_val,
                                    type=post.type,
                                    context=post.context))
        return html.template(request, name=name, form=form, params=params)

    # process the incoming data
    assert request.method == 'POST', "Method=%s" % request.method
    form = factory(request.POST)
    if not form.is_valid():
        # returns with an error message
        return html.template(request, name=name, form=form, params=params)

    # form is valid now set the attributes
    for key, value in form.cleaned_data.items():
        setattr(post, key, value)
        post.lastedit_user = user
        post.lastedit_date = datetime.now()
        post.set_tags()  # this saves the post

    return redirect(post)
Example #25
0
def url500(request):
    "Custom error handler"
    
    type, value, tb = sys.exc_info()
    trace = traceback.format_exc()
    trace = "\n<trace>\n%s</trace>" % trace
    logger.error(trace)
    
    return html.template(request, name='500.html', path=request.path, value=value)
Example #26
0
def show_tag(request, tag_name=None):
    "Display posts by a certain tag"
    user = request.user
    params = html.Params(nav='', tab='tags', sort='')
    msg = 'Filtering by tag: <b>%s</b>. Subscribe to an <a href="/feeds/tag/%s/">RSS feed</a> to this tag.' % (tag_name,tag_name)
    messages.info(request, msg)
    posts = models.query_by_tags(user=user, text=tag_name).order_by('-rank')
    page  = get_page(request, posts, per_page=20)
    return html.template( request, name='index.html', page=page, params=params)
Example #27
0
def user_list(request):
    search  = request.GET.get('m','')[:80] # trim for sanity
    if search:
        query = Q(profile__display_name__icontains=search)
        users = models.User.objects.filter(query).select_related('profile').order_by("-profile__score")
    else:
        users = models.User.objects.select_related('profile').order_by("-profile__score")
    page  = get_page(request, users, per_page=24)
    return html.template(request, name='user.list.html', page=page)
Example #28
0
def more(request, pid):
    counts = request.session.get(SESSION_POST_COUNT, {})
    form = SearchForm()
    params = html.Params(tab='search', q="", sort='')
    results = more_like_this(request=request, pid=pid)
    posts = Post.objects.filter(id__in=[row['pid'] for row in results]).exclude(status=POST_DELETED)
    for post, row in zip(posts, results):
        post.context = row['content']
    page = get_page(request, posts, per_page=10)
    return html.template(request, name='search.html', page=page, params=params, counts=counts, form=form)
Example #29
0
def user_profile(request, uid, tab='activity'):
    "User's profile page"

    if not models.User.objects.filter(id=uid):
        messages.error(request, "This user does not exist. It has perhaps been deleted.")
        return html.redirect("/")
        
    user = request.user
    target = models.User.objects.get(id=uid)
    awards = []
    page   = None
    
    # some information is only visible to the user
    target.writeable = auth.authorize_user_edit(target=target, user=user, strict=False)
    target.showall = (target == user)

    params = html.Params(tab=tab, sort='')

    # these do not actually get executed unless explicitly rendered in the page
    bookmarks = models.Vote.objects.filter(author=target, type=VOTE_BOOKMARK).select_related('post', 'post__author__profile').order_by('id')
    awards = models.Award.objects.filter(user=target).select_related('badge').order_by('-date')

    # we need to collate and count the awards
    answer_count = models.Post.objects.filter(author=target, type=POST_ANSWER).count()
    question_count = models.Post.objects.filter(author=target, type=POST_QUESTION).count()
    comment_count = models.Post.objects.filter(author=target, type=POST_COMMENT).count()
    post_count = models.Post.objects.filter(author=target).count()
    vote_count = models.Vote.objects.filter(author=target).count()
    award_count = models.Award.objects.filter(user=target).count()
    note_count  = models.Note.objects.filter(target=target, unread=True).count()
    bookmarks_count  = models.Vote.objects.filter(author=target, type=VOTE_BOOKMARK).count()
    
    if tab == 'activity':
        notes = models.Note.objects.filter(target=target, type=NOTE_USER).select_related('author', 'author__profile', 'root').order_by('-date')
        page  = get_page(request, notes, per_page=15)
        # we evalute it here so that subsequent status updates won't interfere
        page.object_list = list(page.object_list)
        if user==target:
            models.Note.objects.filter(target=target).update(unread=False)
            models.UserProfile.objects.filter(user=target).update(new_messages=0)
            note_count = 0
        
    elif tab == 'bookmarks':
        bookmarks = models.Vote.objects.filter(author=target, type=VOTE_BOOKMARK).select_related('post', 'post__author__profile').order_by('-date')
        page  = get_page(request, bookmarks, per_page=15)
    
    elif tab =="moderator":
        notes = models.Note.objects.filter(target=target, type=NOTE_MODERATOR).select_related('author', 'author__profile').order_by('-date')
        page  = get_page(request, notes, per_page=15)

    params.update(dict(question_count=question_count, answer_count=answer_count, note_count=note_count, bookmarks_count=bookmarks_count,
            comment_count=comment_count, post_count=post_count, vote_count=vote_count, award_count=award_count))
    
    return html.template(request, name='user.profile.html', awards=awards,
        user=request.user,target=target, params=params, page=page)
Example #30
0
def post_list(request, uid=0, post_type=None):
    params = html.Params()

    posts = get_posts(request, post_type=post_type)
    if uid:
        user = models.User.objects.filter(id=uid).select_related('profile').all()[0]
        posts = posts.filter(author=user)
        params.setr('Filter: %s' % user.profile.display_name)
    posts = posts.order_by('-lastedit_date')
    page  = get_page(request, posts, per_page=20)
    return html.template( request, name='post.list.html', page=page, params=params)
Example #31
0
def user_list(request):
    search  = request.GET.get('m','')[:80] # trim for sanity
    params = html.Params(nav='users', sort='')
    if search:
        query = Q(profile__display_name__icontains=search)
    else:
        query = Q(id__gt=0)
        
    users = models.User.objects.filter(query).select_related('profile').order_by("-profile__score", "id")
    page  = get_page(request, users, per_page=24)
    return html.template(request, name='user.list.html', page=page, params=params)
Example #32
0
def user_list(request):
    search  = request.GET.get('m','')[:80] # trim for sanity
    params = html.Params(nav='users', sort='')
    if search:
        query = Q(profile__display_name__icontains=search)
    else:
        query = Q(id__gt=0)
        
    users = models.User.objects.filter(query).select_related('profile').order_by("-profile__score")
    page  = get_page(request, users, per_page=24)
    return html.template(request, name='user.list.html', page=page, params=params)
Example #33
0
def more(request, pid):
    counts = request.session.get(SESSION_POST_COUNT, {})
    form = SearchForm()
    params = html.Params(tab='search', q="", sort='')
    res = more_like_this(request=request, pid=pid)
    page = get_page(request, res, per_page=10)
    return html.template(request,
                         name='search.html',
                         page=page,
                         params=params,
                         counts=counts,
                         form=form)
Example #34
0
def post_edit(request, pid=0):
    "Handles the editing of an existing post"
    
    user = request.user
    name = "post.edit.html"
    post = models.Post.objects.get(pk=pid)

    if not post.open and not user.can_moderate:
        messages.error(request, 'Post is closed. It may not be edited.')
        return redirect(post.root)
        
    # verify that this user may indeed modify the post
    if not auth.authorize_post_edit(post=post, user=request.user, strict=False):
        messages.error(request, 'User may not edit the post.')
        return redirect(post.root)
  
    toplevel = post.top_level
    factory  = formdef.TopLevelContent if toplevel else formdef.ChildContent

    params = html.Params(tab='edit', title="Edit post", toplevel=toplevel)
    if request.method == 'GET':
        # no incoming data, render prefilled form
        form = factory(initial=dict(title=post.title, content=post.content, tag_val=post.tag_val, type=post.type))
        return html.template(request, name=name, form=form, params=params)

    # process the incoming data
    assert request.method == 'POST', "Method=%s" % request.method
    form = factory(request.POST)
    if not form.is_valid():
        # returns with an error message
        return html.template(request, name=name, form=form, params=params)

    # form is valid now set the attributes
    for key, value in form.cleaned_data.items():
        setattr(post, key, value)
        post.lastedit_user = user
        post.lastedit_date = datetime.now()
        post.set_tags() # this saves the post
    
    return redirect(post)
Example #35
0
def testpage(request):
    "Renders a test page"
    user = request.user
    params = html.Params(nav='rss')

    posts = models.Post.objects
    posts = posts.exclude(type=POST_BLOG).select_related('author', 'author__profile')
    posts = posts.order_by('-rank')[:10]
    posts = list(posts)


    rows = connection.queries

    return html.template(request, name='pages/testpage.html', params=params, user=user, rows=rows)
Example #36
0
def badge_list(request):
    user = request.user
    
    badges = models.Badge.objects.filter(secret=False).order_by('-count', '-type')
    
    # set a flag for badges that a user has
    if user.is_authenticated():
        earned = set( models.Award.objects.filter(user=user).values_list('badge__name', flat=True).distinct() )
    else:
        earned = []
    for badge in badges:
        badge.earned = badge.name in earned
        
    params = html.Params(nav='badges', sort='')
    return html.template(request, name='badge.list.html', badges=badges, params=params)
Example #37
0
def badge_list(request):
    user = request.user
    
    badges = models.Badge.objects.filter(secret=False).order_by('-count', '-type')
    
    # set a flag for badges that a user has
    if user.is_authenticated():
        earned = set( models.Award.objects.filter(user=user).values_list('badge__name', flat=True).distinct() )
    else:
        earned = []
    for badge in badges:
        badge.earned = badge.name in earned
        
    params = html.Params(nav='badges', sort='')
    return html.template(request, name='badge.list.html', badges=badges, params=params)
Example #38
0
def revision_list(request, pid):
    post = models.Post.objects.get(pk=pid)
    root = post.get_root()
        
    def full_view(rev):
        line    = '-' * 10
        title   = "Title: %s" % rev.title 
        content = "%s" % rev.content
        tag_string = "Tags: %s" % rev.tag_string
        text = "\n".join( (title, line, content, line, tag_string) )
        return text

    revisions = map(full_view, post.revisions.order_by('date'))
    revisions.reverse()
    return html.template(request, name='revision.list.html', revisions=revisions, post=post, root=root)
Example #39
0
def more(request, pid):
    counts = request.session.get(SESSION_POST_COUNT, {})
    form = SearchForm()
    params = html.Params(tab='search', q="", sort='')
    results = more_like_this(request=request, pid=pid)
    posts = Post.objects.filter(
        id__in=[row['pid'] for row in results]).exclude(status=POST_DELETED)
    for post, row in zip(posts, results):
        post.context = row['content']
    page = get_page(request, posts, per_page=10)
    return html.template(request,
                         name='search.html',
                         page=page,
                         params=params,
                         counts=counts,
                         form=form)
Example #40
0
def about(request):
    "Renders the about page"

    post_count     = models.Post.objects.filter(deleted=False).count()
    question_count = models.Post.objects.filter(deleted=False, post_type=const.POST_QUESTION).count()
    answer_count   = models.Post.objects.filter(deleted=False, post_type=const.POST_ANSWER).count()
    comment_count  = models.Post.objects.filter(deleted=False, post_type=const.POST_COMMENT).count()
    user_count = models.User.objects.filter(profile__suspended=False).count()

    mods = models.User.objects.filter(profile__type=const.USER_MODERATOR).select_related("profile").all()[:100]
    admins = models.User.objects.filter(profile__type=const.USER_ADMIN).select_related("profile").all()[:100]

    params = html.Params(post_count=post_count, user_count=user_count, question_count=question_count, 
        answer_count=answer_count, comment_count=comment_count, admins=admins, mods=mods)

    return html.template(request, name='about.html', params=params)
Example #41
0
def show_user(request, uid, post_type=''):
    "Displays posts by a user"

    user = models.User.objects.filter(id=uid).select_related('profile').all()[0]
    params = html.Params(nav='', tab='user', sort='')

    # notification
    messages.info(request, 'Filtering by user: %s' % user.profile.display_name)
   
    post_type = POST_REV_MAP.get(post_type.lower())
    if post_type:
        posts = get_post_manager(request).filter(type=post_type, author=user).order_by('-creation_date')
    else:
        posts = get_post_manager(request).filter(type__in=POST_TOPLEVEL, author=user).order_by('-creation_date')
    page  = get_page(request, posts, per_page=20)
    return html.template( request, name='index.html', page=page, params=params)
Example #42
0
def tag_list(request):
    
    # remove null tags
    models.Tag.objects.all().filter(count=0).delete()
    
    search  = request.GET.get('m','')[:80] # trim for sanity
    
    if search:
        query = Q(name__icontains=search)
    else:
        query = Q(id__gt=0)
        
    tags = models.Tag.objects.filter(query).order_by('name')
    page = get_page(request, tags, per_page=152)
    params = html.Params(nav='tags', sort='')
    return html.template(request, name='tag.list.html', page=page, params=params)
Example #43
0
def tag_list(request):
    
    # remove null tags
    models.Tag.objects.all().filter(count=0).delete()
    
    search  = request.GET.get('m','')[:80] # trim for sanity
    
    if search:
        query = Q(name__icontains=search)
    else:
        query = Q(id__gt=0)
        
    tags = models.Tag.objects.filter(query).order_by('-count')
    page = get_page(request, tags, per_page=152)
    params = html.Params(nav='tags', sort='')
    return html.template(request, name='tag.list.html', page=page, params=params)
Example #44
0
def help_external(request, word='main'):
    "Renders a test page"
    user = request.user

    # create a test key/value pair

    name = "GALAXY"
    pair = settings.EXTERNAL_AUTHENICATION.get(name)

    if pair:
        messages.info(request, "The <b>%s</b> key is active!" % name)
        key, patt = pair
    else:
        key, patt = "abcd", ""

    # prepare the data
    data = dict(display_name="Jane Doe",
                username="******",
                email="*****@*****.**", tags="galaxy bwa", title="How do I run bwa?",
                tool_name="Uber Convert",
                tool_id=1,
                tool_version="0.0.1.alpha",
    )

    # encode the data and get the digest
    enc, digest = formdef.encode(data, key=key)

    # encode into url parameters
    store = dict(name=name, data=enc, digest=digest)

    # encoding the parameters into the url to be loaded
    params = urllib.urlencode(store.items())
    login_url = "/x/?%s" % params

    store['action'] = 'new'
    params = urllib.urlencode(store.items())
    post_url = "/x/?%s" % params

    # override
    login_url = "http://test.biostars.org" + login_url

    post_url = "http://test.biostars.org" + post_url

    # this is used inside the templates
    params = html.Params(post_url=post_url, login_url=login_url, key=key, data=data, enc=enc, digest=digest)
    return html.template(request, name='help/help.external.html', params=params, user=user)
Example #45
0
def help_external(request, word='main'):
    "Renders a test page"
    user = request.user

    # create a test key/value pair

    name = settings.EXTERNAL_AUTHENICATION_TEST_KEY
    pair = settings.EXTERNAL_AUTHENICATION.get(name)

    if pair:
        messages.info(request, "The <b>%s</b> key is active!" % name)
        key, patt = pair
    else:
        key, patt = "abcd", ""

    # prepare the data
    data = dict(display_name="Jane Doe",
                username="******",
                email="*****@*****.**", tags="galaxy bwa", title="How do I run bwa?",
                tool_name="Uber Convert",
                tool_id=1,
                tool_version="0.0.1.alpha",
    )

    # encode the data and get the digest
    enc, digest = formdef.encode(data, key=key)

    # encode into url parameters
    store = dict(name=name, data=enc, digest=digest)

    # encoding the parameters into the url to be loaded
    params = urllib.urlencode(store.items())
    login_url = "/x/?%s" % params

    store['action'] = 'new'
    params = urllib.urlencode(store.items())
    post_url = "/x/?%s" % params

    # override
    login_url = settings.EXTERNAL_AUTHENICATION_TEST_URL + login_url

    post_url = settings.EXTERNAL_AUTHENICATION_TEST_URL + post_url

    # this is used inside the templates
    params = html.Params(post_url=post_url, login_url=login_url, key=key, data=data, enc=enc, digest=digest)
    return html.template(request, name='help/help.external.html', params=params, user=user)
Example #46
0
def index(request):
    "Main page"

    # this will contain the query if it was sent 
    query = request.REQUEST.get('q','')
    pids  = action.search(query)
    params = html.Params()
    if query:
        params.remind = 'Searching for: %s' % query
        qs = get_posts(request, post_type=None)
        qs = qs.filter(id__in=pids)
    else:
        qs = get_posts(request)
        
    qs  = qs.order_by('-touch_date')
    page  = get_page(request, qs, per_page=20)
    return html.template( request, name='index.html', page=page, params=params)
Example #47
0
def about(request):
    "Renders the about page"

    post_count     = models.Post.objects.filter(status=POST_OPEN).count()
    question_count = models.Post.objects.filter(status=POST_OPEN, type=POST_QUESTION).count()
    answer_count   = models.Post.objects.filter(status=POST_OPEN, type=POST_ANSWER).count()
    comment_count  = models.Post.objects.filter(status=POST_OPEN, type=POST_COMMENT).count()
    user_count = models.User.objects.filter(profile__status=USER_ACTIVE).count()

    mods = models.User.objects.filter(profile__type=USER_MODERATOR).select_related("profile").order_by('-profile__score').all()
    admins = models.User.objects.filter(profile__type=USER_ADMIN).select_related("profile").order_by('-profile__score').all()
    managers = models.User.objects.filter(email=settings.ADMINS[0][1]).select_related("profile").order_by('-profile__score').all()
    navloc = dict(about="active")
    params = html.Params(nav='about', post_count=post_count, user_count=user_count, question_count=question_count, 
        answer_count=answer_count, comment_count=comment_count, admins=admins, mods=mods, navloc=navloc, managers=managers)
    
    return html.template(request, name='pages/about.html', params=params)
Example #48
0
def testpage(request):
    "Renders a test page"
    user = request.user
    params = html.Params(nav='rss')

    posts = models.Post.objects
    posts = posts.exclude(type=POST_BLOG).select_related(
        'author', 'author__profile')
    posts = posts.order_by('-rank')[:10]
    posts = list(posts)

    rows = connection.queries

    return html.template(request,
                         name='pages/testpage.html',
                         params=params,
                         user=user,
                         rows=rows)
Example #49
0
def post_reparent(request, pid, rid=0):
    "Reparent a post"
    
    post = models.Post.objects.get(id=pid)
    root = post.root
    parent = post.parent

    allow = auth.authorize_post_edit(post=post, user=request.user, strict=False)
    
    if not allow:
        messages.error(request, "Reparent access denied")
        return html.redirect(post.get_absolute_url())

    if post.type in POST_TOPLEVEL or post == post.root:
        messages.error(request, "Cannot reparent a toplevel post")
        return html.redirect(post.get_absolute_url())

    # these are the valid targets
    targets = models.Post.objects.filter(root=root).select_related('author', 'author__profile').exclude(id__in=(post.id, parent.id))

    target = request.REQUEST.get('target')
    if target:
        target =  models.Post.objects.get(id=target)
        
        if target not in targets:
            messages.error(request, "Invalid reparent %s -> %s" % (post.id, target.id) )
            return html.redirect(post.get_absolute_url())
        
        # comment to comment reparent is not yet supported
        if target.type == POST_COMMENT and post.type == POST_COMMENT:
            messages.error(request, "Comment to comment reparent %s -> %s not implemented" % (post.id, target.id) )
            return html.redirect(post.get_absolute_url())

        # perfomr the reparent
        post.parent = target
        question = (target.type == POST_QUESTION)
        post.type = POST_ANSWER if question else POST_COMMENT
        post.save()

        # valid target to be applied
        messages.info(request, "Reparenting %s to %s" % (post.id, target.id))
        return html.redirect(post.get_absolute_url())
        
    return html.template(request, name='post.reparent.html', post=post, targets=targets)
Example #50
0
def index(request, tab=""):
    "Main page"
    
    user = request.user
    
    if not tab:
        # if the user has a mytags then switch to that
        if user.is_authenticated() and user.profile.my_tags:
            tab = 'mytags'
        else:
            tab = 'questions'
    
    if tab not in VALID_TABS:
        messages.error(request, 'Unknown content type requested')
        
    params = html.Params(tab=tab)
    
    # this will fill in the query (q) and the match (m)parameters
    params.parse(request)
    
    # update with counts
    counts = request.session.get(SESSION_POST_COUNT, {})

    # returns the object manager that contains all or only visible posts
    posts = get_post_manager(request)

    # filter posts by type
    posts = filter_by_type(posts=posts, value=tab)

    # sort selected in the dropdown. by default lists cannot be sorted
    sort = request.GET.get('sort', '').lower()
    
    # attempts to remeber the last sorting
    sort = get_last_sort(request, sort)
    
    # override sort in the recent tab
    if tab == 'recent':
        sort = 'creation'
        posts = posts.order_by('-creation_date')
    else:
        posts = apply_sort(posts, value=sort, request=request)
    
    if tab == 'planet':
        models.decorate_posts(posts, user)
    
    if tab == 'mytags':
        if user.is_authenticated():
            text  = user.profile.my_tags
            if not text:
                messages.warning(request, "This Tab will show posts matching the My Tags fields in your user profile.")
            else:
                messages.info(request, "Filtering by %s" % text)
            posts = models.query_by_tags(user,text=text)
            posts = apply_sort(posts, value=sort, request=request)
        else:
            messages.warning(request, "This Tab is populated only for registered users based on the My Tags field in their user profile")
            posts = []
    
    sort_choices = "rank,views,votes,answers,bookmarks,creation,edit".split(',')
    
    # put sort options in params so they can be displayed
    params.update(dict(sort=sort, sort_choices=sort_choices))
    
    # reset the counts
    update_counts(request, tab, 0)
    page = get_page(request, posts, per_page=POSTS_PER_PAGE)
    return html.template(request, name='index.html', page=page, params=params, counts=counts)
Example #51
0
def modlog_list(request):
    "Lists of all moderator actions"
    mods = models.Note.objects.filter(type=NOTE_MODERATOR).select_related('sender', 'target', 'post', 'sender_profile').order_by('-date')
    page = get_page(request, mods)
    return html.template(request, name='modlog.list.html', page=page)
Example #52
0
                    domain=settings.SITE_DOMAIN, master_id=master.id, remove_id=remove.id,
                    master_name = master.profile.display_name, remove_name=remove.profile.display_name,
                    master_email = master.email, remove_email=remove.email,
                    request_id = request.user.id, request_name = user.profile.display_name,
                )
                body = ACCOUNT_MERGE_EMAIL % fill
                logger.info('sending email to %s' % settings.SERVER_EMAIL)
                send_mail(subject='BioStar: account merge request', message=body, from_email=settings.DEFAULT_FROM_EMAIL, recipient_list=[ settings.DEFAULT_FROM_EMAIL ], fail_silently=False)
                messages.info(request, "Your request for account merge has been submitted for review.")
                return html.redirect( user.profile.get_absolute_url() )
            except Exception, exc:
                messages.error(request, 'Submission error %s' % exc)
    else: 
        form = MergeForm()
    params = html.Params(nav='')
    return html.template(request, name='pages/merge.html', params=params, form=form)



def migrate(master, remove):
    "Migrates user data"
    UserOpenID.objects.filter(user=remove).update(user=master)
    models.Vote.objects.filter(author=remove).update(author=master)
    models.Note.objects.filter(sender=remove).update(sender=master)
    models.Note.objects.filter(target=remove).update(target=master)
    models.Post.objects.filter(author=remove).update(author=master)
    models.Post.objects.filter(lastedit_user=remove).update(lastedit_user=master)
    models.PostRevision.objects.filter(author=remove).update(author=master)
    models.Award.objects.filter(user=remove).update(user=master)
    master.profile.score += remove.profile.score
    master.profile.save()
Example #53
0
        email=settings.ADMINS[0][1]).select_related("profile").order_by(
            '-profile__score').all()
    navloc = dict(about="active")
    params = html.Params(nav='about',
                         post_count=post_count,
                         user_count=user_count,
                         question_count=question_count,
                         answer_count=answer_count,
                         comment_count=comment_count,
                         admins=admins,
                         mods=mods,
                         navloc=navloc,
                         managers=managers,
                         visitors=visitors)

    return html.template(request, name='pages/about.html', params=params)


def rss(request):
    "Renders the rss feed page"
    user = request.user
    params = html.Params(nav='rss')
    return html.template(request,
                         name='pages/rss.html',
                         params=params,
                         user=user)


def request_info(request, pid):
    "Requests information from a source"
    user = request.user
Example #54
0
def faq(request):
    "Renders the faq page"
    best = models.User.objects.all().select_related("profile").order_by(
        '-profile__score')[:3]
    params = html.Params(nav='faq', best=best)
    return html.template(request, name='pages/faq.html', params=params)
Example #55
0
def beta(request):
    "Renders the beta test information page"
    params = html.Params(nav='')
    return html.template(request, name='pages/beta.html', params=params)