def review():
"""Enters the review, and comparisons, for a particular task.
This function is only used to enter NEW reviews."""
# Here is where the comparisons are entered.
t = db.task(request.args(0)) or redirect(URL('default', 'index'))
if t.user != auth.user.email:
session.flash = T('Invalid request.')
redirect(URL('default', 'index'))
# Check that the venue rating deadline is currently open, or that the ranker
# is a manager or observer.
venue = db.venue(t.venue_id)
if ((auth.user.email not in util.get_list(venue.managers)) and
(auth.user.email not in util.get_list(venue.observers)) and
(datetime.utcnow() < venue.rate_open_date or datetime.utcnow() > venue.rate_close_date)):
session.flash = T('The review deadline for this venue is closed.')
redirect(URL('venues', 'view_venue', args=[venue.id]))
# Ok, the task belongs to the user.
# Gets the last reviewing task done for the same venue.
last_comparison = db((db.comparison.user == auth.user.email)
& (db.comparison.venue_id == t.venue_id)).select(orderby=~db.comparison.date).first()
if last_comparison == None:
last_ordering = []
subm_id_to_nickname = {}
else:
last_ordering = util.get_list(last_comparison.ordering)
try:
subm_id_to_nickname = simplejson.loads(last_comparison.submission_nicknames)
except Exception, e:
logger.warning("Failed to decode submission_nicknames: " +
str(last_comparison.submission_nicknames))
subm_id_to_nickname = {}
def download_viewer():
"""This method allows the download of a submission by someone who has access to
all the submissions of the venue. We need to do all access control here."""
subm = db.submission(request.args(0)) or redirect(URL('default', 'index'))
c = db.venue(subm.venue_id) or redirect(URL('default', 'index'))
# Does the user have access to the venue submissions?
# TODO(luca): factor this in a permission module.
props = db(db.user_properties.email == auth.user.email).select().first()
can_manage = c.id in util.get_list(props.venues_can_manage)
can_observe = c.id in util.get_list(props.venues_can_observe)
can_view_ratings = can_manage or c.rating_available_to_all or can_observe
if not can_view_ratings:
session.flash(T('Not authorized.'))
redirect(URL('default', 'index'))
# Creates an appropriate file name for the submission.
original_ext = subm.original_filename.split('.')[-1]
filename = subm.email or 'anonymous'
if subm.title != None and len(subm.title) > 0:
filename += '_' + subm.title
else:
filename += '_' + subm.identifier
filename += '.' + original_ext
# Allows the download.
# TODO(luca): The next line should be useless.
request.args = request.args[1:]
return my_download(request, db, filename)
def observed_index():
props = db(db.user_properties.user == get_user_email()).select().first()
if props == None:
l = []
else:
l = util.id_list(util.get_list(props.venues_can_observe))
l1 = util.id_list(util.get_list(props.venues_can_manage))
for el in l1:
if el not in l:
l.append(el)
if len(l) > 0:
q = (db.venue.id.belongs(l) & (db.venue.is_approved == True))
else:
q = (db.venue.id == -1)
db.venue.number_of_submissions_per_reviewer.readable = True
db.venue.grading_instructions.readable = True
db.venue.is_approved.readable = True
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.close_date, db.venue.rate_close_date],
csv=False,
details=True,
create=False,
editable=False,
deletable=False,
maxtextlength=24,
)
return dict(grid=grid)
def observed_index():
props = db(db.user_properties.user == auth.user.email).select().first()
if props == None:
l = []
else:
l = util.id_list(util.get_list(props.venues_can_observe))
l1 = util.id_list(util.get_list(props.venues_can_manage))
for el in l1:
if el not in l:
l.append(el)
if len(l) > 0:
q = db.venue.id.belongs(l) & (db.venue.is_approved == True)
else:
q = db.venue.id == -1
db.venue.number_of_submissions_per_reviewer.readable = True
db.venue.grading_instructions.readable = True
db.venue.is_approved.readable = True
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.close_date, db.venue.rate_close_date],
csv=False,
details=True,
create=False,
editable=False,
deletable=False,
)
return dict(grid=grid)
def submit():
# Gets the information on the venue.
c = db.venue(request.args[0]) or redirect(URL('default', 'index'))
# Gets information on the user.
props = db(db.user_properties.email == auth.user.email).select().first()
if props == None:
venue_ids = []
venues_has_submitted = []
else:
venue_ids = util.get_list(props.venues_can_submit)
venues_has_submitted = util.get_list(props.venues_has_submitted)
# Is the venue open for submission?
if not (c.submit_constraint == None or c.id in venue_ids):
session.flash = T('You cannot submit to this venue.')
redirect(URL('venues', 'view_venue', args=[c.id]))
t = datetime.utcnow()
if not (c.is_active and c.is_approved and c.open_date <= t and c.close_date >= t):
session.flash = T('The submission deadline has passed; submissions are closed.')
redirect(URL('venues', 'view_venue', args=[c.id]))
# Ok, the user can submit. Looks for previous submissions.
sub = db((db.submission.author == auth.user_id) & (db.submission.venue_id == c.id)).select().first()
if sub != None and not c.allow_multiple_submissions:
session.flash = T('You have already submitted to this venue.')
redirect(URL('my_submissions_index', args=[c.id]))
# The author can access the title.
db.submission.title.readable = db.submission.title.writable = True
# Check whether link submission is allowed.
db.submission.link.readable = db.submission.link.writable = c.allow_link_submission
db.submission.n_completed_reviews.readable = False
db.submission.n_rejected_reviews.readable = False
db.submission.feedback.readable = db.submission.feedback.writable = False
# Produces an identifier for the submission.
db.submission.identifier.default = util.get_random_id()
db.submission.email.default = auth.user.email
# Assigns default quality to the submission.
avg, stdev = ranker.get_init_average_stdev()
db.submission.quality.default = avg
db.submission.error.default = stdev
# No percentile readable.
db.submission.percentile.readable = False
# TODO(luca): check that it is fine to do the download link without parameters.
form = SQLFORM(db.submission, upload=URL('download_auhor', args=[None]))
form.vars.venue_id = c.id
if request.vars.content != None and request.vars.content != '':
form.vars.original_filename = request.vars.content.filename
if form.process().accepted:
# Adds the venue to the list of venues where the user submitted.
# TODO(luca): Enable users to delete submissions. But this is complicated; we need to
# delete also their quality information etc. For the moment, no deletion.
submitted_ids = util.id_list(venues_has_submitted)
submitted_ids = util.list_append_unique(submitted_ids, c.id)
if props == None:
db.user_properties.insert(email = auth.user.email,
venues_has_submitted = submitted_ids)
else:
props.update_record(venues_has_submitted = submitted_ids)
db.commit()
session.flash = T('Your submission has been accepted.')
redirect(URL('feedback', 'index', args=['all']))
return dict(form=form, venue=c)
def edit_ordering():
""" Edit last ordering."""
# Gets the information on the venue and comparison.
venue = db.venue(request.args[0]) or redirect(URL('default', 'index'))
last_comparison = db.comparison(request.args[1]) or redirect(URL('default', 'index'))
if last_comparison.author != auth.user_id:
session.flash = T('Invalid request.')
redirect(URL('default', 'index'))
# Check that the venue rating deadline is currently open, or that the ranker
# is a manager or observer.
if ((auth.user.email not in util.get_list(venue.managers)) and
(auth.user.email not in util.get_list(venue.observers)) and
(datetime.utcnow() < venue.rate_open_date or datetime.utcnow() > venue.rate_close_date)):
session.flash = T('The review deadline for this venue is closed.')
redirect(URL('venues', 'view_venue', args=[venue.id]))
# Ok, the task belongs to the user.
# Gets the last reviewing task done for the same venue.
if last_comparison == None:
last_ordering = []
else:
last_ordering = util.get_list(last_comparison.ordering)
# Finds the grades that were given for the submissions previously reviewed.
if last_comparison == None or last_comparison.grades == None:
str_grades = {}
else:
try:
str_grades = simplejson.loads(last_comparison.grades)
except Exception, e:
str_grades = {}
logger.warning("Grades cannot be read: " + str(last_comparison.grades))
def can_observe(venue, props):
if current.is_user_admin():
return True
if props is None:
return False
can_manage = venue.is_active and venue.id in util.get_list(props.venues_can_manage)
can_observe = venue.is_approved and venue.is_active and venue.id in util.get_list(props.venues_can_observe)
return can_manage or can_observe
def rerun_processing_comparisons(db,
venue_id,
alpha_annealing=0.5,
run_twice=False):
# We reset the ranking to the initial values.
# Gets a ranker object to do the ranking, initialized with all the submissions with
# their default stdev and avg.
sub = db(db.submission.venue_id == venue_id).select(db.submission.id)
items = []
qdistr_param = []
for x in sub:
items.append(x.id)
qdistr_param.append(AVRG)
qdistr_param.append(STDEV)
rankobj = Rank.from_qdistr_param(items,
qdistr_param,
alpha=alpha_annealing)
# Processes the list of comparisons.
result = None
comparison_list = db(db.comparison.venue_id == venue_id).select(
orderby=db.comparison.date)
for comp in comparison_list:
# Processes the comparison, if valid.
if comp.is_valid is None or comp.is_valid == True:
# Reverses the list.
sorted_items = util.get_list(comp.ordering)[::-1]
if len(sorted_items) < 2:
continue
result = rankobj.update(sorted_items, new_item=comp.new_item)
if run_twice:
comparison_list = db(db.comparison.venue_id == venue_id).select(
orderby=~db.comparison.date)
for comp in comparison_list:
# Processes the comparison, if valid.
if comp.is_valid is None or comp.is_valid == True:
# Reverses the list.
sorted_items = util.get_list(comp.ordering)[::-1]
if len(sorted_items) < 2:
continue
result = rankobj.update(sorted_items, new_item=comp.new_item)
# Writes the updated statistics to the db. Note that result contains the result for
# all the ids, due to how the rankobj has been initialized.
if result is None:
return
for x in items:
perc, avrg, stdev = result[x]
db((db.submission.id == x)
& (db.submission.venue_id == venue_id)).update(quality=avrg,
error=stdev,
percentile=perc)
# Saving the latest rank update date.
description = "Ranking without reputation system. All comparisons are used in chronological order"
db(db.venue.id == venue_id).update(
latest_rank_update_date=datetime.utcnow(),
ranking_algo_description=description)
def write_to_db_for_rep_sys(db, venue_id, rankobj_result, subm_l, user_l,
ordering_d, accuracy_d, rep_d, perc_final_d,
final_grade_d, subm_d, ranking_algo_description):
# Gets the users that participate in the class.
c = db.venue(venue_id)
ul = []
r = db.user_list(c.submit_constraint)
if r is not None:
ul = util.get_list(r.user_list)
if not c.raters_equal_submitters:
ulr = []
r = db.user_list(c.rate_constraint)
if r is not None:
ulr = util.get_list(r.user_list)
ul = util.union_list(ul, ulr)
if len(ul) == 0:
# Nothing to write.
db(db.grades.venue_id == venue_id).delete()
db.commit()
return
# Writes the grades for each user.
for u in ul:
# Write to the submission.
subm_id = subm_d.get(u)
if subm_id is not None:
perc, avrg, stdev = rankobj_result[subm_id]
db(db.submission.id == subm_id).update(quality=avrg, error=stdev, percentile=perc)
submission_percentile = perc
else:
submission_percentile = None
# Write the grade.
if ordering_d.has_key(u):
n_ratings = len(ordering_d[u])
else:
n_ratings = 0
db.grades.update_or_insert((db.grades.venue_id == venue_id) &
(db.grades.user == u),
venue_id = venue_id,
user = u,
submission_percentile = submission_percentile,
accuracy = accuracy_d.get(u),
reputation = rep_d.get(u),
n_ratings = n_ratings,
percentile = perc_final_d.get(u),)
# Saving evaluation date.
t = datetime.utcnow()
db(db.venue.id == venue_id).update(latest_grades_date = t,
ranking_algo_description = ranking_algo_description)
db.commit()
def can_view_submissions(venue, props):
can_manage = venue.id in util.get_list(props.venues_can_manage)
can_observe = venue.id in util.get_list(props.venues_can_observe)
if can_manage or can_observe:
return True
if venue.submissions_visible_to_all:
if venue.submissions_visible_immediately:
return True
else:
return venue.close_date > datetime.utcnow()
else:
return False
def can_view_feedback(venue, props):
can_manage = venue.id in util.get_list(props.venues_can_manage)
can_observe = venue.id in util.get_list(props.venues_can_observe)
if can_manage or can_observe:
return True
if venue.feedback_available_to_all:
if venue.feedback_accessible_immediately:
return True
else:
return venue.rate_close_date > datetime.utcnow()
else:
return False
def can_view_feedback(venue, props):
can_manage = venue.id in util.get_list(props.venues_can_manage)
can_observe = venue.id in util.get_list(props.venues_can_observe)
if can_manage or can_observe:
return True
if venue.feedback_available_to_all:
if venue.feedback_accessible_immediately:
return True
else:
return venue.rate_close_date > datetime.utcnow()
else:
return False
def can_view_submissions(venue, props):
can_manage = venue.id in util.get_list(props.venues_can_manage)
can_observe = venue.id in util.get_list(props.venues_can_observe)
if can_manage or can_observe:
return True
if venue.submissions_visible_to_all:
if venue.submissions_visible_immediately:
return True
else:
return venue.close_date > datetime.utcnow()
else:
return False
def read_user_list(self):
""" Gets the users that participate in the class."""
db = current.db
c = db.venue(self.venue_id)
r = db.user_list(c.submit_constraint)
if r is not None:
self.user_list = util.get_list(r.user_list)
if not c.raters_equal_submitters:
ulr = []
r = db.user_list(c.rate_constraint)
if r is not None:
ulr = util.get_list(r.user_list)
self.user_list = util.union_list(self.user_list, ulr)
def get_num_rows_of_D(compar_rows,
matrix_D_type=current.MATRIX_D_TYPE_GRADES_DIST):
"""Computes number of rows in matrix D."""
num_rows = 0
if matrix_D_type == current.MATRIX_D_TYPE_GRADES_DIST:
for r in compar_rows:
m = len(util.get_list(r.ordering))
if m >= 2:
num_rows += (m - 1) * m * 0.5
else:
# compute number of rows for matrix D in case when
# main optimization problem has form \sum r c(g - x)
for r in compar_rows:
num_rows += len(util.get_list(r.ordering))
return num_rows
def rerun_processing_comparisons(db, venue_id, alpha_annealing=0.5, run_twice=False):
# We reset the ranking to the initial values.
# Gets a ranker object to do the ranking, initialized with all the submissions with
# their default stdev and avg.
sub = db(db.submission.venue_id == venue_id).select(db.submission.id)
items = []
qdistr_param = []
for x in sub:
items.append(x.id)
qdistr_param.append(AVRG)
qdistr_param.append(STDEV)
rankobj = Rank.from_qdistr_param(items, qdistr_param, alpha=alpha_annealing)
# Processes the list of comparisons.
result = None
comparison_list = db(db.comparison.venue_id == venue_id).select(orderby=db.comparison.date)
for comp in comparison_list:
# Processes the comparison, if valid.
if comp.is_valid is None or comp.is_valid == True:
# Reverses the list.
sorted_items = util.get_list(comp.ordering)[::-1]
if len(sorted_items) < 2:
continue
result = rankobj.update(sorted_items, new_item=comp.new_item)
if run_twice:
comparison_list = db(db.comparison.venue_id == venue_id).select(orderby=~db.comparison.date)
for comp in comparison_list:
# Processes the comparison, if valid.
if comp.is_valid is None or comp.is_valid == True:
# Reverses the list.
sorted_items = util.get_list(comp.ordering)[::-1]
if len(sorted_items) < 2:
continue
result = rankobj.update(sorted_items, new_item=comp.new_item)
# Writes the updated statistics to the db. Note that result contains the result for
# all the ids, due to how the rankobj has been initialized.
if result is None:
return
for x in items:
perc, avrg, stdev = result[x]
db((db.submission.id == x) &
(db.submission.venue_id == venue_id)).update(quality=avrg, error=stdev, percentile=perc)
# Saving the latest rank update date.
description = "Ranking without reputation system. All comparisons are used in chronological order"
db(db.venue.id == venue_id).update(latest_rank_update_date = datetime.utcnow(),
ranking_algo_description = description)
def review():
"""Enters the review, and comparisons, for a particular task.
This also allows to decline a review.
This can be used both for old, and new, reviews.
The function is accessed by task id."""
t = db.task(request.args(0)) or redirect(URL('default', 'index'))
if t.user != get_user_email():
session.flash = T('Invalid request.')
redirect(URL('default', 'index'))
props = db(db.user_properties.user == get_user_email()).select().first()
# Check that the venue rating deadline is currently open, or that the ranker
# is a manager or observer.
venue = db.venue(t.venue_id)
if ((not access.can_observe(venue, props)) and
(datetime.utcnow() < venue.rate_open_date or datetime.utcnow() > venue.rate_close_date)):
session.flash = T('Reviewing for this venue is closed.')
redirect(URL('venues', 'view_venue', args=[venue.id]))
# Ok, the task belongs to the user.
# Gets the valid comparison for the venue, so we can read the grades.
last_comparison = db((db.comparison.user == get_user_email())
& (db.comparison.venue_id == t.venue_id) & (db.comparison.is_valid == True)).select().first()
if last_comparison == None:
last_ordering = []
subm_id_to_nickname = {}
else:
last_ordering = util.get_list(last_comparison.ordering)
try:
subm_id_to_nickname = simplejson.loads(last_comparison.submission_nicknames)
except Exception, e:
logger.warning("Failed to decode submission_nicknames: " +
str(last_comparison.submission_nicknames))
subm_id_to_nickname = {}
def reviewing_duties():
"""This function lists venues where users have reviews to accept, so that users
can be redirected to a page where to perform such reviews."""
# Produces a list of venues that are open for rating.
props = db(db.user_properties.user == get_user_email()).select(db.user_properties.venues_can_rate).first()
if props == None:
l = []
else:
l = util.get_list(props.venues_can_rate)
t = datetime.utcnow()
if len(l) == 0:
q = (db.venue.id == -1)
else:
q = ((db.venue.rate_open_date < t) & (db.venue.rate_close_date > t)
& (db.venue.is_active == True) & (db.venue.id.belongs(l)))
db.venue.rate_close_date.label = T('Review deadline')
db.venue.number_of_submissions_per_reviewer.label = T('Total n. of reviews')
grid = SQLFORM.grid(q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.rate_open_date, db.venue.rate_close_date,
db.venue.number_of_submissions_per_reviewer],
csv=False, details=False, create=False, editable=False, deletable=False,
links=[
dict(header=T('N. reviews still to do'), body = lambda r: get_num_reviews_todo(r)),
dict(header='Accept', body = lambda r: review_link(r)),
],
maxtextlength=24,
)
return dict(grid=grid)
def rateopen_index():
#TODO(luca): see if I can put an inline form for accepting review tasks.
props = db(db.user_properties.user == get_user_email()).select().first()
if props == None:
l = []
else:
l = util.get_list(props.venues_can_rate)
t = datetime.utcnow()
if len(l) == 0:
q = (db.venue.id == -1)
else:
q = ((db.venue.id.belongs(l)) & (db.venue.rate_open_date < t) &
(db.venue.rate_close_date > t) & (db.venue.is_active == True) &
(db.venue.is_approved == True))
db.venue.rate_close_date.label = T('Review deadline')
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[
db.venue.name, db.venue.rate_open_date, db.venue.rate_close_date
],
csv=False,
details=False,
create=False,
editable=False,
deletable=False,
links=[
dict(header=T('Review'), body=lambda r: review_link(r)),
],
maxtextlength=24,
)
return dict(grid=grid)
def rateopen_index():
# TODO(luca): see if I can put an inline form for accepting review tasks.
props = db(db.user_properties.user == auth.user.email).select().first()
if props == None:
l = []
else:
l = util.get_list(props.venues_can_rate)
t = datetime.utcnow()
if len(l) == 0:
q = db.venue.id == -1
else:
q = (
(db.venue.rate_open_date < t)
& (db.venue.rate_close_date > t)
& (db.venue.is_active == True)
& (db.venue.is_approved == True)
& (db.venue.id.belongs(l))
)
db.venue.rate_close_date.label = T("Review deadline")
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.rate_open_date, db.venue.rate_close_date],
csv=False,
details=False,
create=False,
editable=False,
deletable=False,
links=[dict(header=T("Review"), body=lambda r: review_link(r))],
)
return dict(grid=grid)
def subopen_index():
props = db(db.user_properties.user == get_user_email()).select(
db.user_properties.venues_can_submit).first()
if props == None:
l = []
else:
l = util.get_list(props.venues_can_submit)
t = datetime.utcnow()
if len(l) == 0:
q = (db.venue.id == -1)
else:
q = ((db.venue.id.belongs(l)) & (db.venue.close_date > t) &
(db.venue.open_date < t) & (db.venue.is_active == True) &
(db.venue.is_approved == True))
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.open_date, db.venue.close_date],
csv=False,
details=False,
create=False,
editable=False,
deletable=False,
links=[
dict(header=T('Submit'), body=lambda r: submit_link(r)),
],
maxtextlength=24,
)
return dict(grid=grid)
def reviewed_index():
props = db(db.user_properties.user == auth.user.email).select(db.user_properties.venues_has_rated).first()
if props == None:
l = []
else:
l = util.id_list(util.get_list(props.venues_has_rated))
if len(l) > 0:
q = db.venue.id.belongs(l) & (db.venue.is_approved == True)
else:
q = db.venue.id == -1
db.venue.rate_close_date.readable = True
db.venue.close_date.readable = True
db.venue.name.label = T("Venue")
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.close_date, db.venue.rate_close_date],
csv=False,
details=False,
create=False,
editable=False,
deletable=False,
links=[
dict(
header="Review feedback",
body=lambda r: A(
T("Read feedback"), _class="btn", _href=URL("feedback", "view_feedback", args=["v", r.id])
),
)
],
)
return dict(grid=grid)
def submitted_index():
props = db(db.user_properties.user == auth.user.email).select(db.user_properties.venues_has_submitted).first()
if props == None:
l = []
else:
l = util.id_list(util.get_list(props.venues_has_submitted))
if len(l) > 0:
q = db.venue.id.belongs(l) & (db.venue.is_approved == True)
else:
q = db.venue.id == -1
db.venue.rate_close_date.readable = True
db.venue.close_date.readable = True
db.venue.allow_multiple_submissions.readable = False
db.venue.name.label = T("Venue")
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.close_date, db.venue.rate_close_date, db.venue.allow_multiple_submissions],
csv=False,
details=False,
create=False,
editable=False,
deletable=False,
links=[dict(header="Actions", body=submission_feedback_link)],
)
return dict(grid=grid)
def review_index():
def get_venue_review_link(r):
tt = datetime.utcnow()
if tt >= r.rate_open_date and tt <= r.rate_close_date:
return A(T('View/edit your reviews'), _class='btn',
_href=URL('rating', 'edit_reviews', args=[r.id], user_signature=True))
else:
return A(T('View reviews and feedback'), _class='btn',
_href=URL('feedback', 'view_my_reviews', args=[r.id]))
props = db(db.user_properties.user == get_user_email()).select().first()
if props is None:
q = (db.venue.id == -1)
else:
venue_list = util.get_list(props.venues_has_rated)
q = (db.venue.id.belongs(venue_list))
db.venue.name.label = T('Assignment')
db.venue.rate_open_date.readable = db.venue.rate_close_date.readable = False
grid = SQLFORM.grid(q,
field_id = db.venue.id,
fields = [db.venue.name, db.venue.rate_open_date, db.venue.rate_close_date],
create=False, details=False,
csv=False, editable=False, deletable=False,
links=[dict(header=T(''), body = lambda r: get_venue_review_link(r)),
],
)
return dict(grid=grid)
def can_manage(venue, props):
if current.is_user_admin():
return True
if props is None:
return False
can_manage = venue.id in util.get_list(props.venues_can_manage)
return can_manage
def get_list_of_all_students(venue_id):
""" Gets the users that participate in the class."""
db = current.db
logger = current.logger
c = db.venue(venue_id)
ul = []
r = db.user_list(c.submit_constraint)
if r is not None:
ul = util.get_list(r.user_list)
if not c.raters_equal_submitters:
ulr = []
r = db.user_list(c.rate_constraint)
if r is not None:
ulr = util.get_list(r.user_list)
ul = util.union_list(ul, ulr)
return ul
def submitted_index():
props = db(db.user_properties.email == auth.user.email).select(db.user_properties.venues_has_submitted).first()
if props == None:
l = []
else:
l = util.id_list(util.get_list(props.venues_has_submitted))
if len(l) > 0:
q = (db.venue.id.belongs(l))
else:
q = (db.venue.id == -1)
db.venue.feedback_accessible_immediately.readable = False
db.venue.rate_open_date.readable = False
db.venue.rate_close_date.readable = False
db.venue.name.readable = False
grid = SQLFORM.grid(q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.rate_open_date, db.venue.rate_close_date, db.venue.feedback_accessible_immediately],
csv=False, details=False, create=False, editable=False, deletable=False,
links=[
dict(header=T('Venue'),
body = lambda r: A(r.name, _href=URL('view_venue', args=[r.id]))),
dict(header='Feedback', body = lambda r: link_feedback(r)),
dict(header='My submissions', body = lambda r:
A(T('My submissions'),
_class='btn',
_href=URL('submission', 'my_submissions_index', args=[r.id]))),
],
)
return dict(grid=grid)
def preprocess_for_publish(self, obj):
"""Preprocess an object before trying to publish it.
By default this tries to massage person tags so that the tag's
"url" points to the person's profile on this service (as opposed
to a person's homepage).
The object is modified in place.
Args:
obj: ActivityStreams activity or object dict
"""
for tag in obj.get('tags', []):
if tag.get('objectType') == 'person':
silo_url = None
for url in microformats2.object_urls(tag):
silo_url = url and self.infer_profile_url(url)
if silo_url:
break
if silo_url:
tag['url'] = silo_url
# recurse on contained object(s)
for obj in util.get_list(obj, 'object'):
self.preprocess_for_publish(obj)
def read_db_for_rep_sys(db, venue_id):
# Containers to fill.
# Lists have l suffix, dictionaries user -> val have d suffix.
user_l = [] # This list contains submitters and reviewers.
subm_l = []
subm_d = {}
ordering_l = []
ordering_d = {}
# Reading submission table.
rows = db(db.submission.venue_id == venue_id).select()
for r in rows:
subm_l.append(r.id)
subm_d[r.user] = r.id
user_l.append(r.user)
# Reading comparisons table.
rows = db((db.comparison.venue_id == venue_id) & (db.comparison.is_valid == True)).select()
for r in rows:
# Reverses the ordering.
sorted_items = util.get_list(r.ordering)[::-1]
if len(sorted_items) < 2:
continue
ordering_d[r.user] = sorted_items
# Initializing reviewers reputation and accuracy.
ordering_l.append((sorted_items, r.user))
# Adding reviewers to user_l.
for user in ordering_d.iterkeys():
if user not in user_l:
user_l.append(user)
return user_l, subm_l, ordering_l, subm_d, ordering_d
def reviewing_duties():
"""This function lists venues where users have reviews to accept, so that users
can be redirected to a page where to perform such reviews."""
# Produces a list of venues that are open for rating.
props = db(db.user_properties.user == auth.user.email).select(db.user_properties.venues_can_rate).first()
if props == None:
l = []
else:
l = util.get_list(props.venues_can_rate)
t = datetime.utcnow()
if len(l) == 0:
q = (db.venue.id == -1)
else:
q = ((db.venue.rate_close_date > t) & (db.venue.is_active == True) & (db.venue.id.belongs(l)))
db.venue.rate_close_date.label = T('Review deadline')
db.venue.number_of_submissions_per_reviewer.label = T('Total n. of reviews')
grid = SQLFORM.grid(q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.rate_open_date, db.venue.rate_close_date,
db.venue.number_of_submissions_per_reviewer],
csv=False, details=False, create=False, editable=False, deletable=False,
links=[
dict(header=T('N. reviews to do'), body = lambda r: get_num_reviews_todo(r)),
dict(header='Accept',
body = lambda r:
A(T('Accept to do a review'), _class='btn', _href=URL('rating', 'accept_review', args=[r.id]))),
]
)
return dict(grid=grid)
def preprocess_for_publish(self, obj):
"""Preprocess an object before trying to publish it.
By default this tries to massage person tags so that the tag's
"url" points to the person's profile on this service (as opposed
to a person's homepage).
The object is modified in place.
Args:
obj: ActivityStreams activity or object dict
"""
for tag in obj.get('tags', []):
if tag.get('objectType') == 'person':
silo_url = None
for url in microformats2.object_urls(tag):
silo_url = url and self.infer_profile_url(url)
if silo_url:
break
if silo_url:
tag['url'] = silo_url
# recurse on contained object(s)
for obj in util.get_list(obj, 'object'):
self.preprocess_for_publish(obj)
def submitted_index():
props = db(db.user_properties.user == auth.user.email).select(db.user_properties.venues_has_submitted).first()
if props == None:
l = []
else:
l = util.id_list(util.get_list(props.venues_has_submitted))
if len(l) > 0:
q = (db.venue.id.belongs(l))
else:
q = (db.venue.id == -1)
db.venue.feedback_accessible_immediately.readable = False
db.venue.rate_open_date.readable = False
db.venue.rate_close_date.readable = False
grid = SQLFORM.grid(q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.rate_open_date, db.venue.rate_close_date, db.venue.feedback_accessible_immediately],
csv=False, details=False, create=False, editable=False, deletable=False,
links=[
dict(header='Feedback', body = lambda r: link_feedback(r)),
dict(header='My submissions', body = lambda r:
A(T('My submissions'),
_class='btn',
_href=URL('feedback', 'index', args=[r.id]))),
],
)
return dict(grid=grid)
def main():
print('Start process')
logging.info("start\ncollecting data...")
data = collect_data(conf.data_dir, conf.do_lemmatize, conf.lemmatized_data,
conf.data_encoding)
if conf.algorithm == "doc2vec":
logging.info("fitting doc2vec...")
doc2vec.fit_model(data, dm=conf.dm, alpha=conf.alpha, n_epochs=conf.n_epochs,
vector_dim=conf.vector_dim, window=conf.window,
min_count=conf.min_count, n_best=conf.num_best)
elif conf.algorithm == "lda":
logging.info("fitting lda...")
lda.fit_model(data, n_topics=conf.topics, iterations=conf.iterations,
min_prob=conf.min_prob, passes=conf.passes,
eval_every=conf.eval_every, n_best=conf.num_best,
min_df=conf.min_df, max_df=conf.max_df,
preserved_words=get_list(conf.preserved_words_list,
encoding=conf.data_encoding))
else:
raise UnexpectedArgumentException("Invalid algorithm!")
print("Process finished.\n")
logging.info("Process finished.")
input("Press enter to exit")
def read_db_for_rep_sys(db, venue_id, last_compar_param):
# Containers to fill.
# Lists have l suffix, dictionaries user -> val have d suffix.
user_l = [] # This list contains submitters and reviewers.
subm_l = []
subm_d = {}
ordering_l = []
ordering_d = {}
# Reading submission table.
rows = db(db.submission.venue_id == venue_id).select()
for r in rows:
subm_l.append(r.id)
subm_d[r.user] = r.id
user_l.append(r.user)
# Reading comparisons table.
rows = db(db.comparison.venue_id == venue_id).select(orderby=db.comparison.date)
for r in rows:
# Check if comparison is valid.
if r.is_valid is None or r.is_valid == True:
# Reverses the ordering.
sorted_items = util.get_list(r.ordering)[::-1]
if len(sorted_items) < 2:
continue
ordering_d[r.user] = sorted_items
# Initializing reviewers reputation and accuracy.
ordering_l.append((sorted_items, r.user))
# Adding reviewers to user_l.
for user in ordering_d.iterkeys():
if user not in user_l:
user_l.append(user)
# If we want to use only last comparisons.
if not last_compar_param is None:
ordering_l = [(ordering, user) for user, ordering in ordering_d.iteritems()]
return user_l, subm_l, ordering_l, subm_d, ordering_d
def my_reviews():
props = db(db.user_properties.user == auth.user.email).select(
db.user_properties.venues_has_rated).first()
venue_list = util.get_list(props.venues_has_rated)
q = (db.venue.id.belongs(venue_list))
db.venue.name.readable = False
grid = SQLFORM.grid(
q,
field_id=db.venue.id,
fields=[db.venue.name],
create=False,
details=False,
csv=False,
editable=False,
deletable=False,
# TODO(michael): link to View/edit reviews is disabled for now.
links=[
dict(header=T('Venue'),
body=lambda r: A(
r.name, _href=URL('venues', 'view_venue', args=[r.id]))),
dict(
header=T('My reviews'),
#body = lambda r: A(T('View/edit reviews'), _href=URL('rating', 'edit_reviews', args=[r.id]))),
body=lambda r: T('View/edit reviews')),
],
)
return dict(grid=grid)
def manager_submit():
"""This function is used by venue managers to do submissions on behalf of others. It can be used
even when the submission deadline is past."""
# Gets the information on the venue.
c = db.venue(request.args[0]) or redirect(URL('default', 'index'))
# Checks that the user is a manager for the venue.
manager_props = db(db.user_properties.email == auth.user.email).select().first()
can_manage = c.id in util.get_list(manager_props.venues_can_manage)
if not can_manage:
session.flash = T('Not authorized!')
redirect(URL('default', 'index'))
# Prepares the submission.
db.submission.email.writable = db.submission.email.readable = True
db.submission.author.readable = db.submission.author.writable = False
db.submission.feedback.readable = db.submission.feedback.writable = False
db.submission.email.label = T('Author')
# Assigns default quality to the submission.
avg, stdev = ranker.get_init_average_stdev()
db.submission.quality.default = avg
db.submission.error.default = stdev
# Produces an identifier for the submission.
db.submission.identifier.default = util.get_random_id()
form = SQLFORM(db.submission, upload=URL('download_manager', args=[None]))
form.vars.venue_id = c.id
if request.vars.content != None and request.vars.content != '':
form.vars.original_filename = request.vars.content.filename
if form.process(onvalidation=manager_submit_validation).accepted:
# Fixes the author field of the submission.
db(db.submission.id == form.vars.id).update(author=form.vars.author)
# Adds the venue to the list of venues where the user submitted.
# TODO(luca): Enable users to delete submissions. But this is complicated; we need to
# delete also their quality information etc. For the moment, no deletion.
props = db(db.user_properties.email == form.vars.email).select().first()
if props == None:
venues_has_submitted = []
else:
venues_has_submitted = util.get_list(props.venues_has_submitted)
submitted_ids = util.id_list(venues_has_submitted)
submitted_ids = util.list_append_unique(submitted_ids, c.id)
if props == None:
db(db.user_properties.email == form.vars.email).update(venues_has_submitted = submitted_ids)
else:
props.update_record(venues_has_submitted = submitted_ids)
db.commit()
session.flash = T('The submission has been accepted.')
redirect(URL('ranking', 'view_venue', args=[c.id]))
return dict(form=form, venue=c)
def accept_review():
"""A user is accepting to do a review (notice that the GET is signed).
Picks a task and adds it to the set of tasks for the user."""
# Checks the permissions.
c = db.venue(request.args(0)) or redirect('default', 'index')
props = db(db.user_properties.user == get_user_email()).select(db.user_properties.venues_can_rate).first()
if props == None:
c_can_rate = []
else:
c_can_rate = util.get_list(props.venues_can_rate)
if not (c.rate_constraint == None or c.id in c_can_rate):
session.flash = T('You cannot rate this venue.')
redirect(URL('venues', 'rateopen_index'))
t = datetime.utcnow()
if not (c.is_active and c.is_approved and c.rate_open_date <= t and c.rate_close_date >= t):
session.flash = T('This venue is not open for rating.')
redirect(URL('venues', 'rateopen_index'))
# The user can rate the venue.
# Does the user have any pending reviewing tasks for the venue?
# TODO(luca): rewrite this in terms of completed flag.
num_open_tasks = db((db.task.user == get_user_email()) &
(db.task.venue_id == c.id) &
(db.task.is_completed == False)).count()
if num_open_tasks >= c.max_number_outstanding_reviews:
session.flash = T('You have too many reviews outstanding for this venue. '
'Complete some of them before accepting additional reviewing tasks.')
redirect(URL('rating', 'task_index'))
while True:
new_item = ranker.get_item(c.id, get_user_email(),
can_rank_own_submissions=c.can_rank_own_submissions)
if new_item == None:
session.flash = T('There are no additional items that can be reviewed.')
redirect(URL('venues', 'rateopen_index'))
# Checks that there are no other review tasks for the same user and submission id.
# This is a safety measure, to prevent bugs caused by get_item.
already_assigned = db((db.task.user == get_user_email()) & (db.task.submission_id == new_item)).count()
if already_assigned == 0:
break
logger.error("get_item tried to assign twice submission %r to user %r" % (new_item, get_user_email()))
# Creates a reviewing task.
# To name it, counts how many tasks the user has already for this venue.
num_tasks = db((db.task.venue_id == c.id) & (db.task.user == get_user_email())).count()
task_name = (c.name + ' ' + T('Submission') + ' ' + str(num_tasks + 1))[:STRING_FIELD_LENGTH]
task_name_id = keystore_write(task_name)
task_id = db.task.insert(submission_id = new_item, venue_id = c.id, submission_name = task_name_id)
# Increments the number of reviews for the item.
subm = db.submission(new_item)
if subm is not None:
if subm.n_assigned_reviews is None:
subm.n_assigned_reviews = 1
else:
subm.n_assigned_reviews = subm.n_assigned_reviews + 1
subm.update_record()
db.commit()
session.flash = T('A review has been added to your review assignments.')
redirect(URL('task_index', args=[task_id]))
def check_manager_eligibility(venue_id, user, reject_msg):
props = db(db.user_properties.user == user).select().first()
if props == None:
session.flash = T(reject_msg)
redirect(URL('default', 'index'))
managed_venues_list = util.get_list(props.venues_can_manage)
if venue_id not in managed_venues_list:
session.flash = T(regect_msg)
redirect(URL('default', 'index'))
def check_manager_eligibility(venue_id, user_id, reject_msg):
props = db(db.user_properties.email == user_id).select().first()
if props == None:
session.flash = T(reject_msg)
redirect(URL('default', 'index'))
managed_venues_list = util.get_list(props.venues_can_manage)
if venue_id not in managed_venues_list:
session.flash = T(regect_msg)
redirect(URL('default', 'index'))
def index():
"""Index of user list one can manage or use."""
# Reads the list of ids of lists managed by the user.
list_ids_l = db(db.user_properties.user == get_user_email()).select(
db.user_properties.managed_user_lists).first()
if list_ids_l == None:
list_ids = []
else:
list_ids = util.get_list(list_ids_l.managed_user_lists)
# Keeps track of old managers, if this is an update.
if len(request.args) > 2 and request.args[-3] == 'edit':
ul = db.user_list[request.args[-1]]
old_managers = ul.managers
old_members = ul.user_list
else:
old_managers = []
old_members = []
# Adds a few comments.
if len(request.args) > 0 and (request.args[0] == 'edit'
or request.args[0] == 'new'):
db.user_list.name.comment = T('Name of user list')
db.user_list.managers.comment = T(
'Email addresses of users who can manage the list')
db.user_list.user_list.comment = T(
'Email addresses of list members. '
' You can enter multiple addresses per line, separated by a mix of spaces and commas.'
)
# Forms the query.
if len(list_ids) == 0:
q = (db.user_list.id == -1)
else:
q = (db.user_list.id.belongs(list_ids))
# Fixes the query for admins.
if is_user_admin():
q = db.user_list
# Deals with search parameter
if request.vars.id and request.vars.id != '':
try:
id = int(request.vars.id)
except ValueError:
id = None
if id != None and id in list_ids:
q = (db.user_list.id == id)
grid = SQLFORM.grid(
q,
field_id=db.user_list.id,
csv=False,
details=True,
deletable=is_user_admin(),
oncreate=create_user_list,
onvalidation=validate_user_list,
onupdate=update_user_list(old_managers, old_members),
ondelete=delete_user_list,
)
db.commit()
return dict(grid=grid)
def assign_reviewers():
c = db.venue(request.args(0)) or redirect('default', 'index')
props = db(db.user_properties.email == auth.user.email).select().first()
if props == None:
session.flash = T('You cannot assign reviewers to this venue.')
redirect(URL('default', 'index'))
if not access.can_manage(c, props):
session.flash = T('You cannot assign reviewers to this venue.')
redirect(URL('default', 'index'))
# These are the users that can be called upon reviewing the submissions.
managed_user_lists = util.get_list(props.managed_user_lists)
# Constrains the user lists to those managed by the user.
list_q = (db.user_list.id.belongs(managed_user_lists))
# The default is the list of users that can review the venue.
if c.rate_constraint is None:
form = SQLFORM.factory(
Field('users', requires = IS_IN_DB(db(list_q), 'user_list.id', '%(name)s')),
Field('number_of_reviews_per_user', 'integer'),
Field('incremental', 'boolean'),
)
else:
form = SQLFORM.factory(
Field('users', default = c.rate_constraint,
requires = IS_IN_DB(db(list_q), 'user_list.id', '%(name)s')),
Field('number_of_reviews_per_user', 'integer'),
Field('incremental', 'boolean'),
)
if form.process().accepted:
if (util.is_none(form.vars.users) or form.vars.number_of_reviews_per_user == 0
or (form.vars.number_of_reviews_per_user < 0 and not form.vars.incremental)):
session.flash = T('No reviewing duties added.')
redirect(URL('venues', 'managed_index'))
n = c.number_of_submissions_per_reviewer
c.update_record(number_of_submissions_per_reviewer = n + form.vars.number_of_reviews_per_user)
# TODO(luca): this should be implemented in terms of a job queue
user_list = db.user_list(form.vars.users)
for m in user_list.email_list:
current_asgn = db((db.reviewing_duties.user_email == m) &
(db.reviewing_duties.venue_id == c.id)).select().first()
if current_asgn == None:
# Creates a new one.
db.reviewing_duties.insert(user_email = m, venue_id = c.id,
num_reviews = form.vars.number_of_reviews_per_user)
else:
# Update an existing one
if form.vars.incremental:
new_number = max(0, current_asgn.num_reviews + form.vars.number_of_reviews_per_user)
else:
new_number = form.vars.number_of_reviews_per_user
current_asgn.update_record(num_reviews = new_number)
db.commit()
session.flash = T('The reviewing duties have been assigned.')
redirect(URL('venues', 'managed_index'))
venue_form = SQLFORM(db.venue, record=c, readonly=True)
return dict(venue=c, form=form, vform=venue_form)
def get_item(self, id):
posts = self.source.get_activities(activity_id=id, user_id=self.source.key.id())
post = posts[0] if posts else None
if not post:
return None
originals, mentions = original_post_discovery.discover(self.source, post, fetch_hfeed=False)
obj = post["object"]
obj["upstreamDuplicates"] = list(set(util.get_list(obj, "upstreamDuplicates")) | originals)
self.merge_urls(obj, "tags", mentions, object_type="mention")
return obj
def get_dict_subm_id_to_idx(compar_rows):
items_from_orderings = set()
for r in compar_rows:
ordering = util.get_list(r.ordering)
m = len(ordering)
if m >= 2:
items_from_orderings.update(set(ordering))
subm_id_list = list(items_from_orderings)
subm_id_to_idx = dict(
(subm_id_list[idx], idx) for idx in xrange(len(subm_id_list)))
return subm_id_to_idx
def add_user_list_managers(id, managers):
for m in managers:
u = db(db.user_properties.user == m).select(db.user_properties.managed_user_lists).first()
if u == None:
# We never heard of this user, but we still create the permission.
logger.debug("Creating user properties for user:"******"<")
db.user_properties.insert(user=m, managed_user_lists=[id])
else:
l = util.get_list(u.managed_user_lists)
l = util.list_append_unique(l, id)
db(db.user_properties.user == m).update(managed_user_lists = l)
def observed_index():
props = db(db.user_properties.user == auth.user.email).select().first()
if props == None:
l = []
else:
l = util.id_list(util.get_list(props.venues_can_observe))
l1 = util.id_list(util.get_list(props.venues_can_manage))
for el in l1:
if el not in l:
l.append(l)
if len(l) > 0:
q = (db.venue.id.belongs(l))
else:
q = (db.venue.id == -1)
grid = SQLFORM.grid(q,
field_id=db.venue.id,
fields=[db.venue.name, db.venue.close_date, db.venue.rate_close_date],
csv=False, details=False, create=False, editable=False, deletable=False,
)
return dict(grid=grid)
def add_user_list_managers(id, managers):
for m in managers:
u = db(db.user_properties.user == m).select(
db.user_properties.managed_user_lists).first()
if u == None:
# We never heard of this user, but we still create the permission.
logger.debug("Creating user properties for user:"******"<")
db.user_properties.insert(user=m, managed_user_lists=[id])
else:
l = util.get_list(u.managed_user_lists)
l = util.list_append_unique(l, id)
db(db.user_properties.user == m).update(managed_user_lists=l)
def add_venue_to_user_rate(venue_id, users):
"""Add the given users to those that can rate venue_id."""
for m in users:
u = db(db.user_properties.user == m).select(db.user_properties.venues_can_rate).first()
if u == None:
# We never heard of this user, but we still create the permission.
logger.debug("Creating user properties for user:"******"<")
db.user_properties.insert(user=m, venues_can_rate = [venue_id])
else:
l = util.get_list(u.venues_can_rate)
l = util.list_append_unique(l, venue_id)
db(db.user_properties.user == m).update(venues_can_rate = l)
def delete_venue_from_user_rate(venue_id, users):
"""Delete the users from those that can rate venue_id."""
for m in users:
u = db(db.user_properties.user == m).select(db.user_properties.venues_can_rate).first()
if u == None:
# We never heard of this user, but we still create the permission.
logger.debug("Creating user properties for user:"******"<")
db.user_properties.insert(user=m, venues_can_rate = [])
else:
l = util.get_list(u.venues_can_rate)
l = util.list_remove(l, venue_id)
db(db.user_properties.user == m).update(venues_can_rate = l)
def add_venue_to_user_rate(venue_id, users):
"""Add the given users to those that can rate venue_id."""
for m in users:
u = db(db.user_properties.user == m).select(
db.user_properties.venues_can_rate).first()
if u == None:
# We never heard of this user, but we still create the permission.
logger.debug("Creating user properties for user:"******"<")
db.user_properties.insert(user=m, venues_can_rate=[venue_id])
else:
l = util.get_list(u.venues_can_rate)
l = util.list_append_unique(l, venue_id)
db(db.user_properties.user == m).update(venues_can_rate=l)
def get_item(self, id):
posts = self.source.get_activities(activity_id=id, user_id=self.source.key_id())
if not posts:
return None
post = posts[0]
originals, mentions = original_post_discovery.discover(
self.source, post, fetch_hfeed=False)
obj = post['object']
obj['upstreamDuplicates'] = list(
set(util.get_list(obj, 'upstreamDuplicates')) | originals)
self.merge_urls(obj, 'tags', mentions, object_type='mention')
return obj
def delete_venue_from_user_rate(venue_id, users):
"""Delete the users from those that can rate venue_id."""
for m in users:
u = db(db.user_properties.user == m).select(
db.user_properties.venues_can_rate).first()
if u == None:
# We never heard of this user, but we still create the permission.
logger.debug("Creating user properties for user:"******"<")
db.user_properties.insert(user=m, venues_can_rate=[])
else:
l = util.get_list(u.venues_can_rate)
l = util.list_remove(l, venue_id)
db(db.user_properties.user == m).update(venues_can_rate=l)
def download_manager():
# The user must be the manager of the venue where the submission occurred.
subm = db.submission(request.args(0)) or redirect(URL('default', 'index'))
# Gets the venue.
c = db.venue(subm.venue_id)
if c is None:
session.flash = T('Not authorized.')
redirect(URL('default', 'index'))
managers = util.get_list(c.managers)
if auth.user.email not in managers:
session.flash = T('Not authorized.')
redirect(URL('default', 'index'))
return my_download(subm.original_filename, subm_content=subm.content)
def edit_ordering():
""" Edit last ordering."""
# Gets the information on the venue and comparison.
venue = db.venue(request.args(0)) or redirect(URL('default', 'index'))
last_comparison = db.comparison(request.args(1)) or redirect(
URL('default', 'index'))
if last_comparison.user != auth.user.email:
session.flash = T('Invalid request.')
redirect(URL('default', 'index'))
# Check that the venue rating deadline is currently open, or that the ranker
# is a manager or observer.
if ((auth.user.email not in util.get_list(venue.managers))
and (auth.user.email not in util.get_list(venue.observers))
and (datetime.utcnow() < venue.rate_open_date
or datetime.utcnow() > venue.rate_close_date)):
session.flash = T('The review deadline for this venue is closed.')
redirect(URL('venues', 'view_venue', args=[venue.id]))
# Ok, the task belongs to the user.
# Gets the last reviewing task done for the same venue.
if last_comparison == None:
last_ordering = []
subm_id_to_nickname_str = None
else:
last_ordering = util.get_list(last_comparison.ordering)
subm_id_to_nickname_str = last_ordering.subm_id_to_nickname_str
# Finds the grades that were given for the submissions previously reviewed.
if last_comparison == None or last_comparison.grades == None:
str_grades = {}
else:
try:
str_grades = simplejson.loads(last_comparison.grades)
except Exception, e:
str_grades = {}
logger.warning("Grades cannot be read: " +
str(last_comparison.grades))
def review():
"""Enters the review, and comparisons, for a particular task.
This function is only used to enter NEW reviews."""
# Here is where the comparisons are entered.
t = db.task(request.args(0)) or redirect(URL('default', 'index'))
if t.user != auth.user.email:
session.flash = T('Invalid request.')
redirect(URL('default', 'index'))
# Check that the venue rating deadline is currently open, or that the ranker
# is a manager or observer.
venue = db.venue(t.venue_id)
if ((auth.user.email not in util.get_list(venue.managers))
and (auth.user.email not in util.get_list(venue.observers))
and (datetime.utcnow() < venue.rate_open_date
or datetime.utcnow() > venue.rate_close_date)):
session.flash = T('The review deadline for this venue is closed.')
redirect(URL('venues', 'view_venue', args=[venue.id]))
# Ok, the task belongs to the user.
# Gets the last reviewing task done for the same venue.
last_comparison = db((db.comparison.user == auth.user.email)
& (db.comparison.venue_id == t.venue_id)).select(
orderby=~db.comparison.date).first()
if last_comparison == None:
last_ordering = []
subm_id_to_nickname = {}
else:
last_ordering = util.get_list(last_comparison.ordering)
try:
subm_id_to_nickname = simplejson.loads(
last_comparison.submission_nicknames)
except Exception, e:
logger.warning("Failed to decode submission_nicknames: " +
str(last_comparison.submission_nicknames))
subm_id_to_nickname = {}
