def _add_hateoas_links(self, item):
obj = item.dictize()
related = request.args.get('related')
if related:
if item.__class__.__name__ == 'Task':
obj['task_runs'] = []
obj['result'] = None
task_runs = task_repo.filter_task_runs_by(task_id=item.id)
results = result_repo.filter_by(task_id=item.id,
last_version=True)
for tr in task_runs:
obj['task_runs'].append(tr.dictize())
for r in results:
obj['result'] = r.dictize()
if item.__class__.__name__ == 'TaskRun':
tasks = task_repo.filter_tasks_by(id=item.task_id)
results = result_repo.filter_by(task_id=item.task_id,
last_version=True)
obj['task'] = None
obj['result'] = None
for t in tasks:
obj['task'] = t.dictize()
for r in results:
obj['result'] = r.dictize()
if item.__class__.__name__ == 'Result':
tasks = task_repo.filter_tasks_by(id=item.task_id)
task_runs = task_repo.filter_task_runs_by(task_id=item.task_id)
obj['task_runs'] = []
for t in tasks:
obj['task'] = t.dictize()
for tr in task_runs:
obj['task_runs'].append(tr.dictize())
stats = request.args.get('stats')
if stats:
if item.__class__.__name__ == 'Project':
stats = project_stats_repo.filter_by(project_id=item.id,
limit=1)
obj['stats'] = stats[0].dictize() if stats else {}
links, link = self.hateoas.create_links(item)
if links:
obj['links'] = links
if link:
obj['link'] = link
return obj
def anonymize_ips():
"""Anonymize all the IPs of the server."""
from pybossa.core import anonymizer, task_repo
taskruns = task_repo.filter_task_runs_by(user_id=None)
for tr in taskruns:
print "Working on taskrun %s" % tr.id
print "From %s to %s" % (tr.user_ip, anonymizer.ip(tr.user_ip))
tr.user_ip = anonymizer.ip(tr.user_ip)
task_repo.update(tr)
def anonymize_ips():
"""Anonymize all the IPs of the server."""
from pybossa.core import anonymizer, task_repo
taskruns = task_repo.filter_task_runs_by(user_id=None)
for tr in taskruns:
print "Working on taskrun %s" % tr.id
print "From %s to %s" % (tr.user_ip, anonymizer.ip(tr.user_ip))
tr.user_ip = anonymizer.ip(tr.user_ip)
task_repo.update(tr)
def _add_hateoas_links(self, item):
obj = item.dictize()
related = request.args.get('related')
if related:
if item.__class__.__name__ == 'Task':
obj['task_runs'] = []
obj['result'] = None
task_runs = task_repo.filter_task_runs_by(task_id=item.id)
results = result_repo.filter_by(task_id=item.id, last_version=True)
for tr in task_runs:
obj['task_runs'].append(tr.dictize())
for r in results:
obj['result'] = r.dictize()
if item.__class__.__name__ == 'TaskRun':
tasks = task_repo.filter_tasks_by(id=item.task_id)
results = result_repo.filter_by(task_id=item.task_id, last_version=True)
obj['task'] = None
obj['result'] = None
for t in tasks:
obj['task'] = t.dictize()
for r in results:
obj['result'] = r.dictize()
if item.__class__.__name__ == 'Result':
tasks = task_repo.filter_tasks_by(id=item.task_id)
task_runs = task_repo.filter_task_runs_by(task_id=item.task_id)
obj['task_runs'] = []
for t in tasks:
obj['task'] = t.dictize()
for tr in task_runs:
obj['task_runs'].append(tr.dictize())
links, link = self.hateoas.create_links(item)
if links:
obj['links'] = links
if link:
obj['link'] = link
return obj
def export_userdata(user_id, **kwargs):
from pybossa.core import user_repo, project_repo, task_repo, result_repo
from flask import current_app, url_for
json_exporter = JsonExporter()
user = user_repo.get(user_id)
user_data = user.dictize()
del user_data['passwd_hash']
projects = project_repo.filter_by(owner_id=user.id)
projects_data = [project.dictize() for project in projects]
taskruns = task_repo.filter_task_runs_by(user_id=user.id)
taskruns_data = [tr.dictize() for tr in taskruns]
pdf = json_exporter._make_zip(None, '', 'personal_data', user_data, user_id,
'personal_data.zip')
upf = json_exporter._make_zip(None, '', 'user_projects', projects_data, user_id,
'user_projects.zip')
ucf = json_exporter._make_zip(None, '', 'user_contributions', taskruns_data, user_id,
'user_contributions.zip')
upload_method = current_app.config.get('UPLOAD_METHOD')
if upload_method == 'local':
upload_method = 'uploads.uploaded_file'
personal_data_link = url_for(upload_method,
filename="user_%s/%s" % (user_id, pdf))
personal_projects_link = url_for(upload_method,
filename="user_%s/%s" % (user_id,
upf))
personal_contributions_link = url_for(upload_method,
filename="user_%s/%s" % (user_id,
ucf))
body = render_template('/account/email/exportdata.md',
user=user.dictize(),
personal_data_link=personal_data_link,
personal_projects_link=personal_projects_link,
personal_contributions_link=personal_contributions_link,
config=current_app.config)
html = render_template('/account/email/exportdata.html',
user=user.dictize(),
personal_data_link=personal_data_link,
personal_projects_link=personal_projects_link,
personal_contributions_link=personal_contributions_link,
config=current_app.config)
subject = 'Your personal data'
mail_dict = dict(recipients=[user.email_addr],
subject=subject,
body=body,
html=html)
send_mail(mail_dict)
def test_external_uid_02_gets_different_tasks_limits(self):
""" Test SCHED newtask returns N different list of Tasks
for a external User ID."""
assigned_tasks = []
# Get a Task until scheduler returns None
project = ProjectFactory.create(info=dict(sched='depth_first_all'))
tasks = TaskFactory.create_batch(10, project=project, info={})
headers = self.get_headers_jwt(project)
url = 'api/project/%s/newtask?limit=5&external_uid=%s' % (project.id, '1xa')
res = self.app.get(url, headers=headers)
data = json.loads(res.data)
while len(data) > 0 :
# Save the assigned task
for t in data:
assigned_tasks.append(t)
task = db.session.query(Task).get(t['id'])
# Submit an Answer for the assigned task
tr = ExternalUidTaskRunFactory.create(project=project, task=task)
res = self.app.get(url, headers=headers)
data = json.loads(res.data)
# Check if we received the same number of tasks that the available ones
assert len(assigned_tasks) == len(tasks), len(assigned_tasks)
# Check if all the assigned Task.id are equal to the available ones
err_msg = "Assigned Task not found in DB Tasks"
for at in assigned_tasks:
assert self.is_task(at['id'], tasks), err_msg
# Check that there are no duplicated tasks
err_msg = "One Assigned Task is duplicated"
for at in assigned_tasks:
assert self.is_unique(at['id'], assigned_tasks), err_msg
# Check that there are task runs saved with the external UID
answers = task_repo.filter_task_runs_by(external_uid='1xa')
print answers
err_msg = "There should be the same amount of task_runs than tasks"
assert len(answers) == len(assigned_tasks), err_msg
assigned_tasks_ids = sorted([at['id'] for at in assigned_tasks])
task_run_ids = sorted([a.task_id for a in answers])
err_msg = "There should be an answer for each assigned task"
assert assigned_tasks_ids == task_run_ids, err_msg
def _guidelines_updated(project_id, user_id):
"""Function to determine if guidelines has been
updated since last submission"""
query_attrs_log = dict(project_id=project_id,
attribute='task_guidelines',
desc=True)
query_attrs_task_run = dict(project_id=project_id, user_id=user_id)
guidelines_log = auditlog_repo.filter_by(limit=1, **query_attrs_log)
last_guidelines_update = dateutil.parser.parse(
guidelines_log[0].created) if guidelines_log else None
task_runs = task_repo.filter_task_runs_by(limit=1,
desc=True,
**query_attrs_task_run)
last_task_run_time = dateutil.parser.parse(
task_runs[0].created) if task_runs else None
return last_task_run_time < last_guidelines_update if last_task_run_time and last_guidelines_update else False
def visualize(short_name, task_id):
"""Return a file with all the TaskRuns for a given Task"""
# Check if it a supported geotagx project whose schema we know
if 'GEOTAGX_SUPPORTED_PROJECTS_SCHEMA' in current_app.config.keys() \
and short_name in current_app.config['GEOTAGX_SUPPORTED_PROJECTS_SCHEMA'].keys():
# Check if the project exists
(project, owner, n_tasks, n_task_runs,
overall_progress, last_activity) = projects_view.project_by_shortname(short_name)
ensure_authorized_to('read', project)
redirect_to_password = projects_view._check_if_redirect_to_password(project)
if redirect_to_password:
return redirect_to_password
# Check if the task belongs to the project and exists
task = task_repo.get_task_by(project_id=project.id, id=task_id)
if task:
taskruns = task_repo.filter_task_runs_by(task_id=task_id, project_id=project.id)
results = [tr.dictize() for tr in taskruns]
return render_template('geotagx/projects/task_runs_visualize.html',
project=project,
owner=owner,
n_tasks=n_tasks,
n_task_runs=n_task_runs,
overall_progress=overall_progress,
last_activity=last_activity,
n_completed_tasks=cached_projects.n_completed_tasks(project.id),
n_volunteers=cached_projects.n_volunteers(project.id),
task_info = task.info,
task_runs_json = results,
geotagx_project_template_schema = \
current_app.config['GEOTAGX_SUPPORTED_PROJECTS_SCHEMA'][short_name])
else:
return abort(404)
else:
return abort(404)
