def post(self, request):
"""
Presenta el formuario para crear un post y en el caso de que la petición sea post la valida
y la crea en el caso de que sea válida
Args:
request:
returns:
"""
message = None
post_with_user = Post(owner=request.user)
post_form = PostCreationForm(request.POST, instance=post_with_user)
complete_date = request.POST.get(
"publication_date") + " " + request.POST.get("publication_time")
validate_date = datetime.strptime(complete_date, "%Y-%m-%d %H:%M")
# Add timezone (avoid warning):
utc = pytz.utc
validate_date_utc = utc.localize(validate_date)
if post_form.is_valid():
post_form.instance.publication_at = validate_date_utc
post_form.save()
# post_form = PostCreationForm() # vaciamos el formulario
else:
context = {'form': post_form, 'message': message}
return render(request, 'posts/post_creation.html', context)
messages.add_message(request, messages.INFO,
"Artículo creado satisfactoriamente")
return redirect(reverse('post_detail', args=[post_form.instance.pk]))
def events_create(request, club_name_slug):
club_name = club_name_slug.replace('-', ' ')
club = get_object_or_404(Club, name=club_name)
user = request.user
if not ClubMember.objects.filter(club=club, user=request.user).exists():
raise PermissionDenied("Only Club members can create posts")
if request.method == "POST":
postform = PostCreationForm(request.POST, request.FILES)
eventform = EventForm(data=request.POST)
if postform.is_valid() and eventform.is_valid():
post = create_post_generic(request, club, postform)
event = eventform.save(commit=False)
event.post = post
event.save()
if post.is_approved:
send_new_post_notification(request, post)
return redirect('posts:post_detail', club_name_slug,
post.encrypted_id)
else:
postform = PostCreationForm()
eventform = EventForm()
return render(request, 'posts/event_create.html', {
'postform': postform,
'eventform': eventform
})
def new(request):
if request.method == "POST":
form = PostCreationForm(request.POST)
if form.is_valid():
post = form.save(request.user)
return HttpResponseRedirect(reverse('posts.views.show', args=[post.pk]))
else:
form = PostCreationForm()
return render(request, 'posts/new.html', { 'form': form })
def create_post_view(request):
if request.method == 'POST':
title_text = request.POST.get('title')
post_text = request.POST.get('body')
image_url = request.FILES.get('image')
response_data = {}
post = Post(title=title_text, body=post_text,
author=request.user, image=image_url)
post.save()
response_data['title'] = post.title
response_data['body'] = post.body
if post.image:
response_data['image'] = post.image.url
else:
response_data['image'] = ''
response_data['author'] = post.author.username
response_data['id'] = post.id
response_data['created_date'] = post.created_date.strftime(
'%B %d, %Y %I:%M %p')
print(response_data)
return JsonResponse(response_data)
else:
post_list = Post.objects.all().order_by('-created_date')
form = PostCreationForm()
template = 'posts/create_post.html'
page_template = 'posts/post_list.html'
query = request.GET.get("qry")
if query:
post_list = post_list.filter(Q(title__contains=query) |
Q(body__contains=query))
if request.is_ajax():
template = page_template
return render(request, template, {'form': form, 'list': post_list,
'page_template': page_template, })
def edit_poll(request, encrypted_id):
poll = get_object_or_404(Poll, post__encrypted_id=encrypted_id)
if poll.post.author != request.user:
raise PermissionDenied("You are not authorized to edit this post")
if request.method == "POST":
post_form = PostCreationForm(request.POST,
request.FILES,
instance=poll.post)
poll_form = PollCreateForm(request.POST, instance=poll)
if post_form.is_valid() and poll_form.is_valid():
poll_form.save()
post_form.save()
return redirect('posts:post_detail',
poll.post.club.name.replace(' ', '-'),
poll.post.encrypted_id)
else:
post_form = PostCreationForm(instance=poll.post)
poll_form = PollCreateForm(instance=poll)
return render(
request, 'posts/poll_create.html', {
'club_name': poll.post.club.name.replace(' ', '-'),
"post_create_form": post_form,
"poll_create_form": poll_form,
"edit": True
})
def create_poll(request, club_name_slug):
club_name = club_name_slug.replace('-', ' ')
club = get_object_or_404(Club, name=club_name)
if not ClubMember.objects.filter(club=club, user=request.user).exists():
raise PermissionDenied("Only Club members can create posts")
if request.method == "POST":
print(request.POST)
post_create_form = PostCreationForm(request.POST, request.FILES)
poll_create_form = PollCreateForm(request.POST)
if post_create_form.is_valid() and poll_create_form.is_valid():
post = create_post_generic(request, club, post_create_form)
if 'cover_image' in request.FILES:
post.cover_image = request.FILES['cover_image']
post.save()
poll = poll_create_form.save(commit=False)
poll.post = post
poll.save()
option_count = int(request.POST['hidden-count'])
for option in range(option_count):
Option.objects.create(poll=poll,
option_text=request.POST[str(option)])
if post.is_approved:
send_new_post_notification(request, post)
return redirect('posts:post_detail', club_name_slug,
post.encrypted_id)
else:
post_create_form = PostCreationForm()
poll_create_form = PollCreateForm()
return render(
request, 'posts/poll_create.html', {
'club_name': club_name_slug,
"post_create_form": post_create_form,
"poll_create_form": poll_create_form
})
def edit(request, post_id):
try:
post = Post.objects.select_related().get(pk=post_id)
except Post.DoesNotExist:
raise Http404
if not request.user.is_staff or post.created_by != request.user:
return HttpResponseRedirect(reverse('posts.views.show', args=[post.pk]))
if request.method == "POST":
form = PostCreationForm(request.POST, instance=post)
if form.is_valid():
post = form.save(request.user)
return HttpResponseRedirect(reverse('posts.views.show', args=[post.pk]))
else:
form = PostCreationForm(instance=post)
return render(request, 'posts/edit.html', { 'form': form })
def get(self, request):
"""
Presenta el formulario para crear un post y, en caso de que la petición sea POST la valida
y la crea en caso de que sea válida
:param request: objeto HttpRequest con los datos de la petición
:return: HttpResponse con la plantilla
"""
message = None
photo_form = PostCreationForm()
context = {'form': photo_form, 'message': message}
return render(request, 'posts/post_creation.html', context)
def post(self, request):
"""
Presenta el formuario para crear un post y en el caso de que la petición sea post la valida
y la crea en el caso de que sea válida
Args:
request:
returns:
"""
message = None
post_with_user = Post(owner=request.user)
post_form = PostCreationForm(request.POST, instance=post_with_user)
if post_form.is_valid():
new_post = post_form.save()
# post_form = PostCreationForm() # vaciamos el formulario
message = 'Artículo creado satisfactoriamente <a href="{0}">Ver artículo</a>'.format(
reverse('post_detail', args=[new_post.pk]))
context = {'form': post_form, 'message': message}
# return render(request, 'posts/post_creation.html', context)
messages.add_message(request, messages.INFO, "Artículo creado satisfactoriamente")
return redirect(reverse('post_detail', args=[new_post.pk]))
def create_post(request, club_name_slug):
club_name = club_name_slug.replace('-', ' ')
club = get_object_or_404(Club, name=club_name)
if not ClubMember.objects.filter(club=club, user=request.user).exists():
raise PermissionDenied("Only Club members can create posts")
if request.method == "POST":
form = PostCreationForm(request.POST, request.FILES)
if form.is_valid():
post = create_post_generic(request, club, form)
if post.is_approved:
send_new_post_notification(request, post)
return redirect("posts:post_detail", club_name_slug,
post.encrypted_id)
else:
form = PostCreationForm()
context = {
"form": form,
}
return render(request, "posts/post_add.html", context)
def post(self, request):
"""
Presenta el formuario para crear un post y en el caso de que la petición sea post la valida
y la crea en el caso de que sea válida
Args:
request:
returns:
"""
message = None
post_with_user = Post(owner=request.user)
post_form = PostCreationForm(request.POST, instance=post_with_user)
if post_form.is_valid():
new_post = post_form.save()
# post_form = PostCreationForm() # vaciamos el formulario
message = 'Artículo creado satisfactoriamente <a href="{0}">Ver artículo</a>'.format(
reverse('post_detail', args=[new_post.pk]))
context = {'form': post_form, 'message': message}
# return render(request, 'posts/post_creation.html', context)
messages.add_message(request, messages.INFO,
"Artículo creado satisfactoriamente")
return redirect(reverse('post_detail', args=[new_post.pk]))
def get(self, request):
"""
Method get to create a new post
:param request: HttpRequest object
:return: HttpResponse object with the response
"""
message = None
categories = Category.objects.all()
post_form = PostCreationForm()
context = {
'form': post_form,
'categories_list': categories,
'message': message
}
return render(request, 'posts/post_creation.html', context)
def edit_post(request, encrypted_id):
post = get_object_or_404(Post, encrypted_id=encrypted_id)
if post.author != request.user:
raise PermissionDenied("You are not authorized to edit this post")
if request.method == "POST":
form = PostCreationForm(request.POST, request.FILES, instance=post)
if form.is_valid():
form.save()
club_name_slug = post.club.name.replace(' ', '-')
return redirect("posts:post_detail", club_name_slug,
post.encrypted_id)
else:
form = PostCreationForm(instance=post)
context = {
"form": form,
}
return render(request, "posts/post_edit.html", context)
def post(self, request):
"""
Presenta el formulario para crear un post
:param request: objeto HttpRequest con los datos de la petición
:return: HttpResponse con la plantilla
"""
message = None
post_with_user = Post(owner=request.user)
post_form = PostCreationForm(request.POST, instance=post_with_user)
if post_form.is_valid():
new_post = post_form.save()
post_form = PostCreationForm()
message = "Post creado satisfactoriamente. <a href='{0}'>Ver post</a>".format(
reverse('post_detail',
args=(new_post.owner.username, new_post.pk)))
context = {'form': post_form, 'message': message}
return render(request, 'posts/post_creation.html', context)
def events_edit(request, encrypted_id):
post = get_object_or_404(Post, encrypted_id=encrypted_id)
event = get_object_or_404(Event, post=post)
if request.user != post.author:
raise PermissionDenied("You are not allowed to edit this event")
if request.method == "POST":
eventform = EventForm(request.POST or None, instance=event)
postform = PostCreationForm(request.POST, request.FILES, instance=post)
if postform.is_valid() and eventform.is_valid():
postform.save()
eventform.save()
return redirect('posts:post_detail',
post.club.name.replace(' ', '-'),
post.encrypted_id)
else:
eventform = EventForm(instance=event)
postform = PostCreationForm(instance=post)
return render(request, 'posts/event_create.html', {
'postform': postform,
'eventform': eventform
})
