def get_marks(num=None,
start_cursor=None,
ancestor_key=None,
mark_complete=None):
"""Retrieves the num most recent marks, starting at start_cursor, only for the ancestor if provided, and only completed or not-completed tests if mark_complete is provided"""
if ancestor_key:
# This checks for only marks created by this entity
mark_query = Mark.query(
ancestor=ancestor_key).order(-Mark.test.created)
else:
mark_query = Mark.query().order(-Mark.test.created)
if mark_complete is not None:
# Filter completed marks based on mark_complete -> default is None => all marks
mark_query = mark_query.filter(Mark.complete == mark_complete)
if start_cursor:
# Set the query start to the cursor location, if provided
marks, next_cursor, more = mark_query.fetch_page(
num, start_cursor=start_cursor)
try:
return {
'marks': marks,
'next': next_cursor.urlsafe(),
'more': more
}
except:
return {'marks': marks, 'next': None, 'more': False}
elif num:
# Otherwise return the number of requested results
return mark_query.fetch(num)
# Or all if no num was specified
return mark_query.fetch()
def post(self):
template_values = get_template_values( self )
user = users.get_current_user()
if self.request.get('next'):
cursor = search.Cursor(web_safe_string=self.request.get('next'))
else:
cursor = search.Cursor()
q = query = self.request.get("search-text").replace(',',"")
order = self.request.get("search-order")
completed = True if self.request.get("search-completed") == "on" else False
template_values["query_values"] = {
'query':query,
'order':order,
'completed':completed,
}
if order == "rating":
sort_exp = search.SortExpression( expression='rating', direction=search.SortExpression.DESCENDING, default_value=0)
elif order == "times_taken":
sort_exp = search.SortExpression( expression='times_taken', direction=search.SortExpression.DESCENDING, default_value=0)
elif order == "date_inc":
sort_exp = search.SortExpression( expression='date', direction=search.SortExpression.DESCENDING, default_value=0)
elif order == "date_dec":
sort_exp = search.SortExpression( expression='date', direction=search.SortExpression.ASCENDING, default_value=0)
elif order == "level_dec":
sort_exp = search.SortExpression( expression='level', direction=search.SortExpression.DESCENDING, default_value=0)
elif order == "level_inc":
sort_exp = search.SortExpression( expression='level', direction=search.SortExpression.ASCENDING, default_value=0)
query_options = search.QueryOptions(
limit = self.page_depth,
cursor = cursor,
sort_options = search.SortOptions(expressions=[sort_exp,]),
)
query_obj = search.Query(query_string=query, options=query_options)
results = search.Index(name="tests").search(query=query_obj)
template_values["query_results"] = []
for document in results:
test = Test.query( Test.id == document.doc_id ).get()
if completed and user:
# If the "Hide completed" checkbox is selected by the user
if Mark.query( Mark.taker_entity.id == user.user_id(), Mark.test.id == test.id ).get() != None :
# And a Mark has been created
continue # Don't add it to the list.
# If this continue is active, this selects out TAKEN tests
# Otherwise , this if statement selects out MARKED tests
if Mark.query( Mark.complete == False ).get() == None:
# And the Test has been marked as completed for this user.
continue # Don't add it to the list.
template_values["query_results"].append( test )
path = os.path.join( os.path.dirname(__file__), os.path.join( template_dir, 'main.html' ) )
self.response.out.write( template.render( path, template_values ))
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 get_grouped_marks_list( entity_id ):
"""Returns a list of summary of the marks in each group
This only provides values for groups that the user has been given
return {{'group_name':name, 'tests_taken':tests_taken, 'total_score':num }, {...}, ... }
"""
grouped_marks = []
groups = set()
mark_list = Mark.query( ancestor = ndb.Key( "Entity", entity_id) ).filter( Mark.complete == True ).order( -Mark.created ).fetch()
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({
'name': mark.test.group,
'tests_taken': 1,
'total_score': mark.mark * mark.test.level,
})
else:
for group in grouped_marks:
if group['name'] == mark.test.group:
group['tests_taken'] += 1
group['total_score'] += mark.mark * mark.test.level
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
return grouped_marks
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 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 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(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 get_marked( entity, num=None ):
"""Retrieves the responses from other entities that need to have marks assigned for tests created by this entity"""
mark_query = Mark.query( Mark.marker_entity.id == entity.id )
mark_query = mark_query.filter( Mark.complete == True )
if not num:
return mark_query.fetch()
else:
return mark_query.fetch( num )
def get_marked(entity, num=None):
"""Retrieves the responses from other entities that need to have marks assigned for tests created by this entity"""
mark_query = Mark.query(Mark.marker_entity.id == entity.id)
mark_query = mark_query.filter(Mark.complete == True)
if not num:
return mark_query.fetch()
else:
return mark_query.fetch(num)
def get_marks( num=None, start_cursor=None, ancestor_key=None, mark_complete=None):
"""Retrieves the num most recent marks, starting at start_cursor, only for the ancestor if provided, and only completed or not-completed tests if mark_complete is provided"""
if ancestor_key:
# This checks for only marks created by this entity
mark_query = Mark.query( ancestor = ancestor_key ).order( -Mark.test.created )
else:
mark_query = Mark.query().order( -Mark.test.created )
if mark_complete is not None:
# Filter completed marks based on mark_complete -> default is None => all marks
mark_query = mark_query.filter( Mark.complete == mark_complete )
if start_cursor:
# Set the query start to the cursor location, if provided
marks, next_cursor, more = mark_query.fetch_page(num, start_cursor=start_cursor)
try:
return { 'marks':marks, 'next':next_cursor.urlsafe(), 'more':more }
except:
return { 'marks':marks, 'next':None, 'more':False }
elif num:
# Otherwise return the number of requested results
return mark_query.fetch( num )
# Or all if no num was specified
return mark_query.fetch()
def post(self):
user = users.get_current_user()
mark_id = self.request.get("mark_id")
rating = int(self.request.get("rating"))
try:
mark = Mark.query( ancestor = ndb.Key("Entity", user.user_id()) ).filter( Mark.id == mark_id ).get()
except:
mark = None
if mark:
mark.rating = int( rating )
mark.rated = True
mark.put()
self.redirect("/t/%s" % mark_id)
def post(self):
user = users.get_current_user()
mark_id = self.request.get("mark_id")
rating = int(self.request.get("rating"))
try:
mark = Mark.query(
ancestor=ndb.Key("Entity", user.user_id())).filter(
Mark.id == mark_id).get()
except:
mark = None
if mark:
mark.rating = int(rating)
mark.rated = True
mark.put()
self.redirect("/t/%s" % mark_id)
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_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 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 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_grouped_marks_list(entity_id):
"""Returns a list of summary of the marks in each group
This only provides values for groups that the user has been given
return {{'group_name':name, 'tests_taken':tests_taken, 'total_score':num }, {...}, ... }
"""
grouped_marks = []
groups = set()
mark_list = Mark.query(ancestor=ndb.Key("Entity", entity_id)).filter(
Mark.complete == True).order(-Mark.created).fetch()
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({
'name': mark.test.group,
'tests_taken': 1,
'total_score': mark.mark * mark.test.level,
})
else:
for group in grouped_marks:
if group['name'] == mark.test.group:
group['tests_taken'] += 1
group['total_score'] += mark.mark * mark.test.level
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
return grouped_marks
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()
if self.request.get('next'):
cursor = search.Cursor(web_safe_string=self.request.get('next'))
else:
cursor = search.Cursor()
q = query = self.request.get("search-text").replace(',', "")
order = self.request.get("search-order")
completed = True if self.request.get(
"search-completed") == "on" else False
template_values["query_values"] = {
'query': query,
'order': order,
'completed': completed,
}
if order == "rating":
sort_exp = search.SortExpression(
expression='rating',
direction=search.SortExpression.DESCENDING,
default_value=0)
elif order == "times_taken":
sort_exp = search.SortExpression(
expression='times_taken',
direction=search.SortExpression.DESCENDING,
default_value=0)
elif order == "date_inc":
sort_exp = search.SortExpression(
expression='date',
direction=search.SortExpression.DESCENDING,
default_value=0)
elif order == "date_dec":
sort_exp = search.SortExpression(
expression='date',
direction=search.SortExpression.ASCENDING,
default_value=0)
elif order == "level_dec":
sort_exp = search.SortExpression(
expression='level',
direction=search.SortExpression.DESCENDING,
default_value=0)
elif order == "level_inc":
sort_exp = search.SortExpression(
expression='level',
direction=search.SortExpression.ASCENDING,
default_value=0)
query_options = search.QueryOptions(
limit=self.page_depth,
cursor=cursor,
sort_options=search.SortOptions(expressions=[
sort_exp,
]),
)
query_obj = search.Query(query_string=query, options=query_options)
results = search.Index(name="tests").search(query=query_obj)
template_values["query_results"] = []
for document in results:
test = Test.query(Test.id == document.doc_id).get()
if completed and user:
# If the "Hide completed" checkbox is selected by the user
if Mark.query(Mark.taker_entity.id == user.user_id(),
Mark.test.id == test.id).get() != None:
# And a Mark has been created
continue # Don't add it to the list.
# If this continue is active, this selects out TAKEN tests
# Otherwise , this if statement selects out MARKED tests
if Mark.query(Mark.complete == False).get() == None:
# And the Test has been marked as completed for this user.
continue # Don't add it to the list.
template_values["query_results"].append(test)
path = os.path.join(os.path.dirname(__file__),
os.path.join(template_dir, 'main.html'))
self.response.out.write(template.render(path, template_values))
return
