def save(self):
content = self.cleaned_data.get('content', self.post.content)
post = auth.create_post(parent=self.post,
author=self.user,
content=content,
ptype=self.ptype,
root=self.post.root,
title=self.post.title)
return post
def test_comment_traversal(self):
"""Test comment rendering pages"""
# Create a couple of comments to traverse
comment = auth.create_post(title="Test", author=self.owner, content="Test",
post_type=models.Post.COMMENT, root=self.post,
parent=self.post)
comment2 = auth.create_post(title="Test", author=self.owner, content="Test",
post_type=models.Post.COMMENT, root=self.post,
parent=comment)
url = reverse("post_view", kwargs=dict(uid=self.post.uid))
request = fake_request(url=url, data={}, user=self.owner)
response = views.post_view(request=request, uid=self.post.uid)
self.assertTrue(response.status_code == 200, 'Error rendering comments')
def setUp(self):
logger.setLevel(logging.WARNING)
self.owner = User.objects.create(username="******", email="*****@*****.**", password="******")
# Create an existing test post
self.post = auth.create_post(title="Test", author=self.owner, content="Test",
post_type=models.Post.QUESTION)
self.owner.save()
pass
def setUp(self):
logger.setLevel(logging.WARNING)
self.owner = User.objects.create(username=f"tested{get_uuid(10)}", email="*****@*****.**")
self.owner.set_password("tested")
self.badge = Badge.objects.first()
# Create a tested post
self.post = auth.create_post(title="Test", author=self.owner, content="Test",
post_type=models.Post.QUESTION)
self.owner.save()
def off_topic(request, post, **kwargs):
"""
Marks post as off topic. Generate off topic comment.
"""
user = request.user
if "offtopic" not in post.tag_val:
post.tag_val += ",offtopic "
post.save()
# Generate off comment.
content = "This post is off topic."
auth.create_post(ptype=Post.COMMENT, parent=post, content=content, title='', author=request.user)
msg = "off topic"
messages.info(request, mark_safe(msg))
auth.db_logger(user=user, text=f"{msg}", post=post)
else:
messages.warning(request, "post has been already tagged as off topic")
url = post.get_absolute_url()
return url
def test_vote(self):
"""Test the ajax voting using POST request """
user2 = User.objects.create(username="******", email="*****@*****.**", password="******")
answer = auth.create_post(title="answer", author=user2, content="test foo bar too for",
post_type=models.Post.ANSWER, parent=self.post)
self.make_votes(post=answer, user=self.owner)
self.make_votes(post=self.post, user=self.owner)
self.make_votes(post=self.post, user=user2)
return
def test_comment_moderation(self):
"Test comment moderation."
choices = [const.MOVE_TO_ANSWER, const.DELETE]
# Create a comment to moderate
comment = auth.create_post(title="Test",
author=self.owner,
content="Test",
post_type=models.Post.COMMENT,
root=self.post,
parent=self.post)
self.moderate(choices=choices, post=comment)
def post_view(request, uid):
"Return a detailed view for specific post"
# Get the post.
post = Post.objects.filter(uid=uid).select_related('root').first()
user = request.user
if not post:
messages.error(request, "Post does not exist.")
return redirect("post_list")
# Redirect to post view
if not post.is_toplevel:
return redirect(post.get_absolute_url())
# Return 404 when post is spam and user is anonymous.
if post.is_spam and user.is_anonymous:
raise Http404("Post does not exist.")
# Form used for answers
form = forms.PostShortForm(user=request.user, post=post)
if request.method == "POST":
form = forms.PostShortForm(data=request.POST,
user=request.user,
post=post)
if form.is_valid():
author = request.user
content = form.cleaned_data.get("content")
answer = auth.create_post(title=post.title,
parent=post,
author=author,
content=content,
ptype=Post.ANSWER,
root=post.root,
request=request)
return redirect(answer.get_absolute_url())
messages.error(request, form.errors)
# Build the comment tree .
root, comment_tree, answers, thread = auth.post_tree(user=request.user,
root=post.root)
# Bump post views.
models.update_post_views(post=post,
request=request,
timeout=settings.POST_VIEW_TIMEOUT)
context = dict(post=root, tree=comment_tree, form=form, answers=answers)
return render(request, "post_view.html", context=context)
def test_answer_moderation(self):
"Test answer moderation."
choices = [const.TOGGLE_ACCEPT, const.MOVE_TO_COMMENT, const.DELETE]
# Create an answer to moderate
anwser = auth.create_post(title="Test",
author=self.owner,
content="Test",
post_type=models.Post.ANSWER,
root=self.post,
parent=self.post)
self.moderate(choices=choices, post=anwser)
return
def test_user_delete(self):
"Test deleting a user."
# Set up projects/posts to key user to
project = create_project(user=self.user,
name="tested project",
text="Text",
summary="summary",
uid="testing")
posts = create_post(title="Title of post",
author=self.user,
content="Post content",
post_type=Post.QUESTION)
self.user.delete()
def setUp(self):
logger.setLevel(logging.WARNING)
self.owner = User.objects.create(username=f"tested{get_uuid(10)}",
email="*****@*****.**",
password="******",
is_superuser=True,
is_staff=True)
# Create an existing tested post
self.post = auth.create_post(title="Test",
author=self.owner,
content="Test",
post_type=models.Post.QUESTION)
self.owner.save()
pass
def post_view(request, uid):
"Return a detailed view for specific post"
# Get the post.
post = Post.objects.filter(uid=uid).select_related('root').first()
if not post:
messages.error(request, "Post does not exist.")
return redirect("post_list")
auth.update_post_views(post=post, request=request)
if not post.is_toplevel:
return redirect(post.get_absolute_url())
# Form used for answers
form = forms.PostShortForm(user=request.user, post=post)
if request.method == "POST":
form = forms.PostShortForm(data=request.POST,
user=request.user,
post=post)
if form.is_valid():
author = request.user
content = form.cleaned_data.get("content")
answer = auth.create_post(title=post.title,
parent=post,
author=author,
content=content,
ptype=Post.ANSWER,
root=post.root)
return redirect(answer.get_absolute_url())
messages.error(request, form.errors)
# Build the comment tree .
root, comment_tree, answers, thread = auth.post_tree(user=request.user,
root=post.root)
# user string
users_str = auth.get_users_str()
context = dict(post=root,
tree=comment_tree,
form=form,
answers=answers,
users_str=users_str)
return render(request, "post_view.html", context=context)
def new_post(request):
"""
Creates a new post
"""
title = request.GET.get('title', '')
tag_val = request.GET.get('tag_val', '')
tag_val = ','.join(tag_val.split())
initial = dict(title=title, tag_val=tag_val)
content = ''
author = request.user
form = forms.PostLongForm(user=request.user, initial=initial)
if request.method == "POST":
form = forms.PostLongForm(data=request.POST,
user=request.user,
initial=initial)
tag_val = form.data.get('tag_val')
content = form.data.get('content', '')
if form.is_valid():
# Create a new post by user
title = form.cleaned_data.get('title')
content = form.cleaned_data.get("content")
ptype = form.cleaned_data.get('post_type')
tag_val = form.cleaned_data.get('tag_val')
post = auth.create_post(title=title,
content=content,
ptype=ptype,
tag_val=tag_val,
author=author,
request=request)
tasks.created_post.spool(pid=post.id)
return redirect(post.get_absolute_url())
# Action url for the form is the current view
action_url = reverse("post_create")
context = dict(form=form,
tab="new",
tag_val=tag_val,
action_url=action_url,
content=content)
return render(request, "new_post.html", context=context)
def save(self, author=None, edit=False):
data = self.cleaned_data.get
title = data('title')
html = data("content")
content = util.strip_tags(html)
post_type = int(data('post_type'))
tag_val = data('tag_val')
if edit:
self.post.title = title
self.post.content = content
self.post.type = post_type
self.post.html = html
self.post.save()
# Triggers another save
self.post.add_tags(text=tag_val)
else:
self.post = auth.create_post(title=title, content=content, post_type=post_type,
tag_val=tag_val, author=author, project=self.project)
return self.post
def save(self, author=None, post_type=Post.ANSWER, edit=False):
data = self.cleaned_data
html = data.get("content")
project = data.get("project_uid")
parent = data.get("parent_uid")
content = util.strip_tags(html)
if edit:
self.post.html = html
self.post.content = content
self.post.save()
else:
parent = Post.objects.filter(uid=parent).first()
project = Project.objects.filter(uid=project).first()
self.post = auth.create_post(title=parent.root.title,
parent=parent,
author=author,
content=content,
post_type=post_type,
project=project,
sub_to_root=True,
)
return self.post
def herald_publisher(request, limit=20, nmin=1):
"""
Create one publication from Herald accepted submissions ( up to 'limit' ).
"""
# Reset status on published links.
# SharedLink.objects.filter(status=SharedLink.PUBLISHED).update(status=SharedLink.ACCEPTED)
heralds = SharedLink.objects.filter(
status=SharedLink.ACCEPTED).order_by('-pk')[:limit]
count = heralds.count()
if count < nmin:
logger.warning(
f"Not enough stories to publish, minimum of {nmin} required.")
return
# Create herald content
date = util.now()
date_fmt = date.strftime("%A, %B %d, %Y")
title = f"The Biostar Herald for {date_fmt}"
port = f':{settings.HTTP_PORT}' if settings.HTTP_PORT else ''
base_url = f"{settings.PROTOCOL}://{settings.SITE_DOMAIN}{port}"
authors = set(h.author for h in heralds)
editors = set(h.editor for h in heralds)
subscribe_url = reverse('herald_subscribe')
context = dict(heralds=heralds,
title=title,
site_domain=settings.SITE_DOMAIN,
protocol=settings.PROTOCOL,
base_url=base_url,
authors=authors,
editors=editors,
subscribe_url=subscribe_url)
content = render_template(template="herald/herald_content.md",
context=context)
# Create herald post
user = User.objects.filter(is_superuser=True).first()
post = auth.create_post(title=title,
content=content,
author=user,
tag_val='herald',
ptype=Post.HERALD,
nodups=False,
request=request)
# Tie these submissions to herald post
hpks = heralds.values_list('pk', flat=True)
SharedLink.objects.filter(pk__in=hpks).update(status=SharedLink.PUBLISHED,
post=post,
lastedit_date=date)
# Log the action
auth.db_logger(user=user, text=f"published {count} submissions in {title}")
# Create a herald blog post
herald_blog(post=post)
# Send out herald emails
herald_emails.spool(uid=post.uid)
# Clean up declined links
remove_declined()
return post
