def submit_task_assignment(request):
assignment_information = load_encoded_json(request.body)
worker = Worker.objects.get(user=request.user)
command_type = assignment_information['command_type']
if command_type in ('submit', 'accept'):
iteration_status = Iteration.Status.REQUESTED_REVIEW
elif command_type == 'reject':
iteration_status = Iteration.Status.PROVIDED_REVIEW
else:
raise BadRequest('Illegal command')
try:
submit_task(assignment_information['task_id'],
assignment_information['task_data'], iteration_status,
worker)
return {}
except TaskStatusError:
raise BadRequest('Task already completed')
except Task.DoesNotExist:
raise BadRequest('No task for given id')
except IllegalTaskSubmission as e:
raise BadRequest(e)
except TaskAssignmentError as e:
raise BadRequest(e)
def submit_task_assignment(request):
assignment_information = json.loads(request.body.decode())
worker = Worker.objects.get(user=request.user)
command_type = assignment_information['command_type']
work_time_seconds = assignment_information['work_time_seconds']
if command_type == 'accept':
snapshot_type = TaskAssignment.SnapshotType.ACCEPT
elif command_type == 'reject':
snapshot_type = TaskAssignment.SnapshotType.REJECT
elif command_type == 'submit':
snapshot_type = TaskAssignment.SnapshotType.SUBMIT
else:
raise BadRequest('Illegal command')
try:
submit_task(assignment_information['task_id'],
assignment_information['task_data'],
snapshot_type,
worker,
work_time_seconds)
return {}
except TaskStatusError:
raise BadRequest('Task already completed')
except Task.DoesNotExist:
raise BadRequest('No task for given id')
except IllegalTaskSubmission as e:
raise BadRequest(e)
except TaskAssignmentError as e:
raise BadRequest(e)
def save_as(request, pk):
# TODO: This currently only clones the model and ignores all changes
if request.method == 'POST':
form = SaveModelAsForm(request.POST, request.FILES)
if form.is_valid():
name = form.cleaned_data.get('saveas_name')
try:
model = DesignModel.objects.get(user=request.user, pk=pk)
except ObjectDoesNotExist:
raise BadRequest("Bad Model")
all_revs = model.revisions.order_by("date")
model.name = name
model.pk = None
model.save()
for rev in all_revs:
rev.model = model
rev.pk = None
rev.save()
return {
'success': True,
'url': reverse("wedesign:design", kwargs={"pk": model.pk})
}
else:
form_html = render_crispy_form(form, context=request)
return {'success': False, 'form_html': form_html}
raise BadRequest()
def message_project_team(request):
"""
Endpoint for sending arbitrary message to a project team.
Payload example:
{'message': 'Chat message', 'project_id': 'some-id-123'}
"""
data = load_encoded_json(request.body)
try:
message = data['message']
project_id = data['project_id']
project = Project.objects.get(id=project_id)
except KeyError:
text = ('An object with `message` and `project_id` attributes'
' should be supplied')
raise BadRequest(text)
except Project.DoesNotExist:
raise BadRequest('No project for given id')
if project.slack_group_id:
message_experts_slack_group(project.slack_group_id, message)
else:
error_message = (
"The following project doesn't have slack_group_id: {}"
).format(project)
raise BadRequest(error_message)
return {'success': True}
def new_task_assignment(request, task_type):
new_tasks_status = {
'entry_level': Task.Status.AWAITING_PROCESSING,
'reviewer': Task.Status.PENDING_REVIEW
}
try:
task_status = new_tasks_status[task_type]
except KeyError:
raise BadRequest('No such task type')
worker = Worker.objects.get(user=request.user)
try:
task_assignment = get_new_task_assignment(worker, task_status)
except WorkerCertificationError:
raise BadRequest('No worker certificates')
except NoTaskAvailable:
raise BadRequest('No task')
task = task_assignment.task
return {
'id': task.id,
'assignment_id': task_assignment.id,
'step': task.step.slug,
'project': task.project.workflow_version.slug,
'detail': task.project.short_description
}
def task_assignment_information(request):
try:
worker = Worker.objects.get(user=request.user)
return get_task_overview_for_worker(
load_encoded_json(request.body)['task_id'], worker)
except TaskAssignmentError as e:
raise BadRequest(e)
except Task.DoesNotExist as e:
raise BadRequest(e)
def project_information(request):
try:
data = load_encoded_json(request.body)
project_id = data['project_id']
return get_project_information(project_id)
except KeyError:
raise BadRequest('project_id is required')
except Project.DoesNotExist:
raise BadRequest('No project for given id')
def project_information(request):
try:
# TODO(marcua): Add checking for json.loads exceptions to all
# endpoints.
return get_project_information(
json.loads(request.body.decode())['project_id'])
except KeyError:
raise BadRequest('project_id is required')
except Project.DoesNotExist:
raise BadRequest('No project for given id')
def unarchive_slack_channel_api(request):
body = load_encoded_json(request.body)
try:
project_id = body.get('project_id')
project = Project.objects.get(id=project_id)
unarchive_project_slack_group(project)
except Project.DoesNotExist:
raise BadRequest('Project not found for the given id.')
except slacker.Error as e:
raise BadRequest(e)
def save_task_assignment(request):
assignment_information = load_encoded_json(request.body)
worker = Worker.objects.get(user=request.user)
try:
save_task(assignment_information['task_id'],
assignment_information['task_data'], worker)
return {}
except Task.DoesNotExist:
raise BadRequest('No task for given id')
except TaskAssignmentError as e:
raise BadRequest(e)
def set_project_status_api(request):
body = load_encoded_json(request.body)
project_id = body['project_id']
status = body['status']
try:
set_project_status(project_id, status)
except Project.DoesNotExist:
raise BadRequest('Project not found for the given id.')
except ProjectStatusError as e:
raise BadRequest(e)
return {'status': status, 'success': True}
def reassign_assignment_api(request):
worker_username = load_encoded_json(request.body)['worker_username']
try:
worker = Worker.objects.get(user__username=worker_username)
except Worker.DoesNotExist:
raise BadRequest('Worker not found for the given username.')
assignment_id = load_encoded_json(request.body)['assignment_id']
try:
reassign_assignment(worker.id, assignment_id)
except (WorkerCertificationError, TaskAssignmentError) as e:
raise BadRequest(e)
def revert_task_api(request):
body = json.loads(request.body.decode())
try:
revert_datetime = datetime.utcfromtimestamp(body['revert_datetime'])
revert_datetime = pytz.utc.localize(revert_datetime)
except:
raise BadRequest('Invalid timestamp provided.')
try:
audit = revert_task_to_datetime(body['task_id'], revert_datetime,
body['fake'])
except Task.DoesNotExist as e:
raise BadRequest(e)
return audit
def view(request):
if request.GET.get('location') is None or request.GET.get(
'keywords') is None:
raise BadRequest('Missing location or keywords parameter')
places = nearby_places(request.GET.get('location'),
request.GET.get('keywords'))
return places
def edit_slack_membership_api(request):
body = load_encoded_json(request.body)
try:
project_management.edit_slack_membership(
body['project_id'], body['username'], body['action'])
except slacker.Error as e:
raise BadRequest(e)
def get_record(request):
f = GetRecordForm(request.GET)
if not f.is_valid():
raise BadRequest('Invalid ringgold_id')
r = get_object_or_404(RinggoldRecord,
ringgold_id=f.cleaned_data['ringgold_id'])
return r.to_orcid_json()
def delete(request, pk):
try:
DesignModel.objects.get(user=request.user, pk=pk).delete()
except ObjectDoesNotExist:
raise BadRequest("Bad Model")
return {}
def index(request):
print "Places backend reached"
keywords = request.GET.get('keywords')
location = request.GET.get('location')
if keywords is None or location is None:
raise BadRequest('Must include keywords and location')
return nearby_search(keywords, location)
def project_information(request):
try:
data = load_encoded_json(request.body)
project_ids = data['project_ids']
return get_project_information(project_ids)
except KeyError:
raise BadRequest('project_ids is required')
def save_as(request, pk):
if request.method == 'POST':
form = SaveModelAsForm(request.POST, request.FILES)
if form.is_valid():
name = form.cleaned_data.get('saveas_name')
summary = form.cleaned_data.get('saveas_summary')
request.POST = request.POST.copy()
request.POST["summary"] = summary
save(request, pk)
model = DesignModel.objects.get(user=UserProfile.get_profile(
request.user),
pk=pk)
dm = DesignModel.objects.create(user=request.user.profile,
name=name,
filename=model.filename,
content=model.content)
# Repoint to new model
rev = model.get_latest_revision()
rev.model = dm
rev.save()
return {
'success': True,
'url': reverse("cyanodesign:design", kwargs={"pk": dm.pk})
}
else:
form_html = render_crispy_form(form, context=request)
return {'success': False, 'form_html': form_html}
return BadRequest()
def create_subsequent_tasks_api(request):
project_id = load_encoded_json(request.body)['project_id']
try:
project = Project.objects.get(id=project_id)
except Project.DoesNotExist:
raise BadRequest('Project not found for the given id.')
create_subsequent_tasks(project)
def dispatcher(request):
function_request = json.loads(b64decode(request.body.decode()).decode())
try:
execute_function(function_request)
return {}
except Exception as e:
logger.error('Failure running function', exc_info=True)
raise BadRequest(e)
def index_ajax(request):
import json
pk = request.POST.get("pk", 0)
op = request.POST.get("op", "")
if not op in ["load", "delete", "save"]:
raise BadRequest("Invalid op")
if op == "save":
name = request.POST.get("name", "")
query = request.POST.get("query", "")
if any(len(x) == 0 for x in [name, query]):
raise BadRequest("Invalid name or query")
try:
query_obj = models.Query.objects.get(name=name,
user=request.user.profile)
query_obj.query = query
query_obj.save()
created = False
except ObjectDoesNotExist:
query_obj = models.Query.objects.create(name=name,
query=query,
user=request.user.profile)
created = True
return {"name": query_obj.name, "pk": query_obj.pk, "created": created}
try:
pk = int(pk)
except ValueError:
raise BadRequest("Bad pk")
try:
query = models.Query.objects.get(pk=pk, user=request.user.profile)
except ObjectDoesNotExist:
raise BadRequest("No item found")
if op == "load":
return {"name": query.name, "query": query.query}
elif op == "delete":
query.delete()
return {}
def assign_task_api(request):
worker_username = load_encoded_json(request.body)['worker_username']
try:
worker = Worker.objects.get(user__username=worker_username)
task_id = load_encoded_json(request.body)['task_id']
assign_task(worker.id, task_id)
except (Worker.DoesNotExist, Task.DoesNotExist,
WorkerCertificationError) as e:
raise BadRequest(e)
def revert_task_api(request):
body = load_encoded_json(request.body)
try:
audit = revert_task_to_iteration(body['task_id'], body['iteration_id'],
body.get('revert_before'),
body.get('commit'))
except Task.DoesNotExist as e:
raise BadRequest(e)
return audit
def export(request, pk):
form = request.GET.get("format")
if form not in ["bioopt", "sbml", "sbml_wedesign", "json"]:
return HttpResponseBadRequest("Bad format")
user = replace_guest_user(request.user)
try:
model = DesignModel.objects.get(user=user, pk=pk)
content = model.get_latest_revision().sbml
except ObjectDoesNotExist:
return HttpResponseBadRequest("Bad Model")
if form.startswith("sbml"):
xml_handle = StringIO()
cls = SbmlXMLGenerator if form == "sbml" else SbmlXMLGeneratorWithWeDesign
writer = cls(xml_handle, "utf-8")
writer.startDocument()
metabolic_model.MetabolicModel.from_json(
json.loads(content)).write_sbml(writer)
writer.endDocument()
import xml.dom.minidom
dom = xml.dom.minidom.parseString(xml_handle.getvalue())
out = StringIO()
out.write(dom.toprettyxml())
export_data = out.getvalue()
elif form == "bioopt":
parsed_model = metabolic_model.MetabolicModel.from_json(
json.loads(content))
out = StringIO()
OptGeneParser.from_model(parsed_model,
include_compartment=False).write(out)
export_data = out.getvalue()
elif form == "json":
export_data = json.dumps(json.loads(content), indent='\t')
else:
raise BadRequest("Bad format")
types = dict(bioopt="application/x-bioopt",
sbml="application/sbml+xml",
sbml_wedesign="application/sbml+xml",
json="application/json")
exts = dict(bioopt=".txt", sbml=".xml", sbml_wedesign=".xml", json=".json")
response = HttpResponse(export_data, content_type=types[form])
filename = os.path.splitext(model.filename)[0] + exts[form]
response['Content-Disposition'] = "attachment; filename=" + filename
return response
def get_reactions(request, pk):
try:
item = DesignModel.objects.get(user=UserProfile.get_profile(
request.user),
pk=pk)
except ObjectDoesNotExist:
return BadRequest("Bad Model")
try:
revision = request.GET["revision"]
try:
revision = Revision.objects.get(model=item, pk=revision)
except ObjectDoesNotExist:
return BadRequest("Bad Revision")
except KeyError:
revision = item.get_latest_revision()
return JsonModel.from_sbml(revision.content).to_json()
def save(request):
if request.GET.get('location') is None or request.GET.get(
'keywords') is None:
raise BadRequest('Missing location or keywords parameter')
places = nearby_places(request.GET.get('location'),
request.GET.get('keywords'))
for p in places:
db_place = Place(name=p, date_saved=timezone.now())
db_place.save()
return places
def delete(request):
pk = request.POST.get("id", 0)
try:
DesignModel.objects.get(user=UserProfile.get_profile(request.user),
pk=pk).delete()
except ObjectDoesNotExist:
return BadRequest("Bad Model")
return {}
def start_timer(request):
worker = Worker.objects.get(user=request.user)
try:
if request.method == 'POST':
time_entry_data = load_encoded_json(request.body)
assignment_id = None
if 'assignment' in time_entry_data:
assignment_id = time_entry_data['assignment']
timer = time_tracking.start_timer(worker,
assignment_id=assignment_id)
serializer = TaskTimerSerializer(timer)
return serializer.data
except TaskAssignment.DoesNotExist:
raise BadRequest('Worker is not assigned to this task id.')
except TimerError as e:
raise BadRequest(e)
except Exception as e:
logger.exception(e)
raise e
