def compose(request, recipient=None, form_class=ComposeForm,
template_name='pm/compose.html', success_url=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(request.user)
recipient_filter = lambda u: u.id not in blocked_user_ids
if request.method == "POST":
form = form_class(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
form.save(sender=request.user)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [u for u in User.objects.filter(**{'%s__in' %
get_username_field(): [r.strip() for r in
recipient.split('+')]})]
form.fields['recipient'].initial = recipients
return render(request, template_name, {'form': form})
def is_visible_for(self, user, blocked_user_ids=[]):
if user.is_superuser:
return True
if user.is_authenticated():
if self.owner_id == user.id:
return True
if blocked_user_ids == []:
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(user)
if self.owner_id in blocked_user_ids or \
user.id in blocked_user_ids:
return False
if self.status == self.PUBLISHED and \
self.visible_for == Story.VISIBLE_FOR_FOLLOWERS and \
user.id in self.owner.follower_user_ids:
return True
if self.status == Story.PUBLISHED and self.visible_for == \
Story.VISIBLE_FOR_EVERYONE:
return True
return False
def is_visible_for(self, user, blocked_user_ids=[]):
if user.is_superuser:
return True
if user.is_authenticated():
if self.owner_id == user.id:
return True
if blocked_user_ids == []:
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(user)
if self.owner_id in blocked_user_ids or \
user.id in blocked_user_ids:
return False
if self.status == self.PUBLISHED and \
self.visible_for == Story.VISIBLE_FOR_FOLLOWERS and \
user.id in self.owner.follower_user_ids:
return True
if self.status == Story.PUBLISHED and self.visible_for == \
Story.VISIBLE_FOR_EVERYONE:
return True
return False
def build(self,
requested_user=AnonymousUser(),
frm=None,
listing='public',
ordering='recent'):
from apps.question.models import QuestionMeta
from apps.story.models import Story
if not requested_user.is_authenticated() and listing in \
['wall', 'private', 'draft']:
return Story.objects.none()
if listing not in ['public', 'wall', 'private', 'draft']:
listing = 'public'
if listing == 'public':
qset = Q(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_EVERYONE,
owner__is_active=True)
if not requested_user.is_authenticated():
qset = qset & Q(is_nsfw=False)
elif listing == 'wall':
oids = requested_user.following_user_ids
oids.append(requested_user.id)
qset = Q(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_EVERYONE,
owner_id__in=oids)
elif listing == 'private':
oids = requested_user.following_user_ids
oids.append(requested_user.id)
qset = Q(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_FOLLOWERS,
owner_id__in=oids)
elif listing == 'draft':
qset = Q(status=Story.DRAFT, owner=requested_user)
if frm:
if isinstance(frm, QuestionMeta):
qset = qset & Q(question_meta=frm)
if isinstance(frm, User):
qset = qset & Q(owner=frm, is_anonymouse=False)
if requested_user.is_authenticated():
blocked_user_ids = compute_blocked_user_ids_for(requested_user)
else:
blocked_user_ids = []
ordering = {
'popular': '-like_count',
'featured': 'is_featured',
'recent': '-created_at'
}.get(ordering, '-created_at')
return Story.objects\
.filter(qset)\
.exclude(owner_id__in=blocked_user_ids)\
.order_by(ordering)
def get_prev_story(self, requested_user=None):
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(requested_user) \
if requested_user else []
return Story.objects.filter(
question_meta=self.question_meta,
status=Story.PUBLISHED,
created_at__gt=self.created_at)\
.exclude(owner_id__in=blocked_user_ids)\
.order_by('created_at').first()
def get_prev_story(self, requested_user=None):
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(requested_user) if requested_user \
else []
return Story.objects.filter(
question_meta=self.question_meta,
status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_EVERYONE,
created_at__gt=self.created_at)\
.exclude(owner_id__in=blocked_user_ids)\
.order_by('created_at').first()
def get_next_story(self, requested_user=None):
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(requested_user) if requested_user \
else []
return Story.objects.filter(
question_meta=self.question_meta,
status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_EVERYONE,
created_at__lt=self.created_at)\
.exclude(owner_id__in=blocked_user_ids)\
.order_by('-created_at').first()
def index_wall(request):
"""
Show public posts from following users.
"""
blocked_user_ids = compute_blocked_user_ids_for(request.user)
stories = Story.objects\
.filter(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_EVERYONE,
owner_id__in=request.user.following_user_ids)\
.exclude(owner_id__in=blocked_user_ids)
return _index(request, stories, extra={'from': 'followings'})
def index_public(request):
"""
Show public posts from everyone
"""
stories = Story.objects\
.filter(status=Story.PUBLISHED, visible_for=Story.VISIBLE_FOR_EVERYONE)
if request.user.is_authenticated():
blocked_user_ids = compute_blocked_user_ids_for(request.user)
stories = stories.exclude(owner_id__in=blocked_user_ids)
else:
stories = stories.exclude(is_nsfw=True)
return _index(request, stories, extra={'from': 'public'})
def build(self, requested_user=AnonymousUser(), frm=None,
listing='public', ordering='recent'):
from apps.question.models import QuestionMeta
from apps.story.models import Story
if not requested_user.is_authenticated() and listing in \
['wall', 'private', 'draft']:
return Story.objects.none()
if listing not in ['public', 'wall', 'private', 'draft']:
listing = 'public'
if listing == 'public':
qset = Q(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_EVERYONE,
owner__is_active=True)
if not requested_user.is_authenticated():
qset = qset & Q(is_nsfw=False)
elif listing == 'wall':
oids = requested_user.following_user_ids
oids.append(requested_user.id)
qset = Q(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_EVERYONE,
owner_id__in=oids)
elif listing == 'private':
oids = requested_user.following_user_ids
oids.append(requested_user.id)
qset = Q(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_FOLLOWERS,
owner_id__in=oids)
elif listing == 'draft':
qset = Q(status=Story.DRAFT, owner=requested_user)
if frm:
if isinstance(frm, QuestionMeta):
qset = qset & Q(question_meta=frm)
if isinstance(frm, User):
qset = qset & Q(owner=frm, is_anonymouse=False)
if requested_user.is_authenticated():
blocked_user_ids = compute_blocked_user_ids_for(requested_user)
else:
blocked_user_ids = []
ordering = {'popular': '-like_count',
'featured': 'is_featured',
'recent': '-created_at'}.get(ordering, '-created_at')
return Story.objects\
.filter(qset)\
.exclude(owner_id__in=blocked_user_ids)\
.order_by(ordering)
def index_private(request):
"""
Show private posts from users that request.user is
following.
"""
blocked_user_ids = compute_blocked_user_ids_for(request.user)
following_user_ids = request.user.following_user_ids
stories = Story.objects\
.filter(status=Story.PUBLISHED,
visible_for=Story.VISIBLE_FOR_FOLLOWERS,
owner_id__in=following_user_ids)
if blocked_user_ids:
stories = stories.exclude(owner_id__in=blocked_user_ids)
return _index(request, stories, extra={'from': 'private'})
def compose(request,
recipient=None,
form_class=ComposeForm,
template_name='pm/compose.html',
success_url=None):
"""
Displays and handles the ``form_class`` form to compose new messages.
Required Arguments: None
Optional Arguments:
``recipient``: username of a `django.contrib.auth` User, who should
receive the message, optionally multiple usernames
could be separated by a '+'
``form_class``: the form-class to use
``template_name``: the template to use
``success_url``: where to redirect after successfull submission
"""
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(request.user)
recipient_filter = lambda u: u.id not in blocked_user_ids
if request.method == "POST":
form = form_class(request.POST, recipient_filter=recipient_filter)
if form.is_valid():
form.save(sender=request.user)
messages.info(request, _(u"Message successfully sent."))
if success_url is None:
success_url = reverse('messages_inbox')
if 'next' in request.GET:
success_url = request.GET['next']
return HttpResponseRedirect(success_url)
else:
form = form_class()
if recipient is not None:
recipients = [
u for u in User.objects.filter(
**{
'%s__in' % get_username_field():
[r.strip() for r in recipient.split('+')]
})
]
form.fields['recipient'].initial = recipients
return render_to_response(template_name, {
'form': form,
},
context_instance=RequestContext(request))
def is_visible_for(self, user, blocked_user_ids=[]):
if user.is_superuser:
return True
if user.is_authenticated():
if self.owner_id == user.id:
return True
if blocked_user_ids == []:
from apps.follow.models import compute_blocked_user_ids_for
blocked_user_ids = compute_blocked_user_ids_for(user)
if self.owner_id in blocked_user_ids or \
user.id in blocked_user_ids:
return False
if self.status == Story.PUBLISHED:
return True
return False
def story(request, base62_id):
action_keys = filter(lambda i: i in ["delete", "publish"], request.POST)
action_key = action_keys[0] if action_keys else None
if action_key:
method = {u"delete": _delete_story, u"publish": _publish_story}.get(action_key)
if method:
story = get_object_or_404(Story, id=base62.to_decimal(base62_id), owner=request.user)
return method(request, story)
statuses_in = [Story.DRAFT, Story.PUBLISHED] if request.user.is_authenticated() else [Story.PUBLISHED]
story = get_object_or_404(Story, id=base62.to_decimal(base62_id), status__in=statuses_in, owner__is_active=True)
blocked_user_ids = compute_blocked_user_ids_for(request.user)
story_is_visible = story.is_visible_for(request.user, blocked_user_ids=blocked_user_ids)
comments = (
Comment.objects.filter(story=story)
.from_active_owners()
.visible_for(request.user)
.select_related("owner__profile")
)
comments = paginated(request, comments, settings.COMMENTS_PER_PAGE)
if request.user.is_authenticated():
if request.method == "POST" and request.POST.get("action") == "create_comment":
comment_form = CommentForm(request.POST, owner=request.user, story=story)
if comment_form.is_valid():
comment = comment_form.save()
return HttpResponseRedirect(comment.get_absolute_url())
else:
comment_form = CommentForm(owner=request.user, story=story)
else:
comment_form = None
return render(
request,
"story/story_detail.html",
{
"story": story,
"current_site": Site.objects.get_current(),
"story_is_visible": story_is_visible,
"comments": comments,
"comment_form": comment_form,
},
)
def story(request, base62_id):
action_keys = filter(lambda i: i in ['delete', 'publish'], request.POST)
action_key = action_keys[0] if action_keys else None
if action_key:
method = {u'delete': _delete_story,
u'publish': _publish_story}.get(action_key)
if method:
story = get_object_or_404(Story, id=base62.to_decimal(base62_id),
owner=request.user)
return method(request, story)
statuses_in = [Story.DRAFT, Story.PUBLISHED] if \
request.user.is_authenticated() else [Story.PUBLISHED]
story = get_object_or_404(Story, id=base62.to_decimal(base62_id),
status__in=statuses_in, owner__is_active=True)
blocked_user_ids = compute_blocked_user_ids_for(request.user)
story_is_visible = story.is_visible_for(request.user,
blocked_user_ids=blocked_user_ids)
comments = Comment.objects\
.filter(story=story)\
.from_active_owners()\
.visible_for(request.user)\
.select_related('owner__profile')
comments = paginated(request, comments, settings.COMMENTS_PER_PAGE)
if request.user.is_authenticated():
if request.method == 'POST' and request.POST.get('action') ==\
'create_comment':
comment_form = CommentForm(request.POST, owner=request.user,
story=story)
if comment_form.is_valid():
comment = comment_form.save()
return HttpResponseRedirect(comment.get_absolute_url())
else:
comment_form = CommentForm(owner=request.user, story=story)
else:
comment_form = None
return render(request, 'story/story_detail.html',
{'story': story, 'current_site': Site.objects.get_current(),
'story_is_visible': story_is_visible, 'comments': comments,
'comment_form': comment_form})
def visible_for(self, user, blocked_user_ids=None):
if not blocked_user_ids:
blocked_user_ids = compute_blocked_user_ids_for(user)
return self.exclude(owner_id__in=blocked_user_ids)
