def post(self):
greeting = Greeting()
if util.get_current_user():
greeting.author = util.get_current_user()
greeting.content = self.request.get('content')
greeting.put()
self.redirect('/')
def current_user_points(self):
user_video = UserVideo.get_for_video_and_user(self,
util.get_current_user())
if user_video:
return points.VideoPointCalculator(user_video)
else:
return 0
def get(self):
user = util.get_current_user()
coach_email = "Not signed in. Please sign in to see your Coach ID."
if user:
coach_email = user.email()
self.render_template('about/faq.html', {"selected_id": "faq", "approx_vid_count": consts.APPROX_VID_COUNT, "coach_email": coach_email})
def post(self):
user = util.get_current_user()
if not user:
self.redirect(util.create_login_url(self.request.uri))
return
if not is_honeypot_empty(self.request):
# Honeypot caught a spammer (in case this is ever public or spammers
# have google accounts)!
return
question_text = self.request.get("question_text")
video_key = self.request.get("video_key")
playlist_key = self.request.get("playlist_key")
video = db.get(video_key)
if question_text and video:
if len(question_text) > 500:
question_text = question_text[0:500] # max question length, also limited by client
question = models_discussion.Feedback()
question.author = user
question.content = question_text
question.targets = [video.key()]
question.types = [models_discussion.FeedbackType.Question]
db.put(question)
self.redirect("/discussion/pagequestions?video_key=%s&playlist_key=%s&page=0" % (video_key, playlist_key))
def render_template(self, template_name, template_values):
template_values['App'] = App
template_values['None'] = None
template_values['points'] = None
template_values['username'] = ""
user = util.get_current_user()
if user is not None:
template_values['username'] = user.nickname()
user_data = UserData.get_for(user)
template_values['user_data'] = user_data
template_values['points'] = user_data.points if user_data else 0
if not template_values.has_key('continue'):
template_values['continue'] = self.request.uri
# Always insert a post-login request before our continue url
template_values['continue'] = util.create_post_login_url(template_values['continue'])
template_values['login_url'] = ('%s&direct=1' % util.create_login_url(template_values['continue']))
template_values['logout_url'] = util.create_logout_url(self.request.uri)
template_values['is_mobile'] = self.is_mobile()
path = os.path.join(os.path.dirname(__file__), template_name)
self.response.out.write(template.render(path, template_values))
def signature(target=None, verb=None):
return {
"target": target,
"verb": verb,
"is_mod": is_current_user_moderator(),
"is_author": target and target.author == util.get_current_user()
}
def get_profile_target_and_user_data(self):
student = None
user_data_student = None
user = util.get_current_user()
if user:
student = user
student_email = self.request_string("student_email")
if student_email and student_email != student.email():
student_override = users.User(email=student_email)
user_data_student = models.UserData.get_or_insert_for(
student_override)
if (not users.is_current_user_admin()) and user.email(
) not in user_data_student.coaches and user.email().lower(
) not in user_data_student.coaches:
# If current user isn't an admin or student's coach, they can't look at anything other than their own profile.
user_data_student = None
else:
# Allow access to this student's profile
student = student_override
if not user_data_student:
user_data_student = models.UserData.get_or_insert_for(student)
return (student, user_data_student)
def signature(target=None, verb=None):
return {
"target": target,
"verb": verb,
"is_mod": is_current_user_moderator(),
"is_author": target and target.author == util.get_current_user()
}
def post(self):
user = util.get_current_user()
if not user:
self.redirect(util.create_login_url(self.request.uri))
return
if not is_honeypot_empty(self.request):
# Honeypot caught a spammer (in case this is ever public or spammers
# have google accounts)!
return
comment_text = self.request.get("comment_text")
comments_hidden = self.request.get("comments_hidden")
video_key = self.request.get("video_key")
playlist_key = self.request.get("playlist_key")
video = db.get(video_key)
if comment_text and video:
if len(comment_text) > 300:
comment_text = comment_text[0:300] # max comment length, also limited by client
comment = models_discussion.Feedback()
comment.author = user
comment.content = comment_text
comment.targets = [video.key()]
comment.types = [models_discussion.FeedbackType.Comment]
db.put(comment)
self.redirect("/discussion/pagecomments?video_key=%s&playlist_key=%s&page=0&comments_hidden=%s" % (video_key, playlist_key, comments_hidden))
def video_comments_context(video, playlist, page=0, comments_hidden=True):
if page > 0:
comments_hidden = False # Never hide questions if specifying specific page
else:
page = 1
limit_per_page = 10
limit_initially_visible = 3 if comments_hidden else limit_per_page
comments_query = models_discussion.Feedback.gql("WHERE types = :1 AND targets = :2 AND deleted = :3 ORDER BY date DESC", models_discussion.FeedbackType.Comment, video.key(), False)
count_total = comments_query.count()
comments = comments_query.fetch(limit_per_page, (page - 1) * limit_per_page)
count_page = len(comments)
pages_total = max(1, ((count_total - 1) / limit_per_page) + 1)
return {
"user": util.get_current_user(),
"is_mod": is_current_user_moderator(),
"video": video,
"playlist": playlist,
"comments": comments,
"count_total": count_total,
"comments_hidden": count_page > limit_initially_visible,
"limit_initially_visible": limit_initially_visible,
"pages": range(1, pages_total + 1),
"pages_total": pages_total,
"prev_page_1_based": page - 1,
"current_page_1_based": page,
"next_page_1_based": page + 1,
"show_page_controls": pages_total > 1,
"login_url": util.create_login_url("/video?v=%s" % video.youtube_id)
}
def get_for_current_user():
user = util.get_current_user()
if user is not None:
user_data = UserData.get_for(user)
if user_data is not None:
return user_data
return UserData()
def get_user_badges(user = None):
if not user:
user = util.get_current_user()
user_badges = []
user_badges_dict = {}
if user:
user_badges = models_badges.UserBadge.get_for(user)
badges_dict = all_badges_dict()
user_badge_last = None
for user_badge in user_badges:
if user_badge_last and user_badge_last.badge_name == user_badge.badge_name:
user_badge_last.count += 1
if user_badge_last.count > 1:
user_badge_last.list_context_names_hidden.append(user_badge.target_context_name)
else:
user_badge_last.list_context_names.append(user_badge.target_context_name)
else:
user_badge.badge = badges_dict.get(user_badge.badge_name)
user_badge.count = 1
user_badge.list_context_names = [user_badge.target_context_name]
user_badge.list_context_names_hidden = []
user_badge_last = user_badge
user_badges_dict[user_badge.badge_name] = True
possible_badges = all_badges()
for badge in possible_badges:
badge.is_owned = user_badges_dict.has_key(badge.name)
user_badges = sorted(filter(lambda user_badge: hasattr(user_badge, "badge") and user_badge.badge is not None, user_badges), reverse=True, key=lambda user_badge:user_badge.date)
possible_badges = sorted(possible_badges, key=lambda badge:badge.badge_category)
user_badges_normal = filter(lambda user_badge: user_badge.badge.badge_category != badges.BadgeCategory.MASTER, user_badges)
user_badges_master = filter(lambda user_badge: user_badge.badge.badge_category == badges.BadgeCategory.MASTER, user_badges)
user_badges_diamond = filter(lambda user_badge: user_badge.badge.badge_category == badges.BadgeCategory.DIAMOND, user_badges)
user_badges_platinum = filter(lambda user_badge: user_badge.badge.badge_category == badges.BadgeCategory.PLATINUM, user_badges)
user_badges_gold = filter(lambda user_badge: user_badge.badge.badge_category == badges.BadgeCategory.GOLD, user_badges)
user_badges_silver = filter(lambda user_badge: user_badge.badge.badge_category == badges.BadgeCategory.SILVER, user_badges)
user_badges_bronze = filter(lambda user_badge: user_badge.badge.badge_category == badges.BadgeCategory.BRONZE, user_badges)
bronze_badges = sorted(filter(lambda badge:badge.badge_category == badges.BadgeCategory.BRONZE, possible_badges), key=lambda badge:badge.points or sys.maxint)
silver_badges = sorted(filter(lambda badge:badge.badge_category == badges.BadgeCategory.SILVER, possible_badges), key=lambda badge:badge.points or sys.maxint)
gold_badges = sorted(filter(lambda badge:badge.badge_category == badges.BadgeCategory.GOLD, possible_badges), key=lambda badge:badge.points or sys.maxint)
platinum_badges = sorted(filter(lambda badge:badge.badge_category == badges.BadgeCategory.PLATINUM, possible_badges), key=lambda badge:badge.points or sys.maxint)
diamond_badges = sorted(filter(lambda badge:badge.badge_category == badges.BadgeCategory.DIAMOND, possible_badges), key=lambda badge:badge.points or sys.maxint)
master_badges = sorted(filter(lambda badge:badge.badge_category == badges.BadgeCategory.MASTER, possible_badges), key=lambda badge:badge.points or sys.maxint)
return { 'possible_badges': possible_badges,
'user_badges': user_badges,
'user_badges_normal': user_badges_normal,
'user_badges_master': user_badges_master,
"badge_collections": [bronze_badges, silver_badges, gold_badges, platinum_badges, diamond_badges, master_badges],
'bronze_badges': user_badges_bronze,
'silver_badges': user_badges_silver,
'gold_badges': user_badges_gold,
'platinum_badges': user_badges_platinum,
'diamond_badges': user_badges_diamond, }
def clear_question_answers_for_current_user(s_question_id):
user = util.get_current_user()
if not user:
return
question_id = -1
try:
question_id = int(s_question_id)
except:
return
if question_id < 0:
return
question = models_discussion.Feedback.get_by_id(question_id)
if not question:
return;
user_data = models.UserData.get_or_insert_for(user)
feedback_keys = question.children_keys()
for key in feedback_keys:
notifications = models_discussion.FeedbackNotification.gql("WHERE user = :1 AND feedback = :2", user, key)
if notifications.count():
db.delete(notifications)
user_data.count_feedback_notification = -1
user_data.put()
def empty_class_instructions(class_is_empty=True):
user = util.get_current_user()
coach_email = "Not signed in. Please sign in to see your Coach ID."
if user:
coach_email = user.email()
return {'App': App, 'class_is_empty': class_is_empty, 'coach_email': coach_email }
def get(self):
user = util.get_current_user()
if user:
question_key = self.request.get('question_key')
self.redirect('/answerquestion?question_key=' + question_key + '&preview_mode=True')
else:
self.redirect(util.create_login_url(self.request.uri))
def post(self):
user = util.get_current_user()
if user is None:
self.redirect(util.create_login_url(self.request.uri))
return
user_data = UserData.get_or_insert_for(user)
coach_email = self.request_string("coach", default="")
if coach_email:
coach_user = users.User(coach_email)
coach_user_data = UserData.get_for(coach_user)
if coach_user_data:
if coach_email not in user_data.coaches and coach_email.lower(
) not in user_data.coaches:
user_data.coaches.append(coach_email)
user_data.put()
self.redirect("/coaches")
return
self.redirect("/coaches?invalid_coach=1")
def get(self):
user = util.get_current_user()
# This if/then clause just makes sure that the user is logged in
if user:
question_key = self.request.get('question_key')
if question_key:
question = db.get(question_key)
bc = breadcrumb(question.subject)
root = Subject.gql('WHERE parent_subject=:1', None).get()
subjects = Subject.gql('WHERE parent_subject = :1', root)
greeting = 'user: %s [<a href="%s">sign out</a>]' % (user.nickname(), users.create_logout_url('/'))
template_values = {
'question': question,
'subjects': subjects,
'greeting': greeting,
'current_url': self.request.uri,
'breadcrumb': bc,
}
path = os.path.join(os.path.dirname(__file__), 'viewquestion.html')
self.response.out.write(template.render(path, template_values))
else:
self.redirect(util.create_login_url(self.request.uri))
def get_for_current_user():
user = util.get_current_user()
if user is not None:
user_data = UserData.get_for(user)
if user_data is not None:
return user_data
return UserData()
def get_profile_target_and_user_data(self):
student = None
user_data_student = None
user = util.get_current_user()
if user:
student = user
student_email = self.request_string("student_email")
if student_email and student_email != student.email():
student_override = users.User(email=student_email)
user_data_student = models.UserData.get_or_insert_for(student_override)
if (
(not users.is_current_user_admin())
and user.email() not in user_data_student.coaches
and user.email().lower() not in user_data_student.coaches
):
# If current user isn't an admin or student's coach, they can't look at anything other than their own profile.
user_data_student = None
else:
# Allow access to this student's profile
student = student_override
if not user_data_student:
user_data_student = models.UserData.get_or_insert_for(student)
return (student, user_data_student)
def post(self):
user = util.get_current_user()
if not user:
return
key = self.request.get("entity_key")
playlist_key = self.request.get("playlist_key")
text = self.request.get("question_text") or self.request.get("answer_text")
if key and text:
feedback = db.get(key)
if feedback:
if is_current_user_moderator() or feedback.author == user:
feedback.content = text
db.put(feedback)
# Redirect to appropriate list of entities depending on type of
# feedback entity being edited.
if feedback.is_type(models_discussion.FeedbackType.Question):
page = self.request.get("page")
video = feedback.first_target()
self.redirect("/discussion/pagequestions?video_key=%s&playlist_key=%s&page=%s&qa_expand_id=%s" %
(video.key(), playlist_key, page, feedback.key().id()))
elif feedback.is_type(models_discussion.FeedbackType.Answer):
question = feedback.parent()
self.redirect("/discussion/answers?question_key=%s" % question.key())
def post(self):
user = util.get_current_user()
if user:
expanded = self.request_bool("expanded")
user_data = UserData.get_or_insert_for(user)
user_data.expanded_all_exercises = expanded
user_data.put()
def post(self):
user = util.get_current_user()
if user:
expanded = self.request_bool("expanded")
user_data = UserData.get_or_insert_for(user)
user_data.expanded_all_exercises = expanded
user_data.put()
def get(self):
user = util.get_current_user()
if user:
coach = user
coach_email = self.request_string("coach_email")
if users.is_current_user_admin() and coach_email:
# Site administrators can look at any class profile
coach = users.User(email=coach_email)
user_data_coach = models.UserData.get_or_insert_for(coach)
students_data = user_data_coach.get_students_data()
class_points = 0
if students_data:
class_points = reduce(lambda a,b: a + b, map(lambda student_data: student_data.points, students_data))
dict_students = map(lambda student_data: {
"email": student_data.user.email(),
"nickname": util.get_nickname_for(student_data.user),
}, students_data)
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="")))
# Sort students alphabetically and sort into 4 chunked up columns for easy table html
dict_students_sorted = sorted(dict_students, key=lambda dict_student:dict_student["nickname"])
students_per_row = 4
students_per_col = max(1, len(dict_students_sorted) / students_per_row)
list_cols = [[], [], [], []]
list_students_columnized = []
for ix in range(0, len(dict_students_sorted)):
dict_student = dict_students_sorted[ix]
list_cols[(ix / students_per_col) % students_per_row].append(dict_student)
for ix in range(0, len(dict_students_sorted)):
dict_student = list_cols[ix % students_per_row][(ix / students_per_row) % students_per_col]
list_students_columnized.append(dict_student)
template_values = {
'coach': coach,
'coach_email': coach.email(),
'coach_nickname': util.get_nickname_for(coach),
'dict_students': dict_students,
'students_per_row': students_per_row,
'list_students_columnized': list_students_columnized,
'count_students': len(dict_students),
'class_points': class_points,
'selected_graph_type': selected_graph_type,
'initial_graph_url': initial_graph_url,
'exercises': models.Exercise.get_all_use_cache(),
'is_profile_empty': len(dict_students) <= 0,
'selected_nav_link': 'coach',
}
self.render_template('viewclassprofile.html', template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user = util.get_current_user()
if user:
user_data = UserData.get_or_insert_for(user)
invalid_coach = self.request_bool("invalid_coach", default = False)
self.render_template('viewcoaches.html', { 'coaches': user_data.coaches, 'invalid_coach': invalid_coach })
else:
self.redirect(util.create_login_url(self.request.uri))
def post(self):
user = util.get_current_user()
if user:
lat = self.request_float("lat")
lng = self.request_float("lng")
zoom = self.request_int("zoom")
user_data = UserData.get_or_insert_for(user)
user_data.map_coords = serializeMapCoords(lat, lng, zoom)
user_data.put()
def post(self):
user = util.get_current_user()
if user is None:
self.redirect(util.create_login_url(self.request.uri))
return
user_data = UserData.get_or_insert_for(user)
coach_email = self.request.get('coach').lower()
user_data.coaches.append(coach_email)
user_data.put()
self.redirect("/coaches")
def post(self):
user = util.get_current_user()
if user is None:
self.redirect(util.create_login_url(self.request.uri))
return
user_data = UserData.get_or_insert_for(user)
coach_email = self.request.get('coach').lower()
user_data.coaches.append(coach_email)
user_data.put()
self.redirect("/coaches")
def get(self):
user = util.get_current_user()
question_key = self.request.get('question_key')
question = db.get(question_key)
redirect_url = self.request.get('redirect')
if user:
if user == question.author:
question.delete()
self.redirect(redirect_url)
else:
self.redirect(util.create_login_url(self.request.uri))
def video_qa_context(video, playlist=None, page=0, qa_expand_id=None):
limit_per_page = 5
if qa_expand_id:
# If we're showing an initially expanded question,
# make sure we're on the correct page
question = models_discussion.Feedback.get_by_id(qa_expand_id)
if question:
question_preceding_query = models_discussion.Feedback.gql("WHERE types = :1 AND targets = :2 AND deleted = :3 AND date > :4 ORDER BY date DESC", models_discussion.FeedbackType.Question, video.key(), False, question.date)
count_preceding = question_preceding_query.count()
page = 1 + (count_preceding / limit_per_page)
if page <= 0:
page = 1
question_query = models_discussion.Feedback.gql("WHERE types = :1 AND targets = :2 AND deleted = :3 ORDER BY date DESC", models_discussion.FeedbackType.Question, video.key(), False)
answer_query = models_discussion.Feedback.gql("WHERE types = :1 AND targets = :2 AND deleted = :3 ORDER BY date", models_discussion.FeedbackType.Answer, video.key(), False)
count_total = question_query.count()
questions = question_query.fetch(limit_per_page, (page - 1) * limit_per_page)
dict_questions = {}
# Store each question in this page in a dict for answer population
for question in questions:
dict_questions[question.key()] = question
# Just grab all answers for this video and cache in page's questions
for answer in answer_query:
# Grab the key only for each answer, don't run a full gql query on the ReferenceProperty
question_key = answer.parent_key()
if (dict_questions.has_key(question_key)):
question = dict_questions[question_key]
question.children_cache.append(answer)
count_page = len(questions)
pages_total = max(1, ((count_total - 1) / limit_per_page) + 1)
return {
"user": util.get_current_user(),
"is_mod": is_current_user_moderator(),
"video": video,
"playlist": playlist,
"questions": questions,
"count_total": count_total,
"pages": range(1, pages_total + 1),
"pages_total": pages_total,
"prev_page_1_based": page - 1,
"current_page_1_based": page,
"next_page_1_based": page + 1,
"show_page_controls": pages_total > 1,
"qa_expand_id": qa_expand_id,
"issue_labels": ('Component-Videos,Video-%s' % video.youtube_id),
"login_url": util.create_login_url("/video?v=%s" % video.youtube_id)
}
def get(self):
user = util.get_current_user()
if user:
user_data = UserData.get_or_insert_for(user)
invalid_coach = self.request_bool("invalid_coach", default=False)
self.render_template('viewcoaches.html', {
'coaches': user_data.coaches,
'invalid_coach': invalid_coach
})
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user = util.get_current_user()
if user:
subject_key = self.request.get('subject_key')
if subject_key:
subject = db.get(subject_key)
html_tree = htmlChildren(subject)
template_values = {'subject': subject, 'tree': html_tree}
path = os.path.join(os.path.dirname(__file__), 'viewsubject.html')
self.response.out.write(template.render(path, template_values))
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user = util.get_current_user()
coach_email = "Not signed in. Please sign in to see your Coach ID."
if user:
coach_email = user.email()
self.render_template(
'about/faq.html', {
"selected_id": "faq",
"approx_vid_count": consts.APPROX_VID_COUNT,
"coach_email": coach_email
})
def get(self):
if not users.is_current_user_admin():
self.redirect(users.create_login_url(self.request.uri))
return
user = util.get_current_user()
query = models.Exercise.all().order('name')
exercises = query.fetch(1000)
template_values = {'App' : App, 'exercises': exercises}
self.render_template('exerciseadmin.html', template_values)
def get(self):
user = util.get_current_user()
user_data = UserData.get_for_current_user()
template_values = qa.add_template_values({'App': App,
'points': user_data.points,
'username': user and user.nickname() or "",
'login_url': util.create_login_url(self.request.uri),
'student_email' : self.request.get('student_email'),
},
self.request)
self.render_template('import.html', template_values)
def get(self):
if not users.is_current_user_admin():
self.redirect(users.create_login_url(self.request.uri))
return
user = util.get_current_user()
query = models.Exercise.all().order('name')
exercises = query.fetch(1000)
template_values = {'App': App, 'exercises': exercises}
self.render_template('exerciseadmin.html', template_values)
def get(self):
user = util.get_current_user()
user_data = UserData.get_for_current_user()
template_values = qa.add_template_values(
{
'App': App,
'points': user_data.points,
'username': user and user.nickname() or "",
'login_url': util.create_login_url(self.request.uri),
'student_email': self.request.get('student_email'),
}, self.request)
self.render_template('import.html', template_values)
def get(self):
user = util.get_current_user()
if user:
student = user
user_data_student = None
student_email = self.request_string("student_email")
if student_email and student_email != student.email():
student_override = users.User(email=student_email)
user_data_student = models.UserData.get_or_insert_for(student_override)
if (not users.is_current_user_admin()) and user.email() not in user_data_student.coaches and user.email().lower() not in user_data_student.coaches:
# 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")
else:
# Allow access to this student's profile
student = student_override
if not user_data_student:
user_data_student = models.UserData.get_or_insert_for(student)
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': student,
'student_nickname': util.get_nickname_for(student),
'selected_graph_type': selected_graph_type,
'initial_graph_url': initial_graph_url,
'tz_offset': tz_offset,
'student_points': user_data_student.points,
'count_videos': models.Setting.count_videos(),
'count_videos_completed': user_data_student.get_videos_completed(),
'count_exercises': models.Exercise.get_count(),
'count_exercises_proficient': len(user_data_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']],
"show_badge_frequencies": self.request_bool("show_badge_frequencies", default=False),
}
self.render_template('viewprofile.html', template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def post(self):
user = util.get_current_user()
if user:
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 = UserData.get_or_insert_for(user)
user_data.map_coords = serializeMapCoords(lat, lng, zoom)
user_data.put()
def post(self):
user = util.get_current_user()
if not user:
return
key = self.request.get("entity_key")
if key:
entity = db.get(key)
if entity:
# Must be a moderator or author of entity to delete
if is_current_user_moderator() or entity.author == user:
entity.deleted = True
db.put(entity)
def post(self):
user = util.get_current_user()
if user:
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 = UserData.get_or_insert_for(user)
user_data.map_coords = serializeMapCoords(lat, lng, zoom)
user_data.put()
def get(self):
user = util.get_current_user()
user_data = UserData.get_for_current_user()
logout_url = users.create_logout_url(self.request.uri)
template_values = qa.add_template_values({'App': App,
'points': user_data.points,
'username': user and user.nickname() or "",
'login_url': util.create_login_url(self.request.uri),
'student_email' : self.request.get('student_email'),
'logout_url': logout_url},
self.request)
path = os.path.join(os.path.dirname(__file__), 'import.html')
self.response.out.write(template.render(path, template_values))
def get(self):
user = util.get_current_user()
if user is None:
self.redirect(util.create_login_url(self.request.uri))
return
user_data = UserData.get_or_insert_for(user)
coach_email = self.request.get('coach')
if coach_email:
if coach_email in user_data.coaches:
user_data.coaches.remove(coach_email)
user_data.put()
elif coach_email.lower() in user_data.coaches:
user_data.coaches.remove(coach_email.lower())
user_data.put()
self.redirect("/coaches")
def get(self):
user = util.get_current_user()
subject_key = self.request.get('subject_key')
subject = db.get(subject_key)
redirect_url = self.request.get('redirect')
logging.error("current user = " + str(user))
if user:
if user == subject.author:
subject = db.get(subject_key)
self.delete_subject(subject)
self.redirect(redirect_url)
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user = util.get_current_user()
question_key = self.request.get('question_key')
question = db.get(question_key)
redirect_url = self.request.get('redirect')
if user:
if user == question.author:
if question.published:
question.published = None
else:
question.published = True
question.put()
# self.redirect(redirect_url)
self.redirect('/qbrary')
else:
self.redirect(util.create_login_url(self.request.uri))
def get(self):
user = util.get_current_user()
if user:
user_data = UserData.get_or_insert_for(user)
logout_url = users.create_logout_url(self.request.uri)
template_values = {
'App': App,
'username': user.nickname(),
'logout_url': logout_url,
'coaches': user_data.coaches
}
self.render_template('viewcoaches.html', template_values)
else:
self.redirect(util.create_login_url(self.request.uri))
def get_profile_target_and_user_data(self):
coach = None
user_data_coach = None
user = util.get_current_user()
if user:
coach = user
coach_email = self.request_string("coach_email")
if users.is_current_user_admin() and coach_email:
# Site administrators can look at any class profile
coach = users.User(email=coach_email)
user_data_coach = models.UserData.get_or_insert_for(coach)
return (coach, user_data_coach)
