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)