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 create_webhooks(projectId):
"""Create webhooks for a given project ID."""
from pybossa.core import project_repo, task_repo, result_repo
from pybossa.model.webhook import Webhook
project = project_repo.get(projectId)
tasks = task_repo.filter_tasks_by(state='completed',
project_id=projectId)
print "Analyzing %s tasks" % len(tasks)
for task in tasks:
sql = text(
'''select * from webhook where project_id=:project_id and payload@>'{"task_id": :task_id}';''')
results = db.engine.execute(
sql, project_id=project.id, task_id=task.id)
webhook = None
for result in results:
webhook = result
if not webhook:
result = result_repo.get_by(project_id=project.id, task_id=task.id)
payload = dict(
fired_at=None,
project_short_name=project.short_name,
project_id=project.id,
task_id=task.id,
result_id=result.id,
event='task_completed')
wh = Webhook(project_id=projectId,
payload=payload)
print(wh)
db.session.add(wh)
db.session.commit()
print "Project %s completed!" % project.short_name
def get(self, oid):
"""Get all completed tasks. Need admin access"""
try:
if not (current_user.is_authenticated() and current_user.admin):
raise Unauthorized("Insufficient privilege to the request")
# set filter from args
# add 'state'='completed' if missing
filters = {}
filters['state'] = 'completed'
for k in request.args.keys():
if k not in ['limit', 'offset', 'api_key']:
# 'exported' column belongs to Task class
# ignore it for attr check in TaskRun class
# but add it to filter so that its checked
# against Task class in filter_completed_task_runs_by
if k not in ['exported']:
# Raise an error if the k arg is not a column
getattr(self.__class__, k)
filters[k] = request.args[k]
# set limit, offset
limit, offset, orderby = self._set_limit_and_offset()
# query database to obtain the requested data
query = task_repo.filter_tasks_by(limit=limit,
offset=offset,
**filters)
json_response = self._create_json_response(query, oid)
return Response(json_response, mimetype='application/json')
except Exception as e:
return error.format_exception(
e, target=self.__class__.__name__.lower(), action='GET')
def test_breadth_complete(self):
"""Test breadth respects complete."""
db.session.rollback()
admin = UserFactory.create(id=500)
owner = UserFactory.create(id=501)
user = UserFactory.create(id=502)
project = ProjectFactory(owner=owner, info=dict(sched='depth_first'), category_id=1)
tasks = TaskFactory.create_batch(3, project=project, n_answers=1)
url = '/api/project/%s/newtask' % (project.id)
self.register()
self.signin()
self.set_proj_passwd_cookie(project, username='******')
res = self.app.get(url)
task_one = json.loads(res.data)
taskrun = dict(project_id=project.id, task_id=task_one['id'], info=1)
res = self.app.post('api/taskrun', data=json.dumps(taskrun))
taskrun = json.loads(res.data)
assert res.status_code == 200, res.data
#TaskRunFactory.create(task_id=task_one['id'])
url = '/api/project/%s/newtask' % (project.id)
res = self.app.get(url)
task_two = json.loads(res.data)
taskrun = dict(project_id=project.id, task_id=task_two['id'], info=2)
res = self.app.post('api/taskrun', data=json.dumps(taskrun))
taskrun = json.loads(res.data)
assert res.status_code == 200, res.data
#TaskRunFactory.create(task_id=task_two['id'])
url = '/api/project/%s/newtask?api_key=%s' % (project.id, owner.api_key)
res = self.app.get(url)
task_three = json.loads(res.data)
assert task_one['id'] != task_three['id'], (task_one, task_two, task_three)
assert task_two['id'] != task_three['id'], (task_one, task_two, task_three)
taskrun = dict(project_id=project.id, task_id=task_three['id'], info=3)
res = self.app.post('api/taskrun?api_key=%s' % owner.api_key, data=json.dumps(taskrun))
taskrun = json.loads(res.data)
assert res.status_code == 200, res.data
tasks = task_repo.filter_tasks_by(project_id=project.id)
for t in tasks:
assert t.state == 'completed'
url = '/api/project/%s/newtask' % (project.id)
res = self.app.get(url)
task_four = json.loads(res.data)
assert task_four == {}, task_four
url = '/api/project/%s/newtask?api_key=%s' % (project.id, owner.api_key)
res = self.app.get(url)
task_four = json.loads(res.data)
assert task_four == {}, task_four
url = '/api/project/%s/newtask?api_key=%s' % (project.id, admin.api_key)
res = self.app.get(url)
task_four = json.loads(res.data)
assert task_four == {}, task_four
def clean_project(project_id, skip_tasks=False):
"""Remove everything from a project."""
from pybossa.core import task_repo
from pybossa.model import make_timestamp
n_tasks = 0
if not skip_tasks:
print "Deleting tasks"
sql = 'delete from task where project_id=%s' % project_id
db.engine.execute(sql)
else:
sql = 'select count(id) as n from task where project_id=%s' % project_id
result = db.engine.execute(sql)
for row in result:
n_tasks = row.n
sql = 'delete from task_run where project_id=%s' % project_id
db.engine.execute(sql)
sql = 'delete from result where project_id=%s' % project_id
db.engine.execute(sql)
sql = 'delete from counter where project_id=%s' % project_id
db.engine.execute(sql)
sql = 'delete from project_stats where project_id=%s' % project_id
db.engine.execute(sql)
sql = """INSERT INTO project_stats
(project_id, n_tasks, n_task_runs, n_results, n_volunteers,
n_completed_tasks, overall_progress, average_time,
n_blogposts, last_activity, info)
VALUES (%s, %s, 0, 0, 0, 0, 0, 0, 0, 0, '{}');""" % (project_id,
n_tasks)
db.engine.execute(sql)
if skip_tasks:
tasks = task_repo.filter_tasks_by(project_id=project_id, limit=100)
last_id = tasks[len(tasks) - 1].id
while (len(tasks) > 0):
for task in tasks:
sql = (
"insert into counter(created, project_id, task_id, n_task_runs) \
VALUES (TIMESTAMP '%s', %s, %s, 0)" %
(make_timestamp(), project_id, task.id))
db.engine.execute(sql)
tasks = task_repo.filter_tasks_by(project_id=project_id,
limit=100,
last_id=last_id)
if (len(tasks) > 0):
last_id = tasks[len(tasks) - 1].id
print "Project has been cleaned"
def clean_project(project_id, skip_tasks=False):
"""Remove everything from a project."""
from pybossa.core import task_repo
from pybossa.model import make_timestamp
n_tasks = 0
if not skip_tasks:
print "Deleting tasks"
sql = 'delete from task where project_id=%s' % project_id
db.engine.execute(sql)
else:
sql = 'select count(id) as n from task where project_id=%s' % project_id
result = db.engine.execute(sql)
for row in result:
n_tasks = row.n
sql = 'delete from task_run where project_id=%s' % project_id
db.engine.execute(sql)
sql = 'delete from result where project_id=%s' % project_id
db.engine.execute(sql)
sql = 'delete from counter where project_id=%s' % project_id
db.engine.execute(sql)
sql = 'delete from project_stats where project_id=%s' % project_id
db.engine.execute(sql)
sql = """INSERT INTO project_stats
(project_id, n_tasks, n_task_runs, n_results, n_volunteers,
n_completed_tasks, overall_progress, average_time,
n_blogposts, last_activity, info)
VALUES (%s, %s, 0, 0, 0, 0, 0, 0, 0, 0, '{}');""" % (project_id,
n_tasks)
db.engine.execute(sql)
if skip_tasks:
tasks = task_repo.filter_tasks_by(project_id=project_id, limit=100)
last_id = tasks[len(tasks)-1].id
while(len(tasks) > 0):
for task in tasks:
sql= ("insert into counter(created, project_id, task_id, n_task_runs) \
VALUES (TIMESTAMP '%s', %s, %s, 0)"
% (make_timestamp(), project_id, task.id))
db.engine.execute(sql)
tasks = task_repo.filter_tasks_by(project_id=project_id,
limit=100,
last_id=last_id)
if (len(tasks) > 0):
last_id = tasks[len(tasks)-1].id
print "Project has been cleaned"
def validate_parent(project):
"""Validate a parent project."""
empty_results = [
r for r in result_repo.filter_by(project_id=project.id) if not r.info
]
incomplete_tasks = task_repo.filter_tasks_by(state='ongoing',
project_id=project.id)
if empty_results or incomplete_tasks:
return False
return True
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 get_searchable_columns(project_id):
from pybossa.core import task_repo
tasks = task_repo.filter_tasks_by(project_id=project_id,
limit=1,
desc=True)
if not tasks:
return []
info = tasks[0].info
if not isinstance(info, dict):
return []
columns = [key for key in info if is_valid_searchable_column(key)]
return sorted(columns)
def create_results():
"""Create results when migrating."""
from pybossa.core import project_repo, task_repo, result_repo
from pybossa.model.result import Result
projects = project_repo.filter_by(published=True)
for project in projects:
print "Working on project: %s" % project.short_name
tasks = task_repo.filter_tasks_by(state='completed',
project_id=project.id)
print "Analyzing %s tasks" % len(tasks)
for task in tasks:
result = result_repo.get_by(project_id=project.id, task_id=task.id)
if result is None:
result = Result(project_id=project.id,
task_id=task.id,
task_run_ids=[tr.id for tr in task.task_runs],
last_version=True)
db.session.add(result)
db.session.commit()
print "Project %s completed!" % project.short_name
def create_results():
"""Create results when migrating."""
from pybossa.core import project_repo, task_repo, result_repo
from pybossa.model.result import Result
projects = project_repo.filter_by(published=True)
for project in projects:
print "Working on project: %s" % project.short_name
tasks = task_repo.filter_tasks_by(state='completed',
project_id=project.id)
print "Analyzing %s tasks" % len(tasks)
for task in tasks:
result = result_repo.get_by(project_id=project.id, task_id=task.id)
if result is None:
result = Result(project_id=project.id,
task_id=task.id,
task_run_ids=[tr.id for tr in task.task_runs],
last_version=True)
db.session.add(result)
db.session.commit()
print "Project %s completed!" % project.short_name
