def form_valid(self, form):
reviewer_request = Reviewer.objects.create(
user=self.request.user, conference=current_conference())
reviewer_ct = ContentType.objects.get_for_model(Reviewer)
perm = auth_models.Permission.objects.get(
content_type_id=reviewer_ct.pk, codename='change_reviewer')
mails = []
subject = _('New reviewer application')
from_email = settings.DEFAULT_FROM_EMAIL
url = 'https://' if self.request.is_secure() else 'http://'
url += self.request.get_host()
url += reverse('admin:reviews_reviewer_change',
args=(reviewer_request.pk, ))
data_dict = {
'applicant_username': self.request.user.username,
'applicant_display_name': get_display_name(self.request.user),
'reviewer_list_url': url,
'conference_title': current_conference().title,
}
for user in perm.user_set.all():
data_dict['receiver'] = get_addressed_as(user)
message = render_to_string(
'accounts/reviewer_application_mail.txt', data_dict)
mails.append((subject, message, from_email, [user.email]))
send_mass_mail(mails)
return super(ReviewerApplication, self).form_valid(form)
def can_see_proposal_author(user):
if (
conference_models.current_conference() is not None and
not conference_models.current_conference().anonymize_proposal_author
):
return True
if user.has_perm('proposals.see_proposal_author'):
return True
return False
def post(self, *args, **kwargs):
self.clear_purchase_info()
self.form = forms.PurchaseForm(self.request.POST)
# Create a quantity for for each available ticket type.
self.quantity_forms = []
all_quantity_forms_valid = True
self.total_ticket_num = 0
ticket_types = TicketType.objects.available().filter(
conference=current_conference())
for ticket_type in ticket_types:
quantity_form = forms.TicketQuantityForm(
data=self.request.POST,
ticket_type=ticket_type)
if quantity_form.is_valid():
ticket_quantity = quantity_form.cleaned_data.get(
'quantity', 0)
if ticket_quantity is None:
ticket_quantity = 0
self.total_ticket_num += ticket_quantity
else:
all_quantity_forms_valid = False
self.quantity_forms.append(quantity_form)
# Address, quantities (limits) and at least one ticket must be bought
if self.form.is_valid() and all_quantity_forms_valid\
and self.total_ticket_num > 0:
purchase = self.form.save(commit=False)
if self.request.user.is_authenticated():
purchase.user = self.request.user
purchase.conference = current_conference()
# Create a ticket for each ticket type and amount
for quantity_form in self.quantity_forms:
ticket_quantity = quantity_form.cleaned_data.get('quantity', 0)
if ticket_quantity is None:
ticket_quantity = 0
for _i in range(0, ticket_quantity):
ticket_model = quantity_form.ticket_type.content_type.model_class()
self.tickets.append(
ticket_model(purchase=purchase,
ticket_type=quantity_form.ticket_type))
purchase.payment_total = purchase.calculate_payment_total(
tickets=self.tickets)
self.purchase = purchase
# Please note that we don't save the purchase object nor the
# freshly created tickets yet but instead put them just into
# the session.
self.save_state()
return redirect('attendees_purchase_names')
return self.get(*args, **kwargs)
def get_context_data(self, **kwargs):
this_speaker = self.request.user.speaker_profile
ctx = super(ListUserProposalsView, self).get_context_data(**kwargs)
ctx.update({
'proposals': this_speaker.proposals
.filter(conference=current_conference()).all(),
'proposal_participations': this_speaker.proposal_participations
.filter(conference=current_conference()).all()
})
return ctx
def get_context_data(self, **kwargs):
this_speaker = self.request.user.speaker_profile
ctx = super(ListUserProposalsView, self).get_context_data(**kwargs)
ctx.update({
'proposals': this_speaker.proposals
.filter(conference=current_conference()).all(),
'proposal_participations': this_speaker.proposal_participations
.filter(conference=current_conference()).all()
})
return ctx
def post(self, *args, **kwargs):
self.clear_purchase_info()
self.form = forms.PurchaseForm(self.request.POST)
# Create a quantity for for each available ticket type.
self.quantity_forms = []
all_quantity_forms_valid = True
self.total_ticket_num = 0
ticket_types = TicketType.objects.available().filter(
conference=current_conference())
for ticket_type in ticket_types:
quantity_form = forms.TicketQuantityForm(data=self.request.POST,
ticket_type=ticket_type)
if quantity_form.is_valid():
ticket_quantity = quantity_form.cleaned_data.get('quantity', 0)
if ticket_quantity is None:
ticket_quantity = 0
self.total_ticket_num += ticket_quantity
else:
all_quantity_forms_valid = False
self.quantity_forms.append(quantity_form)
# Address, quantities (limits) and at least one ticket must be bought
if self.form.is_valid() and all_quantity_forms_valid\
and self.total_ticket_num > 0:
purchase = self.form.save(commit=False)
if self.request.user.is_authenticated():
purchase.user = self.request.user
purchase.conference = current_conference()
# Create a ticket for each ticket type and amount
for quantity_form in self.quantity_forms:
ticket_quantity = quantity_form.cleaned_data.get('quantity', 0)
if ticket_quantity is None:
ticket_quantity = 0
for _i in range(0, ticket_quantity):
ticket_model = quantity_form.ticket_type.content_type.model_class(
)
self.tickets.append(
ticket_model(purchase=purchase,
ticket_type=quantity_form.ticket_type))
purchase.payment_total = purchase.calculate_payment_total(
tickets=self.tickets)
self.purchase = purchase
# Please note that we don't save the purchase object nor the
# freshly created tickets yet but instead put them just into
# the session.
self.save_state()
return redirect('attendees_purchase_names')
return self.get(*args, **kwargs)
def get_context_data(self, **kwargs):
comment_form = forms.CommentForm()
comment_form.helper.form_action = reverse(
'reviews-submit-comment', kwargs={'pk': self.object.pk})
comments = self.object.comments.select_related('proposal_version',
'author').all()
proposal_versions = self.object.versions.select_related(
'creator').all()
data = super(ProposalDetailsView, self).get_context_data(**kwargs)
data['comments'] = comments
data[
'proposal_version'] = models.ProposalVersion.objects.get_latest_for(
self.object)
data['comment_form'] = comment_form
data['versions'] = proposal_versions
data['timeline'] = map(
self.wrap_timeline_elements,
utils.merge_comments_and_versions(comments, proposal_versions))
data['can_review'] = utils.can_review_proposal(
self.request.user, self.object) and not utils.is_proposal_author(
self.request.user, self.object)
data['can_update'] = utils.is_proposal_author(self.request.user,
self.object)
data['can_comment'] = utils.can_participate_in_review(
self.request.user,
self.object) and current_conference().get_reviews_active()
try:
review = self.object.reviews.get(user=self.request.user)
data['user_review'] = review
data['review_outdated'] = review.proposal_version != data[
'proposal_version']
except:
pass
return data
def send_proposal_update_notification(version, notify_author=False):
"""
Send a version notification mail to all users related to the version's
proposal except for the author of the version unless notify_author=True
is passed.
"""
proposal = version.original
current_user = version.creator
if notify_author:
current_user = None
hide_author = conference_models.current_conference().anonymize_proposal_author and\
is_proposal_author(current_user, proposal)
body = render_to_string('reviews/emails/version_notification.txt', {
'version': version,
'proposal': proposal,
'site': Site.objects.get_current(),
'hide_author': hide_author,
'proposal_url': reverse('reviews-proposal-details', kwargs={'pk': proposal.pk}),
})
if hide_author:
subject = _("[REVIEW] The author updated %(title)s")
else:
subject = _("[REVIEW] %(author)s updated %(title)s")
msg = EmailMessage(subject=subject % {
'author': account_utils.get_display_name(version.creator),
'title': proposal.title},
bcc=[u.email for u in get_people_to_notify(proposal, current_user)],
body=body)
msg.send()
def handle(self, *args, **options):
necessary_slots = set()
all_slots = set()
created_slots = set()
for section in conference_models.Section.current_objects.all():
if section.start_date and section.end_date:
for date in utils.get_date_range(section.start_date, section.end_date):
for slot in models.DATE_SLOT_CHOICES:
obj, created = models.TimeSlot.objects.get_or_create(
date=date, slot=slot[0], section=section)
necessary_slots.add(obj)
if created:
LOG.info("Created {0}".format(obj))
created_slots.add(obj)
else:
LOG.warn("Section {0} has no valid date range!".format(
section))
all_slots.update(list(models.TimeSlot.objects.filter(section__conference=conference_models.current_conference())))
print("Created {0} slots".format(len(created_slots)))
unnecessary_slots = all_slots - necessary_slots
if unnecessary_slots:
print("Found unnecssary slots:")
for slot in unnecessary_slots:
print(" - {0}".format(slot))
def send_comment_notification(comment, notify_author=False):
"""
Send a comment notification mail to all users related to the comment's
proposal except for the author of the comment unless notify_author=True
is passed.
"""
proposal = comment.proposal
current_user = comment.author
if notify_author:
current_user = None
# WARNING: We cannot use `can_see_proposal_author` here, because we
# write a BCC mail to all involved reviewers and there will
# probably be at least one not allowed to see the author
hide_author = conference_models.current_conference().anonymize_proposal_author and\
is_proposal_author(comment.author, proposal)
body = render_to_string('reviews/emails/comment_notification.txt', {
'comment': comment,
'proposal': proposal,
'hide_author': hide_author,
'site': Site.objects.get_current(),
'proposal_url': reverse('reviews-proposal-details', kwargs={'pk': proposal.pk}),
})
if hide_author:
subject = _("[REVIEW] The author has commented on \"%(title)s\"")
else:
subject = _("[REVIEW] %(author)s commented on \"%(title)s\"")
msg = EmailMessage(subject=subject % {
'author': account_utils.get_display_name(comment.author),
'title': proposal.title},
bcc=[u.email for u in get_people_to_notify(proposal, current_user)
if has_valid_mailaddr(u)],
body=body)
msg.send()
def __init__(self, *args, **kwargs):
assert 'instance' in kwargs, 'instance is required.'
super(TicketNameForm,
self).__init__(prefix='tn-%s' % kwargs['instance'].pk,
*args,
**kwargs)
self.fields['first_name'].required = True
self.fields['last_name'].required = True
self.fields['organisation'].required = False
self.fields['dietary_preferences'] = forms.ModelMultipleChoiceField(
label=mark_safe(pgettext('nameform', 'Dietary preferences')),
queryset=DietaryPreference.objects.all(),
required=False,
widget=forms.CheckboxSelectMultiple)
if 'dietary_preferences' in kwargs['instance'].related_data:
self.initial['dietary_preferences'] = [
obj.pk for obj in kwargs['instance'].related_data.get(
'dietary_preferences', [])
]
self.fields['shirtsize'].queryset = self.fields['shirtsize']\
.queryset.filter(conference=current_conference())
self.fields['shirtsize'].help_text = _(
'''Sizing charts: <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/813" target="_blank">Women</a>, <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/812" target="_blank">Men</a>'''
)
def __init__(self, output=None, conference=None):
self.output = output
self.conference = conference
if self.output is None:
self.output = sys.stdout
if self.conference is None:
self.conference = conference_models.current_conference()
def render(self, context):
conference = current_conference()
if self.level:
level = self.level.resolve(context)
queryset = Sponsor.objects.filter(level__conference = conference, level__slug__iexact = level, active = True).order_by("added")
else:
queryset = Sponsor.objects.filter(level__conference = conference, active = True).order_by("level__order", "added")
context[self.context_var] = queryset
return u""
def form_valid(self, form):
obj = form.save(commit=False)
obj.speaker = self.request.user.speaker_profile
# TODO: Filter out duplications between speaker and additional speakers
obj.conference = current_conference()
obj.save()
self.object = obj
form.save_m2m()
return HttpResponseRedirect(self.get_success_url())
def form_valid(self, form):
obj = form.save(commit=False)
obj.speaker = self.request.user.speaker_profile
# TODO: Filter out duplications between speaker and additional speakers
obj.conference = current_conference()
obj.save()
self.object = obj
form.save_m2m()
return HttpResponseRedirect(self.get_success_url())
def __init__(self, *args, **kwargs):
assert 'instance' in kwargs, 'instance is required.'
super(TicketNameForm, self).__init__(
prefix='tn-%s' % kwargs['instance'].pk, *args, **kwargs)
self.fields['first_name'].required = True
self.fields['last_name'].required = True
self.fields['shirtsize'].queryset = self.fields['shirtsize']\
.queryset.filter(conference=current_conference())
self.fields['shirtsize'].help_text = _('''Sizing charts: <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/813" target="_blank">Women</a>, <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/812" target="_blank">Men</a>''')
def get_queryset(self):
qs = models.ProposalMetaData.objects.select_related('proposal', 'proposal__track', 'proposal__kind').order_by(self.get_order()).all()
qs = qs.filter(proposal__conference=current_conference())
if self.filter_form.is_valid():
track_slug = self.filter_form.cleaned_data['track']
kind_slug = self.filter_form.cleaned_data['kind']
if track_slug:
qs = qs.filter(proposal__track__slug=track_slug)
if kind_slug:
qs = qs.filter(proposal__kind__slug=kind_slug)
return qs
def __init__(self, *args, **kwargs):
assert 'instance' in kwargs, 'instance is required.'
super(TicketNameForm, self).__init__(
prefix='tn-%s' % kwargs['instance'].pk, *args, **kwargs)
self.fields['first_name'].required = True
self.fields['last_name'].required = True
self.fields['shirtsize'].queryset = self.fields['shirtsize']\
.queryset.filter(conference=current_conference())
self.fields['shirtsize'].help_text = _('''Sizing charts: <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/813" target="_blank">Women</a>, <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/812" target="_blank">Men</a>''')
def wrap_timeline_elements(self, item):
type_ = 'comment'
user = None
if isinstance(item, models.ProposalVersion):
type_ = 'version'
user = item.creator
else:
user = item.author
return {
'type': type_,
'item': item,
'hide_author': current_conference().anonymize_proposal_author and utils.is_proposal_author(user, self.object),
}
def render(self, context):
conference = current_conference()
if self.level:
level = self.level.resolve(context)
queryset = Sponsor.objects.filter(level__conference=conference,
level__slug__iexact=level,
active=True).order_by("added")
else:
queryset = Sponsor.objects.filter(level__conference=conference,
active=True).order_by(
"level__order", "added")
context[self.context_var] = queryset
return u""
def get_queryset(self):
qs = models.ProposalMetaData.objects.select_related(
'proposal', 'proposal__track',
'proposal__kind').order_by(self.get_order()).all()
qs = qs.filter(proposal__conference=current_conference())
if self.filter_form.is_valid():
track_slug = self.filter_form.cleaned_data['track']
kind_slug = self.filter_form.cleaned_data['kind']
if track_slug:
qs = qs.filter(proposal__track__slug=track_slug)
if kind_slug:
qs = qs.filter(proposal__kind__slug=kind_slug)
return qs
def export(self):
output = StringIO.StringIO()
with etree.xmlfile(output) as xf:
sessions = models.Session.objects \
.select_related('kind', 'audience_level', 'track',
'speaker__user__profile') \
.prefetch_related('additional_speakers__user__profile',
'location') \
.filter(released=True, start__isnull=False, end__isnull=False,
kind__slug__in=('talk', 'keynote', 'sponsored')) \
.order_by('start') \
.only('end', 'start', 'title', 'abstract', 'description', 'language',
'kind__name',
'audience_level__name',
'track__name',
'speaker__user__username',
'speaker__user__profile__avatar',
'speaker__user__profile__full_name',
'speaker__user__profile__display_name',
'speaker__user__profile__short_info',
'speaker__user__profile__user') \
.all()
side_events = models.SideEvent.objects \
.select_related() \
.prefetch_related('location') \
.filter(start__isnull=False, end__isnull=False, is_recordable=True) \
.order_by('start') \
.only('end', 'start', 'name') \
.all()
self.conference = force_text(conference_models.current_conference())
self._duration_base = datetime.datetime.combine(datetime.date.today(), datetime.time(0, 0, 0))
with xf.element('iCalendar'):
with xf.element('vcalendar'):
with xf.element('version'):
xf.write('2.0')
with xf.element('prodid'):
xf.write('-//Pentabarf//Schedule %s//EN' % self.conference)
with xf.element('x-wr-caldesc'):
xf.write(self.conference)
with xf.element('x-wr-calname'):
xf.write(self.conference)
for session in sessions:
self._export_session(xf, session)
for session in side_events:
self._export_side_event(xf, session)
return output
def handle(self, *args, **options):
max_in_db = models.Purchase.objects\
.filter(conference=current_conference())\
.aggregate(Max('invoice_number'))\
.get('invoice_number__max', 0)
redis = get_redis_connection()
redis_value = redis.get(settings.INVOICE_NUMBER_SEQUENCE_NAME)
if redis_value is None:
redis_value = 0
else:
redis_value = int(redis_value)
if redis_value != max_in_db:
print("Sequence stored in Redis is different from latest invoice in database: {0} vs. {1}".format(
redis_value, max_in_db), file=sys.stderr)
sys.exit(1)
else:
print("OK")
def wrap_timeline_elements(self, item):
type_ = 'comment'
user = None
if isinstance(item, models.ProposalVersion):
type_ = 'version'
user = item.creator
else:
user = item.author
return {
'type':
type_,
'item':
item,
'hide_author':
current_conference().anonymize_proposal_author
and utils.is_proposal_author(user, self.object),
}
def handle(self, *args, **options):
max_in_db = models.Purchase.objects\
.filter(conference=current_conference())\
.aggregate(Max('invoice_number'))\
.get('invoice_number__max', 0)
redis = get_redis_connection()
redis_value = redis.get(settings.INVOICE_NUMBER_SEQUENCE_NAME)
if redis_value is None:
redis_value = 0
else:
redis_value = int(redis_value)
if redis_value != max_in_db:
print(
"Sequence stored in Redis is different from latest invoice in database: {0} vs. {1}"
.format(redis_value, max_in_db),
file=sys.stderr)
sys.exit(1)
else:
print("OK")
def __init__(self, *args, **kwargs):
assert 'instance' in kwargs, 'instance is required.'
super(TicketNameForm, self).__init__(
prefix='tn-%s' % kwargs['instance'].pk, *args, **kwargs)
self.fields['first_name'].required = True
self.fields['last_name'].required = True
self.fields['organisation'].required = False
self.fields['dietary_preferences'] = forms.ModelMultipleChoiceField(
label=mark_safe(pgettext('nameform', 'Dietary preferences')),
queryset=DietaryPreference.objects.all(),
required=False,
widget=forms.CheckboxSelectMultiple
)
if 'dietary_preferences' in kwargs['instance'].related_data:
self.initial['dietary_preferences'] = [obj.pk for obj in kwargs['instance'].related_data.get('dietary_preferences', [])]
self.fields['shirtsize'].queryset = self.fields['shirtsize']\
.queryset.filter(conference=current_conference())
self.fields['shirtsize'].help_text = _('''Sizing charts: <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/813" target="_blank">Women</a>, <a href="http://maxnosleeves.spreadshirt.com/shop/info/producttypedetails/Popup/Show/productType/812" target="_blank">Men</a>''')
def clean_code(self):
try:
code = self.cleaned_data['code']
ticket = self.instance
voucher = None
if not ticket.voucher or ticket.voucher.code != code:
voucher = Voucher.objects.valid().get(
code=code,
type__conference=current_conference(),
type=ticket.ticket_type.vouchertype_needed)
# Make sure that the found voucher is not one of the locked ones.
cache = get_cache('default')
if cache.get('voucher_lock:{0}'.format(voucher.pk)) and\
not utils.voucher_is_locked_for_session(
self.request, voucher):
raise Voucher.DoesNotExist()
except Voucher.DoesNotExist:
raise forms.ValidationError(_('Voucher verification failed.'))
return code
def clean_code(self):
try:
code = self.cleaned_data['code']
ticket = self.instance
voucher = None
if not ticket.voucher or ticket.voucher.code != code:
voucher = Voucher.objects.valid().get(
code=code,
type__conference=current_conference(),
type=ticket.ticket_type.vouchertype_needed)
# Make sure that the found voucher is not one of the locked ones.
cache = get_cache('default')
if cache.get('voucher_lock:{0}'.format(voucher.pk)) and\
not utils.voucher_is_locked_for_session(
self.request, voucher):
raise Voucher.DoesNotExist()
except Voucher.DoesNotExist:
raise forms.ValidationError(_('Voucher verification failed.'))
return code
def get_queryset(self):
qs = models.ProposalMetaData.objects \
.select_related('proposal', 'proposal__track',
'proposal__kind',
'latest_proposalversion') \
.only('proposal__kind', 'proposal__track',
'proposal__title', 'proposal__id',
'score', 'num_reviews', 'num_comments',
'latest_proposalversion__id',
'latest_proposalversion__title',
'latest_activity_date',
'latest_comment_date') \
.order_by(self.get_order()) \
.filter(proposal__conference_id=current_conference().id)
if self.filter_form.is_valid():
track_slug = self.filter_form.cleaned_data['track']
kind_slug = self.filter_form.cleaned_data['kind']
if track_slug:
qs = qs.filter(proposal__track__slug=track_slug)
if kind_slug:
qs = qs.filter(proposal__kind__slug=kind_slug)
return qs
def get_queryset(self):
qs = models.ProposalMetaData.objects \
.select_related('proposal', 'proposal__track',
'proposal__kind',
'latest_proposalversion') \
.only('proposal__kind', 'proposal__track',
'proposal__title', 'proposal__id',
'score', 'num_reviews', 'num_comments',
'latest_proposalversion__id',
'latest_proposalversion__title',
'latest_activity_date',
'latest_comment_date') \
.order_by(self.get_order()) \
.filter(proposal__conference_id=current_conference().id)
if self.filter_form.is_valid():
track_slug = self.filter_form.cleaned_data['track']
kind_slug = self.filter_form.cleaned_data['kind']
if track_slug:
qs = qs.filter(proposal__track__slug=track_slug)
if kind_slug:
qs = qs.filter(proposal__kind__slug=kind_slug)
return qs
def form_valid(self, form):
reviewer_request = Reviewer.objects.create(user=self.request.user, conference=current_conference())
reviewer_ct = ContentType.objects.get_for_model(Reviewer)
perm = auth_models.Permission.objects.get(content_type_id=reviewer_ct.pk, codename='change_reviewer')
mails = []
subject = _('New reviewer application')
from_email = settings.DEFAULT_FROM_EMAIL
url = 'https://' if self.request.is_secure() else 'http://'
url += self.request.get_host()
url += reverse('admin:reviews_reviewer_change', args=(reviewer_request.pk,))
data_dict = {
'applicant_username': self.request.user.username,
'applicant_display_name': get_display_name(self.request.user),
'reviewer_list_url': url,
'conference_title': current_conference().title,
}
for user in perm.user_set.all():
data_dict['receiver'] = get_addressed_as(user)
message = render_to_string('accounts/reviewer_application_mail.txt', data_dict)
mails.append((subject, message, from_email, [user.email]))
send_mass_mail(mails)
return super(ReviewerApplication, self).form_valid(form)
def send_proposal_update_notification(version, notify_author=False):
"""
Send a version notification mail to all users related to the version's
proposal except for the author of the version unless notify_author=True
is passed.
"""
proposal = version.original
current_user = version.creator
if notify_author:
current_user = None
hide_author = conference_models.current_conference().anonymize_proposal_author and\
is_proposal_author(current_user, proposal)
body = render_to_string(
'reviews/emails/version_notification.txt', {
'version':
version,
'proposal':
proposal,
'site':
Site.objects.get_current(),
'hide_author':
hide_author,
'proposal_url':
reverse('reviews-proposal-details', kwargs={'pk': proposal.pk}),
})
if hide_author:
subject = _("[REVIEW] The author updated %(title)s")
else:
subject = _("[REVIEW] %(author)s updated %(title)s")
msg = EmailMessage(
subject=subject % {
'author': account_utils.get_display_name(version.creator),
'title': proposal.title
},
bcc=[u.email for u in get_people_to_notify(proposal, current_user)],
body=body)
msg.send()
def clean_kind(self):
value = self.cleaned_data["kind"]
if value.conference != current_conference():
raise forms.ValidationError(
_("Please select a valid session type."))
return value
def clean_duration(self):
value = self.cleaned_data["duration"]
if value.conference != current_conference():
raise forms.ValidationError(_("Please select a valid duration."))
return value
def get_context_data(self, **kwargs):
comment_form = forms.CommentForm()
comment_form.helper.form_action = reverse('reviews-submit-comment', kwargs={'pk': self.object.pk})
comments = self.object.comments.select_related('proposal_version', 'author').all()
proposal_versions = self.object.versions.select_related('creator').all()
data = super(ProposalDetailsView, self).get_context_data(**kwargs)
data['comments'] = comments
data['proposal_version'] = models.ProposalVersion.objects.get_latest_for(self.object)
data['comment_form'] = comment_form
data['versions'] = proposal_versions
data['timeline'] = map(self.wrap_timeline_elements, utils.merge_comments_and_versions(comments, proposal_versions))
data['can_review'] = utils.can_review_proposal(self.request.user, self.object) and not utils.is_proposal_author(self.request.user, self.object)
data['can_update'] = utils.is_proposal_author(self.request.user, self.object)
data['can_comment'] = utils.can_participate_in_review(self.request.user, self.object) and current_conference().get_reviews_active()
try:
review = self.object.reviews.get(user=self.request.user)
data['user_review'] = review
data['review_outdated'] = review.proposal_version != data['proposal_version']
except:
pass
return data
def customize_fields(self, instance=None, form=None, tracks=None):
if form is None:
form = self
if tracks is None:
tracks = conference_models.Track.current_objects.all()
if not settings.SUPPORT_ADDITIONAL_SPEAKERS:
del form.fields['additional_speakers']
else:
# Only list already selected speakers or an empty queryset
if instance is not None:
additional_speakers = instance.additional_speakers.all()
else:
additional_speakers = speaker_models.Speaker.objects.none()
form.fields['additional_speakers'] = HiddenSpeakersMultipleChoiceField(label=_("additional speakers"),
queryset=additional_speakers, required=False)
if 'kind' in self.fields:
form.fields['kind'] = forms.ModelChoiceField(label=_("kind"),
queryset=conference_models.SessionKind.current_objects.filter_open_kinds())
if 'audience_level' in self.fields:
form.fields['audience_level'] = forms.ModelChoiceField(label=_("audience level"),
queryset=conference_models.AudienceLevel.current_objects.all())
if 'duration' in self.fields:
form.fields['duration'] = forms.ModelChoiceField(label=_("duration"),
queryset=conference_models.SessionDuration.current_objects.all())
if 'track' in self.fields:
form.fields['track'] = forms.ModelChoiceField(label=_("Track"), required=True, initial=None,
queryset=tracks)
if 'description' in form.fields:
form.fields['description'].help_text = """Bis ca. 50 Worte. Erscheint im gedruckten Programm. <br />Dieses Feld unterstützt <a href="http://daringfireball.net/projects/markdown/syntax" target="_blank" rel="external">Markdown</a>."""
form.fields['description'].validators = [validators.MaxLengthValidator(2000)]
if 'abstract' in self.fields:
form.fields['abstract'].help_text = """Darstellung des Vortragsinhalts und ist die Grundlage für das Review.<br />Dieses Feld unterstützt <a href="http://daringfireball.net/projects/markdown/syntax" target="_blank" rel="external">Markdown</a>."""
form.fields['abstract'].validators = [validators.MaxLengthValidator(3000)]
if 'additional_speakers' in form.fields:
form.fields['additional_speakers'].help_text = """Wenn Sie den Vortrag zusammen mit anderen Personen halten wollen, tragen Sie hier bitte deren Namen ein."""
if 'available_timeslots' in form.fields:
form.fields['available_timeslots'] = forms.ModelMultipleChoiceField(
label=_("available timeslots"),
queryset=models.TimeSlot.objects.select_related('section').filter(section__conference=conference_models.current_conference()).order_by('date', 'slot'),
widget=forms.CheckboxSelectMultiple,
required=False
)
form.fields['available_timeslots'].help_text += u"""<br /><br />Bitte geben Sie hier alle Zeiten an, die für Ihren Vortrag/Ihr Tutorial in Frage kommen. Diese Zeiten werden dann so gut wie möglich für die Erstellung des Zeitplans in Betracht gezogen."""
if 'notes' in form.fields:
form.fields['notes'].help_text = u"""Hier können Sie Anmerkungen und Kommentare eintragen, die nur für die Reviewer und Organisatoren sichtbar sind."""
def save(self, *args, **kwargs):
voucher = Voucher.objects.get(type__conference=current_conference(),
code=self.cleaned_data['code'])
self.instance.voucher = voucher
utils.lock_voucher(self.request, voucher)
def clean_duration(self):
value = self.cleaned_data["duration"]
if value.conference != current_conference():
raise forms.ValidationError(_("Please select a valid duration."))
return value
def clean_audience_level(self):
value = self.cleaned_data["audience_level"]
if value.conference != current_conference():
raise forms.ValidationError(_("Please select a valid audience level."))
return value
def customize_fields(self, instance=None, form=None, tracks=None):
if form is None:
form = self
if tracks is None:
tracks = conference_models.Track.current_objects.all()
if not settings.SUPPORT_ADDITIONAL_SPEAKERS:
del form.fields['additional_speakers']
else:
# Only list already selected speakers or an empty queryset
if instance is not None:
additional_speakers = instance.additional_speakers.all()
else:
additional_speakers = speaker_models.Speaker.objects.none()
form.fields['additional_speakers'] = HiddenSpeakersMultipleChoiceField(label=_("Additional speakers"),
queryset=additional_speakers, required=False)
if 'kind' in self.fields:
form.fields['kind'] = forms.ModelChoiceField(label=_("Type"),
queryset=conference_models.SessionKind.current_objects.filter_open_kinds())
if 'audience_level' in self.fields:
form.fields['audience_level'] = forms.ModelChoiceField(label=_("Target-audience"),
queryset=conference_models.AudienceLevel.current_objects.all())
if 'duration' in self.fields:
form.fields['duration'] = forms.ModelChoiceField(label=_("Duration"),
queryset=conference_models.SessionDuration.current_objects.all())
if 'track' in self.fields:
form.fields['track'] = forms.ModelChoiceField(label=_("Track"), required=True, initial=None,
queryset=tracks)
if 'abstract' in self.fields:
form.fields['abstract'].help_text = _("""Up to around 50 words. Appears in the printed program. <br />This field supports <a href="http://daringfireball.net/projects/markdown/syntax" target="_blank" rel="external">Markdown</a> input.""")
# form.fields['abstract'].validators = [validators.MaxLengthValidator(3000)]
if 'description' in form.fields:
form.fields['description'].help_text = _("""Describe your presentation in detail. This is what will be reviewed during the review phase.<br />This field supports <a href="http://daringfireball.net/projects/markdown/syntax" target="_blank" rel="external">Markdown</a> input.""")
# form.fields['description'].validators = [validators.MaxLengthValidator(2000)]
if 'additional_speakers' in form.fields:
form.fields['additional_speakers'].help_text = _("""If you want to present with others, please enter their names here.""")
if 'available_timeslots' in form.fields:
form.fields['available_timeslots'] = forms.ModelMultipleChoiceField(
label=_("Available timeslots"),
queryset=models.TimeSlot.objects.select_related('section').filter(section__conference=conference_models.current_conference()).order_by('date', 'slot'),
widget=forms.CheckboxSelectMultiple,
required=False
)
form.fields['available_timeslots'].help_text += ugettext(
"""<br /><br />Please pick all the times that should be considered for your """
"""presentation/training. If possible these will be used for the final timeslot.""")
if 'notes' in form.fields:
form.fields['notes'].help_text = _(
"""Add notes or comments here that can only be seen by reviewers and the organizing team.""")
if 'accept_recording' in form.fields:
form.fields['accept_recording'].label =_(
"""I agree to allow the Python Software Verband e.V. to record my presentation on EuroPython 2014 in Berlin.""")
if 'language' in form.fields:
form.fields['language'].initial = settings.DEFAULT_LANGUAGE
def get_queryset(self):
if self.request.user.is_anonymous():
return self.model.objects.none()
return self.model.objects.filter(conference=current_conference())
def render(self, context):
conference = current_conference()
context[self.context_var] = SponsorLevel.objects.filter(conference=conference)
return u""
def render(self, context):
conference = current_conference()
context[self.context_var] = SponsorLevel.objects.filter(
conference=conference)
return u""
def clean_audience_level(self):
value = self.cleaned_data["audience_level"]
if value.conference != current_conference():
raise forms.ValidationError(
_("Please select a valid target-audience."))
return value
def clean_kind(self):
value = self.cleaned_data["kind"]
if value.conference != current_conference():
raise forms.ValidationError(_("Please select a valid session kind."))
return value
def save(self, *args, **kwargs):
voucher = Voucher.objects.get(type__conference=current_conference(),
code=self.cleaned_data['code'])
self.instance.voucher = voucher
utils.lock_voucher(self.request, voucher)
def _wrapper(request, *args, **kwargs):
if not current_conference().get_reviews_active():
if not request.user.is_staff:
raise Http404()
messages.warning(request, _("The review period has ended. Only staff members can see this page."))
return func(request, *args, **kwargs)
def get_queryset(self):
if self.request.user.is_anonymous():
return self.model.objects.none()
return self.model.objects.filter(conference=current_conference())
