def resolve_conflicts(pid):
user = current_user
assignment_id = pid + '-' + user.username
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 project_detail(pid):
user = current_user
project = storage_model.get_project_by_pid(mongo=mongo, pid=pid)
if not project:
return page_not_found('page_not_found')
if project['owner'] != user.username:
return forbidden()
assignee_stat = project['assignee_stat']
pair_idx, total_pairs = 0, 0
for assignee in assignee_stat:
pair_idx += int(assignee['pair_idx'])
total_pairs += int(assignee['total_pairs'])
assignee_progress = int(assignee['pair_idx']) / int(
assignee['total_pairs'])
assignee_progress = round(100 * assignee_progress, 2)
assignee['progress'] = assignee_progress
progress = float(pair_idx) / total_pairs
progress = round(100 * progress, 2)
if progress > 100:
progress = 100
project['progress'] = progress
indices = storage_model.detect_result_conflicts(mongo, pid)
if len(indices) > 0:
project['conflicts'] = 1
else:
project['conflicts'] = 0
data = {'project': project}
return render_template('project_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 create_resolve_conflict_project(pid):
project = storage_model.get_project_by_pid(mongo, pid)
owner = project['owner']
assignment_id = pid + '-' + owner
# get pair_num of conflicts
conflict_indices = storage_model.detect_result_conflicts(mongo, pid)
# get block information of the project
project = storage_model.get_project_by_pid(mongo=mongo, pid=pid)
# arrange conflict pairs by block
block_id = project['block_id']
# arrange pairs by block id
conflicts = list()
for block in block_id:
cur_block = list()
for idx in conflict_indices:
if idx in block:
cur_block.append(idx)
if cur_block:
conflicts.append(cur_block)
# simulate open cells for those opened by assignees
pair_datafile = storage_model.get_pair_datafile_by_owner(mongo=mongo,
owner=owner,
pid=pid)
working_data = dm.DataPairList(
data_pairs=dl.load_data_from_csv(pair_datafile),
indices=conflict_indices)
project_pairfile = storage_model.get_project_pair_datafile(mongo=mongo,
user=owner,
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)
KAPR_key = assignment_id + '_KAPR'
r.set(KAPR_key, 0.0)
ids_list = working_data.get_ids()
ids = list(zip(ids_list[0::2], ids_list[1::2]))
data_mode_list = storage_model.get_conflict_data_mode(
pid, ids, mongo, r, assignment_id)
dm.batched_open_cell(assignment_id,
full_data,
working_data,
ids,
data_mode_list,
r,
kapr_limit=100)
KAPR_key = assignment_id + '_KAPR'
current_kapr = r.get(KAPR_key)
result_path = os.path.join(
config.DATA_DIR, 'internal', project['owner'] + '_' +
project['project_name'] + '_conflict_result.csv')
# create result file
f = open(result_path, 'w+')
f.close()
isfull = storage_model.has_full_assignee(mongo, pid)
conflict_project = {
'pid': pid,
'project_name': project['project_name'],
'pair_num': conflicts,
'current_page': 0,
'page_size': len(conflicts),
'kapr_limit': 100,
'current_kapr': current_kapr,
'pair_idx': 0,
'total_pairs': len(conflict_indices),
'result_path': result_path,
'isfull': isfull,
}
storage_model.save_conflict_project(mongo, conflict_project)
return 'block_id'