def revoke_reviewer(request, conf_pk, user_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
user = get_object_or_404(User, pk=user_pk)
if user.reviewer_set.count() > 0:
Reviewer.objects.filter(user=user, conference=conference).delete()
return JsonResponse(data={})
def notification_details(request, conf_pk, notif_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
notification = get_object_or_404(SystemNotification, pk=notif_pk)
if request.method == 'POST':
notif_form = EditNotificationForm(request.POST, instance=notification)
if notif_form.is_valid():
notif_form.save()
messages.success(request, 'Your changes were saved')
return redirect('chair_mail:notification-details', conf_pk,
notif_pk)
else:
notif_form = EditNotificationForm(instance=notification)
return render(request,
'chair_mail/tab_pages/notification_details.html',
context={
'conference':
conference,
'notification':
notification,
'hide_tabs':
True,
'notif_form':
notif_form,
'variables':
_get_grouped_vars(notification.type),
'preview_url':
reverse_preview_url(notification.type, conference),
'preview_form':
get_preview_form_class(notification.type)(),
'list_objects_url':
reverse_list_objects_url(notification.type, conference),
})
def group_message_details(request, conf_pk, msg_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
msg = get_object_or_404(GroupMessage, pk=msg_pk)
leaf_msg = get_message_leaf_model(msg)
recipients = [{
'name':
get_object_name(leaf_msg.message_type, obj),
'url':
get_object_url(leaf_msg.message_type, conference, obj),
} for obj in leaf_msg.recipients.all()]
if request.is_ajax():
return JsonResponse({
'body': msg.body,
'subject': msg.subject,
'sent_at': msg.sent_at,
'sent_by': msg.sent_by.pk if msg.sent_by else '',
})
return render(request,
'chair_mail/tab_pages/message_details.html',
context={
'conference': conference,
'conf_pk': conference.pk,
'msg': msg,
'hide_tabs': True,
'recipients': recipients,
})
def create_frame(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
if not hasattr(conference, 'email_settings'):
EmailSettings.objects.create(conference=conference)
email_settings = conference.email_settings
frame = email_settings.frame
template_html = get_template(
'chair_mail/email/default_frame_html.html').template
template_plain = get_template(
'chair_mail/email/default_frame_plain.txt').template
if frame:
frame.text_html = template_html.source
frame.text_plain = template_plain.source
frame.created_at = timezone.now()
frame.updated_at = timezone.now()
frame.created_by = request.user
frame.save()
messages.success(request, 'Reset existing frame')
else:
frame = EmailFrame.objects.create(
conference=conference,
created_by=request.user,
text_plain=template_plain.source,
text_html=template_html.source,
)
email_settings.frame = frame
email_settings.save()
messages.success(request, 'Created new template')
default_next = reverse('chair_mail:overview', kwargs={'conf_pk': conf_pk})
next_url = request.GET.get('next', default_next)
return redirect(next_url)
def update_status(request, pk):
submission = get_object_or_404(Submission, pk=pk)
validate_chair_access(request.user, submission.conference)
form = UpdateSubmissionStatusForm(request.POST, instance=submission)
if form.is_valid():
form.save()
return JsonResponse({}, status=200)
return JsonResponse({}, status=500)
def handler(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
form = form_class(request.GET)
if form.is_valid():
data = form.render_html(conference)
return JsonResponse(data)
return JsonResponse({}, status=400)
def update_notification_state(request, conf_pk, notif_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
notification = get_object_or_404(SystemNotification, pk=notif_pk)
form = UpdateNotificationStateForm(request.POST, instance=notification)
if form.is_valid():
form.save()
return redirect('chair_mail:notifications', conf_pk)
def mailing_list_details(request, conf_pk, name):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
try:
ml = find_list(name)
except KeyError:
return JsonResponse({'error': 'list not found'}, status=400)
return JsonResponse(serialize_mailing_list(ml, conference))
def update_volume(request, camera_id):
camera = get_object_or_404(CameraReady, id=camera_id)
validate_chair_access(request.user, camera.submission.conference)
form = UpdateVolumeForm(request.POST, instance=camera)
if form.is_valid():
form.save()
return JsonResponse(status=200, data={})
return JsonResponse(status=500, data={})
def handler(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
default_next_url = reverse('chair:home', kwargs={'conf_pk': conf_pk})
if request.method == 'POST':
next_url = request.POST.get('next', default_next_url)
form = MessageForm(request.POST, msg_type=msg_type)
if form.is_valid():
all_objects_to = list(form.cleaned_objects)
for ml in form.cleaned_lists:
all_objects_to.extend(list(ml.query(conference)))
msg = message_class.create(
subject=form.cleaned_data['subject'],
body=form.cleaned_data['body'],
conference=conference,
objects_to=list(set(all_objects_to)),
)
msg.send(sender=request.user)
return redirect(next_url)
else:
errors = form.non_field_errors()
if len(errors) == 1:
messages.error(request, errors[0])
elif len(errors) > 1:
messages.error(request, errors)
else:
messages.error(request, 'Error sending message')
else:
form = MessageForm(initial={
'objects': request.GET.get('objects', ''),
'lists': request.GET.get('lists', ''),
},
msg_type=msg_type)
next_url = request.GET.get('next', default_next_url)
return render(request,
'chair_mail/compose/compose.html',
context={
'msg_form':
form,
'msg_type':
msg_type,
'conference':
conference,
'next':
next_url,
'variables':
_get_grouped_vars(msg_type),
'preview_url':
reverse_preview_url(msg_type, conference),
'preview_form':
preview_form_class(),
'list_objects_url':
reverse_list_objects_url(msg_type, conference),
'object_icon_class':
object_icon_class,
})
def list_users(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
profiles = Profile.objects.all()
data = {
'type': 'user',
'objects': [serialize_user(prof, conference) for prof in profiles],
}
return JsonResponse(data)
def download_attachment(request, att_pk):
attachment = get_object_or_404(Attachment, pk=att_pk)
validate_chair_access(request.user, attachment.submission.conference)
if attachment.file:
filename = attachment.get_chair_download_name()
mtype = mimetypes.guess_type(filename)[0]
response = HttpResponse(attachment.file.file, content_type=mtype)
response['Content-Disposition'] = f'filename={filename}'
return response
raise Http404
def notifications_list(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
return render(request,
'chair_mail/tab_pages/notifications.html',
context={
'conference': conference,
'frame': get_email_frame(conference),
'active_tab': 'notifications',
})
def reset_notification(request, conf_pk, notif_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
notification = get_object_or_404(SystemNotification, pk=notif_pk)
data = DEFAULT_NOTIFICATIONS_DATA[notification.name]
notification.subject = data['subject']
notification.type = data['type']
notification.body = data['body']
notification.save()
return redirect('chair_mail:notifications', conf_pk)
def send_frame_test_message(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
form = EmailFrameTestForm(request.POST)
if form.is_valid():
form.send_message(request.user, conference)
return JsonResponse({'email': request.user.email})
resp = JsonResponse({'email': request.user.email})
resp.status_code = 400
return resp
def delete_all_messages(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
num_group_messages = GroupMessage.objects.count()
num_email_messages = EmailMessage.objects.count()
GroupMessage.objects.all().delete()
EmailMessage.objects.all().delete()
messages.success(
request, f'Deleted {num_group_messages} group messages and '
f'{num_email_messages} messages instances')
return redirect('chair_mail:sent-messages', conf_pk=conf_pk)
def overview(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
frame = get_email_frame(conference)
return render(request,
'chair_mail/tab_pages/overview.html',
context={
'conference': conference,
'frame': frame,
'active_tab': 'overview',
})
def overview(request, conf_pk, user_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
user = get_object_or_404(User, pk=user_pk)
return render(request,
'chair/users/user_overview.html',
context={
'conference': conference,
'u': user,
'active_tab': 'overview',
})
def render_frame_preview(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
frame = get_email_frame(conference)
if frame:
body = f"<p>Dear {request.user.profile.get_full_name()},</p>" \
f"<p>this is a frame preview.</p>"
subject = 'Frame preview'
html = frame.render_html(subject, body)
return HttpResponse(html)
return HttpResponse()
def reset_all_notifications(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
# Purging all existing notifications:
conference.notifications.all().delete()
# Creating default notifications:
for name, kwargs in DEFAULT_NOTIFICATIONS_DATA.items():
SystemNotification.objects.create(name=name,
conference=conference,
**kwargs)
return redirect('chair_mail:notifications', conf_pk)
def sent_messages(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
frame = get_email_frame(conference)
msg_list = conference.sent_group_emails.all().order_by('-sent_at')
return render(request,
'chair_mail/tab_pages/messages.html',
context={
'conference': conference,
'active_tab': 'messages',
'frame': frame,
'msg_list': msg_list,
})
def refresh_notifications(request, conf_pk):
"""This view doesn't delete or update existing notifications, but
create notifications if some of them do not exist.
"""
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
for name, kwargs in DEFAULT_NOTIFICATIONS_DATA.items():
notif = SystemNotification.objects.filter(
name=name, conference=conference).first()
if not notif:
SystemNotification.objects.create(name=name,
conference=conference,
**kwargs)
return redirect('chair_mail:notifications', conf_pk)
def emails(request, conf_pk, user_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
user = get_object_or_404(User, pk=user_pk)
email_messages = (EmailMessage.objects.filter(
user_to__pk=user_pk).order_by('-sent_at'))
return render(request,
'chair/users/user_messages.html',
context={
'conference': conference,
'u': user,
'email_messages': email_messages,
'active_tab': 'messages',
})
def wrapper(request, sub_pk, *args, **kwargs):
submission = get_object_or_404(Submission, pk=sub_pk)
conference = submission.conference
validate_chair_access(request.user, conference)
names = params.split(',')
names.reverse()
args = list(args)
for name in names:
if name == 'conference':
args = [conference] + args
elif name == 'submission':
args = [submission] + args
else:
raise ValueError(f'unsupported parameter name "{name}"')
return fn(request, *args, **kwargs)
def list_submissions(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
submissions = Submission.objects.filter(conference_id=conf_pk)
profiles_cache = {
user.pk: user.profile
for user in User.objects.filter(authorship__submission__in=submissions)
}
data = {
'type':
'submission',
'objects': [
serialize_submission(submission, profiles_cache)
for submission in submissions
]
}
return JsonResponse(data)
def list_mailing_lists(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
list_type = request.GET.get('type', default='all')
if list_type == 'user':
lists = USER_LISTS
elif list_type == 'submission':
lists = SUBMISSION_LISTS
elif list_type == 'all':
lists = ALL_LISTS
else:
return JsonResponse({'error': 'invalid list type'}, status=400)
data = {
'type': 'mailing_list',
'objects': [serialize_mailing_list(ml, conference) for ml in lists],
}
return JsonResponse(data)
def feed_item(request, conf_pk, user_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
profile = Profile.objects.filter(user_id=user_pk).annotate(
num_reviewers=Count('user__reviewer',
filter=Q(user__reviewer__conference=conf_pk))
).annotate(
full_name_rus=Concat('last_name_rus',
Value(' '),
'first_name_rus',
Value(' '),
'middle_name_rus',
output_field=CharField()),
is_reviewer=Case(When(num_reviewers__gt=0, then=Value(1)),
default=Value(0),
output_field=IntegerField()),
num_reviews=Count(
'user__reviewer__reviews__pk',
filter=Q(
user__reviewer__reviews__stage__submission__conference=conf_pk
),
distinct=True),
num_incomplete_reviews=Count(
'user__reviewer__reviews__pk',
filter=Q(
user__reviewer__reviews__stage__submission__conference=conf_pk,
user__reviewer__reviews__submitted=False),
distinct=True),
num_submissions=Count(
'user__authorship',
filter=Q(user__authorship__submission__conference=conf_pk),
distinct=True)).first()
if not profile:
raise Http404
list_view_url = request.GET.get(
'list_view_url', reverse('chair:users', kwargs={'conf_pk': conf_pk}))
return render(
request, 'chair/users/feed/card.html', {
'profile': profile,
'list_view_url': list_view_url,
'conference': conference,
})
def list_users(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
profiles = Profile.objects.all()
form = FilterProfilesForm(request.GET, instance=conference)
if form.is_valid():
profiles = form.apply(profiles)
pks = profiles.values_list('user_id', flat=True)
paginator = Paginator(pks, settings.ITEMS_PER_PAGE)
page = paginator.page(request.GET.get('page', 1))
context = {
'conference': conference,
'filter_form': form,
'page': page,
}
return render(request, 'chair/users/list.html', context=context)
def update_decision(request, sub_id):
"""Update the the submission's `ReviewDecision` `decision_type` field.
This view is called only in AJAX and returns a `JsonResponse` with either
`200 OK`, or `500` with serialized form errors.
"""
submission = get_object_or_404(Submission, id=sub_id)
validate_chair_access(request.user, submission.conference)
stage, _ = ReviewStage.objects.get_or_create(
submission=submission,
num_reviews_required=(submission.stype.num_reviews
if submission.stype else 0),
locked=False)
decision = stage.decision
form = UpdateReviewDecisionForm(request.POST, instance=decision)
if form.is_valid():
form.save()
return JsonResponse(status=200, data={})
return JsonResponse(status=500, data={'errors': form.errors})
def list_submissions(request, conf_pk):
conference = get_object_or_404(Conference, pk=conf_pk)
validate_chair_access(request.user, conference)
form = FilterSubmissionsForm(request.GET, instance=conference)
submissions = conference.submission_set.all()
if form.is_valid():
submissions = form.apply(submissions)
pks = [sub.pk for sub in submissions]
paginator = Paginator(pks, settings.ITEMS_PER_PAGE)
page = paginator.page(request.GET.get('page', 1))
context = {
'conference': conference,
'filter_form': form,
'page': page,
}
return render(request, 'chair/submissions/list.html', context=context)
