def get(self):
logging.info('loading quiz item')
template_values = {}
if self.request.get('item_key'): this_quiz_item = QuizItem.get(self.request.get('item_key'))
if self.request.get('token'):
from google.appengine.api import memcache
self.session = memcache.get(self.request.get('token'))
this_item = self.session.get('current_item', False)
if this_item: this_quiz_item = QuizItem.get(this_item['key'])
else:
logging.warning('token used past expiration', self.request.get('token'))
return False
quiz_item = {}
try: quiz_item['topic_name'] = this_quiz_item.topic.name
except: print this_quiz_item
if this_quiz_item.content.endswith('.'): this_quiz_item.content = this_quiz_item.content[:-1] + "<br/>" # this should be done in advance,and it should replace </span>. with </span><br/>
quiz_item['content'] = this_quiz_item.content
quiz_item['answers'] = this_quiz_item.answers
quiz_item['theme'] = this_quiz_item.theme
template_values = quiz_item
template_values['browser'] = self.get_browser()
if self.request.get('demo') == 'true': path = tpl_path(QUIZDEMO_PATH + 'quiz_item.html')
else: path = tpl_path(QUIZTAKER_PATH + 'quiz_item.html')
if self.request.get("callback"):
self.response.out.write(jsonp(self.request.get("callback"), template.render(path, template_values)))
else:
self.response.out.write(template.render(path, template_values))
def get(self):
logging.info('Loading Quiz Completed Frame')
template_values = {}
path = tpl_path(QUIZDEMO_PATH + 'quiz_complete.html')
if self.request.get("callback"):
response = jsonp(self.request.get("callback"), template.render(path, template_values))
self.response.out.write(response);
else:
self.response.out.write(template.render(path, template_values))
def get(self):
template_values = {}
path = tpl_path(QUIZTAKER_PATH + 'quizframe.html')
if self.request.get("callback"):
response = jsonp(self.request.get("callback"), template.render(path, template_values))
self.response.headers['Content-Type'] = 'application/x-javascript'
self.response.out.write(response);
else:
self.response.out.write(template.render(path, template_values))
def get(self):
logging.info('loading quiz intro')
template_values = {}
if self.request.get('subject'): template_values['proficiencies'] = self.get_quiz_subjects()
intro_template = QUIZTAKER_PATH + self.request.get('page') + ".html"
if self.request.get('demo') == "true": intro_template = QUIZDEMO_PATH + self.request.get('page') + ".html" # only for demo
path = tpl_path(intro_template)
if self.request.get("callback"):
response = jsonp(self.request.get("callback"), template.render(path, template_values))
self.response.out.write(response);
else:
self.response.out.write(template.render(path, template_values))
def get(self):
error_type = self.request.path.split('/error/')[1]
if error_type == "browser": return self.browser_error()
template_values = {"error_type": error_type}
logging.warning('loaded error page for error type %s', error_type)
path = tpl_path('utils/error.html')
self.response.out.write(template.render(path, template_values))
def load_quiz_js(self):
JQUERY_VERSION = '1.3.2'
DEFAULT_QUIZ_SUBJECT = "Recovery.Gov"
try :
proficiency_arg = self.request.path.split('/quiz/')[1].replace('%20',' ')
this_proficiency = Proficiency.get_by_key_name(proficiency_arg)
assert this_proficiency != None
self.these_proficiencies = [this_proficiency]
except: self.these_proficiencies = [Proficiency.get_by_key_name(DEFAULT_QUIZ_SUBJECT)]
proficiency_names = [str(p.name) for p in self.these_proficiencies]
session_token = self.get_session_token()
template_values = {
'proficiencies': encode(proficiency_names).replace("\n", ""),
'user_token': session_token,
'css': self.get_widget_css().replace('\n','').replace("'",'"'),
'widget_html': self.get_widget_html(),
'widget_subject': self.these_proficiencies[0].key(),
'jquery_version' : JQUERY_VERSION,
'jquery_location': JQUERY_VERSION,
'auto_start': self.get_auto_start()
}
path = widget_path('pqwidget.js')
from utils.random import minify
self.response.out.write( minify(template.render(path, template_values)) )
def get(self):
merchant = self.merchant_info()
# Create a (static) instance of Controller using your vendor ID and merchant key
controller = Controller(merchant['id'], merchant['key'], is_sandbox=merchant['is_sandbox'])
#Create your order:
order = gmodel.checkout_shopping_cart_t(
shopping_cart = gmodel.shopping_cart_t(items = [
gmodel.item_t(merchant_item_id = 'oil_quiz',
name = 'Oil Quiz',
description = 'Oil quiz!',
unit_price = gmodel.price_t(value = DEFAULT_QUIZ_PRICE,
currency = 'USD'),
quantity = 1),
gmodel.item_t(merchant_item_id = 'energy_quiz',
name = 'Energy Quiz',
description = 'Energy quiz.',
unit_price = gmodel.price_t(value = DEFAULT_QUIZ_PRICE,
currency = 'USD'),
quantity = 1),
]),
checkout_flow_support = gmodel.checkout_flow_support_t(
continue_shopping_url = self.return_url() + user_id,
request_buyer_phone_number = False))
# Encode the order into XML, sign it with your merchant key and form
# Google Checkout Button html.
prepared = controller.prepare_order(order)
# Now prepared.html contains the full google checkout button html
template_values = {'checkout_button': prepared.html(), 'page_title': 'Take a Quiz' }
path = tpl_path(STORE_PATH +'store.html')
self.response.out.write(template.render(path, template_values))
def get(self):
return self.redirect('/')
logging.info('continue: %s', self.request.get('continue'))
login_response = str('http://' + self.request._environ['HTTP_HOST'] + '/login/response')
template_values = {'token_url': login_response, 'no_quizlink': True}
if self.request.get('continue'): self.session['continue'] = self.request.get('continue')
if self.request.get('reset'):
self.session['user'] = False # log current user out, if logged in
template_values = self.reset_account_access(template_values)
""" TODO: test taking functionality -- not yet implemented.
if self.request.get('test'):
template_values['pre_test'] = "True"
self.session['continue'] = '/test/' + self.request.get('test')
"""
if self.session['user']:
if not self.session['continue']: self.session['continue'] = '/profile/' + self.session['user'].profile_path
self.redirect(self.session['continue'])
self.session['continue'] = False
#self.session['reset_account'] = False -- Why was this here?
if self.session['continue']: template_values['login_context'] = self.session['continue'].split('/')
if self.request.get('sponsor'):
template_values['login_context'] = "sponsor"
self.session['post_quiz'] = False
if self.request.get('error') == "true":
template_values['error'] = "True"
template_values['login_js'] = login_js(template_values)
path = tpl_path(ACCOUNTS_PATH +'login.html')
self.response.out.write(template.render(path, template_values))
def get(self):
from utils.utils import tpl_path
from utils.webapp import template
path = tpl_path('utils/404.html')
template_values = {'no_load': True}
response = Response()
response.set_status(404)
response.out.write(template.render(path, template_values))
def base_js(self):
from utils.utils import tpl_path, Debug
from utils.webapp import template
if not Debug(): set_expire_header(self)
template_values = {}
path = tpl_path('base.js')
from utils.random import minify
self.response.out.write( minify(template.render(path, template_values)) )
def get(self):
#from model.proficiency import SubjectProfile
#subjects = SubjectProfile.all().fetch(1000)
#template_values = {"subjects": subjects}
from model.proficiency import Proficiency
proficiencies = Proficiency.all().fetch(1000)
template_values = {'proficiencies': proficiencies}
path = tpl_path(DEV_PATH + 'edit_subjects.html')
self.response.out.write(template.render(path, template_values))
def LoadAnswers(self):
correct_answer = self.request.get('correct_answer')
item_text = self.request.get('item_text')
from editor.answers import Answers
answers = Answers()
from utils.webapp import template
from utils.utils import tpl_path
template_values = {"answers": answers.load(correct_answer, item_text)}
path = tpl_path(EDITOR_PATH + 'answer_template.html')
return template.render(path, template_values)
def NewTopic(self): # set moderation status for raw item
this_subject = Proficiency.gql("WHERE name = :1", self.request.get('subject_name')).get()
new_topic = ProficiencyTopic(name = self.request.get('topic_name'), proficiency = this_subject)
db.put([this_subject, new_topic])
if self.request.get('no_template'): return "OK"
from utils.webapp import template
from utils.utils import tpl_path
template_values = {"subject": this_subject, "new_topic":new_topic}
path = tpl_path(EDITOR_PATH + 'item_topic.html')
return template.render(path, template_values)
def upload_subject_img(self):
subject_name = self.request.path.split('/subject_img/')[1].replace('%20',' ')
from model.proficiency import Proficiency
this_subject = Proficiency.get_by_key_name(subject_name)
new_image = this_subject.new_image(self.request.get('subject_img'))
db.put([this_subject, new_image])
logging.info('saved new image for subject %s' % (this_subject.name))
from utils.webapp import template
path = tpl_path(EDITOR_PATH +'load_subject_images.html')
template_values = {'s': {"subject": this_subject, "is_member": "admin" }} # Only admins can upload photos, for now.
return template.render(path, template_values)
def quiz_item(self, item_key):
from model.quiz import QuizItem
item = QuizItem.get(item_key)
item_answers = []
[item_answers.append(str(a)) for a in item.answers]
quiz_item = {"answers": item_answers, "answer1" : item.answers[0], "answer2" : item.answers[1], "answer3": item.answers[2], #answer1,2,3 is deprecated
"proficiency": item.proficiency.name, "topic": item.topic.name, "key": item.key()}
template_values = {"quiz_items": [quiz_item]}
logging.debug('loaded quiz...')
path = tpl_path(QUIZTAKER_PATH + 'debug_quiz.html')
self.response.out.write(template.render(path, template_values))
def remove_link(self):
from model.proficiency import Proficiency, Link
subject_name = self.request.get('subject_name')
this_subject = Proficiency.get_by_key_name(subject_name)
this_link = Link.get( self.request.get('link_key') )
logging.info('removed link: %s', this_link.url )
db.delete(this_link)
db.put(this_subject)
from utils.webapp import template
path = tpl_path(EDITOR_PATH +'subject/links_list.html')
template_values = {'s': {"subject": this_subject, "is_member": "admin" }} # Only admins can edit links, for now.
return template.render(path, template_values)
def delete_subject_image(self):
from model.proficiency import Proficiency, SubjectImage
subject_name = self.request.get('subject_name')
this_subject = Proficiency.get_by_key_name(subject_name)
this_img = SubjectImage.get( self.request.get('img_key') )
logging.info('removed img for subject %s', this_subject.name )
db.delete(this_img)
db.put(this_subject)
from utils.webapp import template
path = tpl_path(EDITOR_PATH +'load_subject_images.html')
template_values = {'s': {"subject": this_subject, "is_member": "admin" }} # Only admins can edit links, for now.
return template.render(path, template_values)
def get(self):
load_proficiencies = self.get_proficiencies()
proficiencies = load_proficiencies[0]
vendor = load_proficiencies[1]
if proficiencies[0] == None:
logging.info('quiz not found for argument %s', load_proficiencies[0])
return self.redirect('/quiz_not_found/')
load_quiz = LoadQuiz()
if vendor == "": vendor = self.get_default_vendor()
template_values = {"proficiencies": proficiencies, "quiz_subject": str(proficiencies[0].name), "vendor_name": vendor.name.capitalize(), "vendor": vendor.key() }
path = tpl_path(QUIZTAKER_PATH + 'takequiz.html')
self.response.out.write(template.render(path, template_values))
def refresh_subjects(self):
from utils.appengine_utilities.sessions import Session
self.session = Session()
from utils.webapp import template
path = tpl_path(EDITOR_PATH +'subject_container.html')
from editor.methods import get_subjects_for_user
offset = int(self.request.get('offset'))
new_subjects = get_subjects_for_user(self.session['user'], offset=offset)
if len(new_subjects) < 5: new_offset = 0
else: new_offset = offset + 5
template_values = { 'subjects' : new_subjects, 'offset': new_offset}
return template.render(path, template_values)
def get(self):
proficiencies = Proficiency.gql("WHERE status = :1", "public");
proficiencies = proficiencies.fetch(1000)
buy_buttons = []
for p in proficiencies:
p.checkout_button = checkout.render_quiz_button(self, p.tag(), p.name)
buy_buttons.append( { 'tag': p.tag().lower(), 'html' : p.checkout_button})
prof_json = encode(proficiencies)
template_values = {'proficiencies' : proficiencies, 'prof_json': prof_json, 'buy_buttons': encode(buy_buttons), 'load': 2000}
path = tpl_path(STORE_PATH + 'proficiency.html')
self.response.out.write(template.render(path, template_values))
def from_quiz_redirect(self):
# redirect after quiz
logging.info('Redirecting From Quiz')
token = self.request.path.split('/from_quiz/')[1]
from utils.utils import set_flash
self.set_flash = set_flash
self.set_flash('post_quiz')
from quiztaker.load_quiz import QuizSession
quiz_session = QuizSession()
quiz_session.update_scores(token, self.session['user'].unique_identifier) # re-assigns token scores to this user
template_values = {'redirect_path': '/profile/' + self.session['user'].profile_path}
path = tpl_path(ACCOUNTS_PATH +'post_quiz.html')
self.response.out.write(template.render(path, template_values))
def get(self):
"""
The splashpage for QuiztheBill, containing an introduction
and a list of bills.
"""
template_values = { 'bills': self.get_bills(),
# subject for quiz widget
'featured_subject': "QuiztheBill" }
path = tpl_path(TEMPLATE_PATH + 'frontpage.html')
self.response.out.write(template.render(path, template_values))
return
def add_link(self):
from model.proficiency import Proficiency, Link
subject_name = self.request.get('subject_name')
this_subject = Proficiency.get_by_key_name(subject_name)
try: new_link = Link(key_name = subject_name + "_" + self.request.get('link_url'),
url = self.request.get('link_url'),
title = self.request.get('link_title'),
subject = this_subject )
except BadValueError: return "error"
db.put([this_subject,new_link])
logging.info('new link with url %s and title %s for subject %s' % (this_subject.name, str(new_link.url), new_link.title ) )
from utils.webapp import template
path = tpl_path(EDITOR_PATH +'subject/links_list.html')
template_values = {'s': {"subject": this_subject, "is_member": "admin" }} # Only admins can edit links, for now.
return template.render(path, template_values)
def change_video(self):
from model.proficiency import Proficiency
subject_name = self.request.get('subject_name')
this_subject = Proficiency.get_by_key_name(subject_name)
if "p=" not in self.request.get('new_video_url'):
logging.info('video url %s is not recognizable as video playlist link', self.request.get('new_video_url'))
return "error"
video_code = self.request.get('new_video_url').split("p=")[1]
this_subject.video_html = video_code
logging.info('changed video for subject %s to %s' % (this_subject.name,video_code) )
db.put(this_subject)
from utils.webapp import template
path = tpl_path(EDITOR_PATH +'subject/video_object.html')
template_values = {'s': {"subject": this_subject, "is_member": "admin" }} # Only admins can edit links, for now.
return template.render(path, template_values)
def get(self):
from model.quiz import QuizItem
from model.user import Profile
from model.proficiency import ProficiencyTopic
try: self.get_subject()
except: print "SUBJECT NOT FOUND" #self.redirect('/error/subject_not_found')
from editor.methods import get_membership, get_user_items
try: self.subject_membership = get_membership(self.session['user'], self.this_subject)
except: print "NOT A MEMBER"
template_values = {'subject': self.this_subject,
'user_items': get_user_items(self.session['user'], self.this_subject),
'subject_membership': self.subject_membership }
template_values['ANSWERCOUNT'] = range(1,3)
path = tpl_path(EDITOR_PATH + 'quiz_item_editor.html')
self.response.out.write(template.render(path, template_values))
def get_html(self):
import urllib
template_values = {'text': urllib.unquote( self.request.get('text') ) }
from model.proficiency import Proficiency
if self.request.get('subject_key'): template_values['subject_key'] = self.request.get('subject_key')
else:
subjects = Proficiency.gql("WHERE status = 'public'").fetch(1000)
template_values['subjects'] = subjects
if self.request.get('topic_key'): template_values['topic_key'] = self.request.get('topic_key')
if self.request.get('topic_name'):
from model.proficiency import ProficiencyTopic
p = ProficiencyTopic.gql("WHERE name = :1", self.request.get('topic_name')).get()
template_values['topic_key'] = p.key()
path = tpl_path(DEV_PATH +'ubiquity_builder.html')
response = simplejson.dumps(template.render(path, template_values))
self.response.out.write(jsonp(self.request.get("callback"), response))
def get(self):
print ""
json_file = open(ROOT_PATH + "/data/topics.json")
json_str = json_file.read()
from utils import simplejson
newdata = simplejson.loads(json_str) # Load JSON file as object
topics = []
types = []
for t in newdata:
topics.append(t)
print t['name']
return
template_values = {}
path = tpl_path(DEV_PATH +'admin.html')
self.response.out.write(template.render(path, template_values))
def join_subject(self):
from utils.appengine_utilities.sessions import Session
self.session = Session()
from model.proficiency import Proficiency
this_subject = Proficiency.gql("WHERE name = :1", self.request.get('subject_name') ).get()
from model.user import SubjectMember
admin_status = False
from google.appengine.api import users
user = users.get_current_user()
if user: admin_status = True
this_membership = SubjectMember(keyname = self.session['user'].unique_identifier + "_" + this_subject.name, user = self.session['user'], subject = this_subject, is_admin = admin_status)
logging.info('user %s joined subject %s'% (self.session['user'].unique_identifier, this_subject.name) )
db.put([this_membership])
from utils.webapp import template
path = tpl_path(EDITOR_PATH +'load_member_section.html')
template_values = {'s': {"subject": this_subject, "is_member": "contributor" }} # Only admins can edit links, for now.
return template.render(path, template_values)
def browser_error(self):
DEFAULT_QUIZ_SUBJECT = "Recovery.Gov"
if not Debug(): self.set_expire_header()
try :
proficiency_arg = self.request.path.split('/quiz/')[1].replace('%20',' ')
this_proficiency = Proficiency.get_by_key_name(proficiency_arg)
assert this_proficiency != None
self.these_proficiencies = [this_proficiency]
except: self.these_proficiencies = [Proficiency.get_by_key_name(DEFAULT_QUIZ_SUBJECT)]
proficiency_names = [str(p.name) for p in self.these_proficiencies]
session_token = self.get_session_token()
template_values = {
'quiz_subject': encode(proficiency_names[0]).replace("\n", "")
}
path = widget_path('error.js')
from utils.random import minify
self.response.out.write( minify(template.render(path, template_values)) )
def get(self):
"""
Renders an frame with a webpage used to create quizzes. For this app,
the frame contains the text of pending Congressional legislation.
"""
import urllib
bill_name = urllib.unquote( self.request.path.split('/bill/')[1] )
self.this_bill = Bill.get_by_key_name(bill_name)
if self.this_bill is None:
logging.error('bill %s not found', bill_name)
return self.redirect('/bill_not_found')
from models import ProficiencyTopic
template_values = {'url': self.get_bill_url(), 'subject_key': APP_NAME,
'topic_name': self.this_bill.title, }
path = tpl_path(TEMPLATE_PATH + 'iframe.html')
self.response.out.write(template.render(path, template_values))
return
