def delete(request, pk):
"""Delete note."""
note = get_object_or_404(Note, pk=pk)
reading = note.reading
if request.method == 'POST':
# if delete value equals note's pk
if request.POST.get('delete') == str(note.pk):
# if current user created note or is staff
if request.user.pk == note.user.pk or request.user.is_staff:
data = defaultdict(str)
note_count = reading.note_count()
if note_count > 1:
note_pk = note.pk
# del rep
del_rep(request, n=note)
note.delete()
d = {
'reading': reading,
}
bullet_notes = loader.get_template(
'notes/bullet_notes.html')
context = RequestContext(request, add_csrf(request, d))
data = {
'bullet_notes': bullet_notes.render(context),
'pk': note_pk,
}
data['note_count'] = note_count
return HttpResponse(json.dumps(data),
mimetype='application/json')
return HttpResponseRedirect(reverse('readings.views.detail',
args=[reading.slug]))
def comment(request, pk):
"""Detail comment."""
comment = get_object_or_404(Comment, pk=pk)
if request.method == 'POST':
if request.user.pk == 2:
form = DavidReplyForm(request.POST)
else:
form = AdminReplyForm(request.POST)
if form.is_valid():
# save reply
reply = form.save(commit=False)
reply.comment = comment
reply.save()
# add rep
add_rep(request, rp=reply)
# create notification
notify(reply=reply)
messages.success(request, 'Reply created')
return HttpResponseRedirect(reverse(
'admins.views.comment', args=[comment.pk]))
else:
if request.user.pk == 2:
form = DavidReplyForm()
else:
form = AdminReplyForm()
d = {
'comment': comment,
'comment_pk': comment.pk,
'form': form,
'title': 'Comment: Add Reply',
}
return render_to_response('admins/detail_comment.html',
add_csrf(request, d), context_instance=RequestContext(request))
def new(request, pk):
"""Create new reply."""
comment = get_object_or_404(Comment, pk=pk)
if request.method == 'POST':
form = ReplyForm(request.POST)
if form.is_valid():
reply = form.save(commit=False)
reply.comment = comment
reply.user = request.user
reply.save()
# add rep
add_rep(request, rp=reply)
# create notification
notify(reply=reply)
d = {
'comment': comment,
'reply': reply,
'reply_form': ReplyForm(),
'static': settings.STATIC_URL,
}
reply_form = loader.get_template('replies/reply_form.html')
reply_temp = loader.get_template('replies/reply.html')
context = RequestContext(request, add_csrf(request, d))
data = {
'comment_pk': comment.pk,
'reply': reply_temp.render(context),
'reply_count': comment.reply_count(),
'reply_form': reply_form.render(context),
'reply_pk': reply.pk,
}
return HttpResponse(json.dumps(data), mimetype='application/json')
return HttpResponseRedirect(reverse('readings.views.detail',
args=[comment.note.reading.slug]))
def detail(request, slug):
"""Show messages between current user and user."""
profile = get_object_or_404(Profile, slug=slug)
msgs = UserMessage.objects.filter(
Q(recipient=profile.user, sender=request.user) | Q(
recipient=request.user, sender=profile.user)).order_by('created')
received_messages = request.user.received_messages.filter(sender=profile.user)
# mark all messages as viewed
if received_messages:
for msg in received_messages:
msg.viewed = True
msg.save()
# group messages by date
if msgs:
dates = sorted(set([msg.date() for msg in msgs]),
key=lambda m: datetime.strptime(m, '%b %d, %y'))
days = []
for day in dates:
usermsgs = [m for m in msgs if m.date() == day]
days.append((day, usermsgs))
d = {
'days': days,
'form': ReplyMessageForm(),
'profile_user': profile.user,
'title': '%s Messages' % profile.user.username,
}
return render_to_response('usermessages/detail.html',
add_csrf(request, d), context_instance=RequestContext(request))
else:
messages.warning(request, 'You have no messages from that user')
return HttpResponseRedirect(reverse('usermessages.views.list'))
def note(request, pk):
"""Detail note."""
note = get_object_or_404(Note, pk=pk)
if request.method == 'POST':
if request.user.pk == 2:
form = DavidCommentForm(request.POST)
else:
form = AdminCommentForm(request.POST)
if form.is_valid():
# save comment
comment = form.save(commit=False)
comment.note = note
comment.save()
# add rep
add_rep(request, c=comment)
# create notification
notify(comment=comment)
messages.success(request, 'Comment created')
return HttpResponseRedirect(reverse(
'admins.views.note', args=[note.pk]))
else:
if request.user.pk == 2:
form = DavidCommentForm(request.POST)
else:
form = AdminCommentForm()
d = {
'form': form,
'note': note,
'note_pk': note.pk,
'title': 'Note: Add Comment',
}
return render_to_response('admins/detail_note.html',
add_csrf(request, d), context_instance=RequestContext(request))
def new(request, pk):
note = get_object_or_404(Note, pk=pk)
if request.method == 'POST':
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.note = note
comment.user = request.user
comment.save()
# add rep
add_rep(request, c=comment)
# create notification
notify(comment=comment)
d = {
'comment': comment,
'comment_form': CommentForm(),
'note': note,
'reply_form': ReplyForm(),
'static': settings.STATIC_URL,
}
comment_form = loader.get_template('comments/comment_form.html')
comment_temp = loader.get_template('comments/comment.html')
context = RequestContext(request, add_csrf(request, d))
data = {
'comment': comment_temp.render(context),
'comment_count': note.comment_count(),
'comment_form': comment_form.render(context),
'comment_pk': comment.pk,
'note_pk': note.pk,
}
return HttpResponse(json.dumps(data), mimetype='application/json')
return HttpResponseRedirect(reverse('readings.views.detail',
args=[reading.slug]))
def fave(request, slug):
"""Save reading to current user's favorites."""
reading = get_object_or_404(Reading, slug=slug)
if request.method == 'POST':
# Check to see if user already has reading saved to favorites
try:
favorite = request.user.favorite_set.get(reading=reading)
# del rep
del_rep(request, fv=favorite)
favorite.delete()
# If user has not saved reading to favorites
except ObjectDoesNotExist:
favorite = request.user.favorite_set.create(reading=reading)
# add rep
add_rep(request, fv=favorite)
d = {
'reading': reading,
'static': settings.STATIC_URL,
}
t = loader.get_template('favorites/favorite_form.html')
context = RequestContext(request, add_csrf(request, d))
data = {
'favorite_count': len(request.user.favorite_set.all()),
'favorite_form': t.render(context),
'pk': reading.pk,
}
return HttpResponse(json.dumps(data), mimetype='application/json')
return HttpResponseRedirect(reverse('readings.views.detail',
args=[reading.slug]))
def detail(request, slug):
"""Reading detail."""
reading = get_object_or_404(Reading, slug=slug)
# get next and previous reading
readings = Reading.objects.all().values("pk").order_by("pk")
first_pk = readings[0]["pk"]
last_pk = readings.reverse()[0]["pk"]
next_count = reading.pk + 1
next_read = None
prev_count = reading.pk - 1
prev_read = None
# if reading is the most recent reading
if reading.pk == last_pk:
next_read = Reading.objects.get(pk=first_pk)
# if reading is not the most recent reading
else:
while not next_read and next_count <= last_pk:
try:
next_read = Reading.objects.get(pk=next_count)
except ObjectDoesNotExist:
next_count += 1
# if reading is the oldest reading
if reading.pk == first_pk:
prev_read = Reading.objects.get(pk=last_pk)
# if reading is not the oldest reading
else:
while not prev_read and prev_count >= first_pk:
try:
prev_read = Reading.objects.get(pk=prev_count)
except ObjectDoesNotExist:
prev_count -= 1
comment_form = CommentForm()
note_form = NoteForm()
reply_form = ReplyForm()
if request.user.is_anonymous():
next = reverse("readings.views.detail", args=[slug])
request.session["next"] = next
user_tag = None
else:
next = ""
request.session.get("next", "")
user_tag = reading.tie_set.filter(user=request.user)
d = {
"comment_form": comment_form,
"form": NewMessageForm(),
"next": next,
"next_read": next_read,
"note_form": note_form,
"prev_read": prev_read,
"reading": reading,
"reply_form": reply_form,
"title": reading.title,
"user_tag": user_tag,
}
return render_to_response("readings/detail.html", add_csrf(request, d), context_instance=RequestContext(request))
def edit(request, slug):
reading = get_object_or_404(Reading, slug=slug)
if request.user.pk != reading.user.pk and not request.user.is_staff:
return HttpResponseRedirect(reverse("readings.views.list_user", args=[request.user.profile.slug]))
if request.method == "POST":
# only save the image
reading.image = request.POST.get("image")
reading.save()
messages.success(request, "Reading updated")
return HttpResponseRedirect(reverse("readings.views.detail", args=[reading.slug]))
d = {"form": EditReadingForm(instance=reading), "reading": reading, "title": "Edit Reading"}
return render_to_response("readings/new.html", add_csrf(request, d), context_instance=RequestContext(request))
def list_user(request, slug):
"""Readings for a single user."""
profile = get_object_or_404(Profile, slug=slug)
user = User.objects.get(pk=profile.user_id)
readings = Reading.objects.filter(user=user).order_by("-created")
d = {
"current_pk": user.pk,
"objects": page(request, readings, 10),
"profile_user": user,
"title": "%s Reads" % user.first_name,
}
return render_to_response("readings/feed.html", add_csrf(request, d), context_instance=RequestContext(request))
def follow(request, slug):
"""Follow or unfollow a user."""
user = user_exists(slug)
change_count = 1
# if request method is POST and
# the follow/unfollow user is not the current user
if request.method == 'POST' and user.pk != request.user.pk:
# if request POST has follow in it
if request.POST.get('follow'):
# follow user
follow = user.followed_set.create(follower=request.user)
# add rep
add_rep(request, fw=follow)
# create notification
notify(follow=follow)
# if request POST has unfollow in it
elif request.POST.get('unfollow'):
# unfollow user
follow = user.followed_set.filter(follower=request.user)[0]
# del rep
del_rep(request, fw=follow)
follow.delete()
# if current user is on another user's page
if user.pk == int(request.POST.get('current_pk', 0)):
followers_count = str(user.profile.followers_count())
following_count = str(user.profile.following_count())
# if current user is on their own page
elif request.user.pk == int(request.POST.get('current_pk', 0)):
followers_count = str(request.user.profile.followers_count())
following_count = str(request.user.profile.following_count())
# if current user is not on anyone's page
else:
followers_count = 0
following_count = 0
change_count = 0
d = {
'current_pk': request.POST.get('current_pk'),
'profile_user': user,
}
t = loader.get_template('follows/follow_form.html')
c = RequestContext(request, add_csrf(request, d))
data = {
'change_count': change_count,
'follow_form': t.render(c),
'followers_count': followers_count,
'following_count': following_count,
'user_id': str(user.pk),
}
return HttpResponse(json.dumps(data), mimetype='application/json')
else:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[profile.slug]))
def follow_tag(request, slug):
"""Follow or unfollow a tag."""
tag = get_object_or_404(Tag, slug=slug)
if request.method == 'POST':
# If current user is already following tag
if request.user in tag.followers():
# delete tag follow
tagfollow = tag.tagfollow_set.get(user=request.user)
# del rep
del_rep(request, tf=tagfollow)
tagfollow.delete()
# If current user is not following tag
else:
# create tag follow
tagfollow = request.user.tagfollow_set.create(tag=tag)
# add rep
add_rep(request, tf=tagfollow)
d = {
'tag': tag,
}
t = loader.get_template('follows/tagfollow_form.html')
context = RequestContext(request, add_csrf(request, d))
data = {
'tagfollowers_count': tag.followers_count(),
'tag_pk': tag.pk,
'tagfollow_form': t.render(context),
'topic_count': request.user.profile.topic_count(),
}
tie = tag.tie_set.all()[0]
if tie:
d = { 'tie': tie }
t = loader.get_template('follows/tiefollow_form.html')
context = RequestContext(request, add_csrf(request, d))
data['tiefollow_form'] = t.render(context)
return HttpResponse(json.dumps(data), mimetype='application/json')
return HttpResponseRedirect(reverse('tags.views.detail',
args=[tag.slug]))
def category(request, slug, category):
"""
Show all readings that user has commented,
faved, added a note, tagged, or voted on.
"""
profile = get_object_or_404(Profile, slug=slug)
user = profile.user
if category == 'comments':
if profile.comment_reply_count() == 0:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[profile.slug]))
li = [comment.note.reading for comment in user.comment_set.all()]
li += [reply.comment.note.reading for reply in user.reply_set.all()]
li = set(li)
title = 'Commented'
if category == 'favorites':
if profile.favorite_count() == 0:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[profile.slug]))
li = set([fave.reading for fave in user.favorite_set.all()])
title = 'Favorite'
if category == 'notes':
if profile.note_count() == 0:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[profile.slug]))
li = set([note.reading for note in user.note_set.all()])
title = 'Noted'
if category == 'tags':
if profile.tie_count() == 0:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[profile.slug]))
li = set([tie.reading for tie in user.tie_set.all()])
title = 'Tagged'
if category == 'votes':
if profile.vote_count() == 0:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[profile.slug]))
li = set([vote.note.reading for vote in user.vote_set.all()])
title = 'Voted'
readings = reading_sorted(li)
d = {
'current_pk': user.pk,
'objects': page(request, readings, 10),
'profile_user': user,
'title': "%s's %s Readings" % (user.first_name, title),
}
return render_to_response('readings/feed.html', add_csrf(request, d),
context_instance=RequestContext(request))
def delete(request, slug):
"""Delete current user's tie tag for reading."""
reading = get_object_or_404(Reading, slug=slug)
if request.method == "POST":
try:
tie = reading.tie_set.get(user=request.user)
if request.POST.get("delete") == str(tie.pk):
# del rep
del_rep(request, t=tie)
tie.delete()
d = {"reading": reading}
tag_form = loader.get_template("tags/tag_form.html")
context = RequestContext(request, add_csrf(request, d))
data = {"tag_form": tag_form.render(context), "tie_id": request.POST.get("delete")}
return HttpResponse(json.dumps(data), mimetype="application/json")
except ObjectDoesNotExist:
messages.error(request, "You have not added a tag to this read")
return HttpResponseRedirect(reverse("readings.views.detail", args=[reading.slug]))
def new(request, slug):
"""Create new note for reading."""
reading = get_object_or_404(Reading, slug=slug)
if request.method == 'POST':
form = NoteForm(request.POST)
if form.is_valid():
note = form.save(commit=False)
note.reading = reading
note.user = request.user
note.save()
# facebook open graph add note
facebook_graph_add_note(request.user, reading)
# add rep
add_rep(request, n=note)
request.user.vote_set.create(note=note, value=1)
notify(note=note)
if request.user.is_staff:
# auto create votes for reading and reading.notes
auto_vote(request, reading)
d = {
'comment_form': CommentForm(),
'note': note,
'note_form': NoteForm(),
'reading': reading,
'static': settings.STATIC_URL,
}
bullet_notes = loader.get_template('notes/bullet_notes.html')
note_form = loader.get_template('notes/note_form.html')
note_temp = loader.get_template('notes/note.html')
context = RequestContext(request, add_csrf(request, d))
data = {
'bullet_notes': bullet_notes.render(context),
'note': note_temp.render(context),
'note_form': note_form.render(context),
'note_pk': note.pk,
}
return HttpResponse(json.dumps(data), mimetype='application/json')
return HttpResponseRedirect(reverse('readings.views.detail',
args=[reading.slug]))
def reading(request, slug):
"""Detail reading."""
reading = get_object_or_404(Reading, slug=slug)
if request.method == 'POST':
if request.user.pk == 2:
form = DavidNoteForm(request.POST)
else:
form = AdminNoteForm(request.POST)
if form.is_valid():
# save note
note = form.save(commit=False)
note.reading = reading
note.save()
# facebook open graph add note
if note.user.pk == request.user.pk:
facebook_graph_add_note(request.user, reading)
# add rep
add_rep(request, n=note)
# create notification
notify(note=note)
note.user.vote_set.create(note=note, value=1)
# auto create votes for reading and reading.notes
auto_vote(request, reading)
messages.success(request, 'Note created')
return HttpResponseRedirect(reverse('admins.views.reading',
args=[reading.slug]))
else:
if request.user.pk == 2:
form = DavidNoteForm()
else:
form = AdminNoteForm()
d = {
'form': form,
'reading': reading,
'title': 'Reading: Add Note',
}
return render_to_response('admins/detail_reading.html',
add_csrf(request, d), context_instance=RequestContext(request))
def new(request):
"""Login page."""
if request.method == "POST":
email = request.POST.get("email", "").lower()
password = request.POST.get("password")
user = authenticate(email=email, password=password)
if user is not None and user.is_active:
auth.login(request, user)
# login url from login required
if request.POST.get("next"):
return HttpResponseRedirect(request.POST["next"])
# friendly forwarding
elif request.session.get("next"):
next = request.session["next"]
del request.session["next"]
return HttpResponseRedirect(next)
else:
return HttpResponseRedirect(reverse("root_path"))
else:
messages.error(request, "The email or password you have entered is invalid")
next = request.GET.get("next", "")
d = {"title": "Login", "email": request.POST.get("email", ""), "next": next}
return render_to_response("sessions/new.html", add_csrf(request, d), context_instance=RequestContext(request))
def new(request):
"""Add new reading."""
NoteFormset = formset_factory(NoteForm, extra=3)
if request.method == "POST":
link = request.POST.get("link")
form = ReadingForm(request.POST)
formset = NoteFormset(request.POST)
# if reading with link already exists, add notes to it
try:
reading = Reading.objects.get(link=link)
if formset.is_valid():
# add tag
name = request.POST.get("tag_name")
# if user added a tag
if name:
name = name.lower()
pattern = only_letters()
# If name contains only letters
if re.search(pattern, name):
# If name does not contain any banned words
blacklist = banned_words()
if not re.search(blacklist, name):
try:
# If tag exists, get tag
tag = Tag.objects.get(name=name)
except ObjectDoesNotExist:
# If tag does not exist, create tag
tag = Tag(name=name, user=request.user)
tag.slug = slugify(tag.name)
tag.save()
try:
# Check to see if tie exists
tie = reading.tie_set.get(tag=tag)
except ObjectDoesNotExist:
# If tie does not exist, create it
tie = request.user.tie_set.create(reading=reading, tag=tag)
# add rep
add_rep(request, t=tie)
# create notification
notify(tie=tie)
# if user did not add a tag, auto tag
else:
auto_tag(request, reading)
# create notes and add it to the existing reading
for index, note_form in enumerate(formset):
note = note_form.save(commit=False)
note.reading = reading
note.user = request.user
if note.content.strip():
note.save()
# create first vote for note
note.user.vote_set.create(note=note, value=1)
# if this is the first note
if index == 0:
# facebook open graph add note
facebook_graph_add_note(note.user, note.reading)
if request.user.is_staff:
# auto create votes for reading and reading.notes
auto_vote(request, reading)
messages.success(request, "This reading exists, your content has been added to it")
return HttpResponseRedirect(reverse("readings.views.detail", args=[reading.slug]))
# if reading with link does not exist, create the reading
except ObjectDoesNotExist:
if form.is_valid() and formset.is_valid():
reading = form.save(commit=False)
reading.user = request.user
reading.save()
# create vote for reading
reading.vote_set.create(user=reading.user, value=1)
# add tag
name = request.POST.get("tag_name")
# if user added tag
if name:
name = name.lower()
pattern = only_letters()
# If name contains only letters
if re.search(pattern, name):
# If name does not contain any banned words
blacklist = banned_words()
if not re.search(blacklist, name):
try:
# If tag exists, get tag
tag = Tag.objects.get(name=name)
except ObjectDoesNotExist:
# If tag does not exist, create tag
tag = Tag(name=name, user=request.user)
tag.slug = slugify(tag.name)
tag.save()
tie = request.user.tie_set.create(reading=reading, tag=tag)
# add rep
add_rep(request, t=tie)
# if user did not add a tag, auto tag
else:
auto_tag(request, reading)
# facebook open graph add reading
facebook_graph_add_reading(request.user, reading)
# add rep
add_rep(request, rd=reading)
# create notes for this reading
for note_form in formset:
note = note_form.save(commit=False)
note.reading = reading
note.user = request.user
if note.content.strip():
note.save()
# create first vote for note
request.user.vote_set.create(note=note, value=1)
if request.user.is_staff:
# auto create votes for reading and reading.notes
auto_vote(request, reading)
messages.success(request, "Reading created")
return HttpResponseRedirect(reverse("readings.views.detail", args=[reading.slug]))
else:
form = ReadingForm()
formset = NoteFormset()
di = {"static": settings.STATIC_URL}
t = loader.get_template("javascript/bookmarklet.js")
context = RequestContext(request, di)
d = {
"bookmarklet": re.sub(r"\s", "%20", str(t.render(context))),
"form": form,
"formset": formset,
"title": "New Reading",
}
return render_to_response("readings/new.html", add_csrf(request, d), context_instance=RequestContext(request))
def followers(request, slug):
"""Show all followers for tag."""
tag = get_object_or_404(Tag, slug=slug)
users = sorted([tf.user for tf in tag.tagfollow_set.all()])
d = {"tag": tag, "title": "%s Followers" % tag.name.capitalize(), "users": users}
return render_to_response("tags/followers.html", add_csrf(request, d), context_instance=RequestContext(request))
def detail(request, slug):
"""Show all readings for a single tag."""
tag = get_object_or_404(Tag, slug=slug)
readings = tag.readings()
d = {"objects": page(request, readings, 10), "tag": tag, "title": "%s Reads" % tag.name.capitalize()}
return render_to_response("readings/feed.html", add_csrf(request, d), context_instance=RequestContext(request))
def edit(request, slug):
"""Edit user page."""
user = user_exists(slug)
# Correct user
if request.user.pk is not user.pk or not request.user.is_staff:
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[request.user.profile.slug]))
profile = user.profile
if request.method == 'POST':
form = EditUserForm(request.POST, instance=user)
profile_form = ProfileForm(request.POST, request.FILES,
instance=profile)
if form.is_valid() and profile_form.is_valid():
username = request.POST.get('username')
password = request.POST.get('password1')
# If user changed their password
if password:
user.set_password(password)
user.save()
user = form.save()
# If an image is uploaded
profile = profile_form.save()
# If user changed their username
if username:
profile.slug = slugify(username)
# if user has a profile image and checked clear image
if profile.image and request.POST.get('clear_image'):
profile.image = ''
s3_delete_file(user)
profile.save()
if request.FILES.get('image'):
file_path = settings.MEDIA_ROOT + '/' + profile.image.name
try:
f = open(file_path)
f.close()
name = str(user.pk) + '_orig.jpg'
# Get absolute path of image
absolute_path = absolute_image_path(profile)
# Rename image
rename_image(name, absolute_path)
# Resize original image if too large
resize_orig_image(user)
# Create medium and small images
create_extra_images(user)
# Upload images to Amazon S3
s3_upload(user)
# Remove any old images
remove_images(user)
# Save profile image name
profile.image = name
profile.save()
except IOError as e:
pass
messages.success(request, 'User updated')
return HttpResponseRedirect(reverse('readings.views.list_user',
args=[user.profile.slug]))
else:
form = EditUserForm(instance=user)
profile_form = ProfileForm(instance=profile)
d = {
'title': 'Edit %s' % user.first_name,
'form': form,
'profile_form': profile_form,
}
return render_to_response('users/edit.html', add_csrf(request, d),
context_instance=RequestContext(request))
def new(request):
"""Create new user."""
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
new_user = form.save()
user = auth.authenticate(email=request.POST.get('email').lower())
auth.login(request, user)
# If the user is signing up through ajax form
pk = request.POST.get('reading')
if pk:
reading = get_object_or_404(Reading, pk=pk)
# Create a dictionary of comment & vote forms for each note
comment_forms = defaultdict(str)
vote_forms = defaultdict(str)
notes = reading.note_set.all()
for note in notes:
d = {
'comment_form': CommentForm(),
'note': note,
}
t = loader.get_template('comments/comment_form.html')
v = loader.get_template('votes/vote_form.html')
context = RequestContext(request, add_csrf(request, d))
comment_forms[str(note.pk)] = t.render(context)
vote_forms[str(note.pk)] = v.render(context)
# Create a dictionary of reply forms for each comment
reply_forms = defaultdict(str)
comments = reading.comments()
for comment in comments:
d = {
'comment': comment,
'reply_form': ReplyForm(),
}
t = loader.get_template('replies/reply_form.html')
context = RequestContext(request, add_csrf(request, d))
reply_forms[str(comment.pk)] = t.render(context)
# Create the note & tag form
d = {
'note_form': NoteForm(),
'reading': reading,
'static': settings.STATIC_URL,
}
favorite_form = loader.get_template('favorites/favorite_form.html')
header = loader.get_template('header.html')
note_form = loader.get_template('notes/note_form.html')
tag_form = loader.get_template('tags/tag_form.html')
context = RequestContext(request, add_csrf(request, d))
# Ready all the partials to be outputted as JSON
data = {
'comment_forms': comment_forms,
'favorite_form': favorite_form.render(context),
'header': header.render(context),
'note_form': note_form.render(context),
'reply_forms': reply_forms,
'success': 'yes',
'tag_form': tag_form.render(context),
'vote_forms': vote_forms,
}
return HttpResponse(json.dumps(data),
mimetype='application/json')
messages.success(request,
"""Welcome %s, skim some reads and discover
something new""" % user.first_name)
return HttpResponseRedirect(reverse('readings.views.discover'))
else:
pk = request.POST.get('reading')
if pk:
data = {
'success': 'no',
}
return HttpResponse(json.dumps(data),
mimetype='application/json')
else:
form = SignUpForm()
d = {
'title': 'Welcome',
'form': form,
}
return render_to_response('users/new.html', add_csrf(request, d),
context_instance=RequestContext(request))
def new(request):
"""Create new message."""
if request.method == 'POST':
form = NewMessageForm(request.POST)
content = request.POST.get('content')
name = request.POST.get('to')
# if a name and content was submitted
if content and name:
pattern = re.compile(r'^[-A-Za-z]{2,} [-A-Za-z]{2,}$')
# if submitted recipient name matches correct format
if re.search(pattern, name):
first_name, last_name = name.split()
username = '******' % (first_name.lower().capitalize(),
last_name.lower().capitalize())
# check to see if user with that name exists
try:
user = User.objects.get(username=username)
# create a message where current user is the snder
# and user is the recipient
message = form.save(commit=False)
message.recipient = user
message.sender = request.user
message.save()
# if replying to a message via detail page
if request.POST.get('reply') == '1':
d = {
'form': ReplyMessageForm(),
'message': message,
'profile_user': message.recipient,
}
message = loader.get_template(
'usermessages/message.html')
reply_message_form = loader.get_template(
'usermessages/reply_message_form.html')
context = RequestContext(request, add_csrf(request, d))
data = {
'message': message.render(context),
'reply_message_form': reply_message_form.render(
context),
}
return HttpResponse(json.dumps(data),
mimetype='application/json')
# if creating a new message
else:
return HttpResponseRedirect(
reverse('usermessages.views.detail',
args=[message.recipient.profile.slug]))
# if user does not exist with that name
except ObjectDoesNotExist:
messages.error(request, 'No user found')
else:
messages.error(request, 'What kind of name is that?')
else:
messages.error(request, 'Leave nothing blank')
else:
form = NewMessageForm()
d = {
'form': form,
'title': 'New Message',
}
return render_to_response('usermessages/new.html', add_csrf(request, d),
context_instance=RequestContext(request))
def new_reading(request, pk):
"""Create a downvote or upvote for reading."""
reading = get_object_or_404(Reading, pk=pk)
if request.method == 'POST' and request.POST.get('action'):
# If user is downvoting
if request.POST.get('action') == 'downvote':
value = -1
# If user is upvoting
elif request.POST.get('action') == 'upvote':
value = 1
try:
# Check to see if user already voted
vote = reading.vote_set.get(user=request.user)
# If user already upvoted
if vote.value == 1:
# If user is upvoting again, remove the vote
if value == 1:
# del rep
del_rep(request, v=vote)
vote.delete()
# If user is downvoting, downvote the note
else:
vote.value = value
vote.save()
# If user changes their vote, update the notifications
notifications = Notification.objects.filter(vote=vote)
for notification in notifications:
notification.created = timezone.now()
notification.viewed = False
notification.save()
# If user already downvoted
elif vote.value == -1:
# If user is downvoting again, remove the vote
if value == -1:
# del rep
del_rep(request, v=vote)
vote.delete()
# If user is upvoting, upvote the note
else:
vote.value = value
vote.save()
# If user changes their vote, update the notifications
notifications = Notification.objects.filter(vote=vote)
for notification in notifications:
notification.created = timezone.now()
notification.viewed = False
notification.save()
except ObjectDoesNotExist:
# If the user has not yet voted, create a new vote
vote = request.user.vote_set.create(reading=reading, value=value)
# add rep
add_rep(request, v=vote)
# create notification
notify(vote=vote)
vote_reading_form = loader.get_template('votes/vote_reading_form.html')
context = RequestContext(request, add_csrf(request,
{ 'reading': reading }))
data = {
'pk': reading.pk,
'vote_reading_form': vote_reading_form.render(context),
}
return HttpResponse(json.dumps(data), mimetype='application/json')
return HttpResponseRedirect(reverse('readings.views.detail',
args=[reading.slug]))
def new_reading(request):
"""Create a new reading."""
NoteFormset = formset_factory(NoteForm, extra=3, formset=RequiredFormSet)
if request.method == 'POST':
if request.user.pk == 2:
form = DavidReadingForm(request.POST)
else:
form = AdminReadingForm(request.POST)
formset = NoteFormset(request.POST)
if form.is_valid() and formset.is_valid():
# save reading
reading = form.save()
# add tag
name = request.POST.get('tag_name')
# if user added a tag
if name:
name = name.lower()
pattern = only_letters()
# If name contains only letters
if re.search(pattern, name):
# If name does not contain any banned words
blacklist = banned_words()
if not re.search(blacklist, name):
try:
# If tag exists, get tag
tag = Tag.objects.get(name=name)
except ObjectDoesNotExist:
# If tag does not exist, create tag
tag = Tag(name=name, user=request.user)
tag.slug = slugify(tag.name)
tag.save()
tie = request.user.tie_set.create(reading=reading,
tag=tag)
# add rep
add_rep(request, t=tie)
# if user did not add a tag, auto tag
else:
auto_tag(request, reading)
# facebook open graph add reading
if reading.user.pk == request.user.pk:
facebook_graph_add_reading(request.user, reading)
# add rep
add_rep(request, rd=reading)
first = True
# save each note
for note_form in formset:
note = note_form.save(commit=False)
if note.content.strip():
note.reading = reading
# if this is the first note
# set note.user to reading.user
if first:
note.user = reading.user
first = False
else:
note.user = random_user()
# save note
note.save()
# create first vote for note
note.user.vote_set.create(note=note, value=1)
# add rep
add_rep(request, n=note)
# auto create votes for reading and reading.notes
auto_vote(request, reading)
messages.success(request, 'Reading created')
return HttpResponseRedirect(reverse('admins.views.reading',
args=[reading.slug]))
else:
if request.user.pk == 2:
form = DavidReadingForm()
else:
form = AdminReadingForm()
formset = NoteFormset()
di = { 'static': settings.STATIC_URL }
t = loader.get_template('javascript/bookmarklet.js')
context = RequestContext(request, di)
d = {
'bookmarklet': re.sub(r'\s', '%20', str(t.render(context))),
'form': form,
'formset': formset,
'title': 'New Reading',
}
return render_to_response('readings/new.html', add_csrf(request, d),
context_instance=RequestContext(request))
def detail_show(request, slug, show, pk):
"""Reading detail."""
if show == "comments":
comment = get_object_or_404(Comment, pk=pk)
a = {"comment_show": comment.note.pk, "comment_focus": comment.pk}
elif show == "notes":
note = get_object_or_404(Note, pk=pk)
a = {"note_focus": note.pk}
elif show == "replies":
reply = get_object_or_404(Reply, pk=pk)
a = {"comment_show": reply.comment.note.pk, "reply_focus": reply.pk, "reply_show": reply.comment.pk}
elif show == "ties":
tie = get_object_or_404(Tie, pk=pk)
a = {"tie_focus": tie.pk}
elif show == "votes":
vote = get_object_or_404(Vote, pk=pk)
if vote.value == 1:
value = 1
else:
value = -1
if vote.note:
a = {"note_pk": vote.note.pk}
elif vote.reading:
a = {"reading_pk": vote.reading.pk}
a["value"] = value
reading = get_object_or_404(Reading, slug=slug)
# get next and previous reading
readings = Reading.objects.all().values("pk").order_by("pk")
first_pk = readings[0]["pk"]
last_pk = readings.reverse()[0]["pk"]
next_count = reading.pk + 1
next_read = None
prev_count = reading.pk - 1
prev_read = None
# if reading is the most recent reading
if reading.pk == last_pk:
next_read = Reading.objects.get(pk=first_pk)
# if reading is not the most recent reading
else:
while not next_read and next_count <= last_pk:
try:
next_read = Reading.objects.get(pk=next_count)
except ObjectDoesNotExist:
next_count += 1
# if reading is the oldest reading
if reading.pk == first_pk:
prev_read = Reading.objects.get(pk=last_pk)
# if reading is not the oldest reading
else:
while not prev_read and prev_count >= first_pk:
try:
prev_read = Reading.objects.get(pk=prev_count)
except ObjectDoesNotExist:
prev_count -= 1
comment_form = CommentForm()
note_form = NoteForm()
reply_form = ReplyForm()
if request.user.is_anonymous():
user_tag = None
else:
user_tag = reading.tie_set.filter(user=request.user)
b = {
"comment_form": comment_form,
"form": NewMessageForm(),
"next_read": next_read,
"note_form": note_form,
"prev_read": prev_read,
"reading": reading,
"reply_form": reply_form,
"title": reading.title,
"user_tag": user_tag,
}
d = dict(a.items() + b.items())
return render_to_response("readings/detail.html", add_csrf(request, d), context_instance=RequestContext(request))
def new_bookmarklet(request):
"""Create new reading from bookmarklet."""
if request.method == "POST":
content = request.POST.get("content", "")
image = request.POST.get("image", "")
link = request.POST.get("link", "")
titl = request.POST.get("title", "")[:80]
if request.user.is_staff:
user_pk = request.POST.get("user")
if user_pk:
try:
user = User.objects.get(pk=int(user_pk))
except ObjectDoesNotExist:
user = request.user
else:
user = request.user
else:
user = request.user
# if there is a link and title, create reading
if link and titl:
try:
# if reading with link exists, add notes to that reading
reading = Reading.objects.get(link=link)
reading_exists = True
except ObjectDoesNotExist:
reading_exists = False
titles = Reading.objects.filter(title=titl)
# if there is a reading with the title
if titles:
titl = "%s-%s" % (titl, str(titles.count()))
reading = Reading(image=image, link=link, title=titl, user=user)
reading.save()
# create vote for reading
reading.vote_set.create(user=user, value=1)
# add tag
name = request.POST.get("tag_name")
# if user added tag
if name:
try:
# check to see if user already tied a tag to this reading
existing_tie = reading.tie_set.get(user=user)
# if user has not added a tag to this reading
except ObjectDoesNotExist:
name = name.lower()
pattern = only_letters()
# If name contains only letters
if re.search(pattern, name):
# If name does not contain any banned words
blacklist = banned_words()
if not re.search(blacklist, name):
try:
# If tag exists, get tag
tag = Tag.objects.get(name=name)
except ObjectDoesNotExist:
# If tag does not exist, create tag
tag = Tag(name=name, user=user)
tag.slug = slugify(tag.name)
tag.save()
tie = user.tie_set.create(reading=reading, tag=tag)
# add rep
add_rep(request, t=tie)
# if user did not add a tag, auto tag
else:
auto_tag(request, reading)
# add rep
add_rep(request, rd=reading)
# if there is content, create note
if content.strip():
note = Note(content=content, reading=reading, user=user)
note.save()
# create first vote for note
user.vote_set.create(note=note, value=1)
if reading_exists:
facebook_graph_add_note(note.user, note.reading)
if not reading_exists:
facebook_graph_add_reading(reading.user, reading)
if request.user.is_staff:
# auto create votes for reading and reading.notes
auto_vote(request, reading)
data = {"success": 1}
return HttpResponse(json.dumps(data), mimetype="application/json")
content = request.GET.get("note", "").lstrip(" ")
link = request.GET.get("link", "")
# split title
html_title = split_title(request.GET.get("title", ""))
if request.user.is_staff:
if request.user.pk == 2:
users = admin_david_list()
else:
users = admin_user_list()
else:
users = []
d = {"content": content, "link": link, "titl": html_title, "title": "Add Reading", "users": users}
return render_to_response(
"readings/new_bookmarklet.html", add_csrf(request, d), context_instance=RequestContext(request)
)
