def assignment_detail(pid):
user = current_user
assignment = storage_model.get_assignment(mongo=mongo,
username=user.username,
pid=pid)
if not assignment:
return page_not_found('page_not_found')
assignee_stat = assignment['assignee_stat']
for assignee in assignee_stat:
if assignee['assignee'] == user.username:
pair_idx = int(assignee['pair_idx'])
total_pairs = int(assignee['total_pairs'])
progress = float(pair_idx) / total_pairs
progress = round(100 * progress, 2)
if progress > 100:
progress = 100
kapr = round(100 * float(assignee['current_kapr']), 1)
break
assignment['progress'] = progress
assignment['budget'] = kapr
data = {'assignment': assignment}
return render_template('assignment_detail.html', data=data)
def record_linkage_next(pid):
"""
update page number to db
update kapr to db
flush related cache in redis
"""
user = current_user
assignment_id = pid + '-' + user.username
# find if this project exist
project = storage_model.get_assignment(mongo=mongo,
username=user.username,
pid=pid)
if not project:
return page_not_found('page_not_found')
# increase page number to db
storage_model.increase_assignment_page(mongo=mongo,
username=user.username,
pid=pid)
# increase pair index to db
storage_model.increase_pair_idx(mongo=mongo,
pid=pid,
username=user.username)
# update kapr to db
KAPR_key = assignment_id + '_KAPR'
kapr = r.get(KAPR_key)
storage_model.update_kapr(mongo=mongo,
username=user.username,
pid=pid,
kapr=kapr)
# flush related cache in redis
# dont flush yet, because resolve conflicts need these data
# TODO: flush these data when resolve conflict finished
# storage_model.clear_working_page_cache(assignment_id, r)
# check if the project is completed
completed = storage_model.is_project_completed(mongo=mongo, pid=pid)
if completed:
storage_model.combine_result(mongo, pid)
# don't update the result yet, because we use ajax to write result, the result might not been updated
# if there are conflicts, the result is updated after the resolve_conflict
indices = storage_model.detect_result_conflicts(mongo, pid)
if len(indices) == 0:
storage_model.update_result(mongo=mongo, pid=pid)
else:
create_resolve_conflict_project(pid)
flask.flash('You have completed the project.', 'alert-success')
return redirect(url_for('project'))
return redirect(url_for('record_linkage', pid=pid))
def resolve_conflicts(pid):
user = current_user
assignment_id = pid + '-' + user.username
# find if this project exist
project = storage_model.get_assignment(mongo=mongo,
username=user.username,
pid=pid)
if not project:
return page_not_found('page_not_found')
indices = storage_model.detect_result_conflicts(mongo, pid)
pair_datafile = storage_model.get_pair_datafile(mongo=mongo,
user=user,
pid=pid)
working_data = dm.DataPairList(
data_pairs=dl.load_data_from_csv(pair_datafile), indices=indices)
icons = working_data.get_icons()
ids_list = working_data.get_ids()
ids = list(zip(ids_list[0::2], ids_list[1::2]))
pairs_formatted = working_data.get_data_display('full')
data = list(zip(pairs_formatted[0::2], pairs_formatted[1::2]))
ret_data = {
'data': data,
'icons': icons,
'ids': ids,
'title': project['project_name'],
'this_url': '/record_linkage/' + pid,
'next_url': '/project/' + pid,
'pid': pid,
'data_size': len(data),
}
return render_template('resolve_conflicts.html', data=ret_data)
def record_linkage(pid):
user = current_user
# find if this project exist
project = storage_model.get_assignment(mongo=mongo,
username=user.username,
pid=pid)
if not project:
return page_not_found('page_not_found')
# username and project_id can identify an assignment
assignment_id = pid + '-' + user.username
# get assignment status
assignment_status = storage_model.get_assignment_status(
mongo=mongo, username=user.username, pid=pid)
current_page = assignment_status['current_page']
page_size = assignment_status['page_size']
kapr_limit = assignment_status['kapr_limit']
current_kapr = assignment_status['current_kapr']
display_mode = assignment_status['display_mode']
isfull = False
if 'isfull' in assignment_status:
isfull = assignment_status['isfull']
if isfull == 'true':
default_mode = 'B'
else:
default_mode = 'M'
if current_page >= page_size:
flask.flash('You have completed the project.', 'alert-success')
return redirect(url_for('project'))
# get working data and full data
pair_datafile = storage_model.get_pair_datafile(mongo=mongo,
user=user,
pid=pid)
indices, pair_idx = storage_model.get_current_block(mongo=mongo,
pid=pid,
assignee=user.username)
working_data = dm.DataPairList(
data_pairs=dl.load_data_from_csv(pair_datafile), indices=indices)
project_pairfile = storage_model.get_project_pair_datafile(
mongo=mongo, user=user.username, pid=pid)
full_project_pairs = storage_model.get_total_pairs_from_pairfile(
project_pairfile)
working_data.set_kapr_size(full_project_pairs)
full_data = dl.load_data_from_csv(project_pairfile)
# prepare return data
icons = working_data.get_icons()
#print(icons)
ids_list = working_data.get_ids()
ids = list(zip(ids_list[0::2], ids_list[1::2]))
data_mode = display_mode.lower()
data_mode_list = storage_model.get_data_mode(assignment_id,
ids,
r=r,
data_mode=data_mode,
default_mode=default_mode)
pairs_formatted = working_data.get_data_display(data_mode, data_mode_list)
data = list(zip(pairs_formatted[0::2], pairs_formatted[1::2]))
pair_ids = indices
record_ids = storage_model.get_record_id_by_pair_id(mongo, pid, indices)
# get the delta information
delta = list()
for i in range(working_data.size()):
data_pair = working_data.get_data_pair_by_index(i)
if data_pair is None:
break
delta += dm.KAPR_delta(full_data, data_pair, 11 * ['M'],
len(full_data))
# prepare cache data for ajax query
r.set(user.username + '_working_pid', pid)
r.set(user.username + '_working_pid_rc', 0)
KAPR_key = assignment_id + '_KAPR'
r.set(KAPR_key, float(current_kapr))
# get saved working answers
answers = storage_model.get_working_answers(assignment_id, r)
ret_data = {
'data': data,
'data_mode_list': data_mode_list,
'icons': icons,
'ids': ids,
'record_ids': record_ids,
'pair_ids': pair_ids,
'title': project['project_name'],
'kapr': round(100 * float(current_kapr), 1),
'kapr_limit': float(kapr_limit),
'page_number': current_page + 1,
'page_size': page_size,
'pair_num_base': pair_idx + 1,
'delta': delta,
'this_url': '/record_linkage/' + pid,
'saved_answers': answers,
'data_size': len(data),
'isfull': isfull,
}
return render_template('record_linkage_ppirl.html', data=ret_data)