def list_posts(request):
posts = get_active_event().posts.all()
ctx = {}
ctx['posts'] = posts
return render(request, 'blog/list_posts.html', ctx)
def event(request):
event = get_active_event()
return {
'event': event,
'cfp': event.get_cfp(),
}
def get_queryset(self):
event = get_active_event()
return (super().get_queryset().filter(event=event,
published=True).prefetch_related(
'applicants__user',
'skill_level'))
def list_schedule(request):
talks = get_active_event().talks.prefetch_related("applicants",
"applicants__user",
"sponsor")
return render(request, 'schedule/schedule.html',
{"schedule_talks": {t.slug: t
for t in talks}})
def get_invite(self, request):
"""
If invite_token is specified in the URL, return the corresponding Invite.
"""
invite_token = request.GET.get('invite_token')
if not invite_token or not is_uuid(invite_token):
return None
event = get_active_event()
return Invite.objects.filter(user=request.user,
token=invite_token,
cfp__event=event).first()
def list_talks(request):
event = get_active_event()
talks = event.talks.prefetch_related(
'skill_level',
'sponsor',
'application__applicant',
'application__applicant__user',
).order_by('-keynote', 'title')
return render(request, 'talks/list_talks.html', {
"talks": talks,
})
def index(request):
event = get_active_event()
posts = event.posts.all()[:3]
talks = event.talks.filter(keynote=False).order_by('?')[:3]
workshops = event.workshops.filter(published=True).order_by('?')[:3]
return render(
request, 'ui/index.html', {
"is_frontpage": True,
"posts": posts,
"talks": talks,
"workshops": workshops,
})
def _get_ticket_and_application(ticket_code, application_id):
event = get_active_event()
ticket = _get_ticket_by_code(event, ticket_code)
if not ticket:
raise SuspiciousOperation()
application = get_object_or_404(PaperApplication, id=application_id)
# Only able to vote for the event for which the ticket is
if ticket.event != application.cfp.event:
raise SuspiciousOperation()
return ticket, application
def test_vote_unvote(client):
enable_voting()
event = get_active_event()
cfp = CallForPaperFactory(event=event)
ticket = TicketFactory(event=event)
application = PaperApplicationFactory(cfp=cfp)
vote_url = reverse('voting_add_vote',
kwargs={
"ticket_code": ticket.code,
"application_id": application.pk,
})
unvote_url = reverse('voting_remove_vote',
kwargs={
"ticket_code": ticket.code,
"application_id": application.pk,
})
assert CommunityVote.objects.count() == 0
# Get forbidden
response = client.get(vote_url)
assert response.status_code == 405
# Vote
response = client.post(vote_url)
assert response.status_code == 200
assert response.json() == {"voted": True}
assert CommunityVote.objects.count() == 1
# Idempotent vote
response = client.post(vote_url)
assert response.status_code == 200
assert response.json() == {"voted": True}
assert CommunityVote.objects.count() == 1
# Unvote
response = client.post(unvote_url)
assert response.status_code == 200
assert response.json() == {"voted": False}
assert CommunityVote.objects.count() == 0
# Idempotent unvote
response = client.post(unvote_url)
assert response.status_code == 200
assert response.json() == {"voted": False}
assert CommunityVote.objects.count() == 0
def test_voting_view_enabled_with_ticket(client):
enable_voting()
event = get_active_event()
ticket = TicketFactory(event=event, category="Early Bird")
url = reverse('voting_index', kwargs={"ticket_code": ticket.code})
response = client.get(url)
content = response.content.decode(response.charset)
assert response.status_code == 200
assert "Welcome to the community vote" in content
# Warning they need to enter a ticket code to vote
assert 'warning callout' not in content
assert 'You are voting as' in content
assert ticket.full_name in content
def index(request):
event = get_active_event()
posts = event.posts.all()[:3]
talks = (event.talks.prefetch_related(
'applicants__user',
'skill_level').filter(keynote=False).order_by('?')[:3])
workshops = (event.workshops.prefetch_related('applicants__user').filter(
published=True).order_by('?')[:3])
return render(
request, 'ui/index.html', {
"is_frontpage": True,
"posts": posts,
"talks": talks,
"workshops": workshops,
})
def test_only_able_to_vote_for_talks_in_event_for_which_they_have_a_ticket(
client):
enable_voting()
event = get_active_event()
ticket = TicketFactory(event=event)
# Create a paper application for another event
some_other_event = EventFactory()
some_other_cfp = CallForPaperFactory(event=some_other_event)
application = PaperApplicationFactory(cfp=some_other_cfp)
vote_url = reverse('voting_add_vote',
kwargs={
"ticket_code": ticket.code,
"application_id": application.pk,
})
# Vote should not be possible
response = client.post(vote_url)
assert response.status_code == 400
def get_applications(self):
applicant = self.get_applicant()
event = get_active_event()
return applicant.applications.filter(
cfp__event=event) if applicant else []
def active_event():
return get_active_event()
def past_cfp():
event = get_active_event()
begin_date = date.today() - timedelta(10)
end_date = date.today() - timedelta(5)
return CallForPaperFactory(event=event, begin_date=begin_date, end_date=end_date)
def view_talk(request, slug):
event = get_active_event()
talk = get_object_or_404(Talk, slug=slug, event=event)
return render(request, 'talks/view_talk.html', {'talk': talk})
from blog.models import Post
from config.utils import get_active_event
from django.contrib.sites.models import Site
from django.template.loader import render_to_string
from django.utils.html import strip_tags
from django.utils.text import wrap
from gopher.ascii_art import header
from pages.models import Page
from talks.models import Talk
from twisted.internet import protocol
from workshops.models import Workshop
site = Site.objects.get_current()
domain = site.domain.split(":")[0]
event = get_active_event()
class Gopher(protocol.Protocol):
@property
def port(self):
return self.transport.server.port
def file_item(self, title, id):
line = f"0{title}\t{id}\t{domain}\t{self.port}\r\n"
self.transport.write(line.encode())
def menu_item(self, title, id):
line = f"1{title}\t{id}\t{domain}\t{self.port}\r\n"
self.transport.write(line.encode())
