def get(self):
coach = UserData.current()
if coach:
user_override = self.request_user_data("coach_email")
if user_override and user_override.are_students_visible_to(coach):
# Only allow looking at a student list other than your own
# if you are a dev, admin, or coworker.
coach = user_override
student_lists = StudentList.get_for_coach(coach.key())
student_lists_list = [{
'key': 'allstudents',
'name': 'כל התלמידים'.decode("utf8"),
}];
for student_list in student_lists:
student_lists_list.append({
'key': str(student_list.key()),
'name': student_list.name,
})
list_id, _ = get_last_student_list(self, student_lists, coach==UserData.current())
current_list = None
for student_list in student_lists_list:
if student_list['key'] == list_id:
current_list = student_list
selected_graph_type = self.request_string("selected_graph_type") or ClassProgressReportGraph.GRAPH_TYPE
if selected_graph_type == 'progressreport' or selected_graph_type == 'goals': # TomY This is temporary until all the graphs are API calls
initial_graph_url = "/api/v1/user/students/%s?coach_email=%s&%s" % (selected_graph_type, urllib.quote(coach.email), urllib.unquote(self.request_string("graph_query_params", default="")))
else:
initial_graph_url = "/profile/graph/%s?coach_email=%s&%s" % (selected_graph_type, urllib.quote(coach.email), urllib.unquote(self.request_string("graph_query_params", default="")))
initial_graph_url += 'list_id=%s' % list_id
exercises = models.Exercise.get_all_use_cache()
exercises.sort(key=lambda ex: ex.display_name)
template_values = {
'user_data_coach': coach,
'coach_email': coach.email,
'list_id': list_id,
'student_list': current_list,
'student_lists': student_lists_list,
'student_lists_json': json.dumps(student_lists_list),
'coach_nickname': coach.nickname,
'selected_graph_type': selected_graph_type,
'initial_graph_url': initial_graph_url,
'exercises': exercises,
'is_profile_empty': not coach.has_students(),
'selected_nav_link': 'coach',
"view": self.request_string("view", default=""),
'stats_charts_class': 'coach-view',
}
self.render_jinja2_template('viewclassprofile.html', template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
coach = UserData.current()
if coach:
user_override = self.request_user_data("coach_email")
if user_override and user_override.are_students_visible_to(coach):
# Only allow looking at a student list other than your own
# if you are a dev, admin, or coworker.
coach = user_override
student_lists = StudentList.get_for_coach(coach.key())
student_lists_list = [{
'key': 'allstudents',
'name': 'All students',
}]
for student_list in student_lists:
student_lists_list.append({
'key': str(student_list.key()),
'name': student_list.name,
})
list_id, _ = get_last_student_list(self, student_lists,
coach == UserData.current())
current_list = None
for student_list in student_lists_list:
if student_list['key'] == list_id:
current_list = student_list
selected_graph_type = self.request_string(
"selected_graph_type") or ClassProgressReportGraph.GRAPH_TYPE
initial_graph_url = "/profile/graph/%s?coach_email=%s&%s" % (
selected_graph_type, urllib.quote(coach.email),
urllib.unquote(
self.request_string("graph_query_params", default="")))
initial_graph_url += 'list_id=%s' % list_id
template_values = {
'user_data_coach': coach,
'coach_email': coach.email,
'list_id': list_id,
'student_list': current_list,
'student_lists': student_lists_list,
'student_lists_json': simplejson.dumps(student_lists_list),
'coach_nickname': coach.nickname,
'selected_graph_type': selected_graph_type,
'initial_graph_url': initial_graph_url,
'exercises': models.Exercise.get_all_use_cache(),
'is_profile_empty': not coach.has_students(),
'selected_nav_link': 'coach',
"view": self.request_string("view", default=""),
}
self.render_jinja2_template('viewclassprofile.html',
template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
coach = UserData.current()
if coach:
user_override = self.request_user_data("coach_email")
if user_override and user_override.are_students_visible_to(coach):
# Only allow looking at a student list other than your own
# if you are a dev, admin, or coworker.
coach = user_override
student_lists = StudentList.get_for_coach(coach.key())
student_lists_list = [{"key": "allstudents", "name": "All students"}]
for student_list in student_lists:
student_lists_list.append({"key": str(student_list.key()), "name": student_list.name})
list_id, _ = get_last_student_list(self, student_lists, coach == UserData.current())
current_list = None
for student_list in student_lists_list:
if student_list["key"] == list_id:
current_list = student_list
selected_graph_type = self.request_string("selected_graph_type") or ClassProgressReportGraph.GRAPH_TYPE
initial_graph_url = "/profile/graph/%s?coach_email=%s&%s" % (
selected_graph_type,
urllib.quote(coach.email),
urllib.unquote(self.request_string("graph_query_params", default="")),
)
initial_graph_url += "list_id=%s" % list_id
template_values = {
"user_data_coach": coach,
"coach_email": coach.email,
"list_id": list_id,
"student_list": current_list,
"student_lists": student_lists_list,
"student_lists_json": simplejson.dumps(student_lists_list),
"coach_nickname": coach.nickname,
"selected_graph_type": selected_graph_type,
"initial_graph_url": initial_graph_url,
"exercises": models.Exercise.get_all_use_cache(),
"is_profile_empty": not coach.has_students(),
"selected_nav_link": "coach",
"view": self.request_string("view", default=""),
}
self.render_jinja2_template("viewclassprofile.html", template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def post(self):
template_values = {}
user_data = UserData.current()
status_file = StringIO.StringIO(self.request_string("status_file"))
reader = csv.reader(status_file)
student_list = []
for line in reader:
student_email = line[0]
student_status = line[1]
student_comment = line[2]
student = SummerStudent.all().filter("email =", student_email).get()
if student is None:
logging.error("Student %s not found" % student_email)
continue
student.application_status = student_status
student.comment = student_comment
if student_status == "Accepted":
student.accepted = True
student_list.append(student)
db.put(student_list)
self.response.out.write("OK")
self.response.set_status(200)
def authenticated_response(self):
user_data = UserData.current()
user_email = user_data.user_email
template_values = {
"authenticated": True,
"user_email": user_email,
}
sio = StringIO.StringIO()
sw = csv.writer(sio)
properties = [p for p in SummerStudent().properties()]
sw.writerow(properties)
for student in SummerStudent.all().fetch(5000):
try:
row = []
for p in properties:
v = getattr(student, p)
if isinstance(v, basestring):
v = v.encode("utf-8")
row.append(v)
sw.writerow(row)
except Exception, e:
logging.error("Unable to write row for student %s" %
student.email)
def post(self):
template_values = {}
user_data = UserData.current()
status_file = StringIO.StringIO(self.request_string('status_file'))
reader = csv.reader(status_file)
student_list = []
for line in reader:
student_email = line[0]
student_status = line[1]
student_comment = line[2]
student = SummerStudent.all().filter('email =',
student_email).get()
if student is None:
logging.error("Student %s not found" % student_email)
continue
student.application_status = student_status
student.comment = student_comment
if student_status == "Accepted":
student.accepted = True
student_list.append(student)
db.put(student_list)
self.response.out.write("OK")
self.response.set_status(200)
def can_control_gandalf():
"""CUSTOMIZE can_control_gandalf however you want to specify
whether or not the currently-logged-in user has access
to Gandalf dashboard."
"""
user_data = UserData.current(bust_cache=True)
return users.is_current_user_admin() or (user_data and user_data.developer)
def can_control_gandalf():
"""CUSTOMIZE can_control_gandalf however you want to specify
whether or not the currently-logged-in user has access
to Gandalf dashboard."
"""
user_data = UserData.current(bust_cache=True)
return users.is_current_user_admin() or (user_data and user_data.developer)
def get(self):
user_data = UserData.current()
if user_data:
user_data_override = self.request_user_data("coach_email")
if user_util.is_current_user_developer() and user_data_override:
user_data = user_data_override
invalid_student = self.request_bool("invalid_student",
default=False)
coach_requests = [
x.student_requested_data.email
for x in CoachRequest.get_for_coach(user_data)
if x.student_requested_data
]
student_lists_models = StudentList.get_for_coach(user_data.key())
student_lists_list = []
for student_list in student_lists_models:
student_lists_list.append({
'key': str(student_list.key()),
'name': student_list.name,
})
student_lists_dict = dict(
(g['key'], g) for g in student_lists_list)
students_data = user_data.get_students_data()
students = map(
lambda s: {
'key':
str(s.key()),
'email':
s.email,
'nickname':
s.nickname,
'student_lists': [
l for l in [
student_lists_dict.get(str(list_id))
for list_id in s.student_lists
] if l
],
}, students_data)
students.sort(key=lambda s: s['nickname'])
template_values = {
"students": students,
"students_json": json.dumps(students),
"student_lists": student_lists_list,
"student_lists_json": json.dumps(student_lists_list),
"invalid_student": invalid_student,
"coach_requests": coach_requests,
"coach_requests_json": json.dumps(coach_requests),
'selected_nav_link': 'coach'
}
self.render_jinja2_template('viewstudentlists.html',
template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user_data = UserData.current()
if not user_data:
self.redirect(util.create_login_url(self.request.uri))
return
accept_coach = self.request_bool("accept", default = False)
user_data_coach = self.request_user_data("coach_email")
user_data_student = self.request_user_data('student_email')
if bool(user_data_coach) == bool(user_data_student):
raise Exception('must provide coach_email xor student_email')
if user_data_coach:
user_data_student = user_data
elif user_data_student:
user_data_coach = user_data
if user_data_coach and not user_data_student.is_coached_by(user_data_coach):
coach_request = CoachRequest.get_for(user_data_coach, user_data_student)
if coach_request:
coach_request.delete()
if user_data.key_email == user_data_student.key_email and accept_coach:
user_data_student.coaches.append(user_data_coach.key_email)
user_data_student.put()
if not self.is_ajax_request():
self.redirect("/coaches")
def render_login_outer(self):
"""Render the login page.
Note that part of the contents of this page is hosted on an iframe
and rendered by this same RequestHandler (render_login_form)
"""
cont = self.request_continue_url()
direct = self.request_bool('direct', default=False)
user_data = UserData.current()
if user_data and not user_data.is_phantom:
# Don't let users see the login page if they're already logged in.
# This avoids dangerous edge cases in which users have conflicting
# Google/FB cookies, and google.appengine.api.users.get_current_user
# returns a different user than the actual person logged in.
self.redirect(cont)
return
template_values = {
'continue': cont,
'direct': direct,
'google_url': users.create_login_url(cont),
}
self.render_jinja2_template('login.html', template_values)
def get(self):
user_data = UserData.current()
if not user_data:
self.redirect(util.create_login_url(self.request.uri))
return
accept_coach = self.request_bool("accept", default = False)
user_data_coach = self.request_user_data("coach_email")
user_data_student = self.request_user_data('student_email')
if bool(user_data_coach) == bool(user_data_student):
raise Exception('must provide coach_email xor student_email')
if user_data_coach:
user_data_student = user_data
elif user_data_student:
user_data_coach = user_data
if user_data_coach and not user_data_student.is_coached_by(user_data_coach):
coach_request = CoachRequest.get_for(user_data_coach, user_data_student)
if coach_request:
coach_request.delete()
if user_data.key_email == user_data_student.key_email and accept_coach:
user_data_student.coaches.append(user_data_coach.key_email)
user_data_student.put()
if not self.is_ajax_request():
self.redirect("/coaches")
def render_login_outer(self):
"""Render the login page.
Note that part of the contents of this page is hosted on an iframe
and rendered by this same RequestHandler (render_login_form)
"""
cont = self.request_continue_url()
direct = self.request_bool('direct', default=False)
user_data = UserData.current()
if user_data and not user_data.is_phantom:
# Don't let users see the login page if they're already logged in.
# This avoids dangerous edge cases in which users have conflicting
# Google/FB cookies, and google.appengine.api.users.get_current_user
# returns a different user than the actual person logged in.
self.redirect(cont)
return
template_values = {
'continue': cont,
'direct': direct,
'google_url': users.create_login_url(cont),
}
self.render_jinja2_template('login.html', template_values)
def post(self):
user_data = UserData.current()
if user_data:
expanded = self.request_bool("expanded")
user_data.expanded_all_exercises = expanded
user_data.put()
def post(self):
user_data = UserData.current()
if user_data:
expanded = self.request_bool("expanded")
user_data.expanded_all_exercises = expanded
user_data.put()
def get(self):
student = UserData.current() or UserData.pre_phantom()
user_override = self.request_student_user_data(legacy=True)
if user_override and user_override.key_email != student.key_email:
if not user_override.is_visible_to(student):
# If current user isn't an admin or student's coach, they can't
# look at anything other than their own profile.
self.redirect("/profile")
return
else:
# Allow access to this student's profile
student = user_override
user_badges = util_badges.get_user_badges(student)
selected_graph_type = (self.request_string("selected_graph_type") or
ActivityGraph.GRAPH_TYPE)
# TODO: deal with this one-off hackery. Some graphs use the API
# to fetch data, instead of the /profile/graph methods.
if selected_graph_type == "exerciseprogress":
initial_graph_url = ("/api/v1/user/exercises?email=%s" %
urllib.quote(student.email))
elif selected_graph_type == "goals":
initial_graph_url = ("/api/v1/user/goals?email=%s" %
urllib.quote(student.email))
else:
initial_graph_url = "/profile/graph/%s?student_email=%s&%s" % (
selected_graph_type,
urllib.quote(student.email),
urllib.unquote(self.request_string("graph_query_params",
default="")))
tz_offset = self.request_int("tz_offset", default=0)
template_values = {
'student_email': student.email,
'student_nickname': student.nickname,
'selected_graph_type': selected_graph_type,
'initial_graph_url': initial_graph_url,
'tz_offset': tz_offset,
'student_points': student.points,
'count_videos': models.Setting.count_videos(),
'count_videos_completed': student.get_videos_completed(),
'count_exercises': models.Exercise.get_count(),
'count_exercises_proficient': len(student.all_proficient_exercises),
'badge_collections': user_badges['badge_collections'],
'user_badges_bronze': user_badges['bronze_badges'],
'user_badges_silver': user_badges['silver_badges'],
'user_badges_gold': user_badges['gold_badges'],
'user_badges_platinum': user_badges['platinum_badges'],
'user_badges_diamond': user_badges['diamond_badges'],
'user_badges_master': user_badges['user_badges_master'],
'user_badges': [user_badges['bronze_badges'], user_badges['silver_badges'], user_badges['gold_badges'], user_badges['platinum_badges'], user_badges['diamond_badges'],user_badges['user_badges_master']],
'user_data_student': student,
"show_badge_frequencies": self.request_bool("show_badge_frequencies", default=False),
"view": self.request_string("view", default=""),
}
self.render_jinja2_template('viewprofile.html', template_values)
def get(self, url_id=""):
url = Url.get_by_id(int(url_id))
if url is None:
raise MissingUrlException("Missing url '%s'" % url_id)
user_data = UserData.current()
if user_data:
goals_updated = GoalList.update_goals(user_data, lambda goal: goal.just_visited_url(user_data, url))
self.redirect(url.url.encode("utf8"))
def post(self):
coach_data = UserData.current()
if not coach_data:
return
student_list = util_profile.get_list(coach_data, self)
student_list.delete()
if not self.is_ajax_request():
self.redirect_to('/students')
def post(self):
coach_data = UserData.current()
if not coach_data:
return
student_list = util_profile.get_list(coach_data, self)
student_list.delete()
if not self.is_ajax_request():
self.redirect_to('/students')
def do_request(self, student, coach, redirect_to):
if not UserData.current():
self.redirect(util.create_login_url(self.request.uri))
return
if student and coach:
self.remove_student_from_coach(student, coach)
if not self.is_ajax_request():
self.redirect(redirect_to)
def do_request(self, student, coach, redirect_to):
if not UserData.current():
self.redirect(util.create_login_url(self.request.uri))
return
if student and coach:
self.remove_student_from_coach(student, coach)
if not self.is_ajax_request():
self.redirect(redirect_to)
def get(self):
user_data = UserData.current()
context = {
'user_data': user_data,
# Get pregenerated library content from our in-memory/memcache
# two-layer cache
'library_content': library_content_html(),
}
self.render_jinja2_template("goals/creategoal.html", context)
def get_profile_target_user_data(self):
coach = UserData.current()
if coach:
user_override = self.request_user_data("coach_email")
if user_override and user_override.are_students_visible_to(coach):
# Only allow looking at a student list other than your own
# if you are a dev, admin, or coworker.
coach = user_override
return coach
def post(self):
# You have to be logged in to vote
user_data = UserData.current()
if not user_data:
return
vote_type = self.request_int("vote_type", default=FeedbackVote.ABSTAIN)
if vote_type == FeedbackVote.UP and not Privileges.can_up_vote(
user_data):
self.render_json({
"error":
Privileges.need_points_desc(Privileges.UP_VOTE_THRESHOLD,
"up vote")
})
return
elif vote_type == FeedbackVote.DOWN and not Privileges.can_down_vote(
user_data):
self.render_json({
"error":
Privileges.need_points_desc(Privileges.DOWN_VOTE_THRESHOLD,
"down vote")
})
return
entity_key = self.request_string("entity_key", default="")
if entity_key:
entity = db.get(entity_key)
if entity and entity.authored_by(user_data):
self.render_json(
{"error": "You cannot vote for your own posts."})
return
if vote_type != FeedbackVote.ABSTAIN:
limiter = VoteRateLimiter(user_data)
if not limiter.increment():
self.render_json({"error": limiter.denied_desc()})
return
# We kick off a taskqueue item to perform the actual vote insertion
# so we don't have to worry about fast writes to the entity group
# causing contention problems for the HR datastore, because
# the taskqueue will just retry w/ exponential backoff.
taskqueue.add(url='/admin/discussion/finishvoteentity',
queue_name='voting-queue',
params={
"email":
user_data.email,
"vote_type":
self.request_int("vote_type",
default=FeedbackVote.ABSTAIN),
"entity_key":
entity_key
})
def get_profile_target_user_data(self):
coach = UserData.current()
if coach:
user_override = self.request_user_data("coach_email")
if user_override and user_override.are_students_visible_to(coach):
# Only allow looking at a student list other than your own
# if you are a dev, admin, or coworker.
coach = user_override
return coach
def get(self):
template_values = {}
user_data = UserData.current()
if user_data is not None:
return self.authenticated_response()
else:
template_values = {"authenticated": False}
self.add_global_template_values(template_values)
self.render_jinja2_template("summer/summer_process.html", template_values)
def get(self):
student = UserData.current() or UserData.pre_phantom()
user_override = self.request_user_data("student_email")
if user_override and user_override.key_email != student.key_email:
if not user_override.is_visible_to(student):
# If current user isn't an admin or student's coach, they can't look at anything other than their own profile.
self.redirect("/profile?k")
return
else:
# Allow access to this student's profile
student = user_override
user_badges = util_badges.get_user_badges(student)
selected_graph_type = self.request_string("selected_graph_type") or ActivityGraph.GRAPH_TYPE
initial_graph_url = "/profile/graph/%s?student_email=%s&%s" % (
selected_graph_type,
urllib.quote(student.email),
urllib.unquote(self.request_string("graph_query_params", default="")),
)
tz_offset = self.request_int("tz_offset", default=0)
template_values = {
"student_nickname": student.nickname,
"selected_graph_type": selected_graph_type,
"initial_graph_url": initial_graph_url,
"tz_offset": tz_offset,
"student_points": student.points,
"count_videos": models.Setting.count_videos(),
"count_videos_completed": student.get_videos_completed(),
"count_exercises": models.Exercise.get_count(),
"count_exercises_proficient": len(student.all_proficient_exercises),
"badge_collections": user_badges["badge_collections"],
"user_badges_bronze": user_badges["bronze_badges"],
"user_badges_silver": user_badges["silver_badges"],
"user_badges_gold": user_badges["gold_badges"],
"user_badges_platinum": user_badges["platinum_badges"],
"user_badges_diamond": user_badges["diamond_badges"],
"user_badges_master": user_badges["user_badges_master"],
"user_badges": [
user_badges["bronze_badges"],
user_badges["silver_badges"],
user_badges["gold_badges"],
user_badges["platinum_badges"],
user_badges["diamond_badges"],
user_badges["user_badges_master"],
],
"user_data_student": student,
"show_badge_frequencies": self.request_bool("show_badge_frequencies", default=False),
"view": self.request_string("view", default=""),
}
self.render_jinja2_template("viewprofile.html", template_values)
def get(self):
user_data = UserData.current()
if user_data == None:
return
user_video_css = models.UserVideoCss.get_for_user_data(user_data)
self.response.headers['Content-Type'] = 'text/css'
if user_video_css.version == user_data.uservideocss_version:
# Don't cache if there's a version mismatch and update isn't finished
self.response.headers['Cache-Control'] = 'public,max-age=1000000'
self.response.out.write(user_video_css.video_css)
def get_profile_target_user_data(self):
student = UserData.current() or UserData.pre_phantom()
if student:
user_override = self.request_user_data("student_email")
if user_override and user_override.key_email != student.key_email:
if not user_override.is_visible_to(student):
# If current user isn't an admin or student's coach, they can't look at anything other than their own profile.
student = None
else:
# Allow access to this student's profile
student = user_override
return student
def get_profile_target_user_data(self):
student = UserData.current() or UserData.pre_phantom()
if student:
user_override = self.request_user_data("student_email")
if user_override and user_override.key_email != student.key_email:
if not user_override.is_visible_to(student):
# If current user isn't an admin or student's coach, they can't look at anything other than their own profile.
student = None
else:
# Allow access to this student's profile
student = user_override
return student
def current_logged_in_identity():
"""This should return one of the following:
A) a db.Model that identifies the current user, like models.UserData.current()
B) a unique string that consistently identifies the current user, like users.get_current_user().user_id()
Ideally, this should be connected to your app's existing identity system.
Examples:
return models.UserData.current()
...or...
from google.appengine.api import users
return users.get_current_user().user_id() if users.get_current_user() else None"""
return UserData.current(bust_cache=True)
def current_logged_in_identity():
"""This should return one of the following:
A) a db.Model that identifies the current user, like models.UserData.current()
B) a unique string that consistently identifies the current user, like users.get_current_user().user_id()
Ideally, this should be connected to your app's existing identity system.
Examples:
return models.UserData.current()
...or...
from google.appengine.api import users
return users.get_current_user().user_id() if users.get_current_user() else None"""
return UserData.current(bust_cache=True)
def get(self):
user_data = UserData.current()
video_points_total = 0
if user_data:
video = None
key_str = self.request_string("video_key")
if key_str:
key = db.Key(key_str)
app_id = os.environ['APPLICATION_ID']
if key.app() != app_id:
new_key = db.Key.from_path(key.kind(),
key.id() or key.name(),
_app=app_id)
logging.warning(
"Key '%s' had invalid app_id '%s'. Changed to new key '%s'",
str(key), key.app(), str(new_key))
key = new_key
video = db.get(key)
else:
youtube_id = self.request_string("youtube_id")
if youtube_id:
video = Video.all().filter('youtube_id =',
youtube_id).get()
if video:
# Seconds watched is restricted by both the scrubber's position
# and the amount of time spent on the video page
# so we know how *much* of each video each student has watched
seconds_watched = int(
self.request_float("seconds_watched", default=0))
last_second_watched = int(
self.request_float("last_second_watched", default=0))
user_video, video_log, video_points_total = VideoLog.add_entry(
user_data, video, seconds_watched, last_second_watched)
user_points_html = self.render_jinja2_template_to_string(
"user_points_only.html", user_points(user_data))
json = simplejson.dumps(
{
"user_points_html": user_points_html,
"video_points": video_points_total
},
ensure_ascii=False)
self.response.out.write(json)
def post(self):
user_data = UserData.current()
if user_data:
try:
lat = self.request_float("lat")
lng = self.request_float("lng")
zoom = self.request_int("zoom")
except ValueError:
# If any of the above values aren't present in request, don't try to save.
return
user_data.map_coords = serializeMapCoords(lat, lng, zoom)
user_data.put()
def post(self):
user_data = UserData.current()
if user_data:
try:
lat = self.request_float("lat")
lng = self.request_float("lng")
zoom = self.request_int("zoom")
except ValueError:
# If any of the above values aren't present in request, don't try to save.
return
user_data.map_coords = serializeMapCoords(lat, lng, zoom)
user_data.put()
def get(self):
template_values = {}
user_data = UserData.current()
if user_data is not None:
return self.authenticated_response()
else:
template_values = {
"authenticated": False,
}
self.add_global_template_values(template_values)
self.render_jinja2_template('summer/summer_process.html',
template_values)
def get(self):
template_values = {}
user_data = UserData.current()
if user_data is not None:
template_values = self.authenticated_response()
if template_values is None:
self.redirect("/summer/application")
return
else:
template_values = {"authenticated": False}
self.add_global_template_values(template_values)
self.render_jinja2_template("summer/summer_status.html", template_values)
def get(self):
user_data = UserData.current()
sort = self.request_int("sort", default=VotingSortOrder.HighestPointsFirst)
if user_data:
user_data.question_sort_order = sort
user_data.put()
readable_id = self.request_string("readable_id", default="")
topic_id = self.request_string("topic_id", default="")
if readable_id and topic_id:
self.redirect("/video/%s?topic=%s&sort=%s" % (urllib.quote(readable_id), urllib.quote(topic_id), sort))
else:
self.redirect("/")
def get(self):
user_data = UserData.current()
from exercises import exercise_graph_dict_json
context = {
'graph_dict_data': exercise_graph_dict_json(user_data),
'user_data': user_data,
'expanded_all_exercises': user_data.expanded_all_exercises,
'map_coords': json.dumps(deserializeMapCoords(user_data.map_coords)),
# Get pregenerated library content from our in-memory/memcache
# two-layer cache
'library_content': library_content_html(),
}
self.render_jinja2_template("goals/creategoal.html", context)
def get(self):
user_data = UserData.current()
from exercises import exercise_graph_dict_json
context = {
'graph_dict_data': exercise_graph_dict_json(user_data),
'user_data': user_data,
'expanded_all_exercises': user_data.expanded_all_exercises,
'map_coords': deserializeMapCoords(user_data.map_coords),
# Get pregenerated library content from our in-memory/memcache
# two-layer cache
'library_content': library_content_html(),
}
self.render_jinja2_template("goals/creategoal.html", context)
def get(self):
user_data = UserData.current()
if user_data:
user_data_override = self.request_user_data("coach_email")
if user_util.is_current_user_developer() and user_data_override:
user_data = user_data_override
invalid_student = self.request_bool("invalid_student", default = False)
coach_requests = [x.student_requested_data.email for x in CoachRequest.get_for_coach(user_data) if x.student_requested_data]
student_lists_models = StudentList.get_for_coach(user_data.key())
student_lists_list = [];
for student_list in student_lists_models:
student_lists_list.append({
'key': str(student_list.key()),
'name': student_list.name,
})
student_lists_dict = dict((g['key'], g) for g in student_lists_list)
students_data = user_data.get_students_data()
students = map(lambda s: {
'key': str(s.key()),
'email': s.email,
'nickname': s.nickname,
'profile_root': s.profile_root,
'studentLists': [l for l in [student_lists_dict.get(str(list_id)) for list_id in s.student_lists] if l],
}, students_data)
students.sort(key=lambda s: s['nickname'])
template_values = {
"students": students,
"students_json": json.dumps(students),
"student_lists": student_lists_list,
"student_lists_json": json.dumps(student_lists_list),
"invalid_student": invalid_student,
"coach_requests": coach_requests,
"coach_requests_json": json.dumps(coach_requests),
'selected_nav_link': 'coach'
}
self.render_jinja2_template('viewstudentlists.html', template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user_data = UserData.current()
sort = self.request_int("sort",
default=VotingSortOrder.HighestPointsFirst)
if user_data:
user_data.question_sort_order = sort
user_data.put()
readable_id = self.request_string("readable_id", default="")
playlist_title = self.request_string("playlist_title", default="")
if readable_id and playlist_title:
self.redirect("/video/%s?playlist=%s&sort=%s" %
(urllib.quote(readable_id),
urllib.quote(playlist_title), sort))
else:
self.redirect("/")
def get(self):
template_values = {}
user_data = UserData.current()
if user_data is not None:
template_values = self.authenticated_response()
if template_values is None:
self.redirect("/summer/application")
return
else:
template_values = {
"authenticated": False,
}
self.add_global_template_values(template_values)
self.render_jinja2_template('summer/summer_status.html',
template_values)
def authenticated_response(self):
user_data = UserData.current()
user_email = user_data.user_email
nickname = ""
if facebook_util.is_facebook_user_id(user_email):
nickname = facebook_util.get_facebook_nickname(user_email)
query = SummerStudent.all()
query.filter('email = ', user_email)
student = query.get()
students = []
is_parent = False
if student is None:
query = SummerParentData.all()
query.filter('email = ', user_email)
parent = query.get()
if parent is None:
return None
is_parent = True
number_of_students = 0
for student_key in parent.students:
student = SummerStudent.get(student_key)
students.append(student)
if student.accepted and not student.tuition_paid:
number_of_students += 1
else:
number_of_students = 1
students.append(student)
template_values = {
"authenticated": True,
"is_parent": is_parent,
"students": students,
"number_of_students": json.dumps(number_of_students),
"student": students[0],
"user_email": user_email,
"nickname": nickname,
}
return template_values
def authenticated_response(self):
user_data = UserData.current()
user_email = user_data.user_email
nickname = ""
if facebook_util.is_facebook_user_id(user_email):
nickname = facebook_util.get_facebook_nickname(user_email)
query = SummerStudent.all()
query.filter("email = ", user_email)
student = query.get()
students = []
is_parent = False
if student is None:
query = SummerParentData.all()
query.filter("email = ", user_email)
parent = query.get()
if parent is None:
return None
is_parent = True
number_of_students = 0
for student_key in parent.students:
student = SummerStudent.get(student_key)
students.append(student)
if student.accepted and not student.tuition_paid:
number_of_students += 1
else:
number_of_students = 1
students.append(student)
template_values = {
"authenticated": True,
"is_parent": is_parent,
"students": students,
"number_of_students": json.dumps(number_of_students),
"student": students[0],
"user_email": user_email,
"nickname": nickname,
}
return template_values
def post(self):
coach_data = UserData.current()
if not coach_data:
return
list_name = self.request_string('list_name')
if not list_name:
raise Exception('Invalid list name')
student_list = StudentList(coaches=[coach_data.key()], name=list_name)
student_list.put()
student_list_json = {
'name': student_list.name,
'key': str(student_list.key())
}
self.render_json(student_list_json)
def post(self):
user_data = UserData.current()
if not user_data:
self.redirect(util.create_login_url(self.request.uri))
return
user_data_student = self.request_user_data("student_email")
if user_data_student:
if not user_data_student.is_coached_by(user_data):
coach_request = CoachRequest.get_or_insert_for(user_data, user_data_student)
if coach_request:
if not self.is_ajax_request():
self.redirect("/students")
return
if self.is_ajax_request():
self.response.set_status(404)
else:
self.redirect("/students?invalid_student=1")
def post(self):
user_data = UserData.current()
if not user_data:
self.redirect(util.create_login_url(self.request.uri))
return
user_data_student = self.request_user_data("student_email")
if user_data_student:
if not user_data_student.is_coached_by(user_data):
coach_request = CoachRequest.get_or_insert_for(user_data, user_data_student)
if coach_request:
if not self.is_ajax_request():
self.redirect("/students")
return
if self.is_ajax_request():
self.response.set_status(404)
else:
self.redirect("/students?invalid_student=1")
def post(self):
coach_data = UserData.current()
if not coach_data:
return
list_name = self.request_string('list_name')
if not list_name:
raise Exception('Invalid list name')
student_list = StudentList(coaches=[coach_data.key()], name=list_name)
student_list.put()
student_list_json = {
'name': student_list.name,
'key': str(student_list.key())
}
self.render_json(student_list_json)
def get(self):
user_data = UserData.current()
if user_data:
invalid_coach = self.request_bool("invalid_coach", default = False)
coach_requests = CoachRequest.get_for_student(user_data).fetch(1000)
template_values = {
"coach_emails": user_data.coach_emails(),
"invalid_coach": invalid_coach,
"coach_requests": coach_requests,
"student_id": user_data.email,
'selected_nav_link': 'coach'
}
self.render_jinja2_template('viewcoaches.html', template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user_data = UserData.current()
if user_data:
invalid_coach = self.request_bool("invalid_coach", default = False)
coach_requests = CoachRequest.get_for_student(user_data).fetch(1000)
template_values = {
"coach_emails": user_data.coach_emails(),
"invalid_coach": invalid_coach,
"coach_requests": coach_requests,
"student_id": user_data.email,
'selected_nav_link': 'coach'
}
self.render_jinja2_template('viewcoaches.html', template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def _resolve_user_in_https_frame(handler):
"""Determine the current logged in user for the HTTPS request.
This has logic in additional to UserData.current(), since it should also
accept TransferAuthTokens, since HTTPS requests may not have normal HTTP
cookies sent.
"""
user_data = UserData.current()
if user_data:
return user_data
if not App.is_dev_server and not handler.request.uri.startswith('https'):
return None
# On https, users aren't recognized through the normal means of cookie auth
# since their cookies were set on HTTP domains.
token_value = handler.request_string("transfer_token", default=None)
return TransferAuthToken.get_user_for_value(
token_value, UserData.get_from_user_id)
def _resolve_user_in_https_frame(handler):
"""Determine the current logged in user for the HTTPS request.
This has logic in additional to UserData.current(), since it should also
accept TransferAuthTokens, since HTTPS requests may not have normal HTTP
cookies sent.
"""
user_data = UserData.current()
if user_data:
return user_data
if not App.is_dev_server and not handler.request.uri.startswith('https'):
return None
# On https, users aren't recognized through the normal means of cookie auth
# since their cookies were set on HTTP domains.
token_value = handler.request_string("transfer_token", default=None)
return TransferAuthToken.get_user_for_value(token_value,
UserData.get_from_user_id)
def authenticated_response(self):
user_data = UserData.current()
user_email = user_data.user_email
template_values = {"authenticated": True, "user_email": user_email}
sio = StringIO.StringIO()
sw = csv.writer(sio)
properties = [p for p in SummerStudent().properties()]
sw.writerow(properties)
for student in SummerStudent.all().fetch(5000):
try:
row = []
for p in properties:
v = getattr(student, p)
if isinstance(v, basestring):
v = v.encode("utf-8")
row.append(v)
sw.writerow(row)
except Exception, e:
logging.error("Unable to write row for student %s" % student.email)
def post(self):
user_data = UserData.current()
if not user_data:
self.redirect(util.create_login_url(self.request.uri))
return
user_data_coach = self.request_user_data("coach")
if user_data_coach:
if not user_data.is_coached_by(user_data_coach):
user_data.coaches.append(user_data_coach.key_email)
user_data.put()
if not self.is_ajax_request():
self.redirect("/coaches")
return
if self.is_ajax_request():
self.response.set_status(400)
else:
self.redirect("/coaches?invalid_coach=1")
def post(self):
user_data = UserData.current()
if not user_data:
self.redirect(util.create_login_url(self.request.uri))
return
user_data_coach = self.request_user_data("coach")
if user_data_coach:
if not user_data.is_coached_by(user_data_coach):
user_data.coaches.append(user_data_coach.key_email)
user_data.put()
if not self.is_ajax_request():
self.redirect("/coaches")
return
if self.is_ajax_request():
self.response.set_status(400)
else:
self.redirect("/coaches?invalid_coach=1")
def authenticated_response(self):
user_data = UserData.current()
user_email = user_data.user_email
nickname = ""
if facebook_util.is_facebook_user_id(user_email):
nickname = facebook_util.get_facebook_nickname(user_email)
query = SummerStudent.all()
query.filter('email = ', user_email)
student = query.get()
students = []
is_parent = False
if student is None:
query = SummerParentData.all()
query.filter('email = ', user_email)
parent = query.get()
if parent is None:
return None
is_parent = True
for student_key in parent.students:
students.append(SummerStudent.get(student_key))
else:
students.append(student)
template_values = {
"authenticated": True,
"is_parent": is_parent,
"students": students,
"user_email": user_email,
"nickname": nickname,
}
return template_values
def current_logged_in_identity():
from models import UserData
return UserData.current(bust_cache=True)
def can_control_experiments():
from models import UserData
user_data = UserData.current(bust_cache=True)
return users.is_current_user_admin() or (user_data and user_data.developer)
