def get(self):
if not(self.request.params.has_key("conf")):
sorrypage.redirect_sorry(self, "ConfKeyMissing")
return
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
disabled = ""
if conference.state() != "Closed":
disabled = "disabled"
if not(conference.user_rights().has_permission(self.get_crrt_user().email(),
userrightsnames.CONF_CREATOR)):
sorrypage.redirect_sorry(self, "NoAccess")
return
template_values = {
"crrt_conf": conference,
"tracks": conference.track_objects(),
"conf_key": conference.key,
"aotb_extras": conference.shortname=="AOTB2021",
"test_setup": conference.shortname == "TEST2017" or conference.shortname == "TEST2018",
"durations": conference.duration_options(),
"formats": conference.delivery_format_options(),
"expenses": conference.expenses_options(),
"read_only": disabled,
}
self.write_page('conference_lib/confoptionspage.html', template_values)
def get(self):
conference_key = None
crrt_conference = None
# Pick up current conference from session
if self.session.has_key("crrt_conference"):
conference_key = ndb.Key(urlsafe=self.session["crrt_conference"])
crrt_conference = conference_key.get()
else:
sorrypage.redirect_sorry(self, "NoConfToReview")
return
template_values = {
'logoutlink':
users.create_logout_url("/"),
"crrt_conference":
crrt_conference,
"conf_key":
crrt_conference.key,
"review_config":
confreviewconfig.get_conference_review_factory(
crrt_conference.key),
"review_options":
confreviewconfig.available_review_models(),
}
self.write_page('subreview_lib/reviewconfigpage.html', template_values)
def get(self):
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
if not (conference.user_rights().has_permission(
self.get_crrt_user().email(), userrightsnames.CONF_CREATOR)):
sorrypage.redirect_sorry(self, "NoAccess")
return
if self.request.params.has_key("usr"):
email = self.request.get("usr")
update = True
else:
email = ""
update = False
template_values = {
"conference":
conference,
"conf_key":
conference.key,
"email":
email,
"update":
update,
"sorted_permissions":
sorted(conference.user_rights().permissions().keys()),
}
self.write_page('conference_lib/permissionspage.html', template_values)
def get(self):
if not(self.request.params.has_key("conf")):
sorrypage.redirect_sorry(self, "ConfKeyMissing")
return
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
disabled = ""
if conference.state() != "Closed":
disabled = "disabled"
if not(conference.user_rights().has_permission(self.get_crrt_user().email(),
userrightsnames.CONF_CREATOR)):
sorrypage.redirect_sorry(self, "NoAccess")
return
template_values = {
"crrt_conf": conference,
"conf_key": conference.key,
"questions": confquestion.retrieve_questions(conf_key),
"read_only": disabled,
}
self.write_page('conference_lib/confquestionspage.html', template_values)
def get(self):
crrt_conf = self.get_crrt_conference_key().get()
if not (crrt_conf.user_rights().has_permission(
self.get_crrt_user().email(),
userrightsnames.CONF_ADMINISTRATOR)):
sorrypage.redirect_sorry(self, "NoAccess")
return
if self.request.params.has_key("newrpt"):
newrpt = ndb.Key(urlsafe=self.request.get("newrpt")).get()
else:
newrpt = None
self.write_page(
'reports/exportspage.html', {
"crrt_conference":
crrt_conf,
"conf_key":
crrt_conf.key,
"reports":
reportrecord.retrieve_reports_newest_to_oldset(crrt_conf.key),
"newrpt":
newrpt,
})
def get(self):
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
rights = conference.user_rights()
if not(rights.has_permission(self.get_crrt_user().email(), userrightsnames.APPOINT_REVIEWERS)):
sorrypage.redirect_sorry(self, "AssignTracksReq")
return
if self.request.get("reviewer"):
reviewer = self.request.get("reviewer")
reviewer_tracks = conference.user_rights().track_assignments(reviewer)
else:
reviewer = ""
reviewer_tracks = []
template_values = {
"crrt_conf": conf_key.get(),
"conf_key": conf_key,
"tracks": conference.track_options(),
"rights": rights,
"reviewer": reviewer,
"reviewer_tracks": reviewer_tracks,
}
self.write_page('conference_lib/assigntrackspage.html', template_values)
def get(self):
if self.session.has_key("singlesubmit"):
if (self.submission_from_login()):
self.show_single_submit_page()
return
else:
sorrypage.redirect_sorry(self, "RequiresEmail")
def show_single_submit_page(self):
if self.submissions_exceeded():
sorrypage.redirect_sorry(self, "SubsLimitReached")
return
conf_questions = confquestion.retrieve_questions(self.crrt_conf.key)
conf_answers = submission_ans.retrieve_answer_map(
None, map(lambda q: q.key, conf_questions))
template_values = {
"crrt_conf": self.crrt_conf,
# Speaker fields
'new_speaker': True,
'speaker': self.submitter,
"emaillocked": "readonly",
'speakerKey': "",
'readonly': "",
# Talk fields
"talk_details": talk.Talk(parent=None),
"is_new": True,
"talk_key": None,
# Conference submission fields
"selected_track": self.crrt_conf.track_options().keys()[0],
"selected_duration": self.crrt_conf.duration_options().keys()[0],
"selected_format":
self.crrt_conf.delivery_format_options().keys()[0],
"selected_expenses": self.crrt_conf.expenses_options().keys()[0],
"conf_questions": conf_questions,
"conf_answers": conf_answers,
}
self.write_page('submission_lib/singlesubmitpage.html',
template_values)
def get(self):
crrt_conf = self.determine_conference()
if crrt_conf == None:
self.welcome_sorry()
return
if not(crrt_conf.are_submissions_open() or submission_overide(self)):
sorrypage.redirect_sorry(self, "ConfNotOpen")
return
self.set_crrt_conference_key(crrt_conf.key)
user = self.get_crrt_user()
spkr = speaker.retrieve_or_make(user.email())
spkr.name = user.name()
spkr.put()
template_values = {
"crrt_conf": crrt_conf,
'new_speaker': True,
'speaker': spkr,
"emaillocked": "readonly",
'speakerKey': spkr.key.urlsafe(),
'readonly': "",
}
self.write_page('submission_lib/flowpage1.html', template_values)
def get(self):
conference_key = self.get_crrt_conference_key()
crrt_conference = conference_key.get()
tracks = crrt_conference.track_options()
if len(tracks)==0:
sorrypage.redirect_sorry(self, "IncompleteSetup")
return
subs_count = {}
subs_count["total"] = 0
submissions = {}
for t in tracks:
if self.request.params.has_key("f"):
submissions[t], filter_description = self.retrieve_submissions(conference_key, t, self.request.get("f"))
else:
submissions[t] = []
filter_description = "No filter selected"
subs_count[t] = len(submissions[t])
subs_count["total"] += len(submissions[t])
template_values = {
"crrt_conference": crrt_conference,
"tracks" : tracks,
"submissions" : submissions,
'logoutlink': users.create_logout_url(self.request.uri),
"subs_count": subs_count,
"filter_description": filter_description,
}
self.write_page('reports/showallpage.html', template_values)
def store_speaker(self):
spkr = ndb.Key(urlsafe=self.request.get("speaker_key")).get()
speaker_fragment.read_speaker_dir(self, spkr)
try:
speaker_fragment.read_and_store_fields(self, spkr)
except apiproxy_errors.RequestTooLargeError:
sorrypage.redirect_sorry(self, "ImageTooBig")
return None
return spkr
def get(self):
crrt_conference = self.get_crrt_conference_key().get()
if (crrt_conference.is_reviewing_compete):
if crrt_conference.user_rights().has_permission(
self.get_crrt_user().email(),
userrightsnames.CONF_SCHEDULE):
self.show_schedule_page(crrt_conference)
else:
sorrypage.redirect_sorry(self, "NoSchedulingPerissoms")
else:
sorrypage.redirect_sorry(self, "NoSchedulingAtThisTime")
def get(self):
crrt_conf = self.get_crrt_conference_key().get()
rights = crrt_conf.user_rights()
review_tracks = rights.tracks_to_review(self.get_crrt_user().email())
if self.request.params.has_key("track"):
crrt_track = self.request.get("track")
else:
if len(review_tracks) > 0:
# no key so default to first track in list
crrt_track = review_tracks[0]
else:
# no tracks or no review rights
crrt_track = "None" # review_tracks[0]
sorrypage.redirect_sorry(self, "NoTracksAssigned")
return
named_reviewer = reviewer.get_reviewer(crrt_conf.key,
self.get_crrt_user().email())
if named_reviewer is None:
named_reviewer = reviewer.make_new_reviewer(
crrt_conf.key,
self.get_crrt_user().email())
review_round = int(self.request.get("round"))
records = named_reviewer.retrieve_review_assignments(
crrt_track, review_round)
newscoringconfig = confreviewconfig.get_conference_review_factory(crrt_conf.key). \
get_round_config(int(self.request.get("round")))
if newscoringconfig.is_speaker_named():
show_name = True
else:
show_name = False
template_values = {
"conference_submissions": map(lambda s: s.get(), records),
"count_submissions": len(records),
"selected_conf": crrt_conf.name,
"useremail": self.get_crrt_user().email(),
"review_tracks": review_tracks,
"track_dictionary": crrt_conf.track_options(),
"selected_track": crrt_track,
"durations": crrt_conf.duration_options(),
"review_round": review_round,
"show_name": show_name
}
self.write_page('subreview_lib/newscoringlistpage.html',
template_values)
def post(self):
if self.request.get("deletespeaker"):
self.delete_speaker()
try:
if self.request.get("updatespeaker"):
self.update_speaker()
self.post_update_redirect()
if self.request.get("updatetags"):
k = self.update_speaker()
self.redirect("/edittags?spk=" + k.urlsafe())
except apiproxy_errors.RequestTooLargeError:
sorrypage.redirect_sorry(self, "ImageTooBig")
def get(self):
crrt_conf = self.get_crrt_conference_key().get()
spkr = ndb.Key(urlsafe=self.request.get("speaker_key")).get()
if not(submission_overide(self)):
if (submission_queries.count_submissions(crrt_conf.key, spkr.key) >= crrt_conf.max_submissions()):
sorrypage.redirect_sorry(self, "SubsLimitReached")
return
template_values = { "crrt_conf" : crrt_conf,
"talk_details": talk.Talk(parent=None),
"speaker" : spkr,
}
self.write_page('submission_lib/flowpage2.html', template_values)
def new_conference(self):
if self.validate_fields():
if confdb.get_conf_by_name(self.request.get("newconfname")):
sorrypage.redirect_sorry(self, "ConfNameInUse")
return
if confdb.get_conf_by_shortname(self.request.get("shortname")):
sorrypage.redirect_sorry(self, "ConfShortnameInUse")
return
conf = self.make_conference()
postmail.Postman().post_conference_msg(
confmsgs.make_conference_created_msg(conf))
self.redirect("/confconfigpage?conf=" + conf.key.urlsafe())
def get(self):
if not (self.request.params.has_key("conf")):
sorrypage.redirect_sorry(self, "ConfKeyMissing")
return
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
template_values = {
"crrt_conf": conference,
"conf_key": conference.key,
"read_only": self.edit_permission(conference),
}
self.write_page('conference_lib/conflimitspage.html', template_values)
def get(self):
if not (self.request.params.has_key("conf")):
sorrypage.redirect_sorry(self, "ConfKeyMissing")
return
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
report = dedupvotes.retrieve_duplicate_report(conf_key)
template_values = {
"crrt_conf": conference,
"has_report": not (report == None),
"report": report,
}
self.write_page('subreview_lib/deduppage.html', template_values)
def get(self):
if self.request.params.has_key("new"):
self.clear_crrt_conference()
self.write_page('conference_lib/confadmin.html',
self.new_conference_values())
return
if self.get_crrt_conference_key() == None:
self.redirect("/chooseconf")
return
rights = self.get_crrt_conference_key().get().user_rights()
if rights.has_permission(self.get_crrt_user().email(),
userrightsnames.CONF_ADMINISTRATOR):
self.write_page('conference_lib/confadmin.html',
self.existing_conference())
else:
sorrypage.redirect_sorry(self, "AdminRightsReq")
def mainpage(self):
# need to pick user up frm session
# retrieve
# do whatever
if not self.session.has_key("uk"):
sorrypage.redirect_sorry("MissingUserSessionKey")
return
user = ndb.Key(urlsafe=self.session["uk"]).get()
crrt_conference_key = self.get_crrt_conference_key()
template_values = {
'name': user.name(),
'email': user.email(),
'logoutlink': users.create_logout_url(self.request.uri),
'crrt_conference_key': crrt_conference_key,
}
self.write_page('scaffold/index.html', template_values)
def get(self):
conf = ndb.Key(urlsafe=self.request.get("conf")).get()
if not (conf.user_rights().has_permission(
self.get_crrt_user().email(),
userrightsnames.SPEAK_COMMS_COMMS)):
sorrypage.redirect_sorry(self, "NoSpeakerCommsRights")
return
template_values = {
"conf":
conf,
"decline":
msgtemplate.retrieveTemplate(msgtemplate.DeclineMsg, conf.key),
"accept":
msgtemplate.retrieveTemplate(msgtemplate.AcceptMsg, conf.key),
"acknowledge":
msgtemplate.retrieveTemplate(msgtemplate.AcknowledgeMsg, conf.key),
}
self.write_page('mailmsg/mailtemplatespage.html', template_values)
def get(self):
username = self.get_crrt_user().email()
all_conf = confdb.test_retrieve_conferences_not_finished()
conference_key = self.get_crrt_conference_key()
if conference_key is None:
if len(all_conf) >= 1:
conference_key = all_conf[0].key
self.session["crrt_conference"] = conference_key.urlsafe()
else:
sorrypage.redirect_sorry(self, "NoConfToReview")
return
crrt_conference = conference_key.get()
rev = reviewer.get_reviewer(crrt_conference.key, username)
if rev is not None:
rev_key = rev.key.urlsafe()
else:
rev_key = None
template_values = {
'name':
username,
'logoutlink':
users.create_logout_url("/"),
'conference_count':
len(all_conf),
"conferences":
all_conf,
"crrt_conference":
crrt_conference,
"review_config":
confreviewconfig.get_conference_review_factory(
crrt_conference.key),
"compeleted_reviewing": (lambda r: rev.is_complete(r)),
"reviewerKey":
rev_key,
}
self.write_page('subreview_lib/reviewmain.html', template_values)
def get(self):
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
if not(conference.user_rights().has_permission(
self.get_crrt_user().email(),
userrightsnames.APPOINT_REVIEWERS)):
sorrypage.redirect_sorry(self, "AssignTracksReq")
return
volunteers = volunteerreviewer.retrieve_all_volunteers(conf_key)
template_values = {
"crrt_conf": conference,
"conf_key": conf_key,
"tracks": conference.track_options(),
"volunteers": volunteers,
"volunteer_count": len(volunteers),
"home_url": sysinfo.home_url(),
}
self.write_page('conference_lib/assignvolreviewerspage.html', template_values)
def get(self):
if not (self.request.params.has_key("conf")):
sorrypage.redirect_sorry(self, "ConfKeyMissing")
return
conf_key = ndb.Key(urlsafe=self.request.get("conf"))
conference = conf_key.get()
if not (conference.user_rights().has_permission(
self.get_crrt_user().email(), userrightsnames.CONF_CREATOR)):
sorrypage.redirect_sorry(self, "NoAccess")
return
self.write_page(
'conference_lib/confemailrecipients.html', {
"crrt_conf": conference,
"tracks": conference.track_options(),
"conf_key": conference.key,
"email_ack_cc": conference.ack_cc_addresses(),
"email_ack_bcc": conference.ack_bcc_addresses(),
"email_accept_cc": conference.accept_cc_addresses(),
})
def get(self):
if self.request.params.has_key("cf"):
shortname = self.request.get("cf")
else:
self.welcome_sorry()
return
conf = confdb.get_conf_by_shortname(shortname)
if (conf == None):
self.welcome_sorry()
return
if not (conf.are_submissions_open()):
sorrypage.redirect_sorry(self, "VolunteerReviewerClosed")
return
self.session["conference_volunteer"] = conf.key.urlsafe()
if self.is_logged_in():
self.redirect('/volunteerreviewer')
else:
self.show_page(conf)
def get(self):
self.crrt_conf = None
if self.session.has_key("conference_volunteer"):
self.crrt_conf = ndb.Key(urlsafe=self.session["conference_volunteer"]).get()
else:
if self.request.params.has_key("conf"):
self.crrt_conf = ndb.Key(urlsafe=self.request.get("conf")).get()
if self.crrt_conf == None:
sorrypage.redirect_sorry(self, "VolunteerFailure")
return
user = self.get_crrt_user()
template_values = {
"crrt_conf": self.crrt_conf,
"email": user.email(),
"name": user.name(),
"firebase_config_variable": firebase.config_js_params(),
}
self.write_page('scaffold/volunteerreviewerpage.html', template_values)
def get(self):
if not (self.request.params.has_key("cospeaker")):
sorrypage.redirect_sorry(self, "UnrecognisedCospeakerID")
return
cospeak = ndb.Key(urlsafe=self.request.get("cospeaker")).get()
speaker_details = speaker.make_new_speaker(cospeak.email)
speaker_details.name = cospeak.name
if self.request.params.has_key("sub_key"):
sub_key = self.request.get("sub_key")
else:
sub_key = "Nokey"
template_values = {
'new_speaker': True,
'speaker': speaker_details,
'speakerKey': None,
'readonly': "",
"emaillocked": "readonly",
"sub_key": sub_key,
}
self.write_page('speaker_lib/cospeakerpage.html', template_values)
def validate_fields(self):
suggested_name = self.request.get("newconfname")
if len(suggested_name) == 0:
sorrypage.redirect_sorry(self, "BlankNameField")
return False
if len(self.request.get("dates")) == 0:
sorrypage.redirect_sorry(self, "BlankDateField")
return False
if len(self.request.get("shortname")) == 0:
sorrypage.redirect_sorry(self, "BlankShortnameField")
return False
if len(self.request.get("contact_email")) == 0:
sorrypage.redirect_sorry(self, "ContactEmailMandatory")
return False
return True
def get(self):
if not (self.session.has_key("crrt_conference")):
logging.debug("Conference key session variable missing")
sorrypage.redirect_sorry(self, "MissingParams")
return
crrt_conf = ndb.Key(urlsafe=self.session["crrt_conference"]).get()
if not (self.request.params.has_key("round")):
logging.debug("Round parameter variable missing")
sorrypage.redirect_sorry(self, "MissingParams")
return
review_round = int(self.request.get("round"))
rights = crrt_conf.user_rights()
review_tracks = rights.tracks_to_review(self.get_crrt_user().email())
if self.request.params.has_key("track"):
crrt_track = self.request.get("track")
else:
if len(review_tracks) > 0:
# no key so default to first track in list
crrt_track = review_tracks[0]
else:
# no tracks or no review rights
crrt_track = "None" # review_tracks[0]
sorrypage.redirect_sorry(self, "NoTracksAssigned")
return
records = submissionrecord.retrieve_conference_submissions_by_track_and_round(
crrt_conf.key, crrt_track, review_round)
template_values = {
"conference_submissions": records,
"count_submissions": len(records),
"selected_conf": crrt_conf.name,
"useremail": self.get_crrt_user().email(),
"review_tracks": review_tracks,
"track_objects": crrt_conf.mapped_track_obects(),
"selected_track": crrt_track,
"track_slots": crrt_conf.mapped_track_obects()[crrt_track].slots,
"durations": crrt_conf.duration_options(),
"review_round": review_round,
}
self.write_page('subreview_lib/classicreviewlistpage.html',
template_values)
def get(self):
if self.request.params.has_key("email"):
email = self.request.get("email")
else:
sorrypage.redirect_sorry(self, "SpeakerPageAccessDenied")
return
if self.request.params.has_key("key"):
requested_speaker = self.request.get("key")
else:
sorrypage.redirect_sorry(self, "SpeakerPageKeyNotSupplied")
return
if speaker.speaker_exists(email):
speaker_details = speaker.retreive_speaker(email)
speaker_key = speaker_details.key.urlsafe()
else:
speaker_key = None
speaker_details = None
if speaker_key != requested_speaker:
sorrypage.redirect_sorry(self, "SpeakerPageCredentialsDoNotMatch")
return
template_values = {
'new_speaker': False,
'speaker': speaker_details,
'speakerKey': speaker_key,
'readonly': "",
"emaillocked": "readonly",
"updateable": True,
"dir_selected": speakerdir.SpeakerDir().is_speaker_listed(speaker_key),
"speaker_tags": tags.TagList(speaker_key).pretty_tag_list()
}
self.write_page('speakerpage.html', template_values)
