def publish(request, topicid):
topic = Topic.objects.get(id=topicid)
if not topiclead(request.user, topic):
return HttpResponseForbidden("Forbidden")
list_calls = ""
baseurl = "http://%s.sched.org/api/session/" % settings.SCHED_URL
for slot in Slot.objects.filter(topic=topicid):
if len(slot.proposals.all()) > 0:
values = {'api_key': settings.SCHED_API_KEY,
'session_key': "slot-%d" % combined_id(slot),
'name': smart_str(combined_title(slot)),
'session_start': slot.start_time,
'session_end': end_time(slot.start_time),
'session_type': 'Design Summit',
'session_subtype': slot.topic,
'venue': slot.room.name,
'description': htmlize(smart_str(
full_description(slot)))}
data = urllib.urlencode(values)
if settings.SCHED_API_KEY == "getThisFromSched":
list_calls += "%s<P>" % data
else:
f = urllib2.urlopen(baseurl + "mod", data)
if f.readline().startswith("ERR:"):
f.close()
f = urllib2.urlopen(baseurl + "add", data)
f.close()
return render(request, "sched.html",
{'list_calls': list_calls,
'topic': topic})
def scheduling(request, topicid):
topic = Topic.objects.get(id=topicid)
if not topiclead(request.user, topic):
return HttpResponseForbidden("Forbidden")
if request.method == 'POST':
action = request.POST['action']
proposal = Proposal.objects.get(id=request.POST['proposal'])
slot = Slot.objects.get(id=request.POST['slot'])
already_scheduled = slot.proposals.all()
if action == "add":
if proposal not in already_scheduled:
slot.proposals.add(proposal)
slot.save()
proposal.scheduled = True
proposal.save()
if action == "del":
if proposal in already_scheduled:
if len(already_scheduled) == 1:
slot.title = ""
slot.description = ""
slot.proposals.remove(proposal)
slot.save()
proposal.scheduled = False
proposal.save()
accepted = Proposal.objects.filter(status='A', scheduled=False,
topic=topic)
schedule = Slot.objects.filter(topic=topic)
return render(request, "scheduling.html",
{'accepted': accepted,
'schedule': schedule,
'topic': topic})
def swap(request, slotid):
oldslot = Slot.objects.get(id=slotid)
if not topiclead(request.user, oldslot.topic):
return HttpResponseForbidden("Forbidden")
if request.method == 'POST':
newslotid = int(request.POST['newslotid'])
newslot = Slot.objects.get(id=newslotid, topic=oldslot.topic)
new_start_time = newslot.start_time
new_room = newslot.room
newslot.start_time = oldslot.start_time
newslot.room = oldslot.room
oldslot.start_time = new_start_time
oldslot.room = new_room
newslot.save()
oldslot.save()
return HttpResponseRedirect('/scheduling/%s' % oldslot.topic.id)
newslots = []
available_slots = Slot.objects.filter(
topic=oldslot.topic).exclude(id=slotid)
for slot in available_slots:
triplet = (slot.start_time, slot.id, combined_title(slot))
newslots.append(triplet)
return render(request, 'slotswap.html',
{'title': combined_title(oldslot),
'oldslot': oldslot,
'newslots': newslots})
def topiclist(request, topicid):
topic = Topic.objects.get(id=topicid)
if not topiclead(request.user, topic):
return HttpResponseForbidden("Forbidden")
proposals = Proposal.objects.filter(topic=topicid)
request.session['lastlist'] = "cfp/topic/%s" % topicid
return render(request, "topiclist.html",
{'proposals': proposals,
'topic': topic})
def review(request, proposalid):
proposal = Proposal.objects.get(id=proposalid)
if not topiclead(request.user, proposal.topic):
return HttpResponseForbidden("Forbidden")
current_status = proposal.status
status_long = proposal.get_status_display()
if request.method == 'POST':
form = ProposalReviewForm(request.POST, instance=proposal)
if form.is_valid():
form.save()
reviewer_notes = ''
if form.cleaned_data['comment']:
reviewer_notes = form.cleaned_data['comment']
c = Comment()
c.proposal = proposal
c.author = request.user
c.content = reviewer_notes
c.save()
if (settings.SEND_MAIL and current_status != proposal.status):
lead = User.objects.get(username=proposal.topic.lead_username)
if (lead.email and proposal.proposer.email):
message = """
This is an automated email.
If needed, you should reply directly to the topic lead (%s).
On your session proposal: %s
The topic lead (%s) changed status from %s to %s.
Reviewer's notes:
%s
You can edit your proposal at: %s/cfp/edit/%s""" \
% (proposal.topic.lead_username,
smart_str(proposal.title),
proposal.topic.lead_username,
status_long, proposal.get_status_display(),
smart_str(reviewer_notes),
settings.SITE_ROOT, proposalid)
email = EmailMessage(settings.EMAIL_PREFIX +
"Status change on your session proposal",
message, settings.EMAIL_FROM,
[proposal.proposer.email, ], [],
headers={'Reply-To': lead.email})
email.send()
return HttpResponseRedirect('/cfp/topic/%d' % proposal.topic.id)
else:
form = ProposalReviewForm(instance=proposal)
comments = Comment.objects.filter(proposal=proposal)
return render(request, 'cfpreview.html',
{'form': form,
'proposal': proposal,
'comments': comments,
'blueprints': linkify(proposal.blueprints)})
def edit(request, slotid):
slot = Slot.objects.get(id=slotid)
if not topiclead(request.user, slot.topic):
return HttpResponseForbidden("Forbidden")
if request.method == 'POST':
form = SlotForm(request.POST, instance=slot)
if form.is_valid():
form.save()
return HttpResponseRedirect('/scheduling/%s' % slot.topic.id)
else:
form = SlotForm(instance=slot)
return render(request, 'slotedit.html',
{'form': form,
'title': combined_title(slot),
'full_desc': combined_description(slot),
'slot': slot})
def switch(request, proposalid):
proposal = Proposal.objects.get(id=proposalid)
if ((proposal.proposer != request.user)
and not topiclead(request.user, proposal.topic)) or proposal.scheduled:
return HttpResponseForbidden("Forbidden")
if request.method == 'POST':
form = ProposalSwitchForm(request.POST, instance=proposal)
if form.is_valid():
form.save()
proposal = Proposal.objects.get(id=proposalid)
proposal.status = 'U'
proposal.save()
return HttpResponseRedirect('/%s' % request.session['lastlist'])
else:
form = ProposalSwitchForm(instance=proposal)
return render(request, 'cfpswitch.html', {'form': form,
'proposal': proposal})
