def create_revision(instance):
models.Project.objects.filter(group_id=instance.group_id).update(
status=models.Project.STATUS_PAUSED)
template = TemplateSerializer.create_revision(
instance=instance.template)
batch_files = copy.copy(instance.batch_files.all())
tasks = copy.copy(instance.tasks.all())
mturk_update_status.delay({
'id': instance.id,
'status': models.Project.STATUS_PAUSED
})
instance.pk = None
instance.template = template
instance.status = models.Project.STATUS_DRAFT
instance.is_prototype = False
instance.is_paid = False
instance.save()
for f in batch_files:
models.ProjectBatchFile.objects.create(project=instance,
batch_file=f)
for t in tasks:
t.pk = None
t.project = instance
TaskSerializer.bulk_create(data=tasks)
return instance
def create_task(project_id):
task_data = {"project": project_id, "data": {}}
task_serializer = TaskSerializer(data=task_data)
if task_serializer.is_valid():
task_serializer.create()
else:
raise ValidationError(task_serializer.errors)
def create_task(project_id):
task_data = {
"project": project_id,
"data": {}
}
task_serializer = TaskSerializer(data=task_data)
if task_serializer.is_valid():
task_serializer.create()
else:
raise ValidationError(task_serializer.errors)
def update(self, *args, **kwargs):
status = self.validated_data.get('status', self.instance.status)
num_rows = self.validated_data.get('num_rows', 0)
if self.instance.status != status and status == 2:
if self.instance.templates.all()[0].template_items.count() == 0:
raise ValidationError('At least one template item is required')
if self.instance.batch_files.count() == 0:
task_data = {
"project": self.instance.id,
"status": 1,
"data": {}
}
task_serializer = TaskSerializer(data=task_data)
if task_serializer.is_valid():
task_serializer.create()
else:
raise ValidationError(task_serializer.errors)
else:
batch_file = self.instance.batch_files.first()
data = batch_file.parse_csv()
count = 0
for row in data:
if count == num_rows:
break
task = {'project': self.instance.id, 'data': row}
task_serializer = TaskSerializer(data=task)
if task_serializer.is_valid():
task_serializer.create(**kwargs)
count += 1
else:
raise ValidationError(task_serializer.errors)
self.instance.published_time = datetime.now()
status += 1
self.instance.name = self.validated_data.get('name',
self.instance.name)
self.instance.price = self.validated_data.get('price',
self.instance.price)
self.instance.repetition = self.validated_data.get(
'repetition', self.instance.repetition)
if status != self.instance.status \
and status in (models.Project.STATUS_PAUSED, models.Project.STATUS_IN_PROGRESS) and \
self.instance.status in (models.Project.STATUS_PAUSED, models.Project.STATUS_IN_PROGRESS):
mturk_update_status.delay({
'id': self.instance.id,
'status': status
})
self.instance.status = status
self.instance.save()
return self.instance
def create(self, **kwargs):
templates = self.validated_data.pop('template')
project = self.validated_data.pop('project')
file_id = self.validated_data.pop('file_id')
csv_data = []
if file_id is not None:
uploaded_file = models.RequesterInputFile.objects.get(id=file_id)
csv_data = uploaded_file.parse_csv()
uploaded_file.delete()
# module_tasks = self.validated_data.pop('module_tasks')
module = models.Module.objects.create(deleted=False,
project=project,
owner=kwargs['owner'].requester,
**self.validated_data)
'''
experiment pool, default 6 ignored
'''
experimental_models.ModulePool.objects.create(module=module, pool=6)
for template in templates:
template_items = template.pop('template_items')
t = models.Template.objects.get_or_create(owner=kwargs['owner'],
**template)
models.ModuleTemplate.objects.get_or_create(module=module,
template=t[0])
for item in template_items:
models.TemplateItem.objects.get_or_create(template=t[0],
**item)
if module.has_data_set:
for row in csv_data:
task = {'module': module.id, 'data': json.dumps(row)}
task_serializer = TaskSerializer(data=task)
if task_serializer.is_valid():
task_serializer.create(**kwargs)
else:
raise ValidationError(task_serializer.errors)
else:
task = {'module': module.id, 'data': "{\"type\": \"static\"}"}
task_serializer = TaskSerializer(data=task)
if task_serializer.is_valid():
task_serializer.create(**kwargs)
else:
raise ValidationError(task_serializer.errors)
return module
def create_revision(instance):
models.Project.objects.filter(group_id=instance.group_id).update(status=models.Project.STATUS_PAUSED)
template = TemplateSerializer.create_revision(instance=instance.template)
# batch_files = copy.copy(instance.batch_files.all())
tasks = copy.copy(instance.tasks.all())
mturk_update_status.delay({'id': instance.id, 'status': models.Project.STATUS_PAUSED})
instance.pk = None
instance.template = template
instance.status = models.Project.STATUS_DRAFT
instance.is_prototype = False
instance.is_paid = False
instance.save()
# for f in batch_files:
# models.ProjectBatchFile.objects.create(project=instance, batch_file=f)
for t in tasks:
t.pk = None
t.project = instance
TaskSerializer.bulk_create(data=tasks)
return instance
def update(self, *args, **kwargs):
status = self.validated_data.get('status', self.instance.status)
num_rows = self.validated_data.get('num_rows', 0)
if self.instance.status != status and status == 2:
if self.instance.templates.all()[0].template_items.count() == 0:
raise ValidationError('At least one template item is required')
if self.instance.batch_files.count() == 0:
task_data = {
"project": self.instance.id,
"status": 1,
"data": {}
}
task_serializer = TaskSerializer(data=task_data)
if task_serializer.is_valid():
task_serializer.create()
else:
raise ValidationError(task_serializer.errors)
else:
batch_file = self.instance.batch_files.first()
data = batch_file.parse_csv()
count = 0
for row in data:
if count == num_rows:
break
task = {
'project': self.instance.id,
'data': row
}
task_serializer = TaskSerializer(data=task)
if task_serializer.is_valid():
task_serializer.create(**kwargs)
count += 1
else:
raise ValidationError(task_serializer.errors)
self.instance.published_time = datetime.now()
status += 1
self.instance.name = self.validated_data.get('name', self.instance.name)
self.instance.price = self.validated_data.get('price', self.instance.price)
self.instance.repetition = self.validated_data.get('repetition', self.instance.repetition)
if status != self.instance.status \
and status in (models.Project.STATUS_PAUSED, models.Project.STATUS_IN_PROGRESS) and \
self.instance.status in (models.Project.STATUS_PAUSED, models.Project.STATUS_IN_PROGRESS):
mturk_update_status.delay({'id': self.instance.id, 'status': status})
self.instance.status = status
self.instance.save()
return self.instance
def create(self, **kwargs):
templates = self.validated_data.pop('template')
project = self.validated_data.pop('project')
file_id = self.validated_data.pop('file_id')
csv_data = []
if file_id is not None:
uploaded_file = models.RequesterInputFile.objects.get(id=file_id)
csv_data = uploaded_file.parse_csv()
uploaded_file.delete()
# module_tasks = self.validated_data.pop('module_tasks')
module = models.Module.objects.create(deleted=False, project=project,
owner=kwargs['owner'].requester, **self.validated_data)
'''
experiment pool, default 6 ignored
'''
experimental_models.ModulePool.objects.create(module=module, pool=6)
for template in templates:
template_items = template.pop('template_items')
t = models.Template.objects.get_or_create(owner=kwargs['owner'], **template)
models.ModuleTemplate.objects.get_or_create(module=module, template=t[0])
for item in template_items:
models.TemplateItem.objects.get_or_create(template=t[0], **item)
if module.has_data_set:
for row in csv_data:
task = {
'module': module.id,
'data': json.dumps(row)
}
task_serializer = TaskSerializer(data=task)
if task_serializer.is_valid():
task_serializer.create(**kwargs)
else:
raise ValidationError(task_serializer.errors)
else:
task = {
'module': module.id,
'data': "{\"type\": \"static\"}"
}
task_serializer = TaskSerializer(data=task)
if task_serializer.is_valid():
task_serializer.create(**kwargs)
else:
raise ValidationError(task_serializer.errors)
return module
def create(self, request, *args, **kwargs):
worker = get_or_create_worker(worker_id=request.data.get('workerId'))
provider = MTurkProvider('https://' + request.get_host())
task_id = request.data.get('taskId', -1)
task_hash = Hashids(salt=settings.SECRET_KEY,
min_length=settings.ID_HASH_MIN_LENGTH)
task_id = task_hash.decode(task_id)
if len(task_id) == 0:
task_id = -1
hit_id = request.data.get('hitId', -1)
mturk_hit = get_object_or_404(MTurkHIT, task_id=task_id, hit_id=hit_id)
assignment_id = request.data.get('assignmentId', -1)
mturk_assignment_id = None
task_worker = None
if assignment_id != 'ASSIGNMENT_ID_NOT_AVAILABLE':
assignment, is_valid = provider.get_assignment(assignment_id)
if not assignment or (is_valid and assignment.HITId != hit_id):
return Response(data={"message": "Invalid assignment"},
status=status.HTTP_400_BAD_REQUEST)
task_worker, created = TaskWorker.objects.get_or_create(
worker=worker, task_id=task_id[0])
if created:
task_worker.task_status = TaskWorker.STATUS_IN_PROGRESS
task_worker.save()
assignment, created = MTurkAssignment.objects.get_or_create(
hit=mturk_hit,
assignment_id=assignment_id,
task_worker=task_worker)
mturk_assignment_id = assignment.id
if created:
assignment.status = TaskWorker.STATUS_IN_PROGRESS
assignment.save()
task_serializer = TaskSerializer(instance=mturk_hit.task,
fields=('id', 'template',
'project_data', 'status'),
context={'task_worker': task_worker})
response_data = {
'task': task_serializer.data,
'assignment': mturk_assignment_id
}
return Response(data=response_data, status=status.HTTP_200_OK)
def update(self, *args, **kwargs):
status = self.validated_data.get("status", self.instance.status)
num_rows = self.validated_data.get("num_rows", 0)
if self.instance.status != status and status == 2:
if self.instance.templates.all()[0].template_items.count() == 0:
raise ValidationError("At least one template item is required")
if self.instance.batch_files.count() == 0:
task_data = {"project": self.instance.id, "status": 1, "data": {}}
task_serializer = TaskSerializer(data=task_data)
if task_serializer.is_valid():
task_serializer.create()
else:
raise ValidationError(task_serializer.errors)
else:
batch_file = self.instance.batch_files.first()
data = batch_file.parse_csv()
count = 0
for row in data:
if count == num_rows:
break
task = {"project": self.instance.id, "data": row}
task_serializer = TaskSerializer(data=task)
if task_serializer.is_valid():
task_serializer.create(**kwargs)
count += 1
else:
raise ValidationError(task_serializer.errors)
self.instance.published_time = datetime.now()
status += 1
self.instance.name = self.validated_data.get("name", self.instance.name)
self.instance.price = self.validated_data.get("price", self.instance.price)
self.instance.repetition = self.validated_data.get("repetition", self.instance.repetition)
self.instance.status = status
self.instance.save()
return self.instance
def download_results(self, request, *args, **kwargs):
project_id = request.query_params.get('project_id')
task = Task.objects.filter(project=project_id)
task_serializer = TaskSerializer(task,
many=True,
fields=('data', 'task_workers',
'comments'))
tasks = task_serializer.data
column_headers = [
'task_status', 'worker_alias', 'created', 'last_updated',
'feedback'
]
data_keys = eval(tasks[0]['data']).keys()
for key in data_keys:
column_headers.append(key)
data = []
items = []
for task in tasks:
task_workers = task['task_workers']
for task_worker in task_workers:
task_worker_results = task_worker['task_worker_results']
results = []
for task_worker_result in task_worker_results:
results.append(task_worker_result['result'])
item = {
'id':
task_worker['id'],
'data':
task['data'],
'worker_alias':
task_worker['worker_alias'],
'task_status':
task_worker['task_status'],
'results':
results,
'created':
task_worker['created_timestamp'],
'last_updated':
task_worker['last_updated'],
'feedback':
', '.join(
map(lambda x: x['comment'].get('body', ''),
[comment for comment in task['comments']]))
}
items.append(item)
max_results = 0
for item in items:
temp = [
item['task_status'], item['worker_alias'], item['created'],
item['last_updated'], item['feedback']
]
for key in data_keys:
temp.append(eval(item['data'])[key])
num_results = 0
for result in item['results']:
num_results += 1
temp.append(result)
if num_results > max_results:
max_results = num_results
data.append(temp)
for i in xrange(1, max_results + 1):
column_headers.append('Output_' + str(i))
df = pd.DataFrame(data)
output = StringIO.StringIO()
df.to_csv(output, header=column_headers, index=False, encoding="utf-8")
data = output.getvalue()
output.close()
return Response(data, status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
worker = get_or_create_worker(worker_id=request.data.get('workerId'))
task_id = request.data.get('taskId', -1)
task_hash = Hashids(salt=settings.SECRET_KEY,
min_length=settings.ID_HASH_MIN_LENGTH)
task_id = task_hash.decode(task_id)
if len(task_id) == 0:
task_id = -1
else:
task_id = task_id[0]
hit_id = request.data.get('hitId', -1)
mturk_hit = get_object_or_404(MTurkHIT, task_id=task_id, hit_id=hit_id)
assignment_id = request.data.get('assignmentId', -1)
mturk_assignment_id = None
task_worker = None
provider = get_provider(mturk_hit.task.project.owner,
host='https://' + request.get_host())
notify = True
if assignment_id != 'ASSIGNMENT_ID_NOT_AVAILABLE':
assignment, is_valid = provider.get_assignment(assignment_id)
if not assignment or (is_valid and assignment.HITId != hit_id):
return Response(data={"message": "Invalid assignment"},
status=status.HTTP_400_BAD_REQUEST)
if not is_allowed_to_work(worker, task_id, assignment_id):
return Response(data={
"message":
"You are not allowed to work on this HIT, please skip it."
},
status=status.HTTP_403_FORBIDDEN)
task_worker, created = TaskWorker.objects.get_or_create(
worker=worker, task_id=task_id)
if created:
task_worker.status = TaskWorker.STATUS_IN_PROGRESS
task_worker.save()
# get or create notification preference
preference, p_created = ProjectNotificationPreference.objects.get_or_create(
project_group_id=mturk_hit.task.project.group_id,
worker=worker)
notify = preference.notify
assignment, created = MTurkAssignment.objects.get_or_create(
hit=mturk_hit,
assignment_id=assignment_id,
task_worker=task_worker)
mturk_assignment_id = assignment.id
if created:
assignment.status = TaskWorker.STATUS_IN_PROGRESS
assignment.save()
task_serializer = TaskSerializer(instance=mturk_hit.task,
fields=('id', 'template',
'project_data', 'status'),
context={'task_worker': task_worker})
response_data = {
'task':
task_serializer.data,
'assignment':
mturk_assignment_id,
'is_review':
mturk_hit.task.project.is_review,
'is_rejected':
task_worker.collective_rejection is not None
if task_worker is not None else False,
'notify':
notify
}
return Response(data=response_data, status=status.HTTP_200_OK)
