def get(self, profile_to_get=None):
template_values = get_template_values(self)
user = users.get_current_user()
if user:
if not profile_to_get or profile_to_get == user.user_id():
entity_query = Entity.query(
Entity.id == user.user_id()).fetch()
else:
entity_query = Entity.query(
Entity.id == profile_to_get).fetch()
if len(entity_query) < 1:
entity_query = Entity.query(
Entity.display_name == profile_to_get).order(
-Entity.created).fetch()
if len(entity_query) < 1:
self.redirect('/')
return
entity = entity_query[0]
if len(entity_query) > 0:
if user.user_id() == entity.id:
template_values['this_user'] = True
template_values = add_entity_to_template(
template_values, entity, self.request)
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'profile.html'))
self.response.out.write(template.render(path, template_values))
return
self.redirect('/')
return
def post(self):
test_id = self.request.get( 'test_id' )
author_id = self.request.get( 'author_id' )
user = users.get_current_user()
if user:
test = Test.query( Test.id == test_id ).get()
mark_query = Mark.query( ancestor = ndb.Key("Entity", user.user_id() ) )
mark_query = mark_query.filter( Mark.test.id == test.id )
this_mark = mark_query.get()
if this_mark == None:
print "IndexError"
this_mark = Mark( parent = ndb.Key("Entity", user.user_id() ) )
this_mark.test = test
this_mark.created = datetime.datetime.now()
this_mark.mark = None
this_mark.rated = False
this_mark.rating = 0
test.times_taken += 1
test.put()
this_mark.response = self.request.get( 'response' )
this_mark.complete = False
this_mark.modified = datetime.datetime.now()
this_mark.id = test_id + user.user_id()
this_mark.marker_entity = Entity.query( Entity.id == author_id ).get()
this_mark.taker_entity = Entity.query( Entity.id == user.user_id() ).get()
send_email( this_mark.marker_entity.user.email() , test, "Test-Answer")
this_mark.put()
self.redirect( '/t/%s' % test_id )
return
def get(self, profile_to_get=None):
template_values = get_template_values( self )
user = users.get_current_user()
if user:
if not profile_to_get or profile_to_get == user.user_id():
entity_query = Entity.query( Entity.id == user.user_id() ).fetch()
else:
entity_query = Entity.query( Entity.id == profile_to_get ).fetch()
if len(entity_query) < 1:
entity_query = Entity.query( Entity.display_name == profile_to_get ).order(-Entity.created).fetch()
if len(entity_query) < 1:
self.redirect('/')
return
entity = entity_query[0]
if len(entity_query) > 0:
if user.user_id() == entity.id:
template_values['this_user'] = True
template_values = add_entity_to_template(template_values, entity, self.request)
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'profile.html' ) )
self.response.out.write( template.render( path, template_values ))
return
self.redirect('/')
return
def get(self, test_to_get=None):
template_values = get_template_values( self )
user = users.get_current_user()
if not test_to_get:
self.logger.debug("No test was provided for lookup")
self.redirect('/')
return
else:
try:
test = Test.query( Test.id == test_to_get).fetch(1)[0]
except IndexError:
self.logger.debug("Invalid Test ID")
self.redirect('/')
else:
if user:
template_values = add_entity_to_template(
template_values,
Entity.query( Entity.id == user.user_id() ).fetch(1)[0]
)
user_level = get_user_group_level(
get_grouped_marks( user.user_id() ),
test.group
)
if user_level == None:
user_level = 1
template_values['user_level'] = user_level
if user_level < test.level:
template_values['locked'] = True
try:
mark_query = Mark.query( ancestor = ndb.Key("Entity", user.user_id() ) )
mark = mark_query.filter( Mark.test.id == test.id ).fetch(1)[0]
template_values = add_mark_to_template( template_values, mark )
if (datetime.datetime.now() - mark.modified) < datetime.timedelta(hours=24) or mark.complete:
template_values['locked'] = True
except IndexError:
self.logger.debug( "No mark found" )
template_values = add_test_to_template( template_values, test )
finally:
if test.author_id == user.user_id():
template_values['is_test_marker'] = True
template_values['locked'] = True
test_marker = Entity.query( Entity.id == user.user_id() ).get()
template_values['to_be_marked'] = get_to_be_marked( test_marker, test )
template_values['name'] = test_marker.display_name
template_values['current_user'] = user.user_id()
else:
template_values['locked'] = True
template_values['visitor'] = True
logging.warning("User not found!")
template_values = add_test_to_template( template_values, test )
finally:
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'test_detail.html') )
self.response.out.write( template.render( path, template_values) )
return
def post(self):
template_values = get_template_values(self)
user = users.get_current_user()
try:
entity_query = Entity.query(Entity.id == user.user_id()).fetch()
entity = entity_query[0]
except IndexError:
# This user must not exist yet, so create one
entity = Entity(
user=user,
id=user.user_id(),
created=datetime.datetime.now(),
test_groups=[],
)
if not entity.display_name:
posted_name = self.request.get('display_name')
else:
posted_name = entity.display_name
# Show an error if the name isn't formatted properly.
if re.match('^[a-z0-9]{3,16}$', posted_name) is None:
template_values[
'error'] = "Usernames must be 16 or fewer alphanumeric characters [a-z0-9]."
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'register.html'))
self.response.out.write(template.render(path, template_values))
return
users_with_name = Entity.query(
Entity.display_name == posted_name).count()
if users_with_name == 0 or entity.display_name == posted_name:
# Update values
entity.display_name = posted_name if posted_name else entity.display_name
entity.bio = self.request.get('bio') if len(
self.request.get('bio')) > 0 else "I am mysterious."
# Save and visit
entity.put()
time.sleep(
0.1
) # The user doesn't exist for a short period of time after put()
self.redirect('/u/%s' % entity.display_name)
else:
template_values[
'error'] = "That username is in use. Please choose again."
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'register.html'))
self.response.out.write(template.render(path, template_values))
return
def post(self, in_test_id):
path = urlparse.urlsplit(self.request.referrer).path
author_id = self.request.get("author_id")
test_id = self.request.get("test_id")
mark_id = self.request.get("mark_id")
address = self.request.get("mark_address")
comment = self.request.get("comment")
mark = self.request.get("mark")
author_entity = Entity.query(Entity.id == author_id).get()
test_entity = Test.query(Test.id == test_id).get()
mark_entity = Mark.query(ancestor=ndb.Key("Entity", mark_id))
mark_entity = mark_entity.filter(Mark.test.id == test_id).get()
mark_entity.marker_entity = author_entity
mark_entity.test = test_entity
mark_entity.comment = comment
mark_entity.mark = int(mark)
test_entity.total_score += mark_entity.mark
test_entity.num_marked += 1
mark_entity.modified = datetime.datetime.now()
mark_entity.complete = True
mark_entity.put()
send_email(address, test_entity, "Answer-Response")
test_entity.put()
self.redirect(path)
return
def add_test_to_template(template_values, in_test):
"""Combines Test object properties into template_values"""
template_values['test_id'] = in_test.id
template_values['title'] = in_test.title
template_values['description'] = in_test.description
template_values['group'] = in_test.group
template_values['level'] = in_test.level
template_values['test_created'] = in_test.created
template_values['test_modified'] = in_test.modified
template_values['author_id'] = in_test.author_id
template_values['author_name'] = Entity.query(
Entity.id == in_test.author_id).get().display_name
template_values['times_taken'] = in_test.times_taken
template_values['total_score'] = in_test.total_score
template_values['num_marked'] = in_test.num_marked
template_values['open'] = in_test.open
if in_test.num_marked > 0:
template_values['average_mark'] = template_values[
'total_score'] / template_values['num_marked']
mark_list = Mark.query(Mark.test.id == in_test.id).filter(
Mark.rating > -1).fetch()
template_values['num_ratings'] = len(mark_list)
if template_values['num_ratings'] > 0:
template_values['average_rating'] = sum(
[mark.rating
for mark in mark_list]) / template_values['num_ratings']
if template_values['average_rating'] is not in_test.average_rating:
save_average_rating(in_test.id, template_values['average_rating'])
return template_values
def network():
entities = Entity.query().order(Entity.name)
result = list()
for e in entities:
result.extend(e.get_json())
return render_template('network.html',
result=result)
def post( self, in_test_id ):
path = urlparse.urlsplit(self.request.referrer).path
author_id = self.request.get("author_id")
test_id = self.request.get("test_id")
mark_id = self.request.get("mark_id")
address = self.request.get("mark_address")
comment = self.request.get("comment")
mark = self.request.get("mark")
author_entity = Entity.query( Entity.id == author_id ).get()
test_entity = Test.query( Test.id == test_id ).get()
mark_entity = Mark.query( ancestor = ndb.Key("Entity", mark_id) )
mark_entity = mark_entity.filter( Mark.test.id == test_id ).get()
mark_entity.marker_entity = author_entity
mark_entity.test = test_entity
mark_entity.comment = comment
mark_entity.mark = int(mark)
test_entity.total_score += mark_entity.mark
test_entity.num_marked += 1
mark_entity.modified = datetime.datetime.now()
mark_entity.complete = True
mark_entity.put()
send_email( address, test_entity, "Answer-Response")
test_entity.put()
self.redirect( path )
return
def get_query(self,id):
lines = []
if ALL_DIGITS.match(id) is not None:
lines = Entity.query(Entity.id==id).fetch(1)
else:
lines = Entity.query(Entity.name==id).fetch(1)
if len(lines)>0:
ret = lines[0].to_dict()
id = ret['id']
logging.debug('entity-api: id='+id)
supports = SupportLine.query(SupportLine.entity_id==id).order(-SupportLine.year).fetch(1000)
ret['supports'] = [x.to_dict() for x in supports]
exemptions = MRExemptionRecord.query(MRExemptionRecord.entity_id==id).order(-MRExemptionRecord.start_date).fetch(1000)
ret['exemptions'] = [x.to_dict() for x in exemptions]
return ret
else:
return {}
def network():
entities = Entity.query().order(Entity.name)
result = list()
for e in entities:
result.extend(e.get_json())
last_posts = Post.get_lastest()
return render_template('network.html',
last_posts=last_posts,
result=result)
def get(self, in_test_id=None):
template_values = get_template_values(self)
user = users.get_current_user()
try:
entity = Entity.query(Entity.id == user.user_id()).get()
if not entity.display_name: # It's only slightly possible to have a user with no display_name
self.redirect('/login')
except:
self.redirect('/login')
else:
test_query = Test.query(ancestor=ndb.Key('Entity', user.user_id()))
if len(test_query.fetch()) > 0:
if in_test_id:
in_query = test_query.filter(
Test.id == in_test_id).fetch(1)
try: # The test exists
template_values = add_test_to_template(
template_values, in_query[0])
except IndexError: # The test does not exist
self.redirect("/")
potential_groups = set(
itertools.chain(entity.test_groups, default_groups))
print potential_groups
grouped_marks = get_grouped_marks(entity.id)
# Add groups with levels for level dropdown
template_values['user_levels'] = json.dumps(grouped_marks)
# Add list of groups for group dropdown
template_values['user_groups'] = []
for group in grouped_marks:
group_test_query = Test.query(
Test.group == group['group']).order(-Test.level).fetch()
try:
threshold = group_test_query[0]
except:
threshold = 0
print threshold
for mark in grouped_marks:
potential_groups = potential_groups - set(group['group'])
if mark['group'] == group and mark["level"] >= threshold:
template_values['user_groups'].append(group)
for group in potential_groups:
template_values['user_groups'].append(group)
if template_values["user_groups"] == []:
template_values[
'error'] = "You may only create a test in a new category."
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'create.html'))
self.response.out.write(template.render(path, template_values))
return
def get_query(self, id):
lines = []
if ALL_DIGITS.match(id) is not None:
lines = Entity.query(Entity.id == id).fetch(1)
else:
lines = Entity.query(Entity.name == id).fetch(1)
if len(lines) > 0:
ret = lines[0].to_dict()
id = ret['id']
logging.debug('entity-api: id=' + id)
supports = SupportLine.query(SupportLine.entity_id == id).order(
-SupportLine.year).fetch(1000)
ret['supports'] = [x.to_dict() for x in supports]
exemptions = MRExemptionRecord.query(
MRExemptionRecord.entity_id == id).order(
-MRExemptionRecord.start_date).fetch(1000)
ret['exemptions'] = [x.to_dict() for x in exemptions]
return ret
else:
return {}
def post(self):
template_values = get_template_values( self )
user = users.get_current_user()
try:
entity_query = Entity.query( Entity.id == user.user_id() ).fetch()
entity = entity_query[0]
except IndexError:
# This user must not exist yet, so create one
entity = Entity(
user = user,
id = user.user_id(),
created = datetime.datetime.now(),
test_groups = [],
)
if not entity.display_name:
posted_name = self.request.get( 'display_name' )
else:
posted_name = entity.display_name
# Show an error if the name isn't formatted properly.
if re.match('^[a-z0-9]{3,16}$', posted_name) is None:
template_values['error'] = "Usernames must be 16 or fewer alphanumeric characters [a-z0-9]."
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'register.html' ) )
self.response.out.write( template.render( path, template_values ))
return
users_with_name = Entity.query( Entity.display_name == posted_name ).count()
if users_with_name == 0 or entity.display_name == posted_name:
# Update values
entity.display_name = posted_name if posted_name else entity.display_name
entity.bio = self.request.get( 'bio' ) if len(self.request.get( 'bio' )) > 0 else "I am mysterious."
# Save and visit
entity.put()
time.sleep(0.1) # The user doesn't exist for a short period of time after put()
self.redirect('/u/%s' % entity.display_name )
else:
template_values['error'] = "That username is in use. Please choose again."
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'register.html' ) )
self.response.out.write( template.render( path, template_values ))
return
def post(self):
group_name = self.request.get('group_name')
user = users.get_current_user()
entity = Entity.query( Entity.id == user.user_id() ).get()
try:
assert re.match('^[a-z0-9_]{2,16}$', group_name ) is not None
except:
self.redirect('/preferences')
else:
if group_name not in entity.test_groups:
entity.test_groups.append(group_name)
entity.put()
time.sleep(0.1) # Need some time to ensure consistency.
self.redirect('/preferences')
def post(self):
group_name = self.request.get('group_name')
user = users.get_current_user()
entity = Entity.query(Entity.id == user.user_id()).get()
try:
assert re.match('^[a-z0-9_]{2,16}$', group_name) is not None
except:
self.redirect('/preferences')
else:
if group_name not in entity.test_groups:
entity.test_groups.append(group_name)
entity.put()
time.sleep(0.1) # Need some time to ensure consistency.
self.redirect('/preferences')
def get(self):
template_values = get_template_values( self )
user = users.get_current_user()
try:
entity = Entity.query( Entity.id == user.user_id() ).fetch()[0]
if not entity.display_name:
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'register.html' ) )
self.response.out.write( template.render( path, template_values ))
else:
self.redirect('/u')
except IndexError:
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'register.html' ) )
self.response.out.write( template.render( path, template_values ))
return
def get(self, in_test_id=None):
template_values = get_template_values( self )
user = users.get_current_user()
try:
entity = Entity.query( Entity.id == user.user_id() ).get()
if not entity.display_name: # It's only slightly possible to have a user with no display_name
self.redirect('/login')
except:
self.redirect('/login')
else:
test_query = Test.query( ancestor = ndb.Key('Entity', user.user_id() ) )
if len(test_query.fetch()) > 0:
if in_test_id:
in_query = test_query.filter( Test.id == in_test_id ).fetch(1)
try: # The test exists
template_values = add_test_to_template( template_values, in_query[0] )
except IndexError: # The test does not exist
self.redirect("/")
potential_groups = set(
itertools.chain( entity.test_groups, default_groups )
)
print potential_groups
grouped_marks = get_grouped_marks( entity.id )
# Add groups with levels for level dropdown
template_values['user_levels'] = json.dumps( grouped_marks )
# Add list of groups for group dropdown
template_values['user_groups'] = []
for group in grouped_marks:
group_test_query = Test.query( Test.group == group['group'] ).order(-Test.level).fetch()
try:
threshold = group_test_query[0]
except:
threshold = 0
print threshold
for mark in grouped_marks:
potential_groups = potential_groups - set(group['group'])
if mark['group'] == group and mark["level"] >= threshold:
template_values['user_groups'].append( group )
for group in potential_groups:
template_values['user_groups'].append( group )
if template_values["user_groups"] == []:
template_values['error'] = "You may only create a test in a new category."
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'create.html' ) )
self.response.out.write( template.render( path, template_values ))
return
def post(self):
test_id = self.request.get('test_id')
author_id = self.request.get('author_id')
user = users.get_current_user()
if user:
test = Test.query(Test.id == test_id).get()
mark_query = Mark.query(ancestor=ndb.Key("Entity", user.user_id()))
mark_query = mark_query.filter(Mark.test.id == test.id)
this_mark = mark_query.get()
if this_mark == None:
print "IndexError"
this_mark = Mark(parent=ndb.Key("Entity", user.user_id()))
this_mark.test = test
this_mark.created = datetime.datetime.now()
this_mark.mark = None
this_mark.rated = False
this_mark.rating = 0
test.times_taken += 1
test.put()
this_mark.response = self.request.get('response')
this_mark.complete = False
this_mark.modified = datetime.datetime.now()
this_mark.id = test_id + user.user_id()
this_mark.marker_entity = Entity.query(
Entity.id == author_id).get()
this_mark.taker_entity = Entity.query(
Entity.id == user.user_id()).get()
send_email(this_mark.marker_entity.user.email(), test,
"Test-Answer")
this_mark.put()
self.redirect('/t/%s' % test_id)
return
def get_grouped_marks(entity_id):
"""Returns a list of summary of the marks in each group
This list will return all available lgroups, even if the level is 0.
"""
grouped_marks = []
groups = set()
mark_list = Mark.query(ancestor=ndb.Key("Entity", entity_id)).filter(
Mark.complete == True).order(-Mark.created).fetch()
entity = Entity.query(Entity.id == entity_id).fetch()[0]
group_list = []
for mark in mark_list:
groups_length = len(groups)
groups.update(mark.test.group)
if groups_length < len(groups):
# If the set of groups got longer, add a new dict to the list
grouped_marks.append({
'group': mark.test.group,
'level': mark.test.level,
'level_progress': 0,
'tests_taken': 0,
'total_score': 0,
})
else:
for group in grouped_marks:
if group['group'] == mark.test.group:
group['tests_taken'] += 1
group['total_score'] += mark.mark * mark.test.level
group_list.append(mark.test.group)
for group in grouped_marks:
if group['total_score'] is not None and group['total_score'] > 0:
group['level'] = math.floor(
math.log(float(group['total_score']), 2))
group['level_progress'] = (math.log(group['total_score'], 2) -
group['level']) * 100
else:
group['total_score'] = 0
group['level'] = 1
group['level_progress'] = 0
unused_defaults = set(itertools.chain(
entity.test_groups, default_groups)) - set(
[group['group'] for group in grouped_marks])
for group in unused_defaults:
grouped_marks.append({'group': group, 'level': 1, 'level_progress': 0})
return grouped_marks
def get(self):
template_values = get_template_values(self)
user = users.get_current_user()
try:
entity = Entity.query(Entity.id == user.user_id()).fetch()[0]
if not entity.display_name:
path = os.path.join(
os.path.dirname(__file__),
os.path.join(template_dir, 'register.html'))
self.response.out.write(template.render(path, template_values))
else:
self.redirect('/u')
except IndexError:
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'register.html'))
self.response.out.write(template.render(path, template_values))
return
def entity(noun=None):
entity = Entity.query(Entity.name==noun).get()
post = Post.query(Post.title==noun).get()
if not post:
return redirect(url_for("idonotknow", noun=noun))
posts = Post.query().filter(Post.category.IN([noun]))
content, toc = md2html(post.content)
txt = noTag(noTag(toc, 'div'), 'ul')
toc = toc if txt.strip() else ''
return render_template('entity.html',
entity=entity,
post=post,
posts=posts,
toc=toc,
content=content)
def get_grouped_marks( entity_id ):
"""Returns a list of summary of the marks in each group
This list will return all available lgroups, even if the level is 0.
"""
grouped_marks = []
groups = set()
mark_list = Mark.query( ancestor = ndb.Key( "Entity", entity_id )).filter( Mark.complete == True ).order( -Mark.created ).fetch()
entity = Entity.query( Entity.id == entity_id).fetch()[0]
group_list = []
for mark in mark_list:
groups_length = len(groups)
groups.update( mark.test.group )
if groups_length < len(groups):
# If the set of groups got longer, add a new dict to the list
grouped_marks.append({
'group' : mark.test.group,
'level' : mark.test.level,
'level_progress' : 0,
'tests_taken' : 0,
'total_score' : 0,
})
else:
for group in grouped_marks:
if group['group'] == mark.test.group:
group['tests_taken'] += 1
group['total_score'] += mark.mark * mark.test.level
group_list.append( mark.test.group )
for group in grouped_marks:
if group['total_score'] is not None and group['total_score'] > 0:
group['level'] = math.floor( math.log( float(group['total_score']),2 ) )
group['level_progress'] = (math.log( group['total_score'],2 ) - group['level']) * 100
else:
group['total_score'] = 0
group['level'] = 1
group['level_progress'] = 0
unused_defaults = set( itertools.chain( entity.test_groups, default_groups )) - set( [ group['group'] for group in grouped_marks ] )
for group in unused_defaults:
grouped_marks.append( {'group':group,'level':1,'level_progress':0} )
return grouped_marks
def update_entity():
tree = Tree()
all_nodes = tree.build('./post/entity.txt', False)
for node in all_nodes:
node = tree.get_or_create(node)
entity = Entity.query(Entity.name==node.entity).get()
print '-----------------------'
print node.get_parent()
print node.entity
print node.get_children()
print node.get_ref()
if entity:
entity.from_entity = node.get_parent()
entity.to_entity = node.get_children()
entity.ref_entity = node.get_ref()
entity.put()
else:
Entity(name=node.entity,
from_entity=node.get_parent(),
to_entity=node.get_children(),
ref_entity=node.get_ref(),
).put()
def entity(noun=None):
entity = Entity.query(Entity.name==noun).get()
post = Post.query(Post.title==noun).get()
if not post:
return redirect(url_for("idonotknow", noun=noun))
posts = Post.query().filter(Post.category.IN([noun])).order(-Post.date)
tagged_posts = Post.get_tagged_post(noun)
content, toc = md2html(post.content)
txt = noTag(noTag(toc, 'div'), 'ul')
toc = toc if txt.strip() else ''
last_posts = Post.get_lastest()
return render_template('entity.html',
entity=entity,
post=post,
posts=posts,
tagged_posts=tagged_posts,
last_posts=last_posts,
toc=toc,
content=content)
def get_template_values( self ):
"""Constructs and returns a dict of common values needed by all or nearly all templates"""
user = users.get_current_user()
template_values= {
'date' : datetime.datetime.now(),
'nav_urls' : get_navigation_urls( self, user ),
}
if user:
try:
entity = Entity.query( Entity.id == user.user_id() ).fetch()[0]
template_values['user_name'] = entity.display_name
template_values['bio'] = entity.bio
except:
# User isn't an entity yet
pass
template_values['user'] = user
template_values['user_id'] = user.user_id()
template_values['nav_grav'] = "http://www.gravatar.com/avatar/" + hashlib.md5(user.email().lower()).hexdigest() + "?s=36"
else:
template_values['user'] = False
return template_values
def update_entity():
tree = Tree()
all_nodes = tree.build('./post/entity.txt', False)
for node in all_nodes:
node = tree.get_or_create(node)
entity = Entity.query(Entity.name == node.entity).get()
print '-----------------------'
print node.get_parent()
print node.entity
print node.get_children()
print node.get_ref()
if entity:
entity.from_entity = node.get_parent()
entity.to_entity = node.get_children()
entity.ref_entity = node.get_ref()
entity.put()
else:
Entity(
name=node.entity,
from_entity=node.get_parent(),
to_entity=node.get_children(),
ref_entity=node.get_ref(),
).put()
def add_test_to_template( template_values, in_test ):
"""Combines Test object properties into template_values"""
template_values['test_id'] = in_test.id
template_values['title'] = in_test.title
template_values['description'] = in_test.description
template_values['group'] = in_test.group
template_values['level'] = in_test.level
template_values['test_created'] = in_test.created
template_values['test_modified'] = in_test.modified
template_values['author_id'] = in_test.author_id
template_values['author_name'] = Entity.query( Entity.id == in_test.author_id ).get().display_name
template_values['times_taken'] = in_test.times_taken
template_values['total_score'] = in_test.total_score
template_values['num_marked'] = in_test.num_marked
template_values['open'] = in_test.open
if in_test.num_marked > 0:
template_values['average_mark'] = template_values['total_score'] / template_values['num_marked']
mark_list = Mark.query( Mark.test.id == in_test.id ).filter( Mark.rating > -1 ).fetch()
template_values['num_ratings'] = len(mark_list)
if template_values['num_ratings'] > 0:
template_values['average_rating'] = sum([mark.rating for mark in mark_list]) / template_values['num_ratings']
if template_values['average_rating'] is not in_test.average_rating:
save_average_rating( in_test.id, template_values['average_rating'])
return template_values
def get_template_values(self):
"""Constructs and returns a dict of common values needed by all or nearly all templates"""
user = users.get_current_user()
template_values = {
'date': datetime.datetime.now(),
'nav_urls': get_navigation_urls(self, user),
}
if user:
try:
entity = Entity.query(Entity.id == user.user_id()).fetch()[0]
template_values['user_name'] = entity.display_name
template_values['bio'] = entity.bio
except:
# User isn't an entity yet
pass
template_values['user'] = user
template_values['user_id'] = user.user_id()
template_values[
'nav_grav'] = "http://www.gravatar.com/avatar/" + hashlib.md5(
user.email().lower()).hexdigest() + "?s=36"
else:
template_values['user'] = False
return template_values
def post(self):
user = users.get_current_user()
entity = Entity.query(Entity.id == user.user_id()).get()
test_query = Test.query(ancestor=ndb.Key('Entity', entity.id))
test_query = test_query.filter(
Test.id == self.request.get('id')).fetch()
if len(test_query) > 0:
test = test_query[0]
test.modified = datetime.datetime.now()
else:
test = Test(parent=ndb.Key('Entity', entity.id))
test.created = datetime.datetime.now()
test.times_taken = 0
test.total_score = 0
test.num_marked = 0
test.average_rating = 0
test.open = True
test.author_id = user.user_id()
test.title = self.request.get('title')
test.description = self.request.get('description')
test.group = self.request.get('group')
test.level = int(self.request.get('level'))
# Define rules for what is and isn't a valid group
try:
assert re.match('^[a-z0-9_]{2,16}$',
self.request.get('group')) is not None
except:
# If the group is invalid, try again
template_values = get_template_values(self)
template_values[
'error'] = """There was an error with the group entered. Please ensure it uses only
lowercase letters, numbers, and underscores."""
template_values['user_groups'] = set(
itertools.chain(entity.test_groups, default_groups))
template_values['user_levels'] = json.dumps(
get_grouped_marks(ndb.Key("Entity", entity.id)))
template_values = add_test_to_template(template_values, test)
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'create.html'))
self.response.out.write(template.render(path, template_values))
return
# Define rules for what is and isn't a valid level for the user to be posting in.
user_level = get_user_group_level(get_grouped_marks(entity.id),
test.group)
max_test_query = Test.query(
Test.group == test.group).order(-Test.level).fetch()
print max_test_query
try:
max_test_level = max_test_query[0].level / 2
except IndexError:
max_test_level = 0
if user_level < max_test_level or user_level < test.level:
# User level is not high enough.
template_values = get_template_values(self)
if user_level < max_test_level:
template_values['error'] = "You must be at least level %d in %s to create a test." \
"You are only level %d." \
% ( math.floor(max_test_level), test.group, user_level)
elif user_level < test.level:
template_values['error'] = """You must be at least level %d in %s to create a level %d test .""" \
% ( test.level, test.group, test.level)
template_values['user_groups'] = set(
itertools.chain(entity.test_groups, default_groups))
template_values['user_levels'] = json.dumps(
get_grouped_marks(entity_id=entity.id))
template_values = add_test_to_template(template_values, test)
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'create.html'))
self.response.out.write(template.render(path, template_values))
return
# Create an id and save the test if the group is valid
test.id = str(test.put().id())
test.put()
# Keep track of which test groups a user has used
if test.group not in entity.test_groups:
entity.test_groups.append(test.group)
entity.put()
# Add/Alter this test's Document in the search index
test_as_document = search.Document(
doc_id=test.id,
fields=[
search.AtomField(name="group", value=test.group),
search.TextField(name="title", value=test.title),
search.NumberField(name="times_taken", value=test.times_taken),
search.DateField(name="date", value=test.created),
search.NumberField(name="level", value=test.level),
search.NumberField(name="rating", value=test.average_rating),
])
try:
index = search.Index(name="tests")
index.put(test_as_document)
except search.Error:
logging.info("Index put failed")
self.redirect('/t/%s' % test.id)
return
def get(self, test_to_get=None):
template_values = get_template_values(self)
user = users.get_current_user()
if not test_to_get:
self.logger.debug("No test was provided for lookup")
self.redirect('/')
return
else:
try:
test = Test.query(Test.id == test_to_get).fetch(1)[0]
except IndexError:
self.logger.debug("Invalid Test ID")
self.redirect('/')
else:
if user:
template_values = add_entity_to_template(
template_values,
Entity.query(Entity.id == user.user_id()).fetch(1)[0])
user_level = get_user_group_level(
get_grouped_marks(user.user_id()), test.group)
if user_level == None:
user_level = 1
template_values['user_level'] = user_level
if user_level < test.level:
template_values['locked'] = True
try:
mark_query = Mark.query(
ancestor=ndb.Key("Entity", user.user_id()))
mark = mark_query.filter(
Mark.test.id == test.id).fetch(1)[0]
template_values = add_mark_to_template(
template_values, mark)
if (datetime.datetime.now() - mark.modified
) < datetime.timedelta(hours=24) or mark.complete:
template_values['locked'] = True
except IndexError:
self.logger.debug("No mark found")
template_values = add_test_to_template(
template_values, test)
finally:
if test.author_id == user.user_id():
template_values['is_test_marker'] = True
template_values['locked'] = True
test_marker = Entity.query(
Entity.id == user.user_id()).get()
template_values['to_be_marked'] = get_to_be_marked(
test_marker, test)
template_values['name'] = test_marker.display_name
template_values['current_user'] = user.user_id()
else:
template_values['locked'] = True
template_values['visitor'] = True
logging.warning("User not found!")
template_values = add_test_to_template(
template_values, test)
finally:
path = os.path.join(
os.path.dirname(__file__),
os.path.join(template_dir, 'test_detail.html'))
self.response.out.write(template.render(path, template_values))
return
def post(self):
user = users.get_current_user()
entity = Entity.query( Entity.id == user.user_id() ).get()
test_query = Test.query( ancestor = ndb.Key('Entity', entity.id ) )
test_query = test_query.filter( Test.id == self.request.get( 'id' ) ).fetch()
if len(test_query) > 0:
test = test_query[0]
test.modified = datetime.datetime.now()
else:
test = Test( parent = ndb.Key('Entity', entity.id ) )
test.created = datetime.datetime.now()
test.times_taken = 0
test.total_score = 0
test.num_marked = 0
test.average_rating = 0
test.open = True
test.author_id = user.user_id()
test.title = self.request.get( 'title' )
test.description = self.request.get( 'description' )
test.group = self.request.get( 'group' )
test.level = int(self.request.get( 'level' ))
# Define rules for what is and isn't a valid group
try:
assert re.match('^[a-z0-9_]{2,16}$', self.request.get( 'group' )) is not None
except:
# If the group is invalid, try again
template_values = get_template_values( self )
template_values['error'] = """There was an error with the group entered. Please ensure it uses only
lowercase letters, numbers, and underscores."""
template_values['user_groups'] = set(
itertools.chain( entity.test_groups, default_groups )
)
template_values['user_levels'] = json.dumps( get_grouped_marks( ndb.Key( "Entity", entity.id ) ))
template_values = add_test_to_template(template_values, test)
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'create.html' ) )
self.response.out.write( template.render( path, template_values ))
return
# Define rules for what is and isn't a valid level for the user to be posting in.
user_level = get_user_group_level( get_grouped_marks( entity.id ), test.group )
max_test_query = Test.query( Test.group == test.group ).order(-Test.level).fetch()
print max_test_query
try:
max_test_level = max_test_query[0].level / 2
except IndexError:
max_test_level = 0
if user_level < max_test_level or user_level < test.level:
# User level is not high enough.
template_values = get_template_values( self )
if user_level < max_test_level:
template_values['error'] = "You must be at least level %d in %s to create a test." \
"You are only level %d." \
% ( math.floor(max_test_level), test.group, user_level)
elif user_level < test.level:
template_values['error'] = """You must be at least level %d in %s to create a level %d test .""" \
% ( test.level, test.group, test.level)
template_values['user_groups'] = set( itertools.chain( entity.test_groups, default_groups ) )
template_values['user_levels'] = json.dumps( get_grouped_marks( entity_id=entity.id ) )
template_values = add_test_to_template(template_values, test)
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'create.html' ) )
self.response.out.write( template.render( path, template_values ))
return
# Create an id and save the test if the group is valid
#test.id = str( test.put().id() )
test.id = ''.join(random.choice(string.digits+string.ascii_lowercase) for x in range(20))
test.put()
# Keep track of which test groups a user has used
if test.group not in entity.test_groups:
entity.test_groups.append(test.group)
entity.put()
# Add/Alter this test's Document in the search index
test_as_document = search.Document(
doc_id = test.id,
fields = [
search.AtomField( name="group", value=test.group ),
search.TextField( name="title", value=test.title ),
search.NumberField( name="times_taken", value=test.times_taken ),
search.DateField( name="date", value=test.created ),
search.NumberField( name="level", value=test.level ),
search.NumberField( name="rating", value=test.average_rating ),
]
)
try:
index = search.Index(name="tests")
index.put( test_as_document )
except search.Error:
logging.info("Index put failed")
self.redirect('/t/%s' % test.id )
return
def archives():
entities = Entity.query().order(Entity.name)
return render_template('archives.html',
entities=entities)
def archives():
entities = Entity.query().order(Entity.name)
last_posts = Post.get_lastest()
return render_template('archives.html',
last_posts=last_posts,
entities=entities)
